Rename VertexData struct to Mesh
Reviewed vertex type variables
This commit is contained in:
raysan5
parent
a640503119
commit
fd05d3e353
4 changed files with 171 additions and 156 deletions
248
src/models.c
248
src/models.c
|
|
@ -56,7 +56,7 @@ extern unsigned int whiteTexture;
|
|||
// Module specific Functions Declaration
|
||||
//----------------------------------------------------------------------------------
|
||||
static float GetHeightValue(Color pixel);
|
||||
static VertexData LoadOBJ(const char *fileName);
|
||||
static Mesh LoadOBJ(const char *fileName);
|
||||
|
||||
//----------------------------------------------------------------------------------
|
||||
// Module Functions Definition
|
||||
|
|
@ -558,23 +558,23 @@ void DrawGizmo(Vector3 position)
|
|||
Model LoadModel(const char *fileName)
|
||||
{
|
||||
Model model;
|
||||
VertexData vData = { 0 };
|
||||
Mesh mesh = { 0 };
|
||||
|
||||
// NOTE: Initialize default data for model in case loading fails, maybe a cube?
|
||||
|
||||
if (strcmp(GetExtension(fileName),"obj") == 0) vData = LoadOBJ(fileName);
|
||||
if (strcmp(GetExtension(fileName),"obj") == 0) mesh = LoadOBJ(fileName);
|
||||
else TraceLog(WARNING, "[%s] Model extension not recognized, it can't be loaded", fileName);
|
||||
|
||||
// NOTE: At this point we have all vertex, texcoord, normal data for the model in vData struct
|
||||
// NOTE: At this point we have all vertex, texcoord, normal data for the model in mesh struct
|
||||
|
||||
if (vData.vertexCount == 0)
|
||||
if (mesh.vertexCount == 0)
|
||||
{
|
||||
TraceLog(WARNING, "Model could not be loaded");
|
||||
}
|
||||
else
|
||||
{
|
||||
// NOTE: model properties (transform, texture, shader) are initialized inside rlglLoadModel()
|
||||
model = rlglLoadModel(vData); // Upload vertex data to GPU
|
||||
model = rlglLoadModel(mesh); // Upload vertex data to GPU
|
||||
|
||||
// Now that vertex data is uploaded to GPU, we can free arrays
|
||||
// NOTE 1: We don't need CPU vertex data on OpenGL 3.3 or ES2... for static meshes...
|
||||
|
|
@ -583,10 +583,10 @@ Model LoadModel(const char *fileName)
|
|||
/*
|
||||
if (rlGetVersion() != OPENGL_11)
|
||||
{
|
||||
free(vData.vertices);
|
||||
free(vData.texcoords);
|
||||
free(vData.normals);
|
||||
free(vData.colors);
|
||||
free(mesh.vertices);
|
||||
free(mesh.texcoords);
|
||||
free(mesh.normals);
|
||||
free(mesh.colors);
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
|
@ -595,7 +595,7 @@ Model LoadModel(const char *fileName)
|
|||
}
|
||||
|
||||
// Load a 3d model (from vertex data)
|
||||
Model LoadModelEx(VertexData data)
|
||||
Model LoadModelEx(Mesh data)
|
||||
{
|
||||
Model model;
|
||||
|
||||
|
|
@ -610,7 +610,7 @@ Model LoadModelEx(VertexData data)
|
|||
// Load a heightmap image as a 3d model
|
||||
Model LoadHeightmap(Image heightmap, float maxHeight)
|
||||
{
|
||||
VertexData vData;
|
||||
Mesh mesh;
|
||||
|
||||
int mapX = heightmap.width;
|
||||
int mapZ = heightmap.height;
|
||||
|
|
@ -621,12 +621,12 @@ Model LoadHeightmap(Image heightmap, float maxHeight)
|
|||
// TODO: Consider resolution when generating model data?
|
||||
int numTriangles = (mapX-1)*(mapZ-1)*2; // One quad every four pixels
|
||||
|
||||
vData.vertexCount = numTriangles*3;
|
||||
mesh.vertexCount = numTriangles*3;
|
||||
|
||||
vData.vertices = (float *)malloc(vData.vertexCount*3*sizeof(float));
|
||||
vData.normals = (float *)malloc(vData.vertexCount*3*sizeof(float));
|
||||
vData.texcoords = (float *)malloc(vData.vertexCount*2*sizeof(float));
|
||||
vData.colors = (unsigned char *)malloc(vData.vertexCount*4*sizeof(unsigned char)); // Not used...
|
||||
mesh.vertices = (float *)malloc(mesh.vertexCount*3*sizeof(float));
|
||||
mesh.normals = (float *)malloc(mesh.vertexCount*3*sizeof(float));
|
||||
mesh.texcoords = (float *)malloc(mesh.vertexCount*2*sizeof(float));
|
||||
mesh.colors = (unsigned char *)malloc(mesh.vertexCount*4*sizeof(unsigned char)); // Not used...
|
||||
|
||||
int vCounter = 0; // Used to count vertices float by float
|
||||
int tcCounter = 0; // Used to count texcoords float by float
|
||||
|
|
@ -644,51 +644,51 @@ Model LoadHeightmap(Image heightmap, float maxHeight)
|
|||
//----------------------------------------------------------
|
||||
|
||||
// one triangle - 3 vertex
|
||||
vData.vertices[vCounter] = x;
|
||||
vData.vertices[vCounter + 1] = GetHeightValue(heightmapPixels[x + z*mapX])*scaleFactor;
|
||||
vData.vertices[vCounter + 2] = z;
|
||||
mesh.vertices[vCounter] = x;
|
||||
mesh.vertices[vCounter + 1] = GetHeightValue(heightmapPixels[x + z*mapX])*scaleFactor;
|
||||
mesh.vertices[vCounter + 2] = z;
|
||||
|
||||
vData.vertices[vCounter + 3] = x;
|
||||
vData.vertices[vCounter + 4] = GetHeightValue(heightmapPixels[x + (z+1)*mapX])*scaleFactor;
|
||||
vData.vertices[vCounter + 5] = z+1;
|
||||
mesh.vertices[vCounter + 3] = x;
|
||||
mesh.vertices[vCounter + 4] = GetHeightValue(heightmapPixels[x + (z+1)*mapX])*scaleFactor;
|
||||
mesh.vertices[vCounter + 5] = z+1;
|
||||
|
||||
vData.vertices[vCounter + 6] = x+1;
|
||||
vData.vertices[vCounter + 7] = GetHeightValue(heightmapPixels[(x+1) + z*mapX])*scaleFactor;
|
||||
vData.vertices[vCounter + 8] = z;
|
||||
mesh.vertices[vCounter + 6] = x+1;
|
||||
mesh.vertices[vCounter + 7] = GetHeightValue(heightmapPixels[(x+1) + z*mapX])*scaleFactor;
|
||||
mesh.vertices[vCounter + 8] = z;
|
||||
|
||||
// another triangle - 3 vertex
|
||||
vData.vertices[vCounter + 9] = vData.vertices[vCounter + 6];
|
||||
vData.vertices[vCounter + 10] = vData.vertices[vCounter + 7];
|
||||
vData.vertices[vCounter + 11] = vData.vertices[vCounter + 8];
|
||||
mesh.vertices[vCounter + 9] = mesh.vertices[vCounter + 6];
|
||||
mesh.vertices[vCounter + 10] = mesh.vertices[vCounter + 7];
|
||||
mesh.vertices[vCounter + 11] = mesh.vertices[vCounter + 8];
|
||||
|
||||
vData.vertices[vCounter + 12] = vData.vertices[vCounter + 3];
|
||||
vData.vertices[vCounter + 13] = vData.vertices[vCounter + 4];
|
||||
vData.vertices[vCounter + 14] = vData.vertices[vCounter + 5];
|
||||
mesh.vertices[vCounter + 12] = mesh.vertices[vCounter + 3];
|
||||
mesh.vertices[vCounter + 13] = mesh.vertices[vCounter + 4];
|
||||
mesh.vertices[vCounter + 14] = mesh.vertices[vCounter + 5];
|
||||
|
||||
vData.vertices[vCounter + 15] = x+1;
|
||||
vData.vertices[vCounter + 16] = GetHeightValue(heightmapPixels[(x+1) + (z+1)*mapX])*scaleFactor;
|
||||
vData.vertices[vCounter + 17] = z+1;
|
||||
mesh.vertices[vCounter + 15] = x+1;
|
||||
mesh.vertices[vCounter + 16] = GetHeightValue(heightmapPixels[(x+1) + (z+1)*mapX])*scaleFactor;
|
||||
mesh.vertices[vCounter + 17] = z+1;
|
||||
vCounter += 18; // 6 vertex, 18 floats
|
||||
|
||||
// Fill texcoords array with data
|
||||
//--------------------------------------------------------------
|
||||
vData.texcoords[tcCounter] = (float)x / (mapX-1);
|
||||
vData.texcoords[tcCounter + 1] = (float)z / (mapZ-1);
|
||||
mesh.texcoords[tcCounter] = (float)x / (mapX-1);
|
||||
mesh.texcoords[tcCounter + 1] = (float)z / (mapZ-1);
|
||||
|
||||
vData.texcoords[tcCounter + 2] = (float)x / (mapX-1);
|
||||
vData.texcoords[tcCounter + 3] = (float)(z+1) / (mapZ-1);
|
||||
mesh.texcoords[tcCounter + 2] = (float)x / (mapX-1);
|
||||
mesh.texcoords[tcCounter + 3] = (float)(z+1) / (mapZ-1);
|
||||
|
||||
vData.texcoords[tcCounter + 4] = (float)(x+1) / (mapX-1);
|
||||
vData.texcoords[tcCounter + 5] = (float)z / (mapZ-1);
|
||||
mesh.texcoords[tcCounter + 4] = (float)(x+1) / (mapX-1);
|
||||
mesh.texcoords[tcCounter + 5] = (float)z / (mapZ-1);
|
||||
|
||||
vData.texcoords[tcCounter + 6] = vData.texcoords[tcCounter + 4];
|
||||
vData.texcoords[tcCounter + 7] = vData.texcoords[tcCounter + 5];
|
||||
mesh.texcoords[tcCounter + 6] = mesh.texcoords[tcCounter + 4];
|
||||
mesh.texcoords[tcCounter + 7] = mesh.texcoords[tcCounter + 5];
|
||||
|
||||
vData.texcoords[tcCounter + 8] = vData.texcoords[tcCounter + 2];
|
||||
vData.texcoords[tcCounter + 9] = vData.texcoords[tcCounter + 3];
|
||||
mesh.texcoords[tcCounter + 8] = mesh.texcoords[tcCounter + 2];
|
||||
mesh.texcoords[tcCounter + 9] = mesh.texcoords[tcCounter + 3];
|
||||
|
||||
vData.texcoords[tcCounter + 10] = (float)(x+1) / (mapX-1);
|
||||
vData.texcoords[tcCounter + 11] = (float)(z+1) / (mapZ-1);
|
||||
mesh.texcoords[tcCounter + 10] = (float)(x+1) / (mapX-1);
|
||||
mesh.texcoords[tcCounter + 11] = (float)(z+1) / (mapZ-1);
|
||||
tcCounter += 12; // 6 texcoords, 12 floats
|
||||
|
||||
// Fill normals array with data
|
||||
|
|
@ -696,9 +696,9 @@ Model LoadHeightmap(Image heightmap, float maxHeight)
|
|||
// NOTE: Current Model implementation doe not use normals!
|
||||
for (int i = 0; i < 18; i += 3)
|
||||
{
|
||||
vData.normals[nCounter + i] = 0.0f;
|
||||
vData.normals[nCounter + i + 1] = 1.0f;
|
||||
vData.normals[nCounter + i + 2] = 0.0f;
|
||||
mesh.normals[nCounter + i] = 0.0f;
|
||||
mesh.normals[nCounter + i + 1] = 1.0f;
|
||||
mesh.normals[nCounter + i + 2] = 0.0f;
|
||||
}
|
||||
|
||||
// TODO: Calculate normals in an efficient way
|
||||
|
|
@ -713,20 +713,20 @@ Model LoadHeightmap(Image heightmap, float maxHeight)
|
|||
|
||||
// Fill color data
|
||||
// NOTE: Not used any more... just one plain color defined at DrawModel()
|
||||
for (int i = 0; i < (4*vData.vertexCount); i++) vData.colors[i] = 255;
|
||||
for (int i = 0; i < (4*mesh.vertexCount); i++) mesh.colors[i] = 255;
|
||||
|
||||
// NOTE: At this point we have all vertex, texcoord, normal data for the model in vData struct
|
||||
// NOTE: At this point we have all vertex, texcoord, normal data for the model in mesh struct
|
||||
|
||||
Model model = rlglLoadModel(vData);
|
||||
Model model = rlglLoadModel(mesh);
|
||||
|
||||
// Now that vertex data is uploaded to GPU, we can free arrays
|
||||
// NOTE: We don't need CPU vertex data on OpenGL 3.3 or ES2
|
||||
if (rlGetVersion() != OPENGL_11)
|
||||
{
|
||||
free(vData.vertices);
|
||||
free(vData.texcoords);
|
||||
free(vData.normals);
|
||||
free(vData.colors);
|
||||
free(mesh.vertices);
|
||||
free(mesh.texcoords);
|
||||
free(mesh.normals);
|
||||
free(mesh.colors);
|
||||
}
|
||||
|
||||
return model;
|
||||
|
|
@ -735,7 +735,7 @@ Model LoadHeightmap(Image heightmap, float maxHeight)
|
|||
// Load a map image as a 3d model (cubes based)
|
||||
Model LoadCubicmap(Image cubicmap)
|
||||
{
|
||||
VertexData vData;
|
||||
Mesh mesh;
|
||||
|
||||
Color *cubicmapPixels = GetImageData(cubicmap);
|
||||
|
||||
|
|
@ -1041,25 +1041,25 @@ Model LoadCubicmap(Image cubicmap)
|
|||
}
|
||||
|
||||
// Move data from mapVertices temp arays to vertices float array
|
||||
vData.vertexCount = vCounter;
|
||||
mesh.vertexCount = vCounter;
|
||||
|
||||
vData.vertices = (float *)malloc(vData.vertexCount*3*sizeof(float));
|
||||
vData.normals = (float *)malloc(vData.vertexCount*3*sizeof(float));
|
||||
vData.texcoords = (float *)malloc(vData.vertexCount*2*sizeof(float));
|
||||
vData.colors = (unsigned char *)malloc(vData.vertexCount*4*sizeof(unsigned char)); // Not used...
|
||||
mesh.vertices = (float *)malloc(mesh.vertexCount*3*sizeof(float));
|
||||
mesh.normals = (float *)malloc(mesh.vertexCount*3*sizeof(float));
|
||||
mesh.texcoords = (float *)malloc(mesh.vertexCount*2*sizeof(float));
|
||||
mesh.colors = (unsigned char *)malloc(mesh.vertexCount*4*sizeof(unsigned char)); // Not used...
|
||||
|
||||
// Fill color data
|
||||
// NOTE: Not used any more... just one plain color defined at DrawModel()
|
||||
for (int i = 0; i < (4*vData.vertexCount); i++) vData.colors[i] = 255;
|
||||
for (int i = 0; i < (4*mesh.vertexCount); i++) mesh.colors[i] = 255;
|
||||
|
||||
int fCounter = 0;
|
||||
|
||||
// Move vertices data
|
||||
for (int i = 0; i < vCounter; i++)
|
||||
{
|
||||
vData.vertices[fCounter] = mapVertices[i].x;
|
||||
vData.vertices[fCounter + 1] = mapVertices[i].y;
|
||||
vData.vertices[fCounter + 2] = mapVertices[i].z;
|
||||
mesh.vertices[fCounter] = mapVertices[i].x;
|
||||
mesh.vertices[fCounter + 1] = mapVertices[i].y;
|
||||
mesh.vertices[fCounter + 2] = mapVertices[i].z;
|
||||
fCounter += 3;
|
||||
}
|
||||
|
||||
|
|
@ -1068,9 +1068,9 @@ Model LoadCubicmap(Image cubicmap)
|
|||
// Move normals data
|
||||
for (int i = 0; i < nCounter; i++)
|
||||
{
|
||||
vData.normals[fCounter] = mapNormals[i].x;
|
||||
vData.normals[fCounter + 1] = mapNormals[i].y;
|
||||
vData.normals[fCounter + 2] = mapNormals[i].z;
|
||||
mesh.normals[fCounter] = mapNormals[i].x;
|
||||
mesh.normals[fCounter + 1] = mapNormals[i].y;
|
||||
mesh.normals[fCounter + 2] = mapNormals[i].z;
|
||||
fCounter += 3;
|
||||
}
|
||||
|
||||
|
|
@ -1079,8 +1079,8 @@ Model LoadCubicmap(Image cubicmap)
|
|||
// Move texcoords data
|
||||
for (int i = 0; i < tcCounter; i++)
|
||||
{
|
||||
vData.texcoords[fCounter] = mapTexcoords[i].x;
|
||||
vData.texcoords[fCounter + 1] = mapTexcoords[i].y;
|
||||
mesh.texcoords[fCounter] = mapTexcoords[i].x;
|
||||
mesh.texcoords[fCounter + 1] = mapTexcoords[i].y;
|
||||
fCounter += 2;
|
||||
}
|
||||
|
||||
|
|
@ -1090,18 +1090,18 @@ Model LoadCubicmap(Image cubicmap)
|
|||
|
||||
free(cubicmapPixels);
|
||||
|
||||
// NOTE: At this point we have all vertex, texcoord, normal data for the model in vData struct
|
||||
// NOTE: At this point we have all vertex, texcoord, normal data for the model in mesh struct
|
||||
|
||||
Model model = rlglLoadModel(vData);
|
||||
Model model = rlglLoadModel(mesh);
|
||||
|
||||
// Now that vertex data is uploaded to GPU, we can free arrays
|
||||
// NOTE: We don't need CPU vertex data on OpenGL 3.3 or ES2
|
||||
if (rlGetVersion() != OPENGL_11)
|
||||
{
|
||||
free(vData.vertices);
|
||||
free(vData.texcoords);
|
||||
free(vData.normals);
|
||||
free(vData.colors);
|
||||
free(mesh.vertices);
|
||||
free(mesh.texcoords);
|
||||
free(mesh.normals);
|
||||
free(mesh.colors);
|
||||
}
|
||||
|
||||
return model;
|
||||
|
|
@ -1617,9 +1617,9 @@ static float GetHeightValue(Color pixel)
|
|||
}
|
||||
|
||||
// Load OBJ mesh data
|
||||
static VertexData LoadOBJ(const char *fileName)
|
||||
static Mesh LoadOBJ(const char *fileName)
|
||||
{
|
||||
VertexData vData = { 0 };
|
||||
Mesh mesh = { 0 };
|
||||
|
||||
char dataType;
|
||||
char comments[200];
|
||||
|
|
@ -1636,7 +1636,7 @@ static VertexData LoadOBJ(const char *fileName)
|
|||
if (objFile == NULL)
|
||||
{
|
||||
TraceLog(WARNING, "[%s] OBJ file could not be opened", fileName);
|
||||
return vData;
|
||||
return mesh;
|
||||
}
|
||||
|
||||
// First reading pass: Get numVertex, numNormals, numTexCoords, numTriangles
|
||||
|
|
@ -1747,15 +1747,15 @@ static VertexData LoadOBJ(const char *fileName)
|
|||
}
|
||||
|
||||
// At this point all vertex data (v, vt, vn) has been gathered on midVertices, midTexCoords, midNormals
|
||||
// Now we can organize that data into our VertexData struct
|
||||
// Now we can organize that data into our Mesh struct
|
||||
|
||||
vData.vertexCount = numTriangles*3;
|
||||
mesh.vertexCount = numTriangles*3;
|
||||
|
||||
// Additional arrays to store vertex data as floats
|
||||
vData.vertices = (float *)malloc(vData.vertexCount*3*sizeof(float));
|
||||
vData.texcoords = (float *)malloc(vData.vertexCount*2*sizeof(float));
|
||||
vData.normals = (float *)malloc(vData.vertexCount*3*sizeof(float));
|
||||
vData.colors = (unsigned char *)malloc(vData.vertexCount*4*sizeof(unsigned char));
|
||||
mesh.vertices = (float *)malloc(mesh.vertexCount*3*sizeof(float));
|
||||
mesh.texcoords = (float *)malloc(mesh.vertexCount*2*sizeof(float));
|
||||
mesh.normals = (float *)malloc(mesh.vertexCount*3*sizeof(float));
|
||||
mesh.colors = (unsigned char *)malloc(mesh.vertexCount*4*sizeof(unsigned char));
|
||||
|
||||
int vCounter = 0; // Used to count vertices float by float
|
||||
int tcCounter = 0; // Used to count texcoords float by float
|
||||
|
|
@ -1783,32 +1783,32 @@ static VertexData LoadOBJ(const char *fileName)
|
|||
else if (numNormals == 0) fscanf(objFile, "%i/%i %i/%i %i/%i", &vNum[0], &vtNum[0], &vNum[1], &vtNum[1], &vNum[2], &vtNum[2]);
|
||||
else fscanf(objFile, "%i/%i/%i %i/%i/%i %i/%i/%i", &vNum[0], &vtNum[0], &vnNum[0], &vNum[1], &vtNum[1], &vnNum[1], &vNum[2], &vtNum[2], &vnNum[2]);
|
||||
|
||||
vData.vertices[vCounter] = midVertices[vNum[0]-1].x;
|
||||
vData.vertices[vCounter + 1] = midVertices[vNum[0]-1].y;
|
||||
vData.vertices[vCounter + 2] = midVertices[vNum[0]-1].z;
|
||||
mesh.vertices[vCounter] = midVertices[vNum[0]-1].x;
|
||||
mesh.vertices[vCounter + 1] = midVertices[vNum[0]-1].y;
|
||||
mesh.vertices[vCounter + 2] = midVertices[vNum[0]-1].z;
|
||||
vCounter += 3;
|
||||
vData.vertices[vCounter] = midVertices[vNum[1]-1].x;
|
||||
vData.vertices[vCounter + 1] = midVertices[vNum[1]-1].y;
|
||||
vData.vertices[vCounter + 2] = midVertices[vNum[1]-1].z;
|
||||
mesh.vertices[vCounter] = midVertices[vNum[1]-1].x;
|
||||
mesh.vertices[vCounter + 1] = midVertices[vNum[1]-1].y;
|
||||
mesh.vertices[vCounter + 2] = midVertices[vNum[1]-1].z;
|
||||
vCounter += 3;
|
||||
vData.vertices[vCounter] = midVertices[vNum[2]-1].x;
|
||||
vData.vertices[vCounter + 1] = midVertices[vNum[2]-1].y;
|
||||
vData.vertices[vCounter + 2] = midVertices[vNum[2]-1].z;
|
||||
mesh.vertices[vCounter] = midVertices[vNum[2]-1].x;
|
||||
mesh.vertices[vCounter + 1] = midVertices[vNum[2]-1].y;
|
||||
mesh.vertices[vCounter + 2] = midVertices[vNum[2]-1].z;
|
||||
vCounter += 3;
|
||||
|
||||
if (numNormals > 0)
|
||||
{
|
||||
vData.normals[nCounter] = midNormals[vnNum[0]-1].x;
|
||||
vData.normals[nCounter + 1] = midNormals[vnNum[0]-1].y;
|
||||
vData.normals[nCounter + 2] = midNormals[vnNum[0]-1].z;
|
||||
mesh.normals[nCounter] = midNormals[vnNum[0]-1].x;
|
||||
mesh.normals[nCounter + 1] = midNormals[vnNum[0]-1].y;
|
||||
mesh.normals[nCounter + 2] = midNormals[vnNum[0]-1].z;
|
||||
nCounter += 3;
|
||||
vData.normals[nCounter] = midNormals[vnNum[1]-1].x;
|
||||
vData.normals[nCounter + 1] = midNormals[vnNum[1]-1].y;
|
||||
vData.normals[nCounter + 2] = midNormals[vnNum[1]-1].z;
|
||||
mesh.normals[nCounter] = midNormals[vnNum[1]-1].x;
|
||||
mesh.normals[nCounter + 1] = midNormals[vnNum[1]-1].y;
|
||||
mesh.normals[nCounter + 2] = midNormals[vnNum[1]-1].z;
|
||||
nCounter += 3;
|
||||
vData.normals[nCounter] = midNormals[vnNum[2]-1].x;
|
||||
vData.normals[nCounter + 1] = midNormals[vnNum[2]-1].y;
|
||||
vData.normals[nCounter + 2] = midNormals[vnNum[2]-1].z;
|
||||
mesh.normals[nCounter] = midNormals[vnNum[2]-1].x;
|
||||
mesh.normals[nCounter + 1] = midNormals[vnNum[2]-1].y;
|
||||
mesh.normals[nCounter + 2] = midNormals[vnNum[2]-1].z;
|
||||
nCounter += 3;
|
||||
}
|
||||
else
|
||||
|
|
@ -1817,17 +1817,17 @@ static VertexData LoadOBJ(const char *fileName)
|
|||
Vector3 norm = VectorCrossProduct(VectorSubtract(midVertices[vNum[1]-1], midVertices[vNum[0]-1]), VectorSubtract(midVertices[vNum[2]-1], midVertices[vNum[0]-1]));
|
||||
VectorNormalize(&norm);
|
||||
|
||||
vData.normals[nCounter] = norm.x;
|
||||
vData.normals[nCounter + 1] = norm.y;
|
||||
vData.normals[nCounter + 2] = norm.z;
|
||||
mesh.normals[nCounter] = norm.x;
|
||||
mesh.normals[nCounter + 1] = norm.y;
|
||||
mesh.normals[nCounter + 2] = norm.z;
|
||||
nCounter += 3;
|
||||
vData.normals[nCounter] = norm.x;
|
||||
vData.normals[nCounter + 1] = norm.y;
|
||||
vData.normals[nCounter + 2] = norm.z;
|
||||
mesh.normals[nCounter] = norm.x;
|
||||
mesh.normals[nCounter + 1] = norm.y;
|
||||
mesh.normals[nCounter + 2] = norm.z;
|
||||
nCounter += 3;
|
||||
vData.normals[nCounter] = norm.x;
|
||||
vData.normals[nCounter + 1] = norm.y;
|
||||
vData.normals[nCounter + 2] = norm.z;
|
||||
mesh.normals[nCounter] = norm.x;
|
||||
mesh.normals[nCounter + 1] = norm.y;
|
||||
mesh.normals[nCounter + 2] = norm.z;
|
||||
nCounter += 3;
|
||||
}
|
||||
|
||||
|
|
@ -1835,14 +1835,14 @@ static VertexData LoadOBJ(const char *fileName)
|
|||
{
|
||||
// NOTE: If using negative texture coordinates with a texture filter of GL_CLAMP_TO_EDGE doesn't work!
|
||||
// NOTE: Texture coordinates are Y flipped upside-down
|
||||
vData.texcoords[tcCounter] = midTexCoords[vtNum[0]-1].x;
|
||||
vData.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtNum[0]-1].y;
|
||||
mesh.texcoords[tcCounter] = midTexCoords[vtNum[0]-1].x;
|
||||
mesh.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtNum[0]-1].y;
|
||||
tcCounter += 2;
|
||||
vData.texcoords[tcCounter] = midTexCoords[vtNum[1]-1].x;
|
||||
vData.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtNum[1]-1].y;
|
||||
mesh.texcoords[tcCounter] = midTexCoords[vtNum[1]-1].x;
|
||||
mesh.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtNum[1]-1].y;
|
||||
tcCounter += 2;
|
||||
vData.texcoords[tcCounter] = midTexCoords[vtNum[2]-1].x;
|
||||
vData.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtNum[2]-1].y;
|
||||
mesh.texcoords[tcCounter] = midTexCoords[vtNum[2]-1].x;
|
||||
mesh.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtNum[2]-1].y;
|
||||
tcCounter += 2;
|
||||
}
|
||||
} break;
|
||||
|
|
@ -1853,19 +1853,19 @@ static VertexData LoadOBJ(const char *fileName)
|
|||
fclose(objFile);
|
||||
|
||||
// Security check, just in case no normals or no texcoords defined in OBJ
|
||||
if (numTexCoords == 0) for (int i = 0; i < (2*vData.vertexCount); i++) vData.texcoords[i] = 0.0f;
|
||||
if (numTexCoords == 0) for (int i = 0; i < (2*mesh.vertexCount); i++) mesh.texcoords[i] = 0.0f;
|
||||
|
||||
// NOTE: We set all vertex colors to white
|
||||
// NOTE: Not used any more... just one plain color defined at DrawModel()
|
||||
for (int i = 0; i < (4*vData.vertexCount); i++) vData.colors[i] = 255;
|
||||
for (int i = 0; i < (4*mesh.vertexCount); i++) mesh.colors[i] = 255;
|
||||
|
||||
// Now we can free temp mid* arrays
|
||||
free(midVertices);
|
||||
free(midNormals);
|
||||
free(midTexCoords);
|
||||
|
||||
// NOTE: At this point we have all vertex, texcoord, normal data for the model in vData struct
|
||||
// NOTE: At this point we have all vertex, texcoord, normal data for the model in mesh struct
|
||||
TraceLog(INFO, "[%s] Model loaded successfully in RAM (CPU)", fileName);
|
||||
|
||||
return vData;
|
||||
return mesh;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue