MrMonopoly/raylib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Small improvements on the naming of functions

Browse Source 
Removed (*model). and replaced it with model->
This commit is contained in:
Hristo Stamenov 2021-03-14 10:50:37 +02:00
parent e7b012c640
commit 8f89692a95
1 changed files with 75 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
src/models.c
View File

@ -118,10 +118,10 @@ static ModelAnimation *LoadIQMModelAnimations(const char *fileName, int *animCou
static Model LoadGLTF(const char *fileName); // Load GLTF mesh data static Model LoadGLTF(const char *fileName); // Load GLTF mesh data
static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCount); // Load GLTF animation data static ModelAnimation *LoadGLTFModelAnimations(const char *fileName, int *animCount); // Load GLTF animation data
static void LoadGLTFModelIndices(Model* model, cgltf_accessor* indexAccessor, int primitiveIndex); static void LoadGLTFModelIndices(Model* model, cgltf_accessor* indexAccessor, int primitiveIndex);
static void BindGLTFPrimitivePose(Model* model, const cgltf_data* data, int primitiveIndex); static void BindGLTFPrimitiveToBones(Model* model, const cgltf_data* data, int primitiveIndex);
static void LoadGLTFBones(Model* model, cgltf_accessor* jointsAccessor, const cgltf_data* data, int primitiveIndex); static void LoadGLTFBoneAttribute(Model* model, cgltf_accessor* jointsAccessor, const cgltf_data* data, int primitiveIndex);
static void LoadGLTFMaterial(Model* model, const char* fileName, const cgltf_data* data); static void LoadGLTFMaterial(Model* model, const char* fileName, const cgltf_data* data);
static void LoadGLTFInitialBoneInformation(Model* model, const cgltf_data* data); static void InitGLTFBones(Model* model, const cgltf_data* data);
#endif #endif
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -3741,7 +3741,7 @@ static Model LoadGLTF(const char *fileName)
model.bones = RL_CALLOC(model.boneCount, sizeof(BoneInfo)); model.bones = RL_CALLOC(model.boneCount, sizeof(BoneInfo));
model.bindPose = RL_CALLOC(model.boneCount, sizeof(Transform)); model.bindPose = RL_CALLOC(model.boneCount, sizeof(Transform));
LoadGLTFInitialBoneInformation(&model, data); InitGLTFBones(&model, data);
LoadGLTFMaterial(&model, fileName, data); LoadGLTFMaterial(&model, fileName, data);
int primitiveIndex = 0; int primitiveIndex = 0;
@ -3842,7 +3842,7 @@ static Model LoadGLTF(const char *fileName)
else if (data->meshes[i].primitives[p].attributes[j].type == cgltf_attribute_type_joints) else if (data->meshes[i].primitives[p].attributes[j].type == cgltf_attribute_type_joints)
{ {
cgltf_accessor *acc = data->meshes[i].primitives[p].attributes[j].data; cgltf_accessor *acc = data->meshes[i].primitives[p].attributes[j].data;
LoadGLTFBones(&model, acc, data, primitiveIndex); LoadGLTFBoneAttribute(&model, acc, data, primitiveIndex);
} }
else if (data->meshes[i].primitives[p].attributes[j].type == cgltf_attribute_type_weights) else if (data->meshes[i].primitives[p].attributes[j].type == cgltf_attribute_type_weights)
{ {
@ -3890,7 +3890,7 @@ static Model LoadGLTF(const char *fileName)
model.meshMaterial[primitiveIndex] = model.materialCount - 1; model.meshMaterial[primitiveIndex] = model.materialCount - 1;
} }
BindGLTFPrimitivePose(&model, data, primitiveIndex); BindGLTFPrimitiveToBones(&model, data, primitiveIndex);
primitiveIndex++; primitiveIndex++;
} }
@ -3906,51 +3906,51 @@ static Model LoadGLTF(const char *fileName)
return model; return model;
} }
static void LoadGLTFInitialBoneInformation(Model* model, const cgltf_data* data) static void InitGLTFBones(Model* model, const cgltf_data* data)
{ {
for (unsigned int j = 0; j < data->nodes_count; j++) for (unsigned int j = 0; j < data->nodes_count; j++)
{ {
strcpy((*model).bones[j].name, data->nodes[j].name == 0 ? "ANIMJOINT" : data->nodes[j].name); strcpy(model->bones[j].name, data->nodes[j].name == 0 ? "ANIMJOINT" : data->nodes[j].name);
(*model).bones[j].parent = (data->nodes[j].parent != NULL) ? data->nodes[j].parent - data->nodes : -1; model->bones[j].parent = (data->nodes[j].parent != NULL) ? data->nodes[j].parent - data->nodes : -1;
} }
for (unsigned int i = 0; i < data->nodes_count; i++) for (unsigned int i = 0; i < data->nodes_count; i++)
{ {
if (data->nodes[i].has_translation) memcpy(&(*model).bindPose[i].translation, data->nodes[i].translation, 3 * sizeof(float)); if (data->nodes[i].has_translation) memcpy(&model->bindPose[i].translation, data->nodes[i].translation, 3 * sizeof(float));
else (*model).bindPose[i].translation = Vector3Zero(); else model->bindPose[i].translation = Vector3Zero();
if (data->nodes[i].has_rotation) memcpy(&(*model).bindPose[i].rotation, data->nodes[i].rotation, 4 * sizeof(float)); if (data->nodes[i].has_rotation) memcpy(&model->bindPose[i].rotation, data->nodes[i].rotation, 4 * sizeof(float));
else (*model).bindPose[i].rotation = QuaternionIdentity(); else model->bindPose[i].rotation = QuaternionIdentity();
(*model).bindPose[i].rotation = QuaternionNormalize((*model).bindPose[i].rotation); model->bindPose[i].rotation = QuaternionNormalize(model->bindPose[i].rotation);
if (data->nodes[i].has_scale) memcpy(&(*model).bindPose[i].scale, data->nodes[i].scale, 3 * sizeof(float)); if (data->nodes[i].has_scale) memcpy(&model->bindPose[i].scale, data->nodes[i].scale, 3 * sizeof(float));
else (*model).bindPose[i].scale = Vector3One(); else model->bindPose[i].scale = Vector3One();
} }
{ {
bool* completedBones = RL_CALLOC((*model).boneCount, sizeof(bool)); bool* completedBones = RL_CALLOC(model->boneCount, sizeof(bool));
int numberCompletedBones = 0; int numberCompletedBones = 0;
while (numberCompletedBones < (*model).boneCount) { while (numberCompletedBones < model->boneCount) {
for (int i = 0; i < (*model).boneCount; i++) for (int i = 0; i < model->boneCount; i++)
{ {
if (completedBones[i]) continue; if (completedBones[i]) continue;
if ((*model).bones[i].parent < 0) { if (model->bones[i].parent < 0) {
completedBones[i] = true; completedBones[i] = true;
numberCompletedBones++; numberCompletedBones++;
continue; continue;
} }
if (!completedBones[(*model).bones[i].parent]) continue; if (!completedBones[model->bones[i].parent]) continue;
Transform* currentTransform = &(*model).bindPose[i]; Transform* currentTransform = &model->bindPose[i];
BoneInfo* currentBone = &(*model).bones[i]; BoneInfo* currentBone = &model->bones[i];
int root = currentBone->parent; int root = currentBone->parent;
if (root >= (*model).boneCount) if (root >= model->boneCount)
root = 0; root = 0;
Transform* parentTransform = &(*model).bindPose[root]; Transform* parentTransform = &model->bindPose[root];
currentTransform->rotation = QuaternionMultiply(parentTransform->rotation, currentTransform->rotation); currentTransform->rotation = QuaternionMultiply(parentTransform->rotation, currentTransform->rotation);
currentTransform->translation = Vector3RotateByQuaternion(currentTransform->translation, parentTransform->rotation); currentTransform->translation = Vector3RotateByQuaternion(currentTransform->translation, parentTransform->rotation);
@ -3967,9 +3967,9 @@ static void LoadGLTFInitialBoneInformation(Model* model, const cgltf_data* data)
static void LoadGLTFMaterial(Model* model, const char* fileName, const cgltf_data* data) static void LoadGLTFMaterial(Model* model, const char* fileName, const cgltf_data* data)
{ {
for (int i = 0; i < (*model).materialCount - 1; i++) for (int i = 0; i < model->materialCount - 1; i++)
{ {
(*model).materials[i] = LoadMaterialDefault(); model->materials[i] = LoadMaterialDefault();
Color tint = (Color){ 255, 255, 255, 255 }; Color tint = (Color){ 255, 255, 255, 255 };
const char *texPath = GetDirectoryPath(fileName); const char *texPath = GetDirectoryPath(fileName);
@ -3981,12 +3981,12 @@ static void LoadGLTFMaterial(Model* model, const char* fileName, const cgltf_dat
tint.b = (unsigned char)(data->materials[i].pbr_metallic_roughness.base_color_factor[2] * 255); tint.b = (unsigned char)(data->materials[i].pbr_metallic_roughness.base_color_factor[2] * 255);
tint.a = (unsigned char)(data->materials[i].pbr_metallic_roughness.base_color_factor[3] * 255); tint.a = (unsigned char)(data->materials[i].pbr_metallic_roughness.base_color_factor[3] * 255);
(*model).materials[i].maps[MAP_ALBEDO].color = tint; model->materials[i].maps[MAP_ALBEDO].color = tint;
if (data->materials[i].pbr_metallic_roughness.base_color_texture.texture) if (data->materials[i].pbr_metallic_roughness.base_color_texture.texture)
{ {
Image albedo = LoadImageFromCgltfImage(data->materials[i].pbr_metallic_roughness.base_color_texture.texture->image, texPath, tint); Image albedo = LoadImageFromCgltfImage(data->materials[i].pbr_metallic_roughness.base_color_texture.texture->image, texPath, tint);
(*model).materials[i].maps[MAP_ALBEDO].texture = LoadTextureFromImage(albedo); model->materials[i].maps[MAP_ALBEDO].texture = LoadTextureFromImage(albedo);
UnloadImage(albedo); UnloadImage(albedo);
} }
@ -3995,13 +3995,13 @@ static void LoadGLTFMaterial(Model* model, const char* fileName, const cgltf_dat
if (data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture) if (data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture)
{ {
Image metallicRoughness = LoadImageFromCgltfImage(data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture->image, texPath, tint); Image metallicRoughness = LoadImageFromCgltfImage(data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture->image, texPath, tint);
(*model).materials[i].maps[MAP_ROUGHNESS].texture = LoadTextureFromImage(metallicRoughness); model->materials[i].maps[MAP_ROUGHNESS].texture = LoadTextureFromImage(metallicRoughness);
float roughness = data->materials[i].pbr_metallic_roughness.roughness_factor; float roughness = data->materials[i].pbr_metallic_roughness.roughness_factor;
(*model).materials[i].maps[MAP_ROUGHNESS].value = roughness; model->materials[i].maps[MAP_ROUGHNESS].value = roughness;
float metallic = data->materials[i].pbr_metallic_roughness.metallic_factor; float metallic = data->materials[i].pbr_metallic_roughness.metallic_factor;
(*model).materials[i].maps[MAP_METALNESS].value = metallic; model->materials[i].maps[MAP_METALNESS].value = metallic;
UnloadImage(metallicRoughness); UnloadImage(metallicRoughness);
} }
@ -4009,38 +4009,38 @@ static void LoadGLTFMaterial(Model* model, const char* fileName, const cgltf_dat
if (data->materials[i].normal_texture.texture) if (data->materials[i].normal_texture.texture)
{ {
Image normalImage = LoadImageFromCgltfImage(data->materials[i].normal_texture.texture->image, texPath, tint); Image normalImage = LoadImageFromCgltfImage(data->materials[i].normal_texture.texture->image, texPath, tint);
(*model).materials[i].maps[MAP_NORMAL].texture = LoadTextureFromImage(normalImage); model->materials[i].maps[MAP_NORMAL].texture = LoadTextureFromImage(normalImage);
UnloadImage(normalImage); UnloadImage(normalImage);
} }
if (data->materials[i].occlusion_texture.texture) if (data->materials[i].occlusion_texture.texture)
{ {
Image occulsionImage = LoadImageFromCgltfImage(data->materials[i].occlusion_texture.texture->image, texPath, tint); Image occulsionImage = LoadImageFromCgltfImage(data->materials[i].occlusion_texture.texture->image, texPath, tint);
(*model).materials[i].maps[MAP_OCCLUSION].texture = LoadTextureFromImage(occulsionImage); model->materials[i].maps[MAP_OCCLUSION].texture = LoadTextureFromImage(occulsionImage);
UnloadImage(occulsionImage); UnloadImage(occulsionImage);
} }
if (data->materials[i].emissive_texture.texture) if (data->materials[i].emissive_texture.texture)
{ {
Image emissiveImage = LoadImageFromCgltfImage(data->materials[i].emissive_texture.texture->image, texPath, tint); Image emissiveImage = LoadImageFromCgltfImage(data->materials[i].emissive_texture.texture->image, texPath, tint);
(*model).materials[i].maps[MAP_EMISSION].texture = LoadTextureFromImage(emissiveImage); model->materials[i].maps[MAP_EMISSION].texture = LoadTextureFromImage(emissiveImage);
tint.r = (unsigned char)(data->materials[i].emissive_factor[0]*255); tint.r = (unsigned char)(data->materials[i].emissive_factor[0]*255);
tint.g = (unsigned char)(data->materials[i].emissive_factor[1]*255); tint.g = (unsigned char)(data->materials[i].emissive_factor[1]*255);
tint.b = (unsigned char)(data->materials[i].emissive_factor[2]*255); tint.b = (unsigned char)(data->materials[i].emissive_factor[2]*255);
(*model).materials[i].maps[MAP_EMISSION].color = tint; model->materials[i].maps[MAP_EMISSION].color = tint;
UnloadImage(emissiveImage); UnloadImage(emissiveImage);
} }
} }
} }
(*model).materials[(*model).materialCount - 1] = LoadMaterialDefault(); model->materials[model->materialCount - 1] = LoadMaterialDefault();
} }
static void LoadGLTFBones(Model* model, cgltf_accessor* jointsAccessor, const cgltf_data* data, int primitiveIndex) static void LoadGLTFBoneAttribute(Model* model, cgltf_accessor* jointsAccessor, const cgltf_data* data, int primitiveIndex)
{ {
if (jointsAccessor->component_type == cgltf_component_type_r_16u) if (jointsAccessor->component_type == cgltf_component_type_r_16u)
{ {
(*model).meshes[primitiveIndex].boneIds = RL_MALLOC(sizeof(int) * jointsAccessor->count * 4); model->meshes[primitiveIndex].boneIds = RL_MALLOC(sizeof(int) * jointsAccessor->count * 4);
short* bones = RL_MALLOC(sizeof(short) * jointsAccessor->count * 4); short* bones = RL_MALLOC(sizeof(short) * jointsAccessor->count * 4);
for(int a = 0; a < jointsAccessor->count; a++) for(int a = 0; a < jointsAccessor->count; a++)
@ -4056,7 +4056,7 @@ static void LoadGLTFBones(Model* model, cgltf_accessor* jointsAccessor, const cg
{ {
if (&(data->nodes[k]) == skinJoint) if (&(data->nodes[k]) == skinJoint)
{ {
(*model).meshes[primitiveIndex].boneIds[a] = k; model->meshes[primitiveIndex].boneIds[a] = k;
break; break;
} }
} }
@ -4065,7 +4065,7 @@ static void LoadGLTFBones(Model* model, cgltf_accessor* jointsAccessor, const cg
} }
else if (jointsAccessor->component_type == cgltf_component_type_r_8u) else if (jointsAccessor->component_type == cgltf_component_type_r_8u)
{ {
(*model).meshes[primitiveIndex].boneIds = RL_MALLOC(sizeof(int) * jointsAccessor->count * 4); model->meshes[primitiveIndex].boneIds = RL_MALLOC(sizeof(int) * jointsAccessor->count * 4);
unsigned char* bones = RL_MALLOC(sizeof(unsigned char) * jointsAccessor->count * 4); unsigned char* bones = RL_MALLOC(sizeof(unsigned char) * jointsAccessor->count * 4);
for(int a = 0; a < jointsAccessor->count; a++) for(int a = 0; a < jointsAccessor->count; a++)
@ -4081,7 +4081,7 @@ static void LoadGLTFBones(Model* model, cgltf_accessor* jointsAccessor, const cg
{ {
if (&(data->nodes[k]) == skinJoint) if (&(data->nodes[k]) == skinJoint)
{ {
(*model).meshes[primitiveIndex].boneIds[a] = k; model->meshes[primitiveIndex].boneIds[a] = k;
break; break;
} }
} }
@ -4095,28 +4095,28 @@ static void LoadGLTFBones(Model* model, cgltf_accessor* jointsAccessor, const cg
} }
} }
static void BindGLTFPrimitivePose(Model* model, const cgltf_data* data, int primitiveIndex) static void BindGLTFPrimitiveToBones(Model* model, const cgltf_data* data, int primitiveIndex)
{ {
if ((*model).meshes[primitiveIndex].boneIds == NULL && data->nodes_count > 0) if (model->meshes[primitiveIndex].boneIds == NULL && data->nodes_count > 0)
{ {
for (int nodeId = 0; nodeId < data->nodes_count; nodeId++) for (int nodeId = 0; nodeId < data->nodes_count; nodeId++)
{ {
if (data->nodes[nodeId].mesh == &(data->meshes[primitiveIndex])) if (data->nodes[nodeId].mesh == &(data->meshes[primitiveIndex]))
{ {
(*model).meshes[primitiveIndex].boneIds = RL_CALLOC(4 * (*model).meshes[primitiveIndex].vertexCount, sizeof(int)); model->meshes[primitiveIndex].boneIds = RL_CALLOC(4 * model->meshes[primitiveIndex].vertexCount, sizeof(int));
(*model).meshes[primitiveIndex].boneWeights = RL_CALLOC(4 * (*model).meshes[primitiveIndex].vertexCount, sizeof(float)); model->meshes[primitiveIndex].boneWeights = RL_CALLOC(4 * model->meshes[primitiveIndex].vertexCount, sizeof(float));
for (int b = 0; b < 4 * (*model).meshes[primitiveIndex].vertexCount; b++) for (int b = 0; b < 4 * model->meshes[primitiveIndex].vertexCount; b++)
{ {
if(b % 4 == 0) if(b % 4 == 0)
{ {
(*model).meshes[primitiveIndex].boneIds[b] = nodeId; model->meshes[primitiveIndex].boneIds[b] = nodeId;
(*model).meshes[primitiveIndex].boneWeights[b] = 1.0f; model->meshes[primitiveIndex].boneWeights[b] = 1.0f;
} }
else else
{ {
(*model).meshes[primitiveIndex].boneIds[b] = 0; model->meshes[primitiveIndex].boneIds[b] = 0;
(*model).meshes[primitiveIndex].boneWeights[b] = 0.0f; model->meshes[primitiveIndex].boneWeights[b] = 0.0f;
} }
} }
@ -4132,30 +4132,30 @@ static void BindGLTFPrimitivePose(Model* model, const cgltf_data* data, int prim
int boneCounter = 0; int boneCounter = 0;
int boneId = 0; int boneId = 0;
for (int i = 0; i < (*model).meshes[primitiveIndex].vertexCount; i++) for (int i = 0; i < model->meshes[primitiveIndex].vertexCount; i++)
{ {
boneId = (*model).meshes[primitiveIndex].boneIds[boneCounter]; boneId = model->meshes[primitiveIndex].boneIds[boneCounter];
outTranslation = (*model).bindPose[boneId].translation; outTranslation = model->bindPose[boneId].translation;
outRotation = (*model).bindPose[boneId].rotation; outRotation = model->bindPose[boneId].rotation;
outScale = (*model).bindPose[boneId].scale; outScale = model->bindPose[boneId].scale;
// Vertices processing // Vertices processing
boundVertex = (Vector3){ (*model).meshes[primitiveIndex].vertices[vCounter], (*model).meshes[primitiveIndex].vertices[vCounter + 1], (*model).meshes[primitiveIndex].vertices[vCounter + 2] }; boundVertex = (Vector3){ model->meshes[primitiveIndex].vertices[vCounter], model->meshes[primitiveIndex].vertices[vCounter + 1], model->meshes[primitiveIndex].vertices[vCounter + 2] };
boundVertex = Vector3Multiply(boundVertex, outScale); boundVertex = Vector3Multiply(boundVertex, outScale);
boundVertex = Vector3RotateByQuaternion(boundVertex, outRotation); boundVertex = Vector3RotateByQuaternion(boundVertex, outRotation);
boundVertex = Vector3Add(boundVertex, outTranslation); boundVertex = Vector3Add(boundVertex, outTranslation);
(*model).meshes[primitiveIndex].vertices[vCounter] = boundVertex.x; model->meshes[primitiveIndex].vertices[vCounter] = boundVertex.x;
(*model).meshes[primitiveIndex].vertices[vCounter + 1] = boundVertex.y; model->meshes[primitiveIndex].vertices[vCounter + 1] = boundVertex.y;
(*model).meshes[primitiveIndex].vertices[vCounter + 2] = boundVertex.z; model->meshes[primitiveIndex].vertices[vCounter + 2] = boundVertex.z;
// Normals processing // Normals processing
if((*model).meshes[primitiveIndex].normals != NULL) if(model->meshes[primitiveIndex].normals != NULL)
{ {
boundNormal = (Vector3){ (*model).meshes[primitiveIndex].normals[vCounter], (*model).meshes[primitiveIndex].normals[vCounter + 1], (*model).meshes[primitiveIndex].normals[vCounter + 2] }; boundNormal = (Vector3){ model->meshes[primitiveIndex].normals[vCounter], model->meshes[primitiveIndex].normals[vCounter + 1], model->meshes[primitiveIndex].normals[vCounter + 2] };
boundNormal = Vector3RotateByQuaternion(boundNormal, outRotation); boundNormal = Vector3RotateByQuaternion(boundNormal, outRotation);
(*model).meshes[primitiveIndex].normals[vCounter] = boundNormal.x; model->meshes[primitiveIndex].normals[vCounter] = boundNormal.x;
(*model).meshes[primitiveIndex].normals[vCounter + 1] = boundNormal.y; model->meshes[primitiveIndex].normals[vCounter + 1] = boundNormal.y;
(*model).meshes[primitiveIndex].normals[vCounter + 2] = boundNormal.z; model->meshes[primitiveIndex].normals[vCounter + 2] = boundNormal.z;
} }
vCounter += 3; vCounter += 3;
@ -4172,45 +4172,45 @@ static void LoadGLTFModelIndices(Model* model, cgltf_accessor* indexAccessor, in
{ {
if (indexAccessor->component_type == cgltf_component_type_r_16u || indexAccessor->component_type == cgltf_component_type_r_16) if (indexAccessor->component_type == cgltf_component_type_r_16u || indexAccessor->component_type == cgltf_component_type_r_16)
{ {
(*model).meshes[primitiveIndex].triangleCount = (int)indexAccessor->count / 3; model->meshes[primitiveIndex].triangleCount = (int)indexAccessor->count / 3;
(*model).meshes[primitiveIndex].indices = RL_MALLOC((*model).meshes[primitiveIndex].triangleCount * 3 * sizeof(unsigned short)); model->meshes[primitiveIndex].indices = RL_MALLOC(model->meshes[primitiveIndex].triangleCount * 3 * sizeof(unsigned short));
unsigned short readValue = 0; unsigned short readValue = 0;
for(int a = 0; a < indexAccessor->count; a++) for(int a = 0; a < indexAccessor->count; a++)
{ {
GLTFReadValue(indexAccessor, a, &readValue, 1, sizeof(short)); GLTFReadValue(indexAccessor, a, &readValue, 1, sizeof(short));
(*model).meshes[primitiveIndex].indices[a] = readValue; model->meshes[primitiveIndex].indices[a] = readValue;
} }
} }
else if (indexAccessor->component_type == cgltf_component_type_r_8u || indexAccessor->component_type == cgltf_component_type_r_8) else if (indexAccessor->component_type == cgltf_component_type_r_8u || indexAccessor->component_type == cgltf_component_type_r_8)
{ {
(*model).meshes[primitiveIndex].triangleCount = (int)indexAccessor->count / 3; model->meshes[primitiveIndex].triangleCount = (int)indexAccessor->count / 3;
(*model).meshes[primitiveIndex].indices = RL_MALLOC((*model).meshes[primitiveIndex].triangleCount * 3 * sizeof(unsigned short)); model->meshes[primitiveIndex].indices = RL_MALLOC(model->meshes[primitiveIndex].triangleCount * 3 * sizeof(unsigned short));
unsigned char readValue = 0; unsigned char readValue = 0;
for(int a = 0; a < indexAccessor->count; a++) for(int a = 0; a < indexAccessor->count; a++)
{ {
GLTFReadValue(indexAccessor, a, &readValue, 1, sizeof(char)); GLTFReadValue(indexAccessor, a, &readValue, 1, sizeof(char));
(*model).meshes[primitiveIndex].indices[a] = (unsigned short)readValue; model->meshes[primitiveIndex].indices[a] = (unsigned short)readValue;
} }
} }
else if (indexAccessor->component_type == cgltf_component_type_r_32u) else if (indexAccessor->component_type == cgltf_component_type_r_32u)
{ {
(*model).meshes[primitiveIndex].triangleCount = (int)indexAccessor->count / 3; model->meshes[primitiveIndex].triangleCount = (int)indexAccessor->count / 3;
(*model).meshes[primitiveIndex].indices = RL_MALLOC((*model).meshes[primitiveIndex].triangleCount * 3 * sizeof(unsigned short)); model->meshes[primitiveIndex].indices = RL_MALLOC(model->meshes[primitiveIndex].triangleCount * 3 * sizeof(unsigned short));
unsigned int readValue; unsigned int readValue;
for(int a = 0; a < indexAccessor->count; a++) for(int a = 0; a < indexAccessor->count; a++)
{ {
GLTFReadValue(indexAccessor, a, &readValue, 1, sizeof(unsigned int)); GLTFReadValue(indexAccessor, a, &readValue, 1, sizeof(unsigned int));
(*model).meshes[primitiveIndex].indices[a] = (unsigned short)readValue; model->meshes[primitiveIndex].indices[a] = (unsigned short)readValue;
} }
} }
} }
else else
{ {
// Unindexed mesh // Unindexed mesh
(*model).meshes[primitiveIndex].triangleCount = (*model).meshes[primitiveIndex].vertexCount / 3; model->meshes[primitiveIndex].triangleCount = model->meshes[primitiveIndex].vertexCount / 3;
} }
} }