From 0c770ecad71bb540d36402311e01a2b6b94242fd Mon Sep 17 00:00:00 2001 From: omnisci3nce <17525998+omnisci3nce@users.noreply.github.com> Date: Wed, 3 Apr 2024 22:42:24 +1100 Subject: load gltf vertices and indices. need to move to git LFS! --- examples/gltf_loading/ex_gltf_loading.c | 67 +++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 examples/gltf_loading/ex_gltf_loading.c (limited to 'examples/gltf_loading') diff --git a/examples/gltf_loading/ex_gltf_loading.c b/examples/gltf_loading/ex_gltf_loading.c new file mode 100644 index 0000000..e00a9de --- /dev/null +++ b/examples/gltf_loading/ex_gltf_loading.c @@ -0,0 +1,67 @@ +#include + +#include "camera.h" +#include "core.h" +#include "loaders.h" +#include "maths.h" +#include "render.h" +#include "render_types.h" + +const vec3 pointlight_positions[4] = { + { 0.7, 0.2, 2.0 }, + { 2.3, -3.3, -4.0 }, + { -4.0, 2.0, -12.0 }, + { 0.0, 0.0, -3.0 }, +}; +point_light point_lights[4]; + +int main() { + core* core = core_bringup(); + + model_handle cube_handle = + model_load_gltf(core, "assets/models/gltf/DamagedHelmet/glTF/DamagedHelmet.gltf", false); + // model_handle cube_handle = model_load_gltf(core, "assets/models/gltf/scifi_girl/scene.gltf", + // false); + model* cube = &core->models->data[cube_handle.raw]; + model_upload_meshes(&core->renderer, cube); + + vec3 camera_pos = vec3(5., 0., 0.); + vec3 camera_front = vec3_normalise(vec3_negate(camera_pos)); + camera cam = camera_create(camera_pos, camera_front, VEC3_NEG_Z, deg_to_rad(45.0)); + // 4. create lights + + // directional (sun) light setup + directional_light dir_light = { .direction = (vec3){ -0.2, -1.0, -0.3 }, + .ambient = (vec3){ 0.2, 0.2, 0.2 }, + .diffuse = (vec3){ 0.5, 0.5, 0.5 }, + .specular = (vec3){ 1.0, 1.0, 1.0 } }; + // point lights setup + for (int i = 0; i < 4; i++) { + point_lights[i].position = pointlight_positions[i]; + point_lights[i].ambient = (vec3){ 0.05, 0.05, 0.05 }; + point_lights[i].diffuse = (vec3){ 0.8, 0.8, 0.8 }; + point_lights[i].specular = (vec3){ 1.0, 1.0, 1.0 }; + point_lights[i].constant = 1.0; + point_lights[i].linear = 0.09; + point_lights[i].quadratic = 0.032; + } + + scene our_scene = { .dir_light = dir_light, .n_point_lights = 4 }; + memcpy(&our_scene.point_lights, &point_lights, sizeof(point_light[4])); + + while (!glfwWindowShouldClose(core->renderer.window)) { + input_update(&core->input); + // threadpool_process_results(&core->threadpool, 1); + + render_frame_begin(&core->renderer); + + // Draw the model + transform model_tf = transform_create(vec3(0.0, 0.2, 0.0), quat_ident(), + 1.8); // make the backpack a bit bigger + draw_model(&core->renderer, &cam, cube, model_tf, &our_scene); + + render_frame_end(&core->renderer); + } + + return 0; +} -- cgit v1.2.3-70-g09d2 From 1d8d7c04786ab3964778e6f21fae145f661bb533 Mon Sep 17 00:00:00 2001 From: omniscient <17525998+omnisci3nce@users.noreply.github.com> Date: Thu, 4 Apr 2024 19:45:19 +1100 Subject: loading textures --- examples/gltf_loading/ex_gltf_loading.c | 14 ++++++- src/maths/maths.h | 12 ++++++ src/resources/gltf.c | 72 ++++++++++++++++++++++++++++----- 3 files changed, 86 insertions(+), 12 deletions(-) (limited to 'examples/gltf_loading') diff --git a/examples/gltf_loading/ex_gltf_loading.c b/examples/gltf_loading/ex_gltf_loading.c index e00a9de..867ddb2 100644 --- a/examples/gltf_loading/ex_gltf_loading.c +++ b/examples/gltf_loading/ex_gltf_loading.c @@ -4,6 +4,7 @@ #include "core.h" #include "loaders.h" #include "maths.h" +#include "maths_types.h" #include "render.h" #include "render_types.h" @@ -16,6 +17,10 @@ const vec3 pointlight_positions[4] = { point_light point_lights[4]; int main() { + double currentFrame = glfwGetTime(); + double lastFrame = currentFrame; + double deltaTime; + core* core = core_bringup(); model_handle cube_handle = @@ -50,13 +55,20 @@ int main() { memcpy(&our_scene.point_lights, &point_lights, sizeof(point_light[4])); while (!glfwWindowShouldClose(core->renderer.window)) { + currentFrame = glfwGetTime(); + deltaTime = currentFrame - lastFrame; + lastFrame = currentFrame; input_update(&core->input); // threadpool_process_results(&core->threadpool, 1); render_frame_begin(&core->renderer); // Draw the model - transform model_tf = transform_create(vec3(0.0, 0.2, 0.0), quat_ident(), + static f32 angle = 0.0; + static f32 rot_speed = 0.5; + quat rot = quat_from_axis_angle(VEC3_Z, fmod(angle, TAU), true); + angle += (rot_speed * deltaTime); + transform model_tf = transform_create(vec3(0.0, 0.1, -0.1), rot, 1.8); // make the backpack a bit bigger draw_model(&core->renderer, &cam, cube, model_tf, &our_scene); diff --git a/src/maths/maths.h b/src/maths/maths.h index d832739..95ced1d 100644 --- a/src/maths/maths.h +++ b/src/maths/maths.h @@ -66,6 +66,18 @@ static inline quat quat_normalise(quat a) { static inline quat quat_ident() { return (quat){ .x = 0.0, .y = 0.0, .z = 0.0, .w = 1.0 }; } +static quat quat_from_axis_angle(vec3 axis, f32 angle, bool normalize) { + const f32 half_angle = 0.5f * angle; + f32 s = sinf(half_angle); + f32 c = cosf(half_angle); + + quat q = (quat){s * axis.x, s * axis.y, s * axis.z, c}; + if (normalize) { + return quat_normalise(q); + } + return q; +} + // --- Matrix Implementations static inline mat4 mat4_ident() { diff --git a/src/resources/gltf.c b/src/resources/gltf.c index 69400b7..b269fcd 100644 --- a/src/resources/gltf.c +++ b/src/resources/gltf.c @@ -1,11 +1,13 @@ #include #include +#include #include "core.h" #include "defines.h" #include "file.h" #include "loaders.h" #include "log.h" #include "path.h" +#include "render.h" #include "render_types.h" #include "str.h" @@ -23,8 +25,8 @@ KITC_DECL_TYPED_ARRAY(vec2) KITC_DECL_TYPED_ARRAY(u32) KITC_DECL_TYPED_ARRAY(face) -bool model_load_gltf_str(const char *file_string, const char *filepath, model *out_model, - bool invert_textures_y); +bool model_load_gltf_str(const char *file_string, const char *filepath, str8 relative_path, + model *out_model, bool invert_textures_y); model_handle model_load_gltf(struct core *core, const char *path, bool invert_texture_y) { size_t arena_size = 1024; @@ -42,7 +44,8 @@ model_handle model_load_gltf(struct core *core, const char *path, bool invert_te model.meshes = mesh_darray_new(1); model.materials = material_darray_new(1); - bool success = model_load_gltf_str(file_string, path, &model, invert_texture_y); + bool success = + model_load_gltf_str(file_string, path, relative_path.path, &model, invert_texture_y); if (!success) { FATAL("Couldnt load OBJ file at path %s", path); @@ -59,8 +62,8 @@ model_handle model_load_gltf(struct core *core, const char *path, bool invert_te // TODO: Brainstorm how I can make this simpler and break it up into more testable pieces -bool model_load_gltf_str(const char *file_string, const char *filepath, model *out_model, - bool invert_textures_y) { +bool model_load_gltf_str(const char *file_string, const char *filepath, str8 relative_path, + model *out_model, bool invert_textures_y) { TRACE("Load GLTF from string"); // Setup temps @@ -81,6 +84,45 @@ bool model_load_gltf_str(const char *file_string, const char *filepath, model *o cgltf_load_buffers(&options, data, filepath); DEBUG("loaded buffers"); + // --- Materials + TRACE("Num materials %d", data->materials_count); + size_t num_materials = data->materials_count; + for (size_t m = 0; m < num_materials; m++) { + cgltf_material gltf_material = data->materials[m]; + material our_material = DEFAULT_MATERIAL; + + strcpy(our_material.name, gltf_material.name); + + cgltf_pbr_metallic_roughness pbr = gltf_material.pbr_metallic_roughness; + if (gltf_material.has_pbr_metallic_roughness) { + // we will use base color texture like blinn phong + cgltf_texture_view diff_tex_view = pbr.base_color_texture; + + char diffuse_map_path[1024]; + snprintf(diffuse_map_path, sizeof(diffuse_map_path), "%s/%s", relative_path.buf, + diff_tex_view.texture->image->uri); + + strcpy(our_material.diffuse_tex_path, diffuse_map_path); + texture diffuse_texture = texture_data_load(our_material.diffuse_tex_path, false); + texture_data_upload(&diffuse_texture); + our_material.diffuse_texture = diffuse_texture; + + cgltf_texture_view specular_tex_view = pbr.metallic_roughness_texture; + + char specular_map_path[1024]; + snprintf(specular_map_path, sizeof(specular_map_path), "%s/%s", relative_path.buf, + specular_tex_view.texture->image->uri); + + strcpy(our_material.specular_tex_path, specular_map_path); + texture specular_texture = texture_data_load(our_material.specular_tex_path, false); + texture_data_upload(&specular_texture); + our_material.specular_texture = specular_texture; + } + + material_darray_push(out_model->materials, our_material); + } + + // --- Meshes TRACE("Num meshes %d", data->meshes_count); size_t num_meshes = data->meshes_count; for (size_t m = 0; m < num_meshes; m++) { @@ -157,26 +199,34 @@ bool model_load_gltf_str(const char *file_string, const char *filepath, model *o for (cgltf_size i = 0; i < indices->count; ++i) { vertex vert; cgltf_uint index = mesh.indices[i]; - // printf("Index %d\n", index); vert.position = tmp_positions->data[index]; vert.normal = tmp_normals->data[index]; vert.uv = tmp_uvs->data[index]; vertex_darray_push(mesh.vertices, vert); } - } else { mesh.has_indices = false; return false; // TODO } - // HACK - mesh.material_index = 0; + if (primitive.material != NULL) { + for (int i = 0; i < material_darray_len(out_model->materials); i++) { + if (strcmp(primitive.material->name, out_model->materials->data[i].name)) { + TRACE("Found material"); + mesh.material_index = i; + break; + } + } + } mesh_darray_push(out_model->meshes, mesh); } - material_darray_push(out_model->materials, DEFAULT_MATERIAL); - + for (int i = 0; i < out_model->meshes->len; i++) { + u32 mat_idx = out_model->meshes->data[i].material_index; + printf("Mesh %d Mat index %d Mat name %s\n", i, mat_idx, + out_model->materials->data[mat_idx].name); + } return true; } -- cgit v1.2.3-70-g09d2