From c2fec36353c29d31ed95451e42413983808fd62e Mon Sep 17 00:00:00 2001 From: omniscient <17525998+omnisci3nce@users.noreply.github.com> Date: Wed, 31 Jul 2024 10:51:59 +1000 Subject: remove old gltf code --- src/resources/gltf.c | 288 --------------------------------------------------- 1 file changed, 288 deletions(-) diff --git a/src/resources/gltf.c b/src/resources/gltf.c index 642fc59..41ff9e2 100644 --- a/src/resources/gltf.c +++ b/src/resources/gltf.c @@ -36,7 +36,6 @@ KITC_DECL_TYPED_ARRAY(Vec2) KITC_DECL_TYPED_ARRAY(Vec4u) KITC_DECL_TYPED_ARRAY(Vec4) KITC_DECL_TYPED_ARRAY(face) -// KITC_DECL_TYPED_ARRAY(joint) size_t GLTF_LoadMaterials(cgltf_data *data, Str8 relative_path, Material_darray *out_materials); @@ -586,290 +585,3 @@ size_t GLTF_LoadMaterials(cgltf_data *data, Str8 relative_path, Material_darray return out_materials->len; } - -/* -bool model_load_gltf(const char *path, model *out_model) { - TRACE("Load GLTF %s", path); - - // Setup temp arrays - kitc_darray *tmp_positions = kitc_darray_new(sizeof(vec3), 1000); - kitc_darray *tmp_normals = kitc_darray_new(sizeof(vec3), 1000); - kitc_darray *tmp_uvs = kitc_darray_new(sizeof(vec2), 1000); - - // may as well just init with max capacity as we're just gonna free at end of this function -anyway bh_material_darray *materials = bh_material_darray_new(MAX_MATERIALS); - CASSERT(materials->len == 0); - - cgltf_options options = {0}; - cgltf_data *data = NULL; - cgltf_result result = cgltf_parse_file(&options, path, &data); - if (result == cgltf_result_success) { - DEBUG("gltf loaded succesfully"); - - cgltf_load_buffers(&options, data, path); - DEBUG("loaded buffers"); - - // -- Load materials. - // Each mesh will be handed a material - TRACE("Num materials %d", data->materials_count); - out_model->num_materials = data->materials_count; - - for (int m = 0; m < data->materials_count; m++) { - cgltf_material gltf_material = data->materials[m]; - bh_material our_material = {0}; - - str8 name = str8_copy(gltf_material.name); - printf("Material name %s\n", name.buf); - our_material.name = 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 = pbr.base_color_texture; - strcpy(our_material.diffuse_tex_path, diff_tex.texture->image->uri); - } - - bh_material_darray_push(materials, our_material); - } - - // -- Load animations. - TRACE("Num animations %d", data->animations_count); - out_model->num_animations = data->animations_count; - for (int anim_idx = 0; anim_idx < data->animations_count; anim_idx++) { - cgltf_animation animation = data->animations[anim_idx]; - animation_clip our_animation = {0}; - - // loop through each channel (track) - for (int c = 0; c < animation.channels_count; c++) { - // each channel (track) has a target and a sampler - // for the time being we assume the target is the model itself - cgltf_animation_channel channel = animation.channels[c]; - animation_track our_track = {0}; - our_track.interpolation = interpolation_fn_from_gltf(channel.sampler->interpolation); - our_track.property = anim_prop_from_gltf(channel.target_path); - - // get the actual data out via the "accessor" - // input will be the times - - // Keyframe times - size_t n_frames = channel.sampler->input->count; - our_track.num_keyframes = n_frames; - f32 *times = malloc(sizeof(f32) * n_frames); - our_track.keyframe_times = times; - CASSERT_MSG(channel.sampler->input->component_type == cgltf_component_type_r_32f, - "Expected animation sampler input component to be type f32 (keyframe times)"); - cgltf_accessor_unpack_floats(channel.sampler->input, times, -channel.sampler->input->count); - - // printf("keyframe times[\n"); - // for (int i = 0; i < n_frames; i++) { - // printf(" %f\n", times[i]); - // } - // printf("]\n"); - - // Data! - if (channel.target_path == cgltf_animation_path_type_rotation) { - CASSERT(channel.sampler->output->component_type == cgltf_component_type_r_32f); - CASSERT(channel.sampler->output->type == cgltf_type_vec4); - } - - our_track.keyframes = malloc(sizeof(keyframe_data) * n_frames); - for (cgltf_size v = 0; v < channel.sampler->output->count; ++v) { - quat rot; - cgltf_accessor_read_float(channel.sampler->output, v, &rot.x, 4); - // vectors[v] = rot; - // printf("Quat %f %f %f %f\n", rot.x, rot.y, rot.z, rot.w); - our_track.keyframes[v].rotation = rot; - } - - our_track.min_time = channel.sampler->input->min[0]; - our_track.max_time = channel.sampler->input->max[0]; - - // printf("min time: %f max time %f\n", our_track.min_time, our_track.max_time); - - animation_track_darray_push(&our_animation.tracks, our_track); - } - - out_model->animations[anim_idx] = our_animation; - } - - // Load meshes - TRACE("Num meshes %d", data->meshes_count); - out_model->num_meshes = data->meshes_count; - - for (int m = 0; m < data->meshes_count; m++) { - // at the moment we only handle one primitives per mesh - // CASSERT(data->meshes[m].primitives_count == 1); - - // Load vertex data from FIRST primitive only - cgltf_primitive primitive = data->meshes[m].primitives[0]; - DEBUG("Found %d attributes", primitive.attributes_count); - for (int a = 0; a < data->meshes[m].primitives[0].attributes_count; a++) { - cgltf_attribute attribute = data->meshes[m].primitives[0].attributes[a]; - if (attribute.type == cgltf_attribute_type_position) { - TRACE("Load positions from accessor"); - - cgltf_accessor *accessor = attribute.data; - CASSERT(accessor->component_type == cgltf_component_type_r_32f); - CASSERT_MSG(accessor->type == cgltf_type_vec3, "Vertex positions should be a vec3"); - - for (cgltf_size v = 0; v < accessor->count; ++v) { - vec3 pos; - cgltf_accessor_read_float(accessor, v, &pos.x, 3); - kitc_darray_push(tmp_positions, &pos); - } - - } else if (attribute.type == cgltf_attribute_type_normal) { - TRACE("Load normals from accessor"); - - cgltf_accessor *accessor = attribute.data; - CASSERT(accessor->component_type == cgltf_component_type_r_32f); - CASSERT_MSG(accessor->type == cgltf_type_vec3, "Normal vectors should be a vec3"); - - for (cgltf_size v = 0; v < accessor->count; ++v) { - vec3 pos; - cgltf_accessor_read_float(accessor, v, &pos.x, 3); - kitc_darray_push(tmp_normals, &pos); - } - - } else if (attribute.type == cgltf_attribute_type_texcoord) { - TRACE("Load texture coordinates from accessor"); - cgltf_accessor *accessor = attribute.data; - CASSERT(accessor->component_type == cgltf_component_type_r_32f); - CASSERT_MSG(accessor->type == cgltf_type_vec2, "Texture coordinates should be a vec2"); - - for (cgltf_size v = 0; v < accessor->count; ++v) { - vec2 tex; - bool success = cgltf_accessor_read_float(accessor, v, &tex.x, 2); - if (!success) { - ERROR("Error loading tex coord"); - } - kitc_darray_push(tmp_uvs, &tex); - } - } else if (attribute.type == cgltf_attribute_type_joints) { - // handle joints - - } else { - WARN("Unhandled cgltf_attribute_type: %s. skipping..", attribute.name); - } - } - - // Create mesh - mesh mesh; - mesh.vertices = - kitc_darray_new(sizeof(mesh_vertex), data->meshes[m].primitives[0].attributes_count); - - // Flatten faces from indices if present otherwise push vertices verbatim - cgltf_accessor *indices = primitive.indices; - if (primitive.indices > 0) { - mesh.has_indices = true; - - kitc_darray *element_indexes = kitc_darray_new(sizeof(cgltf_uint), indices->count); - TRACE("Indices count %ld\n", indices->count); - for (cgltf_size i = 0; i < indices->count; ++i) { - cgltf_uint ei; - cgltf_accessor_read_uint(indices, i, &ei, 1); - kitc_darray_push(element_indexes, &ei); - } - - kitc_darray_iter indices_iter = kitc_darray_iter_new(element_indexes); - cgltf_uint *cur; - while ((cur = kitc_darray_iter_next(&indices_iter))) { - mesh_vertex vert; - memcpy(&vert.position, &((vec3 *)tmp_positions->data)[*cur], sizeof(vec3)); - memcpy(&vert.normal, &((vec3 *)tmp_normals->data)[*cur], sizeof(vec3)); - memcpy(&vert.tex_coord, &((vec2 *)tmp_uvs->data)[*cur], sizeof(vec2)); - kitc_darray_push(mesh.vertices, &vert); - // mesh_vertex_debug_print(vert); - } - // printf("indices: %ld, positions: %ld\n", kitc_darray_len(element_indexes), - kitc_darray_free(element_indexes); - } else { - mesh.has_indices = false; - - bool calc_normals = false; - if (kitc_darray_len(tmp_normals) == 0) { - TRACE("No normals data is present. Normals will be calculated for you."); - calc_normals = true; - } - for (int v = 0; v < kitc_darray_len(tmp_positions); v++) { - mesh_vertex vert; - memcpy(&vert.position, &((vec3 *)tmp_positions->data)[v], sizeof(vec3)); - if (!calc_normals) { - memcpy(&vert.normal, &((vec3 *)tmp_normals->data)[v], sizeof(vec3)); - } - memcpy(&vert.tex_coord, &((vec2 *)tmp_uvs->data)[v], sizeof(vec2)); - kitc_darray_push(mesh.vertices, &vert); - } - - if (calc_normals) { - if (mesh.has_indices) { - // generate_normals_nonindexed(mesh.vertices); - } else { - generate_normals_nonindexed(mesh.vertices); - } - } - } - - // Material - if (primitive.material != NULL) { - for (int i = 0; i < bh_material_darray_len(materials); i++) { - if (strcmp(primitive.material->name, cstr(materials->data->name))) { - TRACE("Found material"); - mesh.material_index = i; - break; - } - } - } - - // mesh.material_index = 0; // TODO: make sure DEFAULT_MATERIAL is added at material index -0 - // TODO: material handling - mesh.material_index = bh_material_darray_len(materials) - 1; - - calc_mesh_bounding_box(&mesh); - // out_model->meshes.data[m] = mesh; - mesh_darray_push(&out_model->meshes, mesh); - - kitc_darray_clear(tmp_positions); - kitc_darray_clear(tmp_normals); - kitc_darray_clear(tmp_uvs); - } - // End Load meshes - - // Load animations - DEBUG("Num animations %d", data->animations_count); - out_model->num_animations = data->animations_count; - - // End Load animations - - cgltf_free(data); - } else { - ERROR("Load failed"); - kitc_darray_free(tmp_positions); - kitc_darray_free(tmp_normals); - kitc_darray_free(tmp_uvs); - return false; - } - - for (int i = 0; i < materials->len; i++) { - out_model->materials[i] = materials->data[i]; - } - - calc_model_bounding_box(out_model); - - DEBUG("Num meshes %d", out_model->num_meshes); - DEBUG("Num materials %d", out_model->num_materials); - DEBUG("Num animations %d", out_model->num_animations); - - CASSERT(out_model->num_materials == 1); - - kitc_darray_free(tmp_positions); - kitc_darray_free(tmp_normals); - kitc_darray_free(tmp_uvs); - bh_material_darray_free(materials); - - TRACE("Finished loading GLTF"); - return true; -} -*/ -- cgit v1.2.3-70-g09d2