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;
|
||||
}
|
||||
|
|
|
|||
34
src/raylib.h
34
src/raylib.h
|
|
@ -308,17 +308,27 @@ typedef struct Camera {
|
|||
Vector3 up;
|
||||
} Camera;
|
||||
|
||||
// Bounding box type
|
||||
typedef struct BoundingBox {
|
||||
Vector3 min;
|
||||
Vector3 max;
|
||||
} BoundingBox;
|
||||
|
||||
// Vertex data definning a mesh
|
||||
// NOTE: If using OpenGL 1.1, data loaded in CPU; if OpenGL 3.3+ data loaded in GPU (vaoId)
|
||||
typedef struct VertexData {
|
||||
int vertexCount;
|
||||
float *vertices; // 3 components per vertex
|
||||
float *texcoords; // 2 components per vertex
|
||||
float *normals; // 3 components per vertex
|
||||
unsigned char *colors; // 4 components per vertex
|
||||
unsigned int vaoId;
|
||||
unsigned int vboId[4];
|
||||
} VertexData;
|
||||
typedef struct Mesh {
|
||||
int vertexCount; // num vertices
|
||||
float *vertices; // vertex position (XYZ - 3 components per vertex)
|
||||
float *texcoords; // vertex texture coordinates (UV - 2 components per vertex)
|
||||
float *texcoords2; // vertex second texture coordinates (useful for lightmaps)
|
||||
float *normals; // vertex normals (XYZ - 3 components per vertex)
|
||||
float *tangents; // vertex tangents (XYZ - 3 components per vertex)
|
||||
unsigned char *colors; // vertex colors (RGBA - 4 components per vertex)
|
||||
|
||||
BoundingBox bounds; // mesh limits defined by min and max points
|
||||
|
||||
unsigned int vaoId; // OpenGL Vertex Array Object id
|
||||
unsigned int vboId[6]; // OpenGL Vertex Buffer Objects id (6 types of vertex data)
|
||||
} Mesh;
|
||||
|
||||
// Shader type (generic shader)
|
||||
typedef struct Shader {
|
||||
|
|
@ -349,7 +359,7 @@ typedef struct Shader {
|
|||
|
||||
// 3d Model type
|
||||
typedef struct Model {
|
||||
VertexData mesh;
|
||||
Mesh mesh;
|
||||
Matrix transform;
|
||||
Texture2D texture; // Only for OpenGL 1.1, on newer versions this should be in the shader
|
||||
Shader shader;
|
||||
|
|
@ -742,7 +752,7 @@ void DrawGizmo(Vector3 position);
|
|||
// Model 3d Loading and Drawing Functions (Module: models)
|
||||
//------------------------------------------------------------------------------------
|
||||
Model LoadModel(const char *fileName); // Load a 3d model (.OBJ)
|
||||
Model LoadModelEx(VertexData data); // Load a 3d model (from vertex data)
|
||||
Model LoadModelEx(Mesh data); // Load a 3d model (from vertex data)
|
||||
//Model LoadModelFromRES(const char *rresName, int resId); // TODO: Load a 3d model from rRES file (raylib Resource)
|
||||
Model LoadHeightmap(Image heightmap, float maxHeight); // Load a heightmap image as a 3d model
|
||||
Model LoadCubicmap(Image cubicmap); // Load a map image as a 3d model (cubes based)
|
||||
|
|
|
|||
16
src/rlgl.c
16
src/rlgl.c
|
|
@ -1100,9 +1100,9 @@ void rlglInitPostpro(void)
|
|||
if (postproFbo.id > 0)
|
||||
{
|
||||
// Create a simple quad model to render fbo texture
|
||||
VertexData quadData;
|
||||
Mesh quad;
|
||||
|
||||
quadData.vertexCount = 6;
|
||||
quad.vertexCount = 6;
|
||||
|
||||
float w = (float)screenWidth;
|
||||
float h = (float)screenHeight;
|
||||
|
|
@ -1112,12 +1112,12 @@ void rlglInitPostpro(void)
|
|||
float quadNormals[6*3] = { 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f };
|
||||
unsigned char quadColors[6*4] = { 255 };
|
||||
|
||||
quadData.vertices = quadPositions;
|
||||
quadData.texcoords = quadTexcoords;
|
||||
quadData.normals = quadNormals;
|
||||
quadData.colors = quadColors;
|
||||
quad.vertices = quadPositions;
|
||||
quad.texcoords = quadTexcoords;
|
||||
quad.normals = quadNormals;
|
||||
quad.colors = quadColors;
|
||||
|
||||
postproQuad = rlglLoadModel(quadData);
|
||||
postproQuad = rlglLoadModel(quad);
|
||||
|
||||
// NOTE: postproFbo.colorTextureId must be assigned to postproQuad model shader
|
||||
}
|
||||
|
|
@ -1982,7 +1982,7 @@ void rlglGenerateMipmaps(Texture2D texture)
|
|||
}
|
||||
|
||||
// Load vertex data into a VAO (if supported) and VBO
|
||||
Model rlglLoadModel(VertexData mesh)
|
||||
Model rlglLoadModel(Mesh mesh)
|
||||
{
|
||||
Model model;
|
||||
|
||||
|
|
|
|||
29
src/rlgl.h
29
src/rlgl.h
|
|
@ -131,17 +131,22 @@ typedef enum { OPENGL_11 = 1, OPENGL_33, OPENGL_ES_20 } GlVersion;
|
|||
COMPRESSED_ASTC_8x8_RGBA // 2 bpp
|
||||
} TextureFormat;
|
||||
|
||||
// VertexData type
|
||||
// Mesh with vertex data type
|
||||
// NOTE: If using OpenGL 1.1, data loaded in CPU; if OpenGL 3.3+ data loaded in GPU (vaoId)
|
||||
typedef struct VertexData {
|
||||
int vertexCount;
|
||||
float *vertices; // 3 components per vertex
|
||||
float *texcoords; // 2 components per vertex
|
||||
float *normals; // 3 components per vertex
|
||||
unsigned char *colors;
|
||||
unsigned int vaoId;
|
||||
unsigned int vboId[4];
|
||||
} VertexData;
|
||||
typedef struct Mesh {
|
||||
int vertexCount; // num vertices
|
||||
float *vertices; // vertex position (XYZ - 3 components per vertex)
|
||||
float *texcoords; // vertex texture coordinates (UV - 2 components per vertex)
|
||||
float *texcoords2; // vertex second texture coordinates (useful for lightmaps)
|
||||
float *normals; // vertex normals (XYZ - 3 components per vertex)
|
||||
float *tangents; // vertex tangents (XYZ - 3 components per vertex)
|
||||
unsigned char *colors; // vertex colors (RGBA - 4 components per vertex)
|
||||
|
||||
BoundingBox bounds; // mesh limits defined by min and max points
|
||||
|
||||
unsigned int vaoId; // OpenGL Vertex Array Object id
|
||||
unsigned int vboId[6]; // OpenGL Vertex Buffer Objects id (6 types of vertex data)
|
||||
} Mesh;
|
||||
|
||||
// Shader type
|
||||
typedef struct Shader {
|
||||
|
|
@ -179,7 +184,7 @@ typedef enum { OPENGL_11 = 1, OPENGL_33, OPENGL_ES_20 } GlVersion;
|
|||
|
||||
// 3d Model type
|
||||
typedef struct Model {
|
||||
VertexData mesh;
|
||||
Mesh mesh;
|
||||
Matrix transform;
|
||||
Texture2D texture;
|
||||
Shader shader;
|
||||
|
|
@ -254,7 +259,7 @@ void rlglGenerateMipmaps(Texture2D texture); // Gene
|
|||
void rlglInitPostpro(void); // Initialize postprocessing system
|
||||
void rlglDrawPostpro(void); // Draw with postprocessing shader
|
||||
|
||||
Model rlglLoadModel(VertexData mesh); // Upload vertex data into GPU and provided VAO/VBO ids
|
||||
Model rlglLoadModel(Mesh mesh); // Upload vertex data into GPU and provided VAO/VBO ids
|
||||
void rlglDrawModel(Model model, Vector3 position, float rotationAngle, Vector3 rotationAxis, Vector3 scale, Color color, bool wires);
|
||||
|
||||
Vector3 rlglUnproject(Vector3 source, Matrix proj, Matrix view); // Get world coordinates from screen coordinates
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue