// PBR model viewer. Based on Foxotron by @gargaj + cce/Peisik (UNLICENSE). // - rlyeh, public domain. // // @todo: Middle mouse button to pan camera @todo #include "v4k.h" #if is(tcc) && !is(win32) // @todo: remove this & test on linux int log2_64 (uint64_t value) { const int tab64[64] = { 63, 0, 58, 1, 59, 47, 53, 2, 60, 39, 48, 27, 54, 33, 42, 3, 61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43, 14, 22, 4, 62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21, 56, 45, 25, 31, 35, 16, 9, 12, 44, 24, 15, 8, 23, 7, 6, 5}; value |= value >> 1; value |= value >> 2; value |= value >> 4; value |= value >> 8; value |= value >> 16; value |= value >> 32; return tab64[((uint64_t)((value - (value >> 1))*0x07EDD5E59A4E28C2)) >> 58]; } #define log2 log2_64 #endif // ----------------------------------------------------------------------------- // textures texture_t *LoadTextureRGBA8( const char *pathfile, unsigned flags ) { int flags_hdr = strendi(pathfile, ".hdr") ? TEXTURE_FLOAT | TEXTURE_RGBA : 0; texture_t t = texture(pathfile, flags | TEXTURE_LINEAR | TEXTURE_MIPMAPS | TEXTURE_REPEAT | flags_hdr); if( t.id == texture_checker().id ) { return NULL; } texture_t *tex = CALLOC(1, sizeof(texture_t)); *tex = t; return tex; } // ----------------------------------------------------------------------------- // pbr materials (kept for backwards compatibility) typedef struct pbr_material_t { char* name; colormap_t diffuse; colormap_t normals; colormap_t specular; colormap_t albedo; colormap_t roughness; colormap_t metallic; colormap_t ao; colormap_t ambient; colormap_t emissive; float specular_shininess; } pbr_material_t; bool pbr_material(pbr_material_t *pbr, const char *material) { pbr->name = STRDUP(material); return true; } void pbr_material_destroy(pbr_material_t *m) { } // ----------------------------------------------------------------------------- // models typedef struct Mesh { GLuint vao, vbo, ibo; int vert_stride; void *vert_stream; int num_verts, num_tris; int material_idx; bool transparent; vec3 aabb_min, aabb_max; } Mesh; typedef struct Model { model_t m; array(Mesh) meshes; array(pbr_material_t) materials; unsigned shader; } Model; bool ModelLoad( Model *G, const char *_path ); void ModelDestroy( Model *G ); void ModelRebind( Model *G, unsigned shader ); void ModelRender( Model *G, const mat44 _worldRootMatrix ); void ModelDestroy( Model *G) { for( int i = 0, end = array_count(G->materials); i < end; ++i ) { pbr_material_destroy(&G->materials[i]); } array_free(G->materials); for( int i = 0, end = array_count(G->meshes); i < end; ++i ) { Mesh *it = &G->meshes[i]; glDeleteBuffers( 1, &it->ibo ); glDeleteBuffers( 1, &it->vbo ); glDeleteVertexArrays( 1, &it->vao ); } array_free(G->meshes); } bool ModelLoad( Model *G, const char *_path ) { ModelDestroy(G); // ------------------------------------------------------------------------- Model g = {0}; *G = g; model_t m = model(_path, MODEL_PBR); G->m = m; int scn_num_meshes = m.num_meshes; int scn_num_materials = array_count(m.materials); // ------------------------------------------------------------------------- for( int i = 0; i < scn_num_materials; i++ ) { const char *name = m.materials[i].name; PRINTF("Loading material %d/%d: '%s'\n", i + 1, scn_num_materials, name); pbr_material_t mt; pbr_material(&mt, name); array_push(G->materials, mt); } for( int i = 0; i < scn_num_meshes; i++ ) { PRINTF("Loading mesh %d/%d\n", i + 1, scn_num_meshes); int verts = m.num_verts; int faces = m.num_triangles; unsigned material_index = 0; // &m.iqm->meshes[i].material; // aiGetMeshMaterialIndex(scn_mesh[i]); bool has_data = verts && faces; if( !has_data ) { continue; } PRINTF("Loading mesh v%d/f%d\n", verts, faces); Mesh mesh = { 0 }; mesh.vao = m.vao; mesh.vbo = m.vbo; mesh.ibo = m.ibo; mat44 id; id44(id); mesh.aabb_min = model_aabb(m, id).min; mesh.aabb_max = model_aabb(m, id).max; // p3 n3 t3 b3 u2 mesh.vert_stride = m.stride; mesh.vert_stream = m.verts; mesh.num_verts = verts; mesh.num_tris = faces; mesh.material_idx = material_index; // By importing materials before meshes we can investigate whether a mesh is transparent and flag it as such. // const pbr_material_t* mtl = G->materials ? &G->materials[mesh.material_idx] : NULL; // mesh.transparent = false; // if( mtl ) { // mesh.transparent |= mtl->albedo .texture ? mtl->albedo .texture->transparent : mtl->albedo .color.a < 1.0f; // mesh.transparent |= mtl->diffuse.texture ? mtl->diffuse.texture->transparent : mtl->diffuse.color.a < 1.0f; // } array_push(G->meshes, mesh); } #if 0 G->mGlobalAmbient = vec4( 0.3,0.3,0.3,0.3 ); int scn_num_lights = 0; for( int i = 0; i < scn_num_lights; i++ ) { PRINTF("Loading light %d/%d\n", i + 1, scn_num_lights); vec4 *color = aiGetLightColor(scn_light[i]); char *type = aiGetLightType(scn_light[i]); if( 0 == strcmp(type, "AMBIENT") ) { memcpy( &G->mGlobalAmbient, &color->r, sizeof( float ) * 4 ); } else { // @todo } } #endif return true; } void ModelRender( Model *G, const mat44 _worldRootMatrix ) { unsigned _shader = G->shader; shader_bind( _shader ); shader_vec4("global_ambient", vec4(1,1,1,1)); // unused // loop thrice: first opaque, then transparent backface, then transparent frontface for(int j = 0; j < 3; ++j) { bool bTransparentPass = j > 0; if(bTransparentPass) { glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glCullFace( j == 1 ? GL_FRONT : GL_BACK ); // glDepthMask( GL_FALSE); } mat44 mat_world; copy44(mat_world, _worldRootMatrix); // @fixme mMatrices[ node.mID ] * _worldRootMatrix shader_mat44( "mat_world", mat_world ); for( int i = 0, end = array_count(G->meshes); i < end; i++ ) { const Mesh *mesh = &G->meshes[ i ]; // Postpone rendering transparent meshes if(mesh->transparent != bTransparentPass) continue; const material_t *material = &G->m.materials[ mesh->material_idx ]; shader_colormap( "map_diffuse", material->layer[MATERIAL_CHANNEL_DIFFUSE].map ); shader_colormap( "map_normals", material->layer[MATERIAL_CHANNEL_NORMALS].map ); shader_colormap( "map_specular", material->layer[MATERIAL_CHANNEL_SPECULAR].map ); shader_colormap( "map_albedo", material->layer[MATERIAL_CHANNEL_ALBEDO].map ); shader_colormap( "map_roughness", material->layer[MATERIAL_CHANNEL_ROUGHNESS].map ); shader_colormap( "map_metallic", material->layer[MATERIAL_CHANNEL_METALLIC].map ); shader_colormap( "map_ao", material->layer[MATERIAL_CHANNEL_AO].map ); shader_colormap( "map_ambient", material->layer[MATERIAL_CHANNEL_AMBIENT].map ); shader_colormap( "map_emissive", material->layer[MATERIAL_CHANNEL_EMISSIVE].map ); // shader_float( "specular_shininess", material->specular_shininess ); // unused, basic_specgloss.fs only shader_vec2( "resolution", vec2(window_width(),window_height())); glActiveTexture(GL_TEXTURE0); // be nice to Mesa before rendering glBindVertexArray( mesh->vao ); glDrawElements( GL_TRIANGLES, mesh->num_tris * 3, GL_UNSIGNED_INT, NULL ); } if(bTransparentPass) { glDisable( GL_BLEND ); // glDepthMask( GL_TRUE ); } } //glBindVertexArray( 0 ); //glUseProgram( 0 ); } static void G_SetupVertexArray( unsigned _shader, const char *name, int stride, int num_floats, int *offset, int opt_location ) { int location = opt_location >= 0 ? opt_location : glGetAttribLocation( _shader, name ); if( location >= 0 ) { glVertexAttribPointer( location, num_floats, GL_FLOAT, GL_FALSE, stride, (GLvoid *)(uintptr_t)(*offset) ); glEnableVertexAttribArray( location ); } *offset += num_floats * sizeof( GLfloat ); } void ModelRebind( Model *G, unsigned _shader ) { shader_bind(_shader); if(_shader == G->shader) return; G->shader = _shader; for( int i = 0, end = array_count(G->meshes); i < end; i++ ) { const Mesh *mesh = &G->meshes[ i ]; glBindVertexArray( mesh->vao ); glBindBuffer( GL_ARRAY_BUFFER, mesh->vbo ); glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, mesh->ibo ); glDisableVertexAttribArray( 0 ); glDisableVertexAttribArray( 1 ); glDisableVertexAttribArray( 2 ); glDisableVertexAttribArray( 3 ); glDisableVertexAttribArray( 4 ); glDisableVertexAttribArray( 5 ); glDisableVertexAttribArray( 6 ); glDisableVertexAttribArray( 7 ); int offset = 0, stride = mesh->vert_stride; G_SetupVertexArray( _shader, "in_pos", stride, 3, &offset, -1/*0*/ ); G_SetupVertexArray( _shader, "in_texcoord", stride, 2, &offset, -1/*1*/ ); G_SetupVertexArray( _shader, "in_normal", stride, 3, &offset, -1/*2*/ ); G_SetupVertexArray( _shader, "in_tangent", stride, 4, &offset, -1/*3*/ ); //glBindVertexArray( 0 ); } } // ----------------------------------------------------------------------------- // skyboxes // Extracts single key value from an HDRLabs IBL file. Returns an empty string on error. static const char *ibl_readkey( const char* pathfile, const char* key ) { char *data = vfs_read(pathfile); if( data ) { const char *found = strstr(data, va("%s=", key)); if( found ) return found + strlen(key) + 1; found = strstr(data, va("%s =", key)); if( found ) return found + strlen(key) + 2; } return ""; } typedef struct Skybox { vec3 sunColor; float sunYaw, sunPitch; // ibl settings texture_t *reflection; // reflection map (hdr) texture_t *env; // irradiance map (env) } Skybox; Skybox g_skybox = { {1,1,1} }; void SkyboxDestroy( Skybox *s ) { if( s->reflection ) texture_destroy( s->reflection ); if( s->env ) texture_destroy( s->env ); *s = (Skybox){0}; } bool SkyboxLoad( Skybox *s, const char **slots ) { // hdr,env,ibl SkyboxDestroy( s ); const char* reflectionPath = slots[0]; const char* envPath = slots[1]; const char* iblPath = slots[2]; // unsigned invalid = texture_checker().id; // Reflection map if( reflectionPath ) { if( (s->reflection = LoadTextureRGBA8( reflectionPath, TEXTURE_SRGB )) != NULL ) { glBindTexture( GL_TEXTURE_2D, s->reflection->id ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); } } // Irradiance map if( envPath ) { if( (s->env = LoadTextureRGBA8( envPath, TEXTURE_SRGB )) != NULL ) { glBindTexture( GL_TEXTURE_2D, s->env->id ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); } } // Sun color & direction from .ibl file s->sunColor = vec3(1,1,1); s->sunYaw = 0, s->sunPitch = 0; if( iblPath ) { vec3 sc; if( 3 == sscanf(ibl_readkey(iblPath, "SUNcolor"), "%f,%f,%f", &sc.x, &sc.y, &sc.z) ) { s->sunColor = scale3(sc, 1/255.f); } vec2 uv = vec2(atof(ibl_readkey(iblPath, "SUNu")), atof(ibl_readkey(iblPath, "SUNv"))); if( len2(uv) > 0 ) { s->sunYaw = C_PI * (-2. * uv.x + 0.5f); s->sunPitch = (0.5f - uv.y) * C_PI; } } return s->reflection && s->env; } // ----------------------------------------------------------------------------- // main const char *shader_names[] = {"Physically Based", "Basic SpecGloss" }; const char *shaders[][2] = { // name, vs, fs { "Shaders/pbr.vs", "Shaders/pbr.fs" }, { "Shaders/basic_specgloss.vs", "Shaders/basic_specgloss.fs" } }; const char *skyboxes[][3] = { // reflection, env, metadata {"hdr/Tokyo_BigSight_1k.hdr","hdr/Tokyo_BigSight_Env.hdr","hdr/Tokyo_BigSight.ibl"}, {"hdr/GCanyon_C_YumaPoint_1k.hdr","hdr/GCanyon_C_YumaPoint_Env.hdr","hdr/GCanyon_C_YumaPoint.ibl"}, {"hdr/Factory_Catwalk_1k.hdr","hdr/Factory_Catwalk_Env.hdr","hdr/Factory_Catwalk.ibl"}, {"hdr/MonValley_G_DirtRoad_1k.hdr","hdr/MonValley_G_DirtRoad_Env.hdr","hdr/MonValley_G_DirtRoad.ibl"}, {"hdr/Shiodome_Stairs_1k.hdr","hdr/Shiodome_Stairs_Env.hdr","hdr/Shiodome_Stairs.ibl"}, }; Model gModel; unsigned gShader = ~0u; unsigned gShaderConfig = ~0u; bool LoadShaderConfig( int slot ) { // name,vs,fs unsigned newShader = shader( vfs_read(shaders[slot][0]), vfs_read(shaders[slot][1]), NULL, NULL, NULL ); if( newShader == ~0u ) return false; shader_destroy( gShader ); gShaderConfig = slot; gShader = newShader; return true; } void camera_fit(camera_t *cam) { vec3 target = scale3( add3( gModel.meshes[0].aabb_min, gModel.meshes[0].aabb_max ), 0.5f); float distance = len3( sub3( gModel.meshes[0].aabb_max, gModel.meshes[0].aabb_min ) ) * 0.85f; cam->position = add3(target, scale3(norm3(sub3(cam->position,target)), distance)); camera_lookat(cam, vec3(0,0,0)); } int main() { window_create( 75, WINDOW_MSAA2 ); window_title(__FILE__); // load all fx files in all subdirs fx_load("fx**.fs"); LoadShaderConfig( 0 ); brdf_lut(); // ------------------------------------------------------------------------- // Mainloop float model_yaw = 0, model_pitch = 0; float lightYaw = 0.0f; float lightPitch = 0.0f; vec4 skyBackgroundColor = vec4(0.01,0.01,0.02,1); // vec4(1,0,0,1); float skyExposure = 1.0; // plain 'exposure' instead? this is camera related float skyBlur = 0.00; // 0.00 float skyOpacity = 0.99; // 0.99 bool do_wireframe = false; bool do_xzySpace = true; // xzySpace or xyzSpace bool do_flipY = false; const mat44 xzyMatrix = { 1, 0, 0, 0, 0, 0, 1, 0, 0,+1, 0, 0, 0, 0, 0, 1 }; camera_t cam = camera(); cam.speed = 0.1; int firstskyboxes = 0; // 0: tokyo_bigsight SkyboxLoad( &g_skybox, &skyboxes[firstskyboxes][0] ); lightYaw = g_skybox.sunYaw; lightPitch = g_skybox.sunPitch; unsigned skysphereShader = shader( vfs_read("Skyboxes/skysphere.vs"), vfs_read("Skyboxes/skysphere.fs"), NULL, NULL, NULL ); Model skysphere = { 0 }; ModelLoad(&skysphere, "Skyboxes/skysphere.fbx"); ModelRebind(&skysphere, skysphereShader); if( ModelLoad( &gModel, option("--model", "damagedhelmet.gltf") ) ) { ModelRebind( &gModel, gShader ); } cam.position = vec3(+1,0,+1); camera_fit(&cam); static mat44 worldRootXYZ; do_once id44(worldRootXYZ); // mat44( 1.0f ); while( window_swap() && !input(KEY_ESC) ) { if( input(KEY_F5) ) window_reload(); if( input_down( KEY_F ) ) camera_fit(&cam); // --------------------------------------------------------------------- static int fps_mode; if(input_down(KEY_TAB)) { fps_mode ^= 1; camera_fit(&cam); } if(fps_mode) { // fps camera bool active = ui_active() || ui_hover() || gizmo_active() ? false : input(MOUSE_L) || input(MOUSE_M) || input(MOUSE_R); window_cursor( !active ); if( active ) cam.speed = clampf(cam.speed + input_diff(MOUSE_W) / 10, 0.05f, 5.0f); vec2 mouse = scale2(vec2(input_diff(MOUSE_X), -input_diff(MOUSE_Y)), 0.2f * active); vec3 wasdecq = scale3(vec3(input(KEY_D)-input(KEY_A),input(KEY_E)-(input(KEY_C)||input(KEY_Q)),input(KEY_W)-input(KEY_S)), cam.speed); camera_moveby(&cam, wasdecq); camera_fps(&cam, mouse.x,mouse.y); } else { // orbit camera window_cursor( true ); bool active = !ui_active() && !ui_hover() && !gizmo_active(); vec2 inc_mouse = scale2(vec2(input_diff(MOUSE_X), -input_diff(MOUSE_Y)), 0.2f * active * input(MOUSE_L)); float inc_distance = -0.2f * active * input_diff(MOUSE_W); camera_orbit(&cam, inc_mouse.x, inc_mouse.y, inc_distance); // rotate model model_yaw -= input_diff(MOUSE_X) * 0.2f * active * input(MOUSE_R); model_pitch += input_diff(MOUSE_Y) * 0.2f * active * input(MOUSE_R); } // --------------------------------------------------------------------- glClearColor( skyBackgroundColor.r, skyBackgroundColor.g, skyBackgroundColor.b, skyBackgroundColor.a ); glEnable(GL_CULL_FACE); glFrontFace(GL_CCW); // --------------------------------------------------------------------- // Mesh state fx_begin(); profile("PBR Model (bindings)") { ModelRebind( &gModel, gShader ); shader_mat44( "mat_projection", cam.proj ); //cameraPosition = scale3(cameraPosition, gCameraDistance); shader_vec3( "camera_position", cam.position ); vec3 lightDirection = vec3( 0, 0, 1 ); lightDirection = rotatex3( lightDirection, deg(lightPitch) ); lightDirection = rotatey3( lightDirection, deg(lightYaw) ); vec3 fillLightDirection = vec3( 0, 0, 1 ); fillLightDirection = rotatex3( fillLightDirection, deg(lightPitch - 0.4f) ); fillLightDirection = rotatey3( fillLightDirection, deg(lightYaw + 0.8f) ); shader_vec3( "lights[0].direction", lightDirection ); shader_vec3( "lights[0].color", g_skybox.sunColor ); shader_vec3( "lights[1].direction", fillLightDirection ); shader_vec3( "lights[1].color", vec3( 0.5f, 0.5f, 0.5f ) ); shader_vec3( "lights[2].direction", neg3(fillLightDirection) ); shader_vec3( "lights[2].color", vec3( 0.25f, 0.25f, 0.25f ) ); shader_float( "skysphere_rotation", lightYaw - g_skybox.sunYaw ); mat44 viewMatrix, inv_viewMatrix; copy44(viewMatrix, cam.view); invert44( inv_viewMatrix, viewMatrix); shader_mat44( "mat_view", viewMatrix ); shader_mat44( "mat_view_inverse", inv_viewMatrix ); shader_bool( "has_tex_skysphere", g_skybox.reflection != NULL ); shader_bool( "has_tex_skyenv", g_skybox.env != NULL ); if( g_skybox.reflection ) { float mipCount = floor( log2( g_skybox.reflection->h ) ); shader_texture( "tex_skysphere", *g_skybox.reflection ); shader_float( "skysphere_mip_count", mipCount ); } if( g_skybox.env ) { shader_texture( "tex_skyenv", *g_skybox.env ); } shader_texture( "tex_brdf_lut", brdf_lut() ); shader_float( "exposure", skyExposure ); shader_uint( "frame_count", (unsigned)window_frame() ); } // --------------------------------------------------------------------- // Mesh render mat44 M; copy44( M, do_xzySpace ? xzyMatrix : worldRootXYZ ); if( do_flipY ) scale44( M, 1,-1,1 ); rotate44( M, model_yaw, 0,0,1 ); rotate44( M, model_pitch, 1,0,0 ); profile("PBR Model (render)") { ModelRender( &gModel, M ); } profile("PBR Model (wireframe)") { if( do_wireframe ) { glPolygonMode( GL_FRONT_AND_BACK, GL_LINE ); glDepthFunc( GL_LEQUAL ); shader_float("exposure", 100.0f ); ModelRender( &gModel, M ); glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); glDepthFunc( GL_LESS ); } } // --------------------------------------------------------------------- // Skysphere render profile("PBR Skybox") { ModelRebind(&skysphere, skysphereShader ); mat44 projview; multiply44x2(projview, cam.proj, cam.view); shader_mat44( "mat_mvp", projview ); shader_bool( "has_tex_skysphere", g_skybox.reflection != NULL ); shader_bool( "has_tex_skyenv", g_skybox.env != NULL ); if( g_skybox.reflection ) { const float mipCount = floor( log2( g_skybox.reflection->h ) ); shader_texture( "tex_skysphere", *g_skybox.reflection ); shader_float( "skysphere_mip_count", mipCount ); } if( g_skybox.env ) { shader_texture( "tex_skyenv", *g_skybox.env ); } shader_vec4( "background_color", skyBackgroundColor ); shader_float( "skysphere_blur", skyBlur ); shader_float( "skysphere_opacity", skyOpacity ); shader_float( "skysphere_rotation", lightYaw - g_skybox.sunYaw ); shader_float( "exposure", skyExposure ); shader_uint( "frame_count", (unsigned)window_frame() ); glDepthFunc( GL_LEQUAL ); ModelRender(&skysphere, worldRootXYZ ); glDepthFunc( GL_LESS ); } fx_end(); // --------------------------------------------------------------------- // UI if( ui_panel( "Viewer", 0 ) ) { ui_bool( "Wireframe", &do_wireframe ); ui_separator(); if( ui_radio("Shader config:", shader_names, countof(shader_names), &gShaderConfig) ) { LoadShaderConfig( gShaderConfig ); ModelRebind(&gModel, gShader ); } ui_separator(); for( int i = 0; i < countof(skyboxes); i++ ) { const char *filename = skyboxes[i][0]; bool selected = !strcmp(g_skybox.reflection->filename, file_name(filename)); if( ui_bool( filename, &selected ) ) { SkyboxLoad( &g_skybox, &skyboxes[i][0] ); lightYaw = g_skybox.sunYaw; lightPitch = g_skybox.sunPitch; } } ui_separator(); ui_float( "Sky exposure", &skyExposure); skyExposure = clampf(skyExposure, 0.1f, 4.0f ); ui_float( "Sky blur", &skyBlur); skyBlur = clampf(skyBlur, 0.0f, 1.0f ); ui_float( "Sky opacity", &skyOpacity); skyOpacity = clampf(skyOpacity, 0.0f, 1.0f ); ui_color4f( "Sky background", (float *) &skyBackgroundColor.x ); ui_separator(); ui_float( "SunLight Yaw", &lightYaw ); ui_float( "SunLight Pitch", &lightPitch ); ui_panel_end(); } // if( ui_panel( "Model", 0 ) ) { // ui_label(va("Material count: %d", array_count(gModel.materials))); // ui_label(va("Mesh count: %d", array_count(gModel.meshes))); // int triCount = 0; for( int i = 0, end = array_count(gModel.meshes); i < end; ++i ) triCount += gModel.meshes[i].num_tris; // ui_label(va("Triangle count: %d", triCount)); // ui_separator(); // bool xyzSpace = !do_xzySpace; // if( ui_bool( "XYZ space", &xyzSpace ) ) { // do_xzySpace = !do_xzySpace; // } // ui_bool( "XZY space", &do_xzySpace ); // ui_bool( "invert Y", &do_flipY ); // ui_separator(); // for( int i = 0, end = array_count(gModel.materials); i < end; ++i ) { // pbr_material_t *it = &gModel.materials[i]; // ui_label(va("Name: %s", it->name)); // ui_float( "Specular shininess", &it->specular_shininess ); // ui_separator(); if(ui_colormap( "Albedo", &it->albedo )) colormap(&it->albedo , app_loadfile(), 1); // ui_separator(); if(ui_colormap( "Ambient", &it->ambient )) colormap(&it->ambient , app_loadfile(), 0); // ui_separator(); if(ui_colormap( "AO", &it->ao )) colormap(&it->ao , app_loadfile(), 0); // ui_separator(); if(ui_colormap( "Diffuse", &it->diffuse )) colormap(&it->diffuse , app_loadfile(), 1); // ui_separator(); if(ui_colormap( "Emissive", &it->emissive )) colormap(&it->emissive , app_loadfile(), 1); // ui_separator(); if(ui_colormap( "Metallic", &it->metallic )) colormap(&it->metallic , app_loadfile(), 0); // ui_separator(); if(ui_colormap( "Normal", &it->normals )) colormap(&it->normals , app_loadfile(), 0); // ui_separator(); if(ui_colormap( "Roughness", &it->roughness )) colormap(&it->roughness, app_loadfile(), 0); // ui_separator(); if(ui_colormap( "Specular", &it->specular )) colormap(&it->specular , app_loadfile(), 0); // } // ui_panel_end(); // } if( ui_panel("Help", 0)) { if( fps_mode ) { ui_label("TAB: switch to Orbit camera mode"); ui_label("WASD,QEC: move camera"); ui_label("Drag + Mouse Button: camera freelook"); } else { ui_label("TAB: switch to FPS camera mode"); ui_label("Drag + Left Mouse Button: orbit camera"); ui_label("Drag + Right Mouse Button: rotate model"); ui_label("Mouse wheel: camera distance"); } ui_label("F: center view"); ui_panel_end(); } } }