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

Remove end-line spaces

Browse Source
This commit is contained in:
Ray 2019-02-21 18:45:19 +01:00
parent 75298b50fb
commit 641895b5ba
7 changed files with 220 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/core.c
View File

@ -707,7 +707,7 @@ bool WindowShouldClose(void)
{ {
#if defined(PLATFORM_WEB) #if defined(PLATFORM_WEB)
// Emterpreter-Async required to run sync code // Emterpreter-Async required to run sync code
// https://github.com/kripken/emscripten/wiki/Emterpreter#emterpreter-async-run-synchronous-code // https://github.com/emscripten-core/emscripten/wiki/Emterpreter#emterpreter-async-run-synchronous-code
// By default, this function is never called on a web-ready raylib example because we encapsulate // By default, this function is never called on a web-ready raylib example because we encapsulate
// frame code in a UpdateDrawFrame() function, to allow browser manage execution asynchronously // frame code in a UpdateDrawFrame() function, to allow browser manage execution asynchronously
// but now emscripten allows sync code to be executed in an interpreted way, using emterpreter! // but now emscripten allows sync code to be executed in an interpreted way, using emterpreter!
@ -1228,7 +1228,7 @@ void BeginTextureMode(RenderTexture2D target)
rlLoadIdentity(); // Reset current matrix (MODELVIEW) rlLoadIdentity(); // Reset current matrix (MODELVIEW)
//rlScalef(0.0f, -1.0f, 0.0f); // Flip Y-drawing (?) //rlScalef(0.0f, -1.0f, 0.0f); // Flip Y-drawing (?)
// Setup current width/height for proper aspect ratio // Setup current width/height for proper aspect ratio
// calculation when using BeginMode3D() // calculation when using BeginMode3D()
currentWidth = target.texture.width; currentWidth = target.texture.width;
@ -1254,7 +1254,7 @@ void EndTextureMode(void)
rlMatrixMode(RL_MODELVIEW); // Switch back to MODELVIEW matrix rlMatrixMode(RL_MODELVIEW); // Switch back to MODELVIEW matrix
rlLoadIdentity(); // Reset current matrix (MODELVIEW) rlLoadIdentity(); // Reset current matrix (MODELVIEW)
// Reset current screen size // Reset current screen size
currentWidth = GetScreenWidth(); currentWidth = GetScreenWidth();
currentHeight = GetScreenHeight(); currentHeight = GetScreenHeight();

208
src/models.c
View File

@ -116,7 +116,7 @@ void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color)
void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color) void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color)
{ {
if (rlCheckBufferLimit(2*36)) rlglDraw(); if (rlCheckBufferLimit(2*36)) rlglDraw();
rlPushMatrix(); rlPushMatrix();
rlTranslatef(center.x, center.y, center.z); rlTranslatef(center.x, center.y, center.z);
rlRotatef(rotationAngle, rotationAxis.x, rotationAxis.y, rotationAxis.z); rlRotatef(rotationAngle, rotationAxis.x, rotationAxis.y, rotationAxis.z);
@ -140,7 +140,7 @@ void DrawCube(Vector3 position, float width, float height, float length, Color c
float x = 0.0f; float x = 0.0f;
float y = 0.0f; float y = 0.0f;
float z = 0.0f; float z = 0.0f;
if (rlCheckBufferLimit(36)) rlglDraw(); if (rlCheckBufferLimit(36)) rlglDraw();
rlPushMatrix(); rlPushMatrix();
@ -221,7 +221,7 @@ void DrawCubeWires(Vector3 position, float width, float height, float length, Co
float x = 0.0f; float x = 0.0f;
float y = 0.0f; float y = 0.0f;
float z = 0.0f; float z = 0.0f;
if (rlCheckBufferLimit(36)) rlglDraw(); if (rlCheckBufferLimit(36)) rlglDraw();
rlPushMatrix(); rlPushMatrix();
@ -626,7 +626,7 @@ Model LoadModel(const char *fileName)
Model LoadModelFromMesh(Mesh mesh) Model LoadModelFromMesh(Mesh mesh)
{ {
Model model = { 0 }; Model model = { 0 };
model.mesh = mesh; model.mesh = mesh;
model.transform = MatrixIdentity(); model.transform = MatrixIdentity();
model.material = LoadMaterialDefault(); model.material = LoadMaterialDefault();
@ -679,11 +679,11 @@ void UnloadMesh(Mesh *mesh)
void ExportMesh(Mesh mesh, const char *fileName) void ExportMesh(Mesh mesh, const char *fileName)
{ {
bool success = false; bool success = false;
if (IsFileExtension(fileName, ".obj")) if (IsFileExtension(fileName, ".obj"))
{ {
FILE *objFile = fopen(fileName, "wt"); FILE *objFile = fopen(fileName, "wt");
fprintf(objFile, "# //////////////////////////////////////////////////////////////////////////////////\n"); fprintf(objFile, "# //////////////////////////////////////////////////////////////////////////////////\n");
fprintf(objFile, "# // //\n"); fprintf(objFile, "# // //\n");
fprintf(objFile, "# // rMeshOBJ exporter v1.0 - Mesh exported as triangle faces and not optimized //\n"); fprintf(objFile, "# // rMeshOBJ exporter v1.0 - Mesh exported as triangle faces and not optimized //\n");
@ -696,33 +696,33 @@ void ExportMesh(Mesh mesh, const char *fileName)
fprintf(objFile, "# //////////////////////////////////////////////////////////////////////////////////\n\n"); fprintf(objFile, "# //////////////////////////////////////////////////////////////////////////////////\n\n");
fprintf(objFile, "# Vertex Count: %i\n", mesh.vertexCount); fprintf(objFile, "# Vertex Count: %i\n", mesh.vertexCount);
fprintf(objFile, "# Triangle Count: %i\n\n", mesh.triangleCount); fprintf(objFile, "# Triangle Count: %i\n\n", mesh.triangleCount);
fprintf(objFile, "g mesh\n"); fprintf(objFile, "g mesh\n");
for (int i = 0, v = 0; i < mesh.vertexCount; i++, v += 3) for (int i = 0, v = 0; i < mesh.vertexCount; i++, v += 3)
{ {
fprintf(objFile, "v %.2f %.2f %.2f\n", mesh.vertices[v], mesh.vertices[v + 1], mesh.vertices[v + 2]); fprintf(objFile, "v %.2f %.2f %.2f\n", mesh.vertices[v], mesh.vertices[v + 1], mesh.vertices[v + 2]);
} }
for (int i = 0, v = 0; i < mesh.vertexCount; i++, v += 2) for (int i = 0, v = 0; i < mesh.vertexCount; i++, v += 2)
{ {
fprintf(objFile, "vt %.2f %.2f\n", mesh.texcoords[v], mesh.texcoords[v + 1]); fprintf(objFile, "vt %.2f %.2f\n", mesh.texcoords[v], mesh.texcoords[v + 1]);
} }
for (int i = 0, v = 0; i < mesh.vertexCount; i++, v += 3) for (int i = 0, v = 0; i < mesh.vertexCount; i++, v += 3)
{ {
fprintf(objFile, "vn %.2f %.2f %.2f\n", mesh.normals[v], mesh.normals[v + 1], mesh.normals[v + 2]); fprintf(objFile, "vn %.2f %.2f %.2f\n", mesh.normals[v], mesh.normals[v + 1], mesh.normals[v + 2]);
} }
for (int i = 0; i < mesh.triangleCount; i += 3) for (int i = 0; i < mesh.triangleCount; i += 3)
{ {
fprintf(objFile, "f %i/%i/%i %i/%i/%i %i/%i/%i\n", i, i, i, i + 1, i + 1, i + 1, i + 2, i + 2, i + 2); fprintf(objFile, "f %i/%i/%i %i/%i/%i %i/%i/%i\n", i, i, i, i + 1, i + 1, i + 1, i + 2, i + 2, i + 2);
} }
fprintf(objFile, "\n"); fprintf(objFile, "\n");
fclose(objFile); fclose(objFile);
success = true; success = true;
} }
else if (IsFileExtension(fileName, ".raw")) { } // TODO: Support additional file formats to export mesh vertex data else if (IsFileExtension(fileName, ".raw")) { } // TODO: Support additional file formats to export mesh vertex data
@ -737,7 +737,7 @@ Mesh GenMeshPoly(int sides, float radius)
{ {
Mesh mesh = { 0 }; Mesh mesh = { 0 };
int vertexCount = sides*3; int vertexCount = sides*3;
// Vertices definition // Vertices definition
Vector3 *vertices = (Vector3 *)malloc(vertexCount*sizeof(Vector3)); Vector3 *vertices = (Vector3 *)malloc(vertexCount*sizeof(Vector3));
for (int i = 0, v = 0; i < 360; i += 360/sides, v += 3) for (int i = 0, v = 0; i < 360; i += 360/sides, v += 3)
@ -745,13 +745,13 @@ Mesh GenMeshPoly(int sides, float radius)
vertices[v] = (Vector3){ 0.0f, 0.0f, 0.0f }; vertices[v] = (Vector3){ 0.0f, 0.0f, 0.0f };
vertices[v + 1] = (Vector3){ sinf(DEG2RAD*i)*radius, 0.0f, cosf(DEG2RAD*i)*radius }; vertices[v + 1] = (Vector3){ sinf(DEG2RAD*i)*radius, 0.0f, cosf(DEG2RAD*i)*radius };
vertices[v + 2] = (Vector3){ sinf(DEG2RAD*(i + 360/sides))*radius, 0.0f, cosf(DEG2RAD*(i + 360/sides))*radius }; vertices[v + 2] = (Vector3){ sinf(DEG2RAD*(i + 360/sides))*radius, 0.0f, cosf(DEG2RAD*(i + 360/sides))*radius };
} }
// Normals definition // Normals definition
Vector3 *normals = (Vector3 *)malloc(vertexCount*sizeof(Vector3)); Vector3 *normals = (Vector3 *)malloc(vertexCount*sizeof(Vector3));
for (int n = 0; n < vertexCount; n++) normals[n] = (Vector3){ 0.0f, 1.0f, 0.0f }; // Vector3.up; for (int n = 0; n < vertexCount; n++) normals[n] = (Vector3){ 0.0f, 1.0f, 0.0f }; // Vector3.up;
// TexCoords definition // TexCoords definition
Vector2 *texcoords = (Vector2 *)malloc(vertexCount*sizeof(Vector2)); Vector2 *texcoords = (Vector2 *)malloc(vertexCount*sizeof(Vector2));
for (int n = 0; n < vertexCount; n++) texcoords[n] = (Vector2){ 0.0f, 0.0f }; for (int n = 0; n < vertexCount; n++) texcoords[n] = (Vector2){ 0.0f, 0.0f };
@ -760,7 +760,7 @@ Mesh GenMeshPoly(int sides, float radius)
mesh.vertices = (float *)malloc(mesh.vertexCount*3*sizeof(float)); mesh.vertices = (float *)malloc(mesh.vertexCount*3*sizeof(float));
mesh.texcoords = (float *)malloc(mesh.vertexCount*2*sizeof(float)); mesh.texcoords = (float *)malloc(mesh.vertexCount*2*sizeof(float));
mesh.normals = (float *)malloc(mesh.vertexCount*3*sizeof(float)); mesh.normals = (float *)malloc(mesh.vertexCount*3*sizeof(float));
// Mesh vertices position array // Mesh vertices position array
for (int i = 0; i < mesh.vertexCount; i++) for (int i = 0; i < mesh.vertexCount; i++)
{ {
@ -768,14 +768,14 @@ Mesh GenMeshPoly(int sides, float radius)
mesh.vertices[3*i + 1] = vertices[i].y; mesh.vertices[3*i + 1] = vertices[i].y;
mesh.vertices[3*i + 2] = vertices[i].z; mesh.vertices[3*i + 2] = vertices[i].z;
} }
// Mesh texcoords array // Mesh texcoords array
for (int i = 0; i < mesh.vertexCount; i++) for (int i = 0; i < mesh.vertexCount; i++)
{ {
mesh.texcoords[2*i] = texcoords[i].x; mesh.texcoords[2*i] = texcoords[i].x;
mesh.texcoords[2*i + 1] = texcoords[i].y; mesh.texcoords[2*i + 1] = texcoords[i].y;
} }
// Mesh normals array // Mesh normals array
for (int i = 0; i < mesh.vertexCount; i++) for (int i = 0; i < mesh.vertexCount; i++)
{ {
@ -783,14 +783,14 @@ Mesh GenMeshPoly(int sides, float radius)
mesh.normals[3*i + 1] = normals[i].y; mesh.normals[3*i + 1] = normals[i].y;
mesh.normals[3*i + 2] = normals[i].z; mesh.normals[3*i + 2] = normals[i].z;
} }
free(vertices); free(vertices);
free(normals); free(normals);
free(texcoords); free(texcoords);
// Upload vertex data to GPU (static mesh) // Upload vertex data to GPU (static mesh)
rlLoadMesh(&mesh, false); rlLoadMesh(&mesh, false);
return mesh; return mesh;
} }
@ -803,7 +803,7 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
#if defined(CUSTOM_MESH_GEN_PLANE) #if defined(CUSTOM_MESH_GEN_PLANE)
resX++; resX++;
resZ++; resZ++;
// Vertices definition // Vertices definition
int vertexCount = resX*resZ; // vertices get reused for the faces int vertexCount = resX*resZ; // vertices get reused for the faces
@ -824,7 +824,7 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
Vector3 *normals = (Vector3 *)malloc(vertexCount*sizeof(Vector3)); Vector3 *normals = (Vector3 *)malloc(vertexCount*sizeof(Vector3));
for (int n = 0; n < vertexCount; n++) normals[n] = (Vector3){ 0.0f, 1.0f, 0.0f }; // Vector3.up; for (int n = 0; n < vertexCount; n++) normals[n] = (Vector3){ 0.0f, 1.0f, 0.0f }; // Vector3.up;
// TexCoords definition // TexCoords definition
Vector2 *texcoords = (Vector2 *)malloc(vertexCount*sizeof(Vector2)); Vector2 *texcoords = (Vector2 *)malloc(vertexCount*sizeof(Vector2));
for (int v = 0; v < resZ; v++) for (int v = 0; v < resZ; v++)
{ {
@ -847,7 +847,7 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
triangles[t++] = i + 1; triangles[t++] = i + 1;
triangles[t++] = i; triangles[t++] = i;
triangles[t++] = i + resX; triangles[t++] = i + resX;
triangles[t++] = i + resX + 1; triangles[t++] = i + resX + 1;
triangles[t++] = i + 1; triangles[t++] = i + 1;
} }
@ -858,7 +858,7 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
mesh.texcoords = (float *)malloc(mesh.vertexCount*2*sizeof(float)); mesh.texcoords = (float *)malloc(mesh.vertexCount*2*sizeof(float));
mesh.normals = (float *)malloc(mesh.vertexCount*3*sizeof(float)); mesh.normals = (float *)malloc(mesh.vertexCount*3*sizeof(float));
mesh.indices = (unsigned short *)malloc(mesh.triangleCount*3*sizeof(unsigned short)); mesh.indices = (unsigned short *)malloc(mesh.triangleCount*3*sizeof(unsigned short));
// Mesh vertices position array // Mesh vertices position array
for (int i = 0; i < mesh.vertexCount; i++) for (int i = 0; i < mesh.vertexCount; i++)
{ {
@ -866,14 +866,14 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
mesh.vertices[3*i + 1] = vertices[i].y; mesh.vertices[3*i + 1] = vertices[i].y;
mesh.vertices[3*i + 2] = vertices[i].z; mesh.vertices[3*i + 2] = vertices[i].z;
} }
// Mesh texcoords array // Mesh texcoords array
for (int i = 0; i < mesh.vertexCount; i++) for (int i = 0; i < mesh.vertexCount; i++)
{ {
mesh.texcoords[2*i] = texcoords[i].x; mesh.texcoords[2*i] = texcoords[i].x;
mesh.texcoords[2*i + 1] = texcoords[i].y; mesh.texcoords[2*i + 1] = texcoords[i].y;
} }
// Mesh normals array // Mesh normals array
for (int i = 0; i < mesh.vertexCount; i++) for (int i = 0; i < mesh.vertexCount; i++)
{ {
@ -881,22 +881,22 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
mesh.normals[3*i + 1] = normals[i].y; mesh.normals[3*i + 1] = normals[i].y;
mesh.normals[3*i + 2] = normals[i].z; mesh.normals[3*i + 2] = normals[i].z;
} }
// Mesh indices array initialization // Mesh indices array initialization
for (int i = 0; i < mesh.triangleCount*3; i++) mesh.indices[i] = triangles[i]; for (int i = 0; i < mesh.triangleCount*3; i++) mesh.indices[i] = triangles[i];
free(vertices); free(vertices);
free(normals); free(normals);
free(texcoords); free(texcoords);
free(triangles); free(triangles);
#else // Use par_shapes library to generate plane mesh #else // Use par_shapes library to generate plane mesh
par_shapes_mesh *plane = par_shapes_create_plane(resX, resZ); // No normals/texcoords generated!!! par_shapes_mesh *plane = par_shapes_create_plane(resX, resZ); // No normals/texcoords generated!!!
par_shapes_scale(plane, width, length, 1.0f); par_shapes_scale(plane, width, length, 1.0f);
par_shapes_rotate(plane, -PI/2.0f, (float[]){ 1, 0, 0 }); par_shapes_rotate(plane, -PI/2.0f, (float[]){ 1, 0, 0 });
par_shapes_translate(plane, -width/2, 0.0f, length/2); par_shapes_translate(plane, -width/2, 0.0f, length/2);
mesh.vertices = (float *)malloc(plane->ntriangles*3*3*sizeof(float)); mesh.vertices = (float *)malloc(plane->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)malloc(plane->ntriangles*3*2*sizeof(float)); mesh.texcoords = (float *)malloc(plane->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)malloc(plane->ntriangles*3*3*sizeof(float)); mesh.normals = (float *)malloc(plane->ntriangles*3*3*sizeof(float));
@ -909,11 +909,11 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
mesh.vertices[k*3] = plane->points[plane->triangles[k]*3]; mesh.vertices[k*3] = plane->points[plane->triangles[k]*3];
mesh.vertices[k*3 + 1] = plane->points[plane->triangles[k]*3 + 1]; mesh.vertices[k*3 + 1] = plane->points[plane->triangles[k]*3 + 1];
mesh.vertices[k*3 + 2] = plane->points[plane->triangles[k]*3 + 2]; mesh.vertices[k*3 + 2] = plane->points[plane->triangles[k]*3 + 2];
mesh.normals[k*3] = plane->normals[plane->triangles[k]*3]; mesh.normals[k*3] = plane->normals[plane->triangles[k]*3];
mesh.normals[k*3 + 1] = plane->normals[plane->triangles[k]*3 + 1]; mesh.normals[k*3 + 1] = plane->normals[plane->triangles[k]*3 + 1];
mesh.normals[k*3 + 2] = plane->normals[plane->triangles[k]*3 + 2]; mesh.normals[k*3 + 2] = plane->normals[plane->triangles[k]*3 + 2];
mesh.texcoords[k*2] = plane->tcoords[plane->triangles[k]*2]; mesh.texcoords[k*2] = plane->tcoords[plane->triangles[k]*2];
mesh.texcoords[k*2 + 1] = plane->tcoords[plane->triangles[k]*2 + 1]; mesh.texcoords[k*2 + 1] = plane->tcoords[plane->triangles[k]*2 + 1];
} }
@ -922,7 +922,7 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
#endif #endif
// Upload vertex data to GPU (static mesh) // Upload vertex data to GPU (static mesh)
rlLoadMesh(&mesh, false); rlLoadMesh(&mesh, false);
return mesh; return mesh;
} }
@ -960,7 +960,7 @@ Mesh GenMeshCube(float width, float height, float length)
-width/2, height/2, length/2, -width/2, height/2, length/2,
-width/2, height/2, -length/2 -width/2, height/2, -length/2
}; };
float texcoords[] = { float texcoords[] = {
0.0f, 0.0f, 0.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f,
@ -987,7 +987,7 @@ Mesh GenMeshCube(float width, float height, float length)
1.0f, 1.0f, 1.0f, 1.0f,
0.0f, 1.0f 0.0f, 1.0f
}; };
float normals[] = { float normals[] = {
0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
@ -1017,15 +1017,15 @@ Mesh GenMeshCube(float width, float height, float length)
mesh.vertices = (float *)malloc(24*3*sizeof(float)); mesh.vertices = (float *)malloc(24*3*sizeof(float));
memcpy(mesh.vertices, vertices, 24*3*sizeof(float)); memcpy(mesh.vertices, vertices, 24*3*sizeof(float));
mesh.texcoords = (float *)malloc(24*2*sizeof(float)); mesh.texcoords = (float *)malloc(24*2*sizeof(float));
memcpy(mesh.texcoords, texcoords, 24*2*sizeof(float)); memcpy(mesh.texcoords, texcoords, 24*2*sizeof(float));
mesh.normals = (float *)malloc(24*3*sizeof(float)); mesh.normals = (float *)malloc(24*3*sizeof(float));
memcpy(mesh.normals, normals, 24*3*sizeof(float)); memcpy(mesh.normals, normals, 24*3*sizeof(float));
mesh.indices = (unsigned short *)malloc(36*sizeof(unsigned short)); mesh.indices = (unsigned short *)malloc(36*sizeof(unsigned short));
int k = 0; int k = 0;
// Indices can be initialized right now // Indices can be initialized right now
@ -1040,10 +1040,10 @@ Mesh GenMeshCube(float width, float height, float length)
k++; k++;
} }
mesh.vertexCount = 24; mesh.vertexCount = 24;
mesh.triangleCount = 12; mesh.triangleCount = 12;
#else // Use par_shapes library to generate cube mesh #else // Use par_shapes library to generate cube mesh
/* /*
// Platonic solids: // Platonic solids:
@ -1057,11 +1057,11 @@ par_shapes_mesh* par_shapes_create_icosahedron(); // 20 sides polyhedron
// NOTE: No normals/texcoords generated by default // NOTE: No normals/texcoords generated by default
par_shapes_mesh *cube = par_shapes_create_cube(); par_shapes_mesh *cube = par_shapes_create_cube();
cube->tcoords = PAR_MALLOC(float, 2*cube->npoints); cube->tcoords = PAR_MALLOC(float, 2*cube->npoints);
for (int i = 0; i < 2*cube->npoints; i++) cube->tcoords[i] = 0.0f; for (int i = 0; i < 2*cube->npoints; i++) cube->tcoords[i] = 0.0f;
par_shapes_scale(cube, width, height, length); par_shapes_scale(cube, width, height, length);
par_shapes_translate(cube, -width/2, 0.0f, -length/2); par_shapes_translate(cube, -width/2, 0.0f, -length/2);
par_shapes_compute_normals(cube); par_shapes_compute_normals(cube);
mesh.vertices = (float *)malloc(cube->ntriangles*3*3*sizeof(float)); mesh.vertices = (float *)malloc(cube->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)malloc(cube->ntriangles*3*2*sizeof(float)); mesh.texcoords = (float *)malloc(cube->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)malloc(cube->ntriangles*3*3*sizeof(float)); mesh.normals = (float *)malloc(cube->ntriangles*3*3*sizeof(float));
@ -1074,11 +1074,11 @@ par_shapes_mesh* par_shapes_create_icosahedron(); // 20 sides polyhedron
mesh.vertices[k*3] = cube->points[cube->triangles[k]*3]; mesh.vertices[k*3] = cube->points[cube->triangles[k]*3];
mesh.vertices[k*3 + 1] = cube->points[cube->triangles[k]*3 + 1]; mesh.vertices[k*3 + 1] = cube->points[cube->triangles[k]*3 + 1];
mesh.vertices[k*3 + 2] = cube->points[cube->triangles[k]*3 + 2]; mesh.vertices[k*3 + 2] = cube->points[cube->triangles[k]*3 + 2];
mesh.normals[k*3] = cube->normals[cube->triangles[k]*3]; mesh.normals[k*3] = cube->normals[cube->triangles[k]*3];
mesh.normals[k*3 + 1] = cube->normals[cube->triangles[k]*3 + 1]; mesh.normals[k*3 + 1] = cube->normals[cube->triangles[k]*3 + 1];
mesh.normals[k*3 + 2] = cube->normals[cube->triangles[k]*3 + 2]; mesh.normals[k*3 + 2] = cube->normals[cube->triangles[k]*3 + 2];
mesh.texcoords[k*2] = cube->tcoords[cube->triangles[k]*2]; mesh.texcoords[k*2] = cube->tcoords[cube->triangles[k]*2];
mesh.texcoords[k*2 + 1] = cube->tcoords[cube->triangles[k]*2 + 1]; mesh.texcoords[k*2 + 1] = cube->tcoords[cube->triangles[k]*2 + 1];
} }
@ -1087,7 +1087,7 @@ par_shapes_mesh* par_shapes_create_icosahedron(); // 20 sides polyhedron
#endif #endif
// Upload vertex data to GPU (static mesh) // Upload vertex data to GPU (static mesh)
rlLoadMesh(&mesh, false); rlLoadMesh(&mesh, false);
return mesh; return mesh;
} }
@ -1099,8 +1099,8 @@ RLAPI Mesh GenMeshSphere(float radius, int rings, int slices)
par_shapes_mesh *sphere = par_shapes_create_parametric_sphere(slices, rings); par_shapes_mesh *sphere = par_shapes_create_parametric_sphere(slices, rings);
par_shapes_scale(sphere, radius, radius, radius); par_shapes_scale(sphere, radius, radius, radius);
// NOTE: Soft normals are computed internally // NOTE: Soft normals are computed internally
mesh.vertices = (float *)malloc(sphere->ntriangles*3*3*sizeof(float)); mesh.vertices = (float *)malloc(sphere->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)malloc(sphere->ntriangles*3*2*sizeof(float)); mesh.texcoords = (float *)malloc(sphere->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)malloc(sphere->ntriangles*3*3*sizeof(float)); mesh.normals = (float *)malloc(sphere->ntriangles*3*3*sizeof(float));
@ -1113,19 +1113,19 @@ RLAPI Mesh GenMeshSphere(float radius, int rings, int slices)
mesh.vertices[k*3] = sphere->points[sphere->triangles[k]*3]; mesh.vertices[k*3] = sphere->points[sphere->triangles[k]*3];
mesh.vertices[k*3 + 1] = sphere->points[sphere->triangles[k]*3 + 1]; mesh.vertices[k*3 + 1] = sphere->points[sphere->triangles[k]*3 + 1];
mesh.vertices[k*3 + 2] = sphere->points[sphere->triangles[k]*3 + 2]; mesh.vertices[k*3 + 2] = sphere->points[sphere->triangles[k]*3 + 2];
mesh.normals[k*3] = sphere->normals[sphere->triangles[k]*3]; mesh.normals[k*3] = sphere->normals[sphere->triangles[k]*3];
mesh.normals[k*3 + 1] = sphere->normals[sphere->triangles[k]*3 + 1]; mesh.normals[k*3 + 1] = sphere->normals[sphere->triangles[k]*3 + 1];
mesh.normals[k*3 + 2] = sphere->normals[sphere->triangles[k]*3 + 2]; mesh.normals[k*3 + 2] = sphere->normals[sphere->triangles[k]*3 + 2];
mesh.texcoords[k*2] = sphere->tcoords[sphere->triangles[k]*2]; mesh.texcoords[k*2] = sphere->tcoords[sphere->triangles[k]*2];
mesh.texcoords[k*2 + 1] = sphere->tcoords[sphere->triangles[k]*2 + 1]; mesh.texcoords[k*2 + 1] = sphere->tcoords[sphere->triangles[k]*2 + 1];
} }
par_shapes_free_mesh(sphere); par_shapes_free_mesh(sphere);
// Upload vertex data to GPU (static mesh) // Upload vertex data to GPU (static mesh)
rlLoadMesh(&mesh, false); rlLoadMesh(&mesh, false);
return mesh; return mesh;
} }
@ -1137,8 +1137,8 @@ RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices)
par_shapes_mesh *sphere = par_shapes_create_hemisphere(slices, rings); par_shapes_mesh *sphere = par_shapes_create_hemisphere(slices, rings);
par_shapes_scale(sphere, radius, radius, radius); par_shapes_scale(sphere, radius, radius, radius);
// NOTE: Soft normals are computed internally // NOTE: Soft normals are computed internally
mesh.vertices = (float *)malloc(sphere->ntriangles*3*3*sizeof(float)); mesh.vertices = (float *)malloc(sphere->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)malloc(sphere->ntriangles*3*2*sizeof(float)); mesh.texcoords = (float *)malloc(sphere->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)malloc(sphere->ntriangles*3*3*sizeof(float)); mesh.normals = (float *)malloc(sphere->ntriangles*3*3*sizeof(float));
@ -1151,19 +1151,19 @@ RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices)
mesh.vertices[k*3] = sphere->points[sphere->triangles[k]*3]; mesh.vertices[k*3] = sphere->points[sphere->triangles[k]*3];
mesh.vertices[k*3 + 1] = sphere->points[sphere->triangles[k]*3 + 1]; mesh.vertices[k*3 + 1] = sphere->points[sphere->triangles[k]*3 + 1];
mesh.vertices[k*3 + 2] = sphere->points[sphere->triangles[k]*3 + 2]; mesh.vertices[k*3 + 2] = sphere->points[sphere->triangles[k]*3 + 2];
mesh.normals[k*3] = sphere->normals[sphere->triangles[k]*3]; mesh.normals[k*3] = sphere->normals[sphere->triangles[k]*3];
mesh.normals[k*3 + 1] = sphere->normals[sphere->triangles[k]*3 + 1]; mesh.normals[k*3 + 1] = sphere->normals[sphere->triangles[k]*3 + 1];
mesh.normals[k*3 + 2] = sphere->normals[sphere->triangles[k]*3 + 2]; mesh.normals[k*3 + 2] = sphere->normals[sphere->triangles[k]*3 + 2];
mesh.texcoords[k*2] = sphere->tcoords[sphere->triangles[k]*2]; mesh.texcoords[k*2] = sphere->tcoords[sphere->triangles[k]*2];
mesh.texcoords[k*2 + 1] = sphere->tcoords[sphere->triangles[k]*2 + 1]; mesh.texcoords[k*2 + 1] = sphere->tcoords[sphere->triangles[k]*2 + 1];
} }
par_shapes_free_mesh(sphere); par_shapes_free_mesh(sphere);
// Upload vertex data to GPU (static mesh) // Upload vertex data to GPU (static mesh)
rlLoadMesh(&mesh, false); rlLoadMesh(&mesh, false);
return mesh; return mesh;
} }
@ -1175,7 +1175,7 @@ Mesh GenMeshCylinder(float radius, float height, int slices)
// Instance a cylinder that sits on the Z=0 plane using the given tessellation // Instance a cylinder that sits on the Z=0 plane using the given tessellation
// levels across the UV domain. Think of "slices" like a number of pizza // levels across the UV domain. Think of "slices" like a number of pizza
// slices, and "stacks" like a number of stacked rings. // slices, and "stacks" like a number of stacked rings.
// Height and radius are both 1.0, but they can easily be changed with par_shapes_scale // Height and radius are both 1.0, but they can easily be changed with par_shapes_scale
par_shapes_mesh *cylinder = par_shapes_create_cylinder(slices, 8); par_shapes_mesh *cylinder = par_shapes_create_cylinder(slices, 8);
par_shapes_scale(cylinder, radius, radius, height); par_shapes_scale(cylinder, radius, radius, height);
@ -1187,16 +1187,16 @@ Mesh GenMeshCylinder(float radius, float height, int slices)
for (int i = 0; i < 2*capTop->npoints; i++) capTop->tcoords[i] = 0.0f; for (int i = 0; i < 2*capTop->npoints; i++) capTop->tcoords[i] = 0.0f;
par_shapes_rotate(capTop, -PI/2.0f, (float[]){ 1, 0, 0 }); par_shapes_rotate(capTop, -PI/2.0f, (float[]){ 1, 0, 0 });
par_shapes_translate(capTop, 0, height, 0); par_shapes_translate(capTop, 0, height, 0);
// Generate an orientable disk shape (bottom cap) // Generate an orientable disk shape (bottom cap)
par_shapes_mesh *capBottom = par_shapes_create_disk(radius, slices, (float[]){ 0, 0, 0 }, (float[]){ 0, 0, -1 }); par_shapes_mesh *capBottom = par_shapes_create_disk(radius, slices, (float[]){ 0, 0, 0 }, (float[]){ 0, 0, -1 });
capBottom->tcoords = PAR_MALLOC(float, 2*capBottom->npoints); capBottom->tcoords = PAR_MALLOC(float, 2*capBottom->npoints);
for (int i = 0; i < 2*capBottom->npoints; i++) capBottom->tcoords[i] = 0.95f; for (int i = 0; i < 2*capBottom->npoints; i++) capBottom->tcoords[i] = 0.95f;
par_shapes_rotate(capBottom, PI/2.0f, (float[]){ 1, 0, 0 }); par_shapes_rotate(capBottom, PI/2.0f, (float[]){ 1, 0, 0 });
par_shapes_merge_and_free(cylinder, capTop); par_shapes_merge_and_free(cylinder, capTop);
par_shapes_merge_and_free(cylinder, capBottom); par_shapes_merge_and_free(cylinder, capBottom);
mesh.vertices = (float *)malloc(cylinder->ntriangles*3*3*sizeof(float)); mesh.vertices = (float *)malloc(cylinder->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)malloc(cylinder->ntriangles*3*2*sizeof(float)); mesh.texcoords = (float *)malloc(cylinder->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)malloc(cylinder->ntriangles*3*3*sizeof(float)); mesh.normals = (float *)malloc(cylinder->ntriangles*3*3*sizeof(float));
@ -1209,19 +1209,19 @@ Mesh GenMeshCylinder(float radius, float height, int slices)
mesh.vertices[k*3] = cylinder->points[cylinder->triangles[k]*3]; mesh.vertices[k*3] = cylinder->points[cylinder->triangles[k]*3];
mesh.vertices[k*3 + 1] = cylinder->points[cylinder->triangles[k]*3 + 1]; mesh.vertices[k*3 + 1] = cylinder->points[cylinder->triangles[k]*3 + 1];
mesh.vertices[k*3 + 2] = cylinder->points[cylinder->triangles[k]*3 + 2]; mesh.vertices[k*3 + 2] = cylinder->points[cylinder->triangles[k]*3 + 2];
mesh.normals[k*3] = cylinder->normals[cylinder->triangles[k]*3]; mesh.normals[k*3] = cylinder->normals[cylinder->triangles[k]*3];
mesh.normals[k*3 + 1] = cylinder->normals[cylinder->triangles[k]*3 + 1]; mesh.normals[k*3 + 1] = cylinder->normals[cylinder->triangles[k]*3 + 1];
mesh.normals[k*3 + 2] = cylinder->normals[cylinder->triangles[k]*3 + 2]; mesh.normals[k*3 + 2] = cylinder->normals[cylinder->triangles[k]*3 + 2];
mesh.texcoords[k*2] = cylinder->tcoords[cylinder->triangles[k]*2]; mesh.texcoords[k*2] = cylinder->tcoords[cylinder->triangles[k]*2];
mesh.texcoords[k*2 + 1] = cylinder->tcoords[cylinder->triangles[k]*2 + 1]; mesh.texcoords[k*2 + 1] = cylinder->tcoords[cylinder->triangles[k]*2 + 1];
} }
par_shapes_free_mesh(cylinder); par_shapes_free_mesh(cylinder);
// Upload vertex data to GPU (static mesh) // Upload vertex data to GPU (static mesh)
rlLoadMesh(&mesh, false); rlLoadMesh(&mesh, false);
return mesh; return mesh;
} }
@ -1233,7 +1233,7 @@ Mesh GenMeshTorus(float radius, float size, int radSeg, int sides)
if (radius > 1.0f) radius = 1.0f; if (radius > 1.0f) radius = 1.0f;
else if (radius < 0.1f) radius = 0.1f; else if (radius < 0.1f) radius = 0.1f;
// Create a donut that sits on the Z=0 plane with the specified inner radius // Create a donut that sits on the Z=0 plane with the specified inner radius
// The outer radius can be controlled with par_shapes_scale // The outer radius can be controlled with par_shapes_scale
par_shapes_mesh *torus = par_shapes_create_torus(radSeg, sides, radius); par_shapes_mesh *torus = par_shapes_create_torus(radSeg, sides, radius);
@ -1251,19 +1251,19 @@ Mesh GenMeshTorus(float radius, float size, int radSeg, int sides)
mesh.vertices[k*3] = torus->points[torus->triangles[k]*3]; mesh.vertices[k*3] = torus->points[torus->triangles[k]*3];
mesh.vertices[k*3 + 1] = torus->points[torus->triangles[k]*3 + 1]; mesh.vertices[k*3 + 1] = torus->points[torus->triangles[k]*3 + 1];
mesh.vertices[k*3 + 2] = torus->points[torus->triangles[k]*3 + 2]; mesh.vertices[k*3 + 2] = torus->points[torus->triangles[k]*3 + 2];
mesh.normals[k*3] = torus->normals[torus->triangles[k]*3]; mesh.normals[k*3] = torus->normals[torus->triangles[k]*3];
mesh.normals[k*3 + 1] = torus->normals[torus->triangles[k]*3 + 1]; mesh.normals[k*3 + 1] = torus->normals[torus->triangles[k]*3 + 1];
mesh.normals[k*3 + 2] = torus->normals[torus->triangles[k]*3 + 2]; mesh.normals[k*3 + 2] = torus->normals[torus->triangles[k]*3 + 2];
mesh.texcoords[k*2] = torus->tcoords[torus->triangles[k]*2]; mesh.texcoords[k*2] = torus->tcoords[torus->triangles[k]*2];
mesh.texcoords[k*2 + 1] = torus->tcoords[torus->triangles[k]*2 + 1]; mesh.texcoords[k*2 + 1] = torus->tcoords[torus->triangles[k]*2 + 1];
} }
par_shapes_free_mesh(torus); par_shapes_free_mesh(torus);
// Upload vertex data to GPU (static mesh) // Upload vertex data to GPU (static mesh)
rlLoadMesh(&mesh, false); rlLoadMesh(&mesh, false);
return mesh; return mesh;
} }
@ -1272,7 +1272,7 @@ Mesh GenMeshTorus(float radius, float size, int radSeg, int sides)
Mesh GenMeshKnot(float radius, float size, int radSeg, int sides) Mesh GenMeshKnot(float radius, float size, int radSeg, int sides)
{ {
Mesh mesh = { 0 }; Mesh mesh = { 0 };
if (radius > 3.0f) radius = 3.0f; if (radius > 3.0f) radius = 3.0f;
else if (radius < 0.5f) radius = 0.5f; else if (radius < 0.5f) radius = 0.5f;
@ -1291,19 +1291,19 @@ Mesh GenMeshKnot(float radius, float size, int radSeg, int sides)
mesh.vertices[k*3] = knot->points[knot->triangles[k]*3]; mesh.vertices[k*3] = knot->points[knot->triangles[k]*3];
mesh.vertices[k*3 + 1] = knot->points[knot->triangles[k]*3 + 1]; mesh.vertices[k*3 + 1] = knot->points[knot->triangles[k]*3 + 1];
mesh.vertices[k*3 + 2] = knot->points[knot->triangles[k]*3 + 2]; mesh.vertices[k*3 + 2] = knot->points[knot->triangles[k]*3 + 2];
mesh.normals[k*3] = knot->normals[knot->triangles[k]*3]; mesh.normals[k*3] = knot->normals[knot->triangles[k]*3];
mesh.normals[k*3 + 1] = knot->normals[knot->triangles[k]*3 + 1]; mesh.normals[k*3 + 1] = knot->normals[knot->triangles[k]*3 + 1];
mesh.normals[k*3 + 2] = knot->normals[knot->triangles[k]*3 + 2]; mesh.normals[k*3 + 2] = knot->normals[knot->triangles[k]*3 + 2];
mesh.texcoords[k*2] = knot->tcoords[knot->triangles[k]*2]; mesh.texcoords[k*2] = knot->tcoords[knot->triangles[k]*2];
mesh.texcoords[k*2 + 1] = knot->tcoords[knot->triangles[k]*2 + 1]; mesh.texcoords[k*2 + 1] = knot->tcoords[knot->triangles[k]*2 + 1];
} }
par_shapes_free_mesh(knot); par_shapes_free_mesh(knot);
// Upload vertex data to GPU (static mesh) // Upload vertex data to GPU (static mesh)
rlLoadMesh(&mesh, false); rlLoadMesh(&mesh, false);
return mesh; return mesh;
} }
@ -1411,7 +1411,7 @@ Mesh GenMeshHeightmap(Image heightmap, Vector3 size)
} }
free(pixels); free(pixels);
// Upload vertex data to GPU (static mesh) // Upload vertex data to GPU (static mesh)
rlLoadMesh(&mesh, false); rlLoadMesh(&mesh, false);
@ -1771,9 +1771,9 @@ Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize)
free(mapTexcoords); free(mapTexcoords);
free(cubicmapPixels); // Free image pixel data free(cubicmapPixels); // Free image pixel data
// Upload vertex data to GPU (static mesh) // Upload vertex data to GPU (static mesh)
rlLoadMesh(&mesh, false); rlLoadMesh(&mesh, false);
return mesh; return mesh;
} }
@ -1821,7 +1821,7 @@ void UnloadMaterial(Material material)
// Unload loaded texture maps (avoid unloading default texture, managed by raylib) // Unload loaded texture maps (avoid unloading default texture, managed by raylib)
for (int i = 0; i < MAX_MATERIAL_MAPS; i++) for (int i = 0; i < MAX_MATERIAL_MAPS; i++)
{ {
if (material.maps[i].texture.id != GetTextureDefault().id) rlDeleteTextures(material.maps[i].texture.id); if (material.maps[i].texture.id != GetTextureDefault().id) rlDeleteTextures(material.maps[i].texture.id);
} }
} }
@ -1842,7 +1842,7 @@ void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rota
Matrix matScale = MatrixScale(scale.x, scale.y, scale.z); Matrix matScale = MatrixScale(scale.x, scale.y, scale.z);
Matrix matRotation = MatrixRotate(rotationAxis, rotationAngle*DEG2RAD); Matrix matRotation = MatrixRotate(rotationAxis, rotationAngle*DEG2RAD);
Matrix matTranslation = MatrixTranslate(position.x, position.y, position.z); Matrix matTranslation = MatrixTranslate(position.x, position.y, position.z);
Matrix matTransform = MatrixMultiply(MatrixMultiply(matScale, matRotation), matTranslation); Matrix matTransform = MatrixMultiply(MatrixMultiply(matScale, matRotation), matTranslation);
// Combine model transformation matrix (model.transform) with matrix generated by function parameters (matTransform) // Combine model transformation matrix (model.transform) with matrix generated by function parameters (matTransform)
@ -2037,7 +2037,7 @@ bool CheckCollisionRaySphereEx(Ray ray, Vector3 spherePosition, float sphereRadi
if (distance < sphereRadius) collisionDistance = vector + sqrtf(d); if (distance < sphereRadius) collisionDistance = vector + sqrtf(d);
else collisionDistance = vector - sqrtf(d); else collisionDistance = vector - sqrtf(d);
// Calculate collision point // Calculate collision point
Vector3 cPoint = Vector3Add(ray.position, Vector3Scale(ray.direction, collisionDistance)); Vector3 cPoint = Vector3Add(ray.position, Vector3Scale(ray.direction, collisionDistance));
@ -2097,7 +2097,7 @@ RayHitInfo GetCollisionRayModel(Ray ray, Model *model)
b = vertdata[i*3 + 1]; b = vertdata[i*3 + 1];
c = vertdata[i*3 + 2]; c = vertdata[i*3 + 2];
} }
a = Vector3Transform(a, model->transform); a = Vector3Transform(a, model->transform);
b = Vector3Transform(b, model->transform); b = Vector3Transform(b, model->transform);
c = Vector3Transform(c, model->transform); c = Vector3Transform(c, model->transform);
@ -2231,7 +2231,7 @@ void MeshTangents(Mesh *mesh)
{ {
if (mesh->tangents == NULL) mesh->tangents = (float *)malloc(mesh->vertexCount*4*sizeof(float)); if (mesh->tangents == NULL) mesh->tangents = (float *)malloc(mesh->vertexCount*4*sizeof(float));
else TraceLog(LOG_WARNING, "Mesh tangents already exist"); else TraceLog(LOG_WARNING, "Mesh tangents already exist");
Vector3 *tan1 = (Vector3 *)malloc(mesh->vertexCount*sizeof(Vector3)); Vector3 *tan1 = (Vector3 *)malloc(mesh->vertexCount*sizeof(Vector3));
Vector3 *tan2 = (Vector3 *)malloc(mesh->vertexCount*sizeof(Vector3)); Vector3 *tan2 = (Vector3 *)malloc(mesh->vertexCount*sizeof(Vector3));
@ -2264,7 +2264,7 @@ void MeshTangents(Mesh *mesh)
Vector3 sdir = { (t2*x1 - t1*x2)*r, (t2*y1 - t1*y2)*r, (t2*z1 - t1*z2)*r }; Vector3 sdir = { (t2*x1 - t1*x2)*r, (t2*y1 - t1*y2)*r, (t2*z1 - t1*z2)*r };
Vector3 tdir = { (s1*x2 - s2*x1)*r, (s1*y2 - s2*y1)*r, (s1*z2 - s2*z1)*r }; Vector3 tdir = { (s1*x2 - s2*x1)*r, (s1*y2 - s2*y1)*r, (s1*z2 - s2*z1)*r };
tan1[i + 0] = sdir; tan1[i + 0] = sdir;
tan1[i + 1] = sdir; tan1[i + 1] = sdir;
tan1[i + 2] = sdir; tan1[i + 2] = sdir;
@ -2296,10 +2296,10 @@ void MeshTangents(Mesh *mesh)
mesh->tangents[i*4 + 3] = (Vector3DotProduct(Vector3CrossProduct(normal, tangent), tan2[i]) < 0.0f) ? -1.0f : 1.0f; mesh->tangents[i*4 + 3] = (Vector3DotProduct(Vector3CrossProduct(normal, tangent), tan2[i]) < 0.0f) ? -1.0f : 1.0f;
#endif #endif
} }
free(tan1); free(tan1);
free(tan2); free(tan2);
TraceLog(LOG_INFO, "Tangents computed for mesh"); TraceLog(LOG_INFO, "Tangents computed for mesh");
} }
@ -2311,7 +2311,7 @@ void MeshBinormals(Mesh *mesh)
Vector3 normal = { mesh->normals[i*3 + 0], mesh->normals[i*3 + 1], mesh->normals[i*3 + 2] }; Vector3 normal = { mesh->normals[i*3 + 0], mesh->normals[i*3 + 1], mesh->normals[i*3 + 2] };
Vector3 tangent = { mesh->tangents[i*4 + 0], mesh->tangents[i*4 + 1], mesh->tangents[i*4 + 2] }; Vector3 tangent = { mesh->tangents[i*4 + 0], mesh->tangents[i*4 + 1], mesh->tangents[i*4 + 2] };
float tangentW = mesh->tangents[i*4 + 3]; float tangentW = mesh->tangents[i*4 + 3];
// TODO: Register computed binormal in mesh->binormal ? // TODO: Register computed binormal in mesh->binormal ?
// Vector3 binormal = Vector3Multiply(Vector3CrossProduct(normal, tangent), tangentW); // Vector3 binormal = Vector3Multiply(Vector3CrossProduct(normal, tangent), tangentW);
} }
@ -2740,11 +2740,11 @@ static Material LoadMTL(const char *fileName)
static Mesh LoadIQM(const char *fileName) static Mesh LoadIQM(const char *fileName)
{ {
Mesh mesh = { 0 }; Mesh mesh = { 0 };
// TODO: Load IQM file // TODO: Load IQM file
return mesh; return mesh;
} }
#endif #endif
#if defined(SUPPORT_FILEFORMAT_GLTF) #if defined(SUPPORT_FILEFORMAT_GLTF)
@ -2752,10 +2752,10 @@ static Mesh LoadIQM(const char *fileName)
static Mesh LoadGLTF(const char *fileName) static Mesh LoadGLTF(const char *fileName)
{ {
Mesh mesh = { 0 }; Mesh mesh = { 0 };
// glTF file loading // glTF file loading
FILE *gltfFile = fopen(fileName, "rb"); FILE *gltfFile = fopen(fileName, "rb");
if (gltfFile == NULL) if (gltfFile == NULL)
{ {
TraceLog(LOG_WARNING, "[%s] glTF file could not be opened", fileName); TraceLog(LOG_WARNING, "[%s] glTF file could not be opened", fileName);
@ -2768,31 +2768,31 @@ static Mesh LoadGLTF(const char *fileName)
void *buffer = malloc(size); void *buffer = malloc(size);
fread(buffer, size, 1, gltfFile); fread(buffer, size, 1, gltfFile);
fclose(gltfFile); fclose(gltfFile);
// glTF data loading // glTF data loading
cgltf_options options = {0}; cgltf_options options = {0};
cgltf_data data; cgltf_data data;
cgltf_result result = cgltf_parse(&options, buffer, size, &data); cgltf_result result = cgltf_parse(&options, buffer, size, &data);
free(buffer); free(buffer);
if (result == cgltf_result_success) if (result == cgltf_result_success)
{ {
printf("Type: %u\n", data.file_type); printf("Type: %u\n", data.file_type);
printf("Version: %d\n", data.version); printf("Version: %d\n", data.version);
printf("Meshes: %lu\n", data.meshes_count); printf("Meshes: %lu\n", data.meshes_count);
// TODO: Process glTF data and map to mesh // TODO: Process glTF data and map to mesh
// NOTE: data.buffers[] and data.images[] should be loaded // NOTE: data.buffers[] and data.images[] should be loaded
// using buffers[n].uri and images[n].uri... or use cgltf_load_buffers(&options, data, fileName); // using buffers[n].uri and images[n].uri... or use cgltf_load_buffers(&options, data, fileName);
cgltf_free(&data); cgltf_free(&data);
} }
else TraceLog(LOG_WARNING, "[%s] glTF data could not be loaded", fileName); else TraceLog(LOG_WARNING, "[%s] glTF data could not be loaded", fileName);
return mesh; return mesh;
} }
#endif #endif

14
src/raudio.c
View File

@ -1245,7 +1245,7 @@ Music LoadMusicStream(const char *fileName)
void UnloadMusicStream(Music music) void UnloadMusicStream(Music music)
{ {
if (music == NULL) return; if (music == NULL) return;
CloseAudioStream(music->stream); CloseAudioStream(music->stream);
#if defined(SUPPORT_FILEFORMAT_OGG) #if defined(SUPPORT_FILEFORMAT_OGG)
@ -1311,7 +1311,7 @@ void ResumeMusicStream(Music music)
void StopMusicStream(Music music) void StopMusicStream(Music music)
{ {
if (music == NULL) return; if (music == NULL) return;
StopAudioStream(music->stream); StopAudioStream(music->stream);
// Restart music context // Restart music context
@ -1343,7 +1343,7 @@ void StopMusicStream(Music music)
void UpdateMusicStream(Music music) void UpdateMusicStream(Music music)
{ {
if (music == NULL) return; if (music == NULL) return;
bool streamEnding = false; bool streamEnding = false;
unsigned int subBufferSizeInFrames = ((AudioBuffer *)music->stream.audioBuffer)->bufferSizeInFrames/2; unsigned int subBufferSizeInFrames = ((AudioBuffer *)music->stream.audioBuffer)->bufferSizeInFrames/2;
@ -1393,16 +1393,16 @@ void UpdateMusicStream(Music music)
} break; } break;
#endif #endif
#if defined(SUPPORT_FILEFORMAT_MOD) #if defined(SUPPORT_FILEFORMAT_MOD)
case MUSIC_MODULE_MOD: case MUSIC_MODULE_MOD:
{ {
// NOTE: 3rd parameter (nbsample) specify the number of stereo 16bits samples you want, so sampleCount/2 // NOTE: 3rd parameter (nbsample) specify the number of stereo 16bits samples you want, so sampleCount/2
jar_mod_fillbuffer(&music->ctxMod, (short *)pcm, samplesCount/2, 0); jar_mod_fillbuffer(&music->ctxMod, (short *)pcm, samplesCount/2, 0);
} break; } break;
#endif #endif
default: break; default: break;
} }
UpdateAudioStream(music->stream, pcm, samplesCount); UpdateAudioStream(music->stream, pcm, samplesCount);
if ((music->ctxType == MUSIC_MODULE_XM) || (music->ctxType == MUSIC_MODULE_MOD)) if ((music->ctxType == MUSIC_MODULE_XM) || (music->ctxType == MUSIC_MODULE_MOD))
{ {
@ -1475,7 +1475,7 @@ void SetMusicLoopCount(Music music, int count)
float GetMusicTimeLength(Music music) float GetMusicTimeLength(Music music)
{ {
float totalSeconds = 0.0f; float totalSeconds = 0.0f;
if (music != NULL) totalSeconds = (float)music->totalSamples/(music->stream.sampleRate*music->stream.channels); if (music != NULL) totalSeconds = (float)music->totalSamples/(music->stream.sampleRate*music->stream.channels);
return totalSeconds; return totalSeconds;

114
src/rlgl.h
View File

@ -356,7 +356,7 @@ typedef unsigned char byte;
LOC_MAP_PREFILTER, LOC_MAP_PREFILTER,
LOC_MAP_BRDF LOC_MAP_BRDF
} ShaderLocationIndex; } ShaderLocationIndex;
// Shader uniform data types // Shader uniform data types
typedef enum { typedef enum {
UNIFORM_FLOAT = 0, UNIFORM_FLOAT = 0,
@ -993,14 +993,14 @@ void rlPushMatrix(void)
// Pop lattest inserted matrix from stack // Pop lattest inserted matrix from stack
void rlPopMatrix(void) void rlPopMatrix(void)
{ {
if (stackCounter > 0) if (stackCounter > 0)
{ {
Matrix mat = stack[stackCounter - 1]; Matrix mat = stack[stackCounter - 1];
*currentMatrix = mat; *currentMatrix = mat;
stackCounter--; stackCounter--;
} }
if ((stackCounter == 0) && (currentMatrixMode == RL_MODELVIEW)) if ((stackCounter == 0) && (currentMatrixMode == RL_MODELVIEW))
{ {
currentMatrix = &modelview; currentMatrix = &modelview;
@ -1141,7 +1141,7 @@ void rlEnd(void)
// Make sure vertexCount is the same for vertices, texcoords, colors and normals // Make sure vertexCount is the same for vertices, texcoords, colors and normals
// NOTE: In OpenGL 1.1, one glColor call can be made for all the subsequent glVertex calls // NOTE: In OpenGL 1.1, one glColor call can be made for all the subsequent glVertex calls
// Make sure colors count match vertex count // Make sure colors count match vertex count
if (vertexData[currentBuffer].vCounter != vertexData[currentBuffer].cCounter) if (vertexData[currentBuffer].vCounter != vertexData[currentBuffer].cCounter)
{ {
@ -1156,7 +1156,7 @@ void rlEnd(void)
vertexData[currentBuffer].cCounter++; vertexData[currentBuffer].cCounter++;
} }
} }
// Make sure texcoords count match vertex count // Make sure texcoords count match vertex count
if (vertexData[currentBuffer].vCounter != vertexData[currentBuffer].tcCounter) if (vertexData[currentBuffer].vCounter != vertexData[currentBuffer].tcCounter)
{ {
@ -1194,10 +1194,10 @@ void rlEnd(void)
void rlVertex3f(float x, float y, float z) void rlVertex3f(float x, float y, float z)
{ {
Vector3 vec = { x, y, z }; Vector3 vec = { x, y, z };
// Transform provided vector if required // Transform provided vector if required
if (useTransformMatrix) vec = Vector3Transform(vec, transformMatrix); if (useTransformMatrix) vec = Vector3Transform(vec, transformMatrix);
// Verify that MAX_BATCH_ELEMENTS limit not reached // Verify that MAX_BATCH_ELEMENTS limit not reached
if (vertexData[currentBuffer].vCounter < (MAX_BATCH_ELEMENTS*4)) if (vertexData[currentBuffer].vCounter < (MAX_BATCH_ELEMENTS*4))
{ {
@ -1499,7 +1499,7 @@ void rlglInit(int width, int height)
//for (int i = 0; i < numComp; i++) TraceLog(LOG_INFO, "Supported compressed format: 0x%x", format[i]); //for (int i = 0; i < numComp; i++) TraceLog(LOG_INFO, "Supported compressed format: 0x%x", format[i]);
// NOTE: We don't need that much data on screen... right now... // NOTE: We don't need that much data on screen... right now...
// TODO: Automatize extensions loading using rlLoadExtensions() and GLAD // TODO: Automatize extensions loading using rlLoadExtensions() and GLAD
// Actually, when rlglInit() is called in InitWindow() in core.c, // Actually, when rlglInit() is called in InitWindow() in core.c,
// OpenGL required extensions have already been loaded (PLATFORM_DESKTOP) // OpenGL required extensions have already been loaded (PLATFORM_DESKTOP)
@ -1512,7 +1512,7 @@ void rlglInit(int width, int height)
// NOTE: On OpenGL 3.3 VAO and NPOT are supported by default // NOTE: On OpenGL 3.3 VAO and NPOT are supported by default
vaoSupported = true; vaoSupported = true;
// Multiple texture extensions supported by default // Multiple texture extensions supported by default
texNPOTSupported = true; texNPOTSupported = true;
texFloatSupported = true; texFloatSupported = true;
@ -1585,11 +1585,11 @@ void rlglInit(int width, int height)
// Check texture float support // Check texture float support
if (strcmp(extList[i], (const char *)"GL_OES_texture_float") == 0) texFloatSupported = true; if (strcmp(extList[i], (const char *)"GL_OES_texture_float") == 0) texFloatSupported = true;
// Check depth texture support // Check depth texture support
if ((strcmp(extList[i], (const char *)"GL_OES_depth_texture") == 0) || if ((strcmp(extList[i], (const char *)"GL_OES_depth_texture") == 0) ||
(strcmp(extList[i], (const char *)"GL_WEBGL_depth_texture") == 0)) texDepthSupported = true; (strcmp(extList[i], (const char *)"GL_WEBGL_depth_texture") == 0)) texDepthSupported = true;
if (strcmp(extList[i], (const char *)"GL_OES_depth24") == 0) maxDepthBits = 24; if (strcmp(extList[i], (const char *)"GL_OES_depth24") == 0) maxDepthBits = 24;
if (strcmp(extList[i], (const char *)"GL_OES_depth32") == 0) maxDepthBits = 32; if (strcmp(extList[i], (const char *)"GL_OES_depth32") == 0) maxDepthBits = 32;
#endif #endif
@ -1648,8 +1648,8 @@ void rlglInit(int width, int height)
if (debugMarkerSupported) TraceLog(LOG_INFO, "[EXTENSION] Debug Marker supported"); if (debugMarkerSupported) TraceLog(LOG_INFO, "[EXTENSION] Debug Marker supported");
// Initialize buffers, default shaders and default textures // Initialize buffers, default shaders and default textures
//---------------------------------------------------------- //----------------------------------------------------------
@ -1666,7 +1666,7 @@ void rlglInit(int width, int height)
// Init default vertex arrays buffers // Init default vertex arrays buffers
LoadBuffersDefault(); LoadBuffersDefault();
// Init transformations matrix accumulator // Init transformations matrix accumulator
transformMatrix = MatrixIdentity(); transformMatrix = MatrixIdentity();
@ -1995,9 +1995,9 @@ unsigned int rlLoadTextureDepth(int width, int height, int bits, bool useRenderB
{ {
unsigned int id = 0; unsigned int id = 0;
unsigned int glInternalFormat = GL_DEPTH_COMPONENT16; unsigned int glInternalFormat = GL_DEPTH_COMPONENT16;
if ((bits != 16) && (bits != 24) && (bits != 32)) bits = 16; if ((bits != 16) && (bits != 24) && (bits != 32)) bits = 16;
if (bits == 24) if (bits == 24)
{ {
#if defined(GRAPHICS_API_OPENGL_33) #if defined(GRAPHICS_API_OPENGL_33)
@ -2006,7 +2006,7 @@ unsigned int rlLoadTextureDepth(int width, int height, int bits, bool useRenderB
if (maxDepthBits >= 24) glInternalFormat = GL_DEPTH_COMPONENT24_OES; if (maxDepthBits >= 24) glInternalFormat = GL_DEPTH_COMPONENT24_OES;
#endif #endif
} }
if (bits == 32) if (bits == 32)
{ {
#if defined(GRAPHICS_API_OPENGL_33) #if defined(GRAPHICS_API_OPENGL_33)
@ -2021,7 +2021,7 @@ unsigned int rlLoadTextureDepth(int width, int height, int bits, bool useRenderB
glGenTextures(1, &id); glGenTextures(1, &id);
glBindTexture(GL_TEXTURE_2D, id); glBindTexture(GL_TEXTURE_2D, id);
glTexImage2D(GL_TEXTURE_2D, 0, glInternalFormat, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); glTexImage2D(GL_TEXTURE_2D, 0, glInternalFormat, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
@ -2036,10 +2036,10 @@ unsigned int rlLoadTextureDepth(int width, int height, int bits, bool useRenderB
glGenRenderbuffers(1, &id); glGenRenderbuffers(1, &id);
glBindRenderbuffer(GL_RENDERBUFFER, id); glBindRenderbuffer(GL_RENDERBUFFER, id);
glRenderbufferStorage(GL_RENDERBUFFER, glInternalFormat, width, height); glRenderbufferStorage(GL_RENDERBUFFER, glInternalFormat, width, height);
glBindRenderbuffer(GL_RENDERBUFFER, 0); glBindRenderbuffer(GL_RENDERBUFFER, 0);
} }
return id; return id;
} }
@ -2053,7 +2053,7 @@ unsigned int rlLoadTextureCubemap(void *data, int size, int format)
glGenTextures(1, &cubemapId); glGenTextures(1, &cubemapId);
glBindTexture(GL_TEXTURE_CUBE_MAP, cubemapId); glBindTexture(GL_TEXTURE_CUBE_MAP, cubemapId);
unsigned int glInternalFormat, glFormat, glType; unsigned int glInternalFormat, glFormat, glType;
rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
@ -2084,7 +2084,7 @@ unsigned int rlLoadTextureCubemap(void *data, int size, int format)
#endif #endif
} }
} }
// Set cubemap texture sampling parameters // Set cubemap texture sampling parameters
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@ -2178,14 +2178,14 @@ void rlUnloadTexture(unsigned int id)
RenderTexture2D rlLoadRenderTexture(int width, int height, int format, int depthBits, bool useDepthTexture) RenderTexture2D rlLoadRenderTexture(int width, int height, int format, int depthBits, bool useDepthTexture)
{ {
RenderTexture2D target = { 0 }; RenderTexture2D target = { 0 };
if (useDepthTexture && texDepthSupported) target.depthTexture = true; if (useDepthTexture && texDepthSupported) target.depthTexture = true;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
// Create the framebuffer object // Create the framebuffer object
glGenFramebuffers(1, &target.id); glGenFramebuffers(1, &target.id);
glBindFramebuffer(GL_FRAMEBUFFER, target.id); glBindFramebuffer(GL_FRAMEBUFFER, target.id);
// Create fbo color texture attachment // Create fbo color texture attachment
//----------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------
if ((format != -1) && (format < COMPRESSED_DXT1_RGB)) if ((format != -1) && (format < COMPRESSED_DXT1_RGB))
@ -2198,7 +2198,7 @@ RenderTexture2D rlLoadRenderTexture(int width, int height, int format, int depth
target.texture.mipmaps = 1; target.texture.mipmaps = 1;
} }
//----------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------
// Create fbo depth renderbuffer/texture // Create fbo depth renderbuffer/texture
//----------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------
if (depthBits > 0) if (depthBits > 0)
@ -2210,7 +2210,7 @@ RenderTexture2D rlLoadRenderTexture(int width, int height, int format, int depth
target.depth.mipmaps = 1; target.depth.mipmaps = 1;
} }
//----------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------
// Attach color texture and depth renderbuffer to FBO // Attach color texture and depth renderbuffer to FBO
//----------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------
rlRenderTextureAttach(target, target.texture.id, 0); // COLOR attachment rlRenderTextureAttach(target, target.texture.id, 0); // COLOR attachment
@ -2235,12 +2235,12 @@ void rlRenderTextureAttach(RenderTexture2D target, unsigned int id, int attachTy
glBindFramebuffer(GL_FRAMEBUFFER, target.id); glBindFramebuffer(GL_FRAMEBUFFER, target.id);
if (attachType == 0) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, id, 0); if (attachType == 0) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, id, 0);
else if (attachType == 1) else if (attachType == 1)
{ {
if (target.depthTexture) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, id, 0); if (target.depthTexture) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, id, 0);
else glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, id); else glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, id);
} }
glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0);
} }
@ -2248,7 +2248,7 @@ void rlRenderTextureAttach(RenderTexture2D target, unsigned int id, int attachTy
bool rlRenderTextureComplete(RenderTexture target) bool rlRenderTextureComplete(RenderTexture target)
{ {
glBindFramebuffer(GL_FRAMEBUFFER, target.id); glBindFramebuffer(GL_FRAMEBUFFER, target.id);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE) if (status != GL_FRAMEBUFFER_COMPLETE)
@ -2264,9 +2264,9 @@ bool rlRenderTextureComplete(RenderTexture target)
default: break; default: break;
} }
} }
glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0);
return (status == GL_FRAMEBUFFER_COMPLETE); return (status == GL_FRAMEBUFFER_COMPLETE);
} }
@ -2349,7 +2349,7 @@ void rlLoadMesh(Mesh *mesh, bool dynamic)
TraceLog(LOG_WARNING, "Trying to re-load an already loaded mesh"); TraceLog(LOG_WARNING, "Trying to re-load an already loaded mesh");
return; return;
} }
mesh->vaoId = 0; // Vertex Array Object mesh->vaoId = 0; // Vertex Array Object
mesh->vboId[0] = 0; // Vertex positions VBO mesh->vboId[0] = 0; // Vertex positions VBO
mesh->vboId[1] = 0; // Vertex texcoords VBO mesh->vboId[1] = 0; // Vertex texcoords VBO
@ -2766,7 +2766,7 @@ unsigned char *rlReadScreenPixels(int width, int height)
for (int x = 0; x < (width*4); x++) for (int x = 0; x < (width*4); x++)
{ {
imgData[((height - 1) - y)*width*4 + x] = screenData[(y*width*4) + x]; // Flip line imgData[((height - 1) - y)*width*4 + x] = screenData[(y*width*4) + x]; // Flip line
// Set alpha component value to 255 (no trasparent image retrieval) // Set alpha component value to 255 (no trasparent image retrieval)
// NOTE: Alpha value has already been applied to RGB in framebuffer, we don't need it! // NOTE: Alpha value has already been applied to RGB in framebuffer, we don't need it!
if (((x + 1)%4) == 0) imgData[((height - 1) - y)*width*4 + x] = 255; if (((x + 1)%4) == 0) imgData[((height - 1) - y)*width*4 + x] = 255;
@ -2822,7 +2822,7 @@ void *rlReadTexturePixels(Texture2D texture)
// We are using Option 1, just need to care for texture format on retrieval // We are using Option 1, just need to care for texture format on retrieval
// NOTE: This behaviour could be conditioned by graphic driver... // NOTE: This behaviour could be conditioned by graphic driver...
RenderTexture2D fbo = rlLoadRenderTexture(texture.width, texture.height, UNCOMPRESSED_R8G8B8A8, 16, false); RenderTexture2D fbo = rlLoadRenderTexture(texture.width, texture.height, UNCOMPRESSED_R8G8B8A8, 16, false);
glBindFramebuffer(GL_FRAMEBUFFER, fbo.id); glBindFramebuffer(GL_FRAMEBUFFER, fbo.id);
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
@ -2836,7 +2836,7 @@ void *rlReadTexturePixels(Texture2D texture)
// Get OpenGL internal formats and data type from our texture format // Get OpenGL internal formats and data type from our texture format
unsigned int glInternalFormat, glFormat, glType; unsigned int glInternalFormat, glFormat, glType;
rlGetGlTextureFormats(texture.format, &glInternalFormat, &glFormat, &glType); rlGetGlTextureFormats(texture.format, &glInternalFormat, &glFormat, &glType);
// NOTE: We read data as RGBA because FBO texture is configured as RGBA, despite binding a RGB texture... // NOTE: We read data as RGBA because FBO texture is configured as RGBA, despite binding a RGB texture...
glReadPixels(0, 0, texture.width, texture.height, glFormat, glType, pixels); glReadPixels(0, 0, texture.width, texture.height, glFormat, glType, pixels);
@ -3064,7 +3064,7 @@ void SetShaderValueV(Shader shader, int uniformLoc, const void *value, int unifo
case UNIFORM_SAMPLER2D: glUniform1iv(uniformLoc, count, (int *)value); break; case UNIFORM_SAMPLER2D: glUniform1iv(uniformLoc, count, (int *)value); break;
default: TraceLog(LOG_WARNING, "Shader uniform could not be set data type not recognized"); default: TraceLog(LOG_WARNING, "Shader uniform could not be set data type not recognized");
} }
//glUseProgram(0); // Avoid reseting current shader program, in case other uniforms are set //glUseProgram(0); // Avoid reseting current shader program, in case other uniforms are set
#endif #endif
} }
@ -3143,7 +3143,7 @@ Texture2D GenTextureCubemap(Shader shader, Texture2D skyHDR, int size)
// NOTE: Faces are stored as 32 bit floating point values // NOTE: Faces are stored as 32 bit floating point values
glGenTextures(1, &cubemap.id); glGenTextures(1, &cubemap.id);
glBindTexture(GL_TEXTURE_CUBE_MAP, cubemap.id); glBindTexture(GL_TEXTURE_CUBE_MAP, cubemap.id);
for (unsigned int i = 0; i < 6; i++) for (unsigned int i = 0; i < 6; i++)
{ {
#if defined(GRAPHICS_API_OPENGL_33) #if defined(GRAPHICS_API_OPENGL_33)
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB32F, size, size, 0, GL_RGB, GL_FLOAT, NULL); glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB32F, size, size, 0, GL_RGB, GL_FLOAT, NULL);
@ -3151,7 +3151,7 @@ Texture2D GenTextureCubemap(Shader shader, Texture2D skyHDR, int size)
if (texFloatSupported) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, size, size, 0, GL_RGB, GL_FLOAT, NULL); if (texFloatSupported) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, size, size, 0, GL_RGB, GL_FLOAT, NULL);
#endif #endif
} }
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
#if defined(GRAPHICS_API_OPENGL_33) #if defined(GRAPHICS_API_OPENGL_33)
@ -3231,7 +3231,7 @@ Texture2D GenTextureIrradiance(Shader shader, Texture2D cubemap, int size)
{ {
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, size, size, 0, GL_RGB, GL_FLOAT, NULL); glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, size, size, 0, GL_RGB, GL_FLOAT, NULL);
} }
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
@ -3309,7 +3309,7 @@ Texture2D GenTexturePrefilter(Shader shader, Texture2D cubemap, int size)
{ {
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, size, size, 0, GL_RGB, GL_FLOAT, NULL); glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, size, size, 0, GL_RGB, GL_FLOAT, NULL);
} }
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
@ -3417,7 +3417,7 @@ Texture2D GenTextureBRDF(Shader shader, int size)
// Unbind framebuffer and textures // Unbind framebuffer and textures
glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Unload framebuffer but keep color texture // Unload framebuffer but keep color texture
glDeleteRenderbuffers(1, &rbo); glDeleteRenderbuffers(1, &rbo);
glDeleteFramebuffers(1, &fbo); glDeleteFramebuffers(1, &fbo);
@ -3464,7 +3464,7 @@ void EndBlendMode(void)
void BeginScissorMode(int x, int y, int width, int height) void BeginScissorMode(int x, int y, int width, int height)
{ {
rlglDraw(); // Force drawing elements rlglDraw(); // Force drawing elements
glEnable(GL_SCISSOR_TEST); glEnable(GL_SCISSOR_TEST);
glScissor(x, screenHeight - (y + height), width, height); glScissor(x, screenHeight - (y + height), width, height);
} }
@ -3473,7 +3473,7 @@ void BeginScissorMode(int x, int y, int width, int height)
void EndScissorMode(void) void EndScissorMode(void)
{ {
rlglDraw(); // Force drawing elements rlglDraw(); // Force drawing elements
glDisable(GL_SCISSOR_TEST); glDisable(GL_SCISSOR_TEST);
} }
@ -4050,7 +4050,7 @@ static void LoadBuffersDefault(void)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(short)*6*MAX_BATCH_ELEMENTS, vertexData[i].indices, GL_STATIC_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(short)*6*MAX_BATCH_ELEMENTS, vertexData[i].indices, GL_STATIC_DRAW);
#endif #endif
} }
TraceLog(LOG_INFO, "Internal buffers uploaded successfully (GPU)"); TraceLog(LOG_INFO, "Internal buffers uploaded successfully (GPU)");
// Unbind the current VAO // Unbind the current VAO
@ -4073,7 +4073,7 @@ static void UpdateBuffersDefault(void)
glBindBuffer(GL_ARRAY_BUFFER, vertexData[currentBuffer].vboId[0]); glBindBuffer(GL_ARRAY_BUFFER, vertexData[currentBuffer].vboId[0]);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float)*3*vertexData[currentBuffer].vCounter, vertexData[currentBuffer].vertices); glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float)*3*vertexData[currentBuffer].vCounter, vertexData[currentBuffer].vertices);
//glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*MAX_BATCH_ELEMENTS, vertexData[currentBuffer].vertices, GL_DYNAMIC_DRAW); // Update all buffer //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*MAX_BATCH_ELEMENTS, vertexData[currentBuffer].vertices, GL_DYNAMIC_DRAW); // Update all buffer
// Texture coordinates buffer // Texture coordinates buffer
glBindBuffer(GL_ARRAY_BUFFER, vertexData[currentBuffer].vboId[1]); glBindBuffer(GL_ARRAY_BUFFER, vertexData[currentBuffer].vboId[1]);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float)*2*vertexData[currentBuffer].vCounter, vertexData[currentBuffer].texcoords); glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float)*2*vertexData[currentBuffer].vCounter, vertexData[currentBuffer].texcoords);
@ -4083,13 +4083,13 @@ static void UpdateBuffersDefault(void)
glBindBuffer(GL_ARRAY_BUFFER, vertexData[currentBuffer].vboId[2]); glBindBuffer(GL_ARRAY_BUFFER, vertexData[currentBuffer].vboId[2]);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(unsigned char)*4*vertexData[currentBuffer].vCounter, vertexData[currentBuffer].colors); glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(unsigned char)*4*vertexData[currentBuffer].vCounter, vertexData[currentBuffer].colors);
//glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*4*MAX_BATCH_ELEMENTS, vertexData[currentBuffer].colors, GL_DYNAMIC_DRAW); // Update all buffer //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*4*MAX_BATCH_ELEMENTS, vertexData[currentBuffer].colors, GL_DYNAMIC_DRAW); // Update all buffer
// NOTE: glMapBuffer() causes sync issue. // NOTE: glMapBuffer() causes sync issue.
// If GPU is working with this buffer, glMapBuffer() will wait(stall) until GPU to finish its job. // If GPU is working with this buffer, glMapBuffer() will wait(stall) until GPU to finish its job.
// To avoid waiting (idle), you can call first glBufferData() with NULL pointer before glMapBuffer(). // To avoid waiting (idle), you can call first glBufferData() with NULL pointer before glMapBuffer().
// If you do that, the previous data in PBO will be discarded and glMapBuffer() returns a new // If you do that, the previous data in PBO will be discarded and glMapBuffer() returns a new
// allocated pointer immediately even if GPU is still working with the previous data. // allocated pointer immediately even if GPU is still working with the previous data.
// Another option: map the buffer object into client's memory // Another option: map the buffer object into client's memory
// Probably this code could be moved somewhere else... // Probably this code could be moved somewhere else...
// vertexData[currentBuffer].vertices = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE); // vertexData[currentBuffer].vertices = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
@ -4135,7 +4135,7 @@ static void DrawBuffersDefault(void)
glUniform1i(currentShader.locs[LOC_MAP_DIFFUSE], 0); glUniform1i(currentShader.locs[LOC_MAP_DIFFUSE], 0);
// NOTE: Additional map textures not considered for default buffers drawing // NOTE: Additional map textures not considered for default buffers drawing
int vertexOffset = 0; int vertexOffset = 0;
if (vaoSupported) glBindVertexArray(vertexData[currentBuffer].vaoId); if (vaoSupported) glBindVertexArray(vertexData[currentBuffer].vaoId);
@ -4160,7 +4160,7 @@ static void DrawBuffersDefault(void)
} }
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
for (int i = 0; i < drawsCounter; i++) for (int i = 0; i < drawsCounter; i++)
{ {
glBindTexture(GL_TEXTURE_2D, draws[i].textureId); glBindTexture(GL_TEXTURE_2D, draws[i].textureId);
@ -4170,7 +4170,7 @@ static void DrawBuffersDefault(void)
{ {
#if defined(GRAPHICS_API_OPENGL_33) #if defined(GRAPHICS_API_OPENGL_33)
// We need to define the number of indices to be processed: quadsCount*6 // We need to define the number of indices to be processed: quadsCount*6
// NOTE: The final parameter tells the GPU the offset in bytes from the // NOTE: The final parameter tells the GPU the offset in bytes from the
// start of the index buffer to the location of the first index to process // start of the index buffer to the location of the first index to process
glDrawElements(GL_TRIANGLES, draws[i].vertexCount/4*6, GL_UNSIGNED_INT, (GLvoid *)(sizeof(GLuint)*vertexOffset/4*6)); glDrawElements(GL_TRIANGLES, draws[i].vertexCount/4*6, GL_UNSIGNED_INT, (GLvoid *)(sizeof(GLuint)*vertexOffset/4*6));
#elif defined(GRAPHICS_API_OPENGL_ES2) #elif defined(GRAPHICS_API_OPENGL_ES2)
@ -4216,7 +4216,7 @@ static void DrawBuffersDefault(void)
} }
drawsCounter = 1; drawsCounter = 1;
// Change to next buffer in the list // Change to next buffer in the list
currentBuffer++; currentBuffer++;
if (currentBuffer >= MAX_BATCH_BUFFERING) currentBuffer = 0; if (currentBuffer >= MAX_BATCH_BUFFERING) currentBuffer = 0;
@ -4369,14 +4369,14 @@ static void GenDrawCube(void)
static VrStereoConfig SetStereoConfig(VrDeviceInfo hmd, Shader distortion) static VrStereoConfig SetStereoConfig(VrDeviceInfo hmd, Shader distortion)
{ {
VrStereoConfig config = { 0 }; VrStereoConfig config = { 0 };
// Initialize framebuffer and textures for stereo rendering // Initialize framebuffer and textures for stereo rendering
// NOTE: Screen size should match HMD aspect ratio // NOTE: Screen size should match HMD aspect ratio
config.stereoFbo = rlLoadRenderTexture(screenWidth, screenHeight, UNCOMPRESSED_R8G8B8A8, 24, false); config.stereoFbo = rlLoadRenderTexture(screenWidth, screenHeight, UNCOMPRESSED_R8G8B8A8, 24, false);
// Assign distortion shader // Assign distortion shader
config.distortionShader = distortion; config.distortionShader = distortion;
// Compute aspect ratio // Compute aspect ratio
float aspect = ((float)hmd.hResolution*0.5f)/(float)hmd.vResolution; float aspect = ((float)hmd.hResolution*0.5f)/(float)hmd.vResolution;
@ -4442,7 +4442,7 @@ static VrStereoConfig SetStereoConfig(VrDeviceInfo hmd, Shader distortion)
SetShaderValue(config.distortionShader, GetShaderLocation(config.distortionShader, "hmdWarpParam"), hmd.lensDistortionValues, UNIFORM_VEC4); SetShaderValue(config.distortionShader, GetShaderLocation(config.distortionShader, "hmdWarpParam"), hmd.lensDistortionValues, UNIFORM_VEC4);
SetShaderValue(config.distortionShader, GetShaderLocation(config.distortionShader, "chromaAbParam"), hmd.chromaAbCorrection, UNIFORM_VEC4); SetShaderValue(config.distortionShader, GetShaderLocation(config.distortionShader, "chromaAbParam"), hmd.chromaAbCorrection, UNIFORM_VEC4);
#endif #endif
return config; return config;
} }

8
src/shapes.c
View File

@ -143,7 +143,7 @@ void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color)
rlTexCoord2f(recTexShapes.x/texShapes.width, (recTexShapes.y + recTexShapes.height)/texShapes.height); rlTexCoord2f(recTexShapes.x/texShapes.width, (recTexShapes.y + recTexShapes.height)/texShapes.height);
rlVertex2f(0.0f, thick); rlVertex2f(0.0f, thick);
rlTexCoord2f((recTexShapes.x + recTexShapes.width)/texShapes.width, (recTexShapes.y + recTexShapes.height)/texShapes.height); rlTexCoord2f((recTexShapes.x + recTexShapes.width)/texShapes.width, (recTexShapes.y + recTexShapes.height)/texShapes.height);
rlVertex2f(d, thick); rlVertex2f(d, thick);
@ -187,7 +187,7 @@ void DrawCircle(int centerX, int centerY, float radius, Color color)
void DrawCircleSector(Vector2 center, float radius, int startAngle, int endAngle, Color color) void DrawCircleSector(Vector2 center, float radius, int startAngle, int endAngle, Color color)
{ {
#define CIRCLE_SECTOR_LENGTH 10 #define CIRCLE_SECTOR_LENGTH 10
#if defined(SUPPORT_QUADS_DRAW_MODE) #if defined(SUPPORT_QUADS_DRAW_MODE)
if (rlCheckBufferLimit(4*((360/CIRCLE_SECTOR_LENGTH)/2))) rlglDraw(); if (rlCheckBufferLimit(4*((360/CIRCLE_SECTOR_LENGTH)/2))) rlglDraw();
@ -307,10 +307,10 @@ void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color
rlTexCoord2f(recTexShapes.x/texShapes.width, recTexShapes.y/texShapes.height); rlTexCoord2f(recTexShapes.x/texShapes.width, recTexShapes.y/texShapes.height);
rlVertex2f(0.0f, 0.0f); rlVertex2f(0.0f, 0.0f);
rlTexCoord2f(recTexShapes.x/texShapes.width, (recTexShapes.y + recTexShapes.height)/texShapes.height); rlTexCoord2f(recTexShapes.x/texShapes.width, (recTexShapes.y + recTexShapes.height)/texShapes.height);
rlVertex2f(0.0f, rec.height); rlVertex2f(0.0f, rec.height);
rlTexCoord2f((recTexShapes.x + recTexShapes.width)/texShapes.width, (recTexShapes.y + recTexShapes.height)/texShapes.height); rlTexCoord2f((recTexShapes.x + recTexShapes.width)/texShapes.width, (recTexShapes.y + recTexShapes.height)/texShapes.height);
rlVertex2f(rec.width, rec.height); rlVertex2f(rec.width, rec.height);

86
src/text.c
View File

@ -790,14 +790,14 @@ void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, f
} }
// Draw text using font inside rectangle limits // Draw text using font inside rectangle limits
void DrawTextRec(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint) void DrawTextRec(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint)
{ {
DrawTextRecEx(font, text, rec, fontSize, spacing, wordWrap, tint, 0, 0, WHITE, WHITE); DrawTextRecEx(font, text, rec, fontSize, spacing, wordWrap, tint, 0, 0, WHITE, WHITE);
} }
// Draw text using font inside rectangle limits with support for text selection // Draw text using font inside rectangle limits with support for text selection
void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint, void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint,
int selectStart, int selectLength, Color selectText, Color selectBack) int selectStart, int selectLength, Color selectText, Color selectBack)
{ {
int length = strlen(text); int length = strlen(text);
int textOffsetX = 0; // Offset between characters int textOffsetX = 0; // Offset between characters
@ -813,12 +813,12 @@ void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, f
int state = wordWrap? MEASURE_STATE : DRAW_STATE; int state = wordWrap? MEASURE_STATE : DRAW_STATE;
int startLine = -1; // Index where to begin drawing (where a line begins) int startLine = -1; // Index where to begin drawing (where a line begins)
int endLine = -1; // Index where to stop drawing (where a line ends) int endLine = -1; // Index where to stop drawing (where a line ends)
for (int i = 0; i < length; i++) for (int i = 0; i < length; i++)
{ {
int glyphWidth = 0; int glyphWidth = 0;
letter = (unsigned char)text[i]; letter = (unsigned char)text[i];
if (letter != '\n') if (letter != '\n')
{ {
if ((unsigned char)text[i] == 0xc2) // UTF-8 encoding identification HACK! if ((unsigned char)text[i] == 0xc2) // UTF-8 encoding identification HACK!
@ -836,41 +836,41 @@ void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, f
i++; i++;
} }
else index = GetGlyphIndex(font, (unsigned char)text[i]); else index = GetGlyphIndex(font, (unsigned char)text[i]);
glyphWidth = (font.chars[index].advanceX == 0)? glyphWidth = (font.chars[index].advanceX == 0)?
(int)(font.chars[index].rec.width*scaleFactor + spacing): (int)(font.chars[index].rec.width*scaleFactor + spacing):
(int)(font.chars[index].advanceX*scaleFactor + spacing); (int)(font.chars[index].advanceX*scaleFactor + spacing);
} }
// NOTE: When wordWrap is ON we first measure how much of the text we can draw // NOTE: When wordWrap is ON we first measure how much of the text we can draw
// before going outside of the `rec` container. We store this info inside // before going outside of the `rec` container. We store this info inside
// `startLine` and `endLine` then we change states, draw the text between those two // `startLine` and `endLine` then we change states, draw the text between those two
// variables then change states again and again recursively until the end of the text // variables then change states again and again recursively until the end of the text
// (or until we get outside of the container). // (or until we get outside of the container).
// When wordWrap is OFF we don't need the measure state so we go to the drawing // When wordWrap is OFF we don't need the measure state so we go to the drawing
// state immediately and begin drawing on the next line before we can get outside // state immediately and begin drawing on the next line before we can get outside
// the container. // the container.
if (state == MEASURE_STATE) if (state == MEASURE_STATE)
{ {
if ((letter == ' ') || (letter == '\t') || (letter == '\n')) endLine = i; if ((letter == ' ') || (letter == '\t') || (letter == '\n')) endLine = i;
if ((textOffsetX + glyphWidth + 1) >= rec.width) if ((textOffsetX + glyphWidth + 1) >= rec.width)
{ {
endLine = (endLine < 1) ? i : endLine; endLine = (endLine < 1) ? i : endLine;
if (i == endLine) endLine -= 1; if (i == endLine) endLine -= 1;
if ((startLine + 1) == endLine) endLine = i - 1; if ((startLine + 1) == endLine) endLine = i - 1;
state = !state; state = !state;
} }
else if ((i + 1) == length) else if ((i + 1) == length)
{ {
endLine = i; endLine = i;
state = !state; state = !state;
} }
else if (letter == '\n') else if (letter == '\n')
{ {
state = !state; state = !state;
} }
if (state == DRAW_STATE) if (state == DRAW_STATE)
{ {
textOffsetX = 0; textOffsetX = 0;
@ -878,8 +878,8 @@ void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, f
glyphWidth = 0; glyphWidth = 0;
} }
} }
else else
{ {
if (letter == '\n') if (letter == '\n')
{ {
@ -888,17 +888,17 @@ void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, f
textOffsetY += (int)((font.baseSize + font.baseSize/2)*scaleFactor); textOffsetY += (int)((font.baseSize + font.baseSize/2)*scaleFactor);
textOffsetX = 0; textOffsetX = 0;
} }
} }
else else
{ {
if (!wordWrap && ((textOffsetX + glyphWidth + 1) >= rec.width)) if (!wordWrap && ((textOffsetX + glyphWidth + 1) >= rec.width))
{ {
textOffsetY += (int)((font.baseSize + font.baseSize/2)*scaleFactor); textOffsetY += (int)((font.baseSize + font.baseSize/2)*scaleFactor);
textOffsetX = 0; textOffsetX = 0;
} }
if ((textOffsetY + (int)((font.baseSize + font.baseSize/2)*scaleFactor)) > rec.height) break; if ((textOffsetY + (int)((font.baseSize + font.baseSize/2)*scaleFactor)) > rec.height) break;
//draw selected //draw selected
bool isGlyphSelected = false; bool isGlyphSelected = false;
if ((selectStart >= 0) && (i >= selectStart) && (i < (selectStart + selectLength))) if ((selectStart >= 0) && (i >= selectStart) && (i < (selectStart + selectLength)))
@ -907,7 +907,7 @@ void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, f
DrawRectangleRec(strec, selectBack); DrawRectangleRec(strec, selectBack);
isGlyphSelected = true; isGlyphSelected = true;
} }
//draw glyph //draw glyph
if ((letter != ' ') && (letter != '\t')) if ((letter != ' ') && (letter != '\t'))
{ {
@ -915,12 +915,12 @@ void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, f
(Rectangle){ rec.x + textOffsetX + font.chars[index].offsetX*scaleFactor, (Rectangle){ rec.x + textOffsetX + font.chars[index].offsetX*scaleFactor,
rec.y + textOffsetY + font.chars[index].offsetY*scaleFactor, rec.y + textOffsetY + font.chars[index].offsetY*scaleFactor,
font.chars[index].rec.width*scaleFactor, font.chars[index].rec.width*scaleFactor,
font.chars[index].rec.height*scaleFactor }, (Vector2){ 0, 0 }, 0.0f, font.chars[index].rec.height*scaleFactor }, (Vector2){ 0, 0 }, 0.0f,
(!isGlyphSelected) ? tint : selectText); (!isGlyphSelected) ? tint : selectText);
} }
} }
if (wordWrap && (i == endLine)) if (wordWrap && (i == endLine))
{ {
textOffsetY += (int)((font.baseSize + font.baseSize/2)*scaleFactor); textOffsetY += (int)((font.baseSize + font.baseSize/2)*scaleFactor);
textOffsetX = 0; textOffsetX = 0;
@ -930,7 +930,7 @@ void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, f
state = !state; state = !state;
} }
} }
textOffsetX += glyphWidth; textOffsetX += glyphWidth;
} }
} }
@ -968,11 +968,11 @@ Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing
unsigned char letter = 0; // Current character unsigned char letter = 0; // Current character
int index = 0; // Index position in sprite font int index = 0; // Index position in sprite font
for (int i = 0; i < len; i++) for (int i = 0; i < len; i++)
{ {
lenCounter++; lenCounter++;
if (text[i] != '\n') if (text[i] != '\n')
{ {
if ((unsigned char)text[i] == 0xc2) // UTF-8 encoding identification if ((unsigned char)text[i] == 0xc2) // UTF-8 encoding identification
@ -1105,7 +1105,7 @@ const char *TextSubtext(const char *text, int position, int length)
const char *TextReplace(char *text, const char *replace, const char *by) const char *TextReplace(char *text, const char *replace, const char *by)
{ {
char *result; char *result;
char *insertPoint; // Next insert point char *insertPoint; // Next insert point
char *temp; // Temp pointer char *temp; // Temp pointer
int replaceLen; // Replace string length of (the string to remove) int replaceLen; // Replace string length of (the string to remove)
@ -1163,7 +1163,7 @@ const char *TextInsert(const char *text, const char *insert, int position)
for (int i = 0; i < position; i++) result[i] = text[i]; for (int i = 0; i < position; i++) result[i] = text[i];
for (int i = position; i < insertLen + position; i++) result[i] = insert[i]; for (int i = position; i < insertLen + position; i++) result[i] = insert[i];
for (int i = (insertLen + position); i < (textLen + insertLen); i++) result[i] = text[i]; for (int i = (insertLen + position); i < (textLen + insertLen); i++) result[i] = text[i];
result[textLen + insertLen] = '\0'; // Make sure text string is valid! result[textLen + insertLen] = '\0'; // Make sure text string is valid!
return result; return result;
@ -1174,7 +1174,7 @@ const char *TextInsert(const char *text, const char *insert, int position)
const char *TextJoin(const char **textList, int count, const char *delimiter) const char *TextJoin(const char **textList, int count, const char *delimiter)
{ {
// TODO: Make sure joined text could fit inside MAX_TEXT_BUFFER_LENGTH // TODO: Make sure joined text could fit inside MAX_TEXT_BUFFER_LENGTH
static char text[MAX_TEXT_BUFFER_LENGTH] = { 0 }; static char text[MAX_TEXT_BUFFER_LENGTH] = { 0 };
memset(text, 0, MAX_TEXT_BUFFER_LENGTH); memset(text, 0, MAX_TEXT_BUFFER_LENGTH);
@ -1197,9 +1197,9 @@ const char **TextSplit(const char *text, char delimiter, int *count)
// all used memory is static... it has some limitations: // all used memory is static... it has some limitations:
// 1. Maximum number of possible split strings is set by MAX_SUBSTRINGS_COUNT // 1. Maximum number of possible split strings is set by MAX_SUBSTRINGS_COUNT
// 2. Maximum size of text to split is MAX_TEXT_BUFFER_LENGTH // 2. Maximum size of text to split is MAX_TEXT_BUFFER_LENGTH
#define MAX_SUBSTRINGS_COUNT 64 #define MAX_SUBSTRINGS_COUNT 64
static const char *result[MAX_SUBSTRINGS_COUNT] = { NULL }; static const char *result[MAX_SUBSTRINGS_COUNT] = { NULL };
static char buffer[MAX_TEXT_BUFFER_LENGTH] = { 0 }; static char buffer[MAX_TEXT_BUFFER_LENGTH] = { 0 };
memset(buffer, 0, MAX_TEXT_BUFFER_LENGTH); memset(buffer, 0, MAX_TEXT_BUFFER_LENGTH);
@ -1208,7 +1208,7 @@ const char **TextSplit(const char *text, char delimiter, int *count)
int counter = 1; int counter = 1;
// Count how many substrings we have on text and point to every one // Count how many substrings we have on text and point to every one
for (int i = 0; i < MAX_TEXT_BUFFER_LENGTH; i++) for (int i = 0; i < MAX_TEXT_BUFFER_LENGTH; i++)
{ {
buffer[i] = text[i]; buffer[i] = text[i];
if (buffer[i] == '\0') break; if (buffer[i] == '\0') break;
@ -1217,7 +1217,7 @@ const char **TextSplit(const char *text, char delimiter, int *count)
buffer[i] = '\0'; // Set an end of string at this point buffer[i] = '\0'; // Set an end of string at this point
result[counter] = buffer + i + 1; result[counter] = buffer + i + 1;
counter++; counter++;
if (counter == MAX_SUBSTRINGS_COUNT) break; if (counter == MAX_SUBSTRINGS_COUNT) break;
} }
} }
@ -1239,11 +1239,11 @@ void TextAppend(char *text, const char *append, int *position)
int TextFindIndex(const char *text, const char *find) int TextFindIndex(const char *text, const char *find)
{ {
int position = -1; int position = -1;
char *ptr = strstr(text, find); char *ptr = strstr(text, find);
if (ptr != NULL) position = ptr - text; if (ptr != NULL) position = ptr - text;
return position; return position;
} }
@ -1314,10 +1314,10 @@ int TextToInteger(const char *text)
{ {
if ((text[i] > 47) && (text[i] < 58)) result += ((int)text[i] - 48)*units; if ((text[i] > 47) && (text[i] < 58)) result += ((int)text[i] - 48)*units;
else { result = -1; break; } else { result = -1; break; }
units *= 10; units *= 10;
} }
return result; return result;
} }

4
src/textures.c
View File

@ -2529,7 +2529,7 @@ void DrawTextureQuad(Texture2D texture, Vector2 tiling, Vector2 offset, Rectangl
{ {
Rectangle source = { offset.x*texture.width, offset.y*texture.height, tiling.x*texture.width, tiling.y*texture.height }; Rectangle source = { offset.x*texture.width, offset.y*texture.height, tiling.x*texture.width, tiling.y*texture.height };
Vector2 origin = { 0.0f, 0.0f }; Vector2 origin = { 0.0f, 0.0f };
DrawTexturePro(texture, source, quad, origin, 0.0f, tint); DrawTexturePro(texture, source, quad, origin, 0.0f, tint);
} }
@ -3198,7 +3198,7 @@ static int SaveKTX(Image image, const char *fileName)
//unsigned char id[12] = { 0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A }; //unsigned char id[12] = { 0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A };
const char ktxIdentifier[12] = { 0xAB, 'K', 'T', 'X', ' ', '1', '1', 0xBB, '\r', '\n', 0x1A, '\n' }; const char ktxIdentifier[12] = { 0xAB, 'K', 'T', 'X', ' ', '1', '1', 0xBB, '\r', '\n', 0x1A, '\n' };
// Get the image header // Get the image header
strncpy(ktxHeader.id, ktxIdentifier, 12); // KTX 1.1 signature strncpy(ktxHeader.id, ktxIdentifier, 12); // KTX 1.1 signature
ktxHeader.endianness = 0; ktxHeader.endianness = 0;