mirrors
/
raylib
mirror of https://github.com/raysan5/raylib
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Support custom memory management macros 

Users can define their custom memory management macros.

NOTE: Most external libraries support custom macros in the same way, raylib should redefine those macros to raylib ones, to unify custom memory loading. That redefinition is only implemented as example for stb_image.h in [textures] module.
This commit is contained in:
Ray 2019-04-23 14:55:35 +02:00
parent 8ed71b9d5a
commit e67ebabb02
9 changed files with 364 additions and 338 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/core.c
View File

@ -1113,7 +1113,7 @@ void EndDrawing(void)
unsigned char *screenData = rlReadScreenPixels(screenWidth, screenHeight);
GifWriteFrame(screenData, screenWidth, screenHeight, 10, 8, false);
free(screenData); // Free image data
RL_FREE(screenData); // Free image data
}
if (((gifFramesCounter/15)%2) == 1)
@ -1595,7 +1595,7 @@ void TakeScreenshot(const char *fileName)
#endif
ExportImage(image, path);
free(imgData);
RL_FREE(imgData);
#if defined(PLATFORM_WEB)
// Download file from MEMFS (emscripten memory filesystem)
@ -1742,8 +1742,8 @@ char **GetDirectoryFiles(const char *dirPath, int *fileCount)
ClearDirectoryFiles();
// Memory allocation for MAX_DIRECTORY_FILES
dirFilesPath = (char **)malloc(sizeof(char *)*MAX_DIRECTORY_FILES);
for (int i = 0; i < MAX_DIRECTORY_FILES; i++) dirFilesPath[i] = (char *)malloc(sizeof(char)*MAX_FILEPATH_LENGTH);
dirFilesPath = (char **)RL_MALLOC(sizeof(char *)*MAX_DIRECTORY_FILES);
for (int i = 0; i < MAX_DIRECTORY_FILES; i++) dirFilesPath[i] = (char *)RL_MALLOC(sizeof(char)*MAX_FILEPATH_LENGTH);
int counter = 0;
struct dirent *ent;
@ -1776,9 +1776,9 @@ void ClearDirectoryFiles(void)
{
if (dirFilesCount > 0)
{
for (int i = 0; i < dirFilesCount; i++) free(dirFilesPath[i]);
for (int i = 0; i < dirFilesCount; i++) RL_FREE(dirFilesPath[i]);
free(dirFilesPath);
RL_FREE(dirFilesPath);
dirFilesCount = 0;
}
}
@ -1808,9 +1808,9 @@ void ClearDroppedFiles(void)
{
if (dropFilesCount > 0)
{
for (int i = 0; i < dropFilesCount; i++) free(dropFilesPath[i]);
for (int i = 0; i < dropFilesCount; i++) RL_FREE(dropFilesPath[i]);
free(dropFilesPath);
RL_FREE(dropFilesPath);
dropFilesCount = 0;
}
@ -1925,7 +1925,7 @@ void OpenURL(const char *url)
}
else
{
char *cmd = (char *)calloc(strlen(url) + 10, sizeof(char));
char *cmd = (char *)RL_CALLOC(strlen(url) + 10, sizeof(char));
#if defined(_WIN32)
sprintf(cmd, "explorer %s", url);
@ -1935,7 +1935,7 @@ void OpenURL(const char *url)
sprintf(cmd, "open '%s'", url);
#endif
system(cmd);
free(cmd);
RL_FREE(cmd);
}
}
@ -3455,11 +3455,11 @@ static void WindowDropCallback(GLFWwindow *window, int count, const char **paths
{
ClearDroppedFiles();
dropFilesPath = (char **)malloc(sizeof(char *)*count);
dropFilesPath = (char **)RL_MALLOC(sizeof(char *)*count);
for (int i = 0; i < count; i++)
{
dropFilesPath[i] = (char *)malloc(sizeof(char)*MAX_FILEPATH_LENGTH);
dropFilesPath[i] = (char *)RL_MALLOC(sizeof(char)*MAX_FILEPATH_LENGTH);
strcpy(dropFilesPath[i], paths[i]);
}

291
src/models.c
View File

@ -651,7 +651,7 @@ Model LoadModel(const char *fileName)
TraceLog(LOG_WARNING, "[%s] No meshes can be loaded, default to cube mesh", fileName);
model.meshCount = 1;
model.meshes = (Mesh *)calloc(model.meshCount, sizeof(Mesh));
model.meshes = (Mesh *)RL_CALLOC(model.meshCount, sizeof(Mesh));
model.meshes[0] = GenMeshCube(1.0f, 1.0f, 1.0f);
}
else
@ -665,10 +665,10 @@ Model LoadModel(const char *fileName)
TraceLog(LOG_WARNING, "[%s] No materials can be loaded, default to white material", fileName);
model.materialCount = 1;
model.materials = (Material *)calloc(model.materialCount, sizeof(Material));
model.materials = (Material *)RL_CALLOC(model.materialCount, sizeof(Material));
model.materials[0] = LoadMaterialDefault();
model.meshMaterial = (int *)calloc(model.meshCount, sizeof(int));
model.meshMaterial = (int *)RL_CALLOC(model.meshCount, sizeof(int));
}
return model;
@ -685,14 +685,14 @@ Model LoadModelFromMesh(Mesh mesh)
model.transform = MatrixIdentity();
model.meshCount = 1;
model.meshes = (Mesh *)malloc(model.meshCount*sizeof(Mesh));
model.meshes = (Mesh *)RL_MALLOC(model.meshCount*sizeof(Mesh));
model.meshes[0] = mesh;
model.materialCount = 1;
model.materials = (Material *)malloc(model.materialCount*sizeof(Material));
model.materials = (Material *)RL_MALLOC(model.materialCount*sizeof(Material));
model.materials[0] = LoadMaterialDefault();
model.meshMaterial = (int *)malloc(model.meshCount*sizeof(int));
model.meshMaterial = (int *)RL_MALLOC(model.meshCount*sizeof(int));
model.meshMaterial[0] = 0; // First material index
return model;
@ -704,13 +704,13 @@ void UnloadModel(Model model)
for (int i = 0; i < model.meshCount; i++) UnloadMesh(&model.meshes[i]);
for (int i = 0; i < model.materialCount; i++) UnloadMaterial(model.materials[i]);
free(model.meshes);
free(model.materials);
free(model.meshMaterial);
RL_FREE(model.meshes);
RL_FREE(model.materials);
RL_FREE(model.meshMaterial);
// Unload animation data
free(model.bones);
free(model.bindPose);
RL_FREE(model.bones);
RL_FREE(model.bindPose);
TraceLog(LOG_INFO, "Unloaded model data from RAM and VRAM");
}
@ -866,7 +866,7 @@ void SetModelMeshMaterial(Model *model, int meshId, int materialId)
// Load model animations from file
ModelAnimation *LoadModelAnimations(const char *filename, int *animCount)
{
ModelAnimation *animations = (ModelAnimation *)malloc(1*sizeof(ModelAnimation));
ModelAnimation *animations = (ModelAnimation *)RL_MALLOC(1*sizeof(ModelAnimation));
int count = 1;
#define IQM_MAGIC "INTERQUAKEMODEL" // IQM file magic number
@ -935,12 +935,12 @@ ModelAnimation *LoadModelAnimations(const char *filename, int *animCount)
// bones
IQMPose *poses;
poses = malloc(sizeof(IQMPose)*iqm.num_poses);
poses = RL_MALLOC(sizeof(IQMPose)*iqm.num_poses);
fseek(iqmFile, iqm.ofs_poses, SEEK_SET);
fread(poses, sizeof(IQMPose)*iqm.num_poses, 1, iqmFile);
animation.boneCount = iqm.num_poses;
animation.bones = malloc(sizeof(BoneInfo)*iqm.num_poses);
animation.bones = RL_MALLOC(sizeof(BoneInfo)*iqm.num_poses);
for (int j = 0; j < iqm.num_poses; j++)
{
@ -957,12 +957,12 @@ ModelAnimation *LoadModelAnimations(const char *filename, int *animCount)
//animation.framerate = anim.framerate;
// frameposes
unsigned short *framedata = malloc(sizeof(unsigned short)*iqm.num_frames*iqm.num_framechannels);
unsigned short *framedata = RL_MALLOC(sizeof(unsigned short)*iqm.num_frames*iqm.num_framechannels);
fseek(iqmFile, iqm.ofs_frames, SEEK_SET);
fread(framedata, sizeof(unsigned short)*iqm.num_frames*iqm.num_framechannels, 1, iqmFile);
animation.framePoses = malloc(sizeof(Transform*)*anim.num_frames);
for (int j = 0; j < anim.num_frames; j++) animation.framePoses[j] = malloc(sizeof(Transform)*iqm.num_poses);
animation.framePoses = RL_MALLOC(sizeof(Transform*)*anim.num_frames);
for (int j = 0; j < anim.num_frames; j++) animation.framePoses[j] = RL_MALLOC(sizeof(Transform)*iqm.num_poses);
int dcounter = anim.first_frame*iqm.num_framechannels;
@ -1069,8 +1069,8 @@ ModelAnimation *LoadModelAnimations(const char *filename, int *animCount)
}
}
free(framedata);
free(poses);
RL_FREE(framedata);
RL_FREE(poses);
fclose(iqmFile);
@ -1145,10 +1145,10 @@ void UpdateModelAnimation(Model model, ModelAnimation anim, int frame)
// Unload animation data
void UnloadModelAnimation(ModelAnimation anim)
{
for (int i = 0; i < anim.frameCount; i++) free(anim.framePoses[i]);
for (int i = 0; i < anim.frameCount; i++) RL_FREE(anim.framePoses[i]);
free(anim.bones);
free(anim.framePoses);
RL_FREE(anim.bones);
RL_FREE(anim.framePoses);
}
// Check model animation skeleton match
@ -1177,7 +1177,7 @@ Mesh GenMeshPoly(int sides, float radius)
int vertexCount = sides*3;
// Vertices definition
Vector3 *vertices = (Vector3 *)malloc(vertexCount*sizeof(Vector3));
Vector3 *vertices = (Vector3 *)RL_MALLOC(vertexCount*sizeof(Vector3));
for (int i = 0, v = 0; i < 360; i += 360/sides, v += 3)
{
vertices[v] = (Vector3){ 0.0f, 0.0f, 0.0f };
@ -1186,18 +1186,18 @@ Mesh GenMeshPoly(int sides, float radius)
}
// Normals definition
Vector3 *normals = (Vector3 *)malloc(vertexCount*sizeof(Vector3));
Vector3 *normals = (Vector3 *)RL_MALLOC(vertexCount*sizeof(Vector3));
for (int n = 0; n < vertexCount; n++) normals[n] = (Vector3){ 0.0f, 1.0f, 0.0f }; // Vector3.up;
// TexCoords definition
Vector2 *texcoords = (Vector2 *)malloc(vertexCount*sizeof(Vector2));
Vector2 *texcoords = (Vector2 *)RL_MALLOC(vertexCount*sizeof(Vector2));
for (int n = 0; n < vertexCount; n++) texcoords[n] = (Vector2){ 0.0f, 0.0f };
mesh.vertexCount = vertexCount;
mesh.triangleCount = sides;
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.vertices = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float));
mesh.texcoords = (float *)RL_MALLOC(mesh.vertexCount*2*sizeof(float));
mesh.normals = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float));
// Mesh vertices position array
for (int i = 0; i < mesh.vertexCount; i++)
@ -1222,9 +1222,9 @@ Mesh GenMeshPoly(int sides, float radius)
mesh.normals[3*i + 2] = normals[i].z;
}
free(vertices);
free(normals);
free(texcoords);
RL_FREE(vertices);
RL_FREE(normals);
RL_FREE(texcoords);
// Upload vertex data to GPU (static mesh)
rlLoadMesh(&mesh, false);
@ -1245,7 +1245,7 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
// Vertices definition
int vertexCount = resX*resZ; // vertices get reused for the faces
Vector3 *vertices = (Vector3 *)malloc(vertexCount*sizeof(Vector3));
Vector3 *vertices = (Vector3 *)RL_MALLOC(vertexCount*sizeof(Vector3));
for (int z = 0; z < resZ; z++)
{
// [-length/2, length/2]
@ -1259,11 +1259,11 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
}
// Normals definition
Vector3 *normals = (Vector3 *)malloc(vertexCount*sizeof(Vector3));
Vector3 *normals = (Vector3 *)RL_MALLOC(vertexCount*sizeof(Vector3));
for (int n = 0; n < vertexCount; n++) normals[n] = (Vector3){ 0.0f, 1.0f, 0.0f }; // Vector3.up;
// TexCoords definition
Vector2 *texcoords = (Vector2 *)malloc(vertexCount*sizeof(Vector2));
Vector2 *texcoords = (Vector2 *)RL_MALLOC(vertexCount*sizeof(Vector2));
for (int v = 0; v < resZ; v++)
{
for (int u = 0; u < resX; u++)
@ -1274,7 +1274,7 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
// Triangles definition (indices)
int numFaces = (resX - 1)*(resZ - 1);
int *triangles = (int *)malloc(numFaces*6*sizeof(int));
int *triangles = (int *)RL_MALLOC(numFaces*6*sizeof(int));
int t = 0;
for (int face = 0; face < numFaces; face++)
{
@ -1292,10 +1292,10 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
mesh.vertexCount = vertexCount;
mesh.triangleCount = numFaces*2;
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.indices = (unsigned short *)malloc(mesh.triangleCount*3*sizeof(unsigned short));
mesh.vertices = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float));
mesh.texcoords = (float *)RL_MALLOC(mesh.vertexCount*2*sizeof(float));
mesh.normals = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float));
mesh.indices = (unsigned short *)RL_MALLOC(mesh.triangleCount*3*sizeof(unsigned short));
// Mesh vertices position array
for (int i = 0; i < mesh.vertexCount; i++)
@ -1323,10 +1323,10 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
// Mesh indices array initialization
for (int i = 0; i < mesh.triangleCount*3; i++) mesh.indices[i] = triangles[i];
free(vertices);
free(normals);
free(texcoords);
free(triangles);
RL_FREE(vertices);
RL_FREE(normals);
RL_FREE(texcoords);
RL_FREE(triangles);
#else // Use par_shapes library to generate plane mesh
@ -1335,9 +1335,9 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
par_shapes_rotate(plane, -PI/2.0f, (float[]){ 1, 0, 0 });
par_shapes_translate(plane, -width/2, 0.0f, length/2);
mesh.vertices = (float *)malloc(plane->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)malloc(plane->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)malloc(plane->ntriangles*3*3*sizeof(float));
mesh.vertices = (float *)RL_MALLOC(plane->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)RL_MALLOC(plane->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)RL_MALLOC(plane->ntriangles*3*3*sizeof(float));
mesh.vertexCount = plane->ntriangles*3;
mesh.triangleCount = plane->ntriangles;
@ -1453,16 +1453,16 @@ Mesh GenMeshCube(float width, float height, float length)
-1.0f, 0.0f, 0.0f
};
mesh.vertices = (float *)malloc(24*3*sizeof(float));
mesh.vertices = (float *)RL_MALLOC(24*3*sizeof(float));
memcpy(mesh.vertices, vertices, 24*3*sizeof(float));
mesh.texcoords = (float *)malloc(24*2*sizeof(float));
mesh.texcoords = (float *)RL_MALLOC(24*2*sizeof(float));
memcpy(mesh.texcoords, texcoords, 24*2*sizeof(float));
mesh.normals = (float *)malloc(24*3*sizeof(float));
mesh.normals = (float *)RL_MALLOC(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 *)RL_MALLOC(36*sizeof(unsigned short));
int k = 0;
@ -1500,9 +1500,9 @@ par_shapes_mesh* par_shapes_create_icosahedron(); // 20 sides polyhedron
par_shapes_translate(cube, -width/2, 0.0f, -length/2);
par_shapes_compute_normals(cube);
mesh.vertices = (float *)malloc(cube->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)malloc(cube->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)malloc(cube->ntriangles*3*3*sizeof(float));
mesh.vertices = (float *)RL_MALLOC(cube->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)RL_MALLOC(cube->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)RL_MALLOC(cube->ntriangles*3*3*sizeof(float));
mesh.vertexCount = cube->ntriangles*3;
mesh.triangleCount = cube->ntriangles;
@ -1539,9 +1539,9 @@ RLAPI Mesh GenMeshSphere(float radius, int rings, int slices)
par_shapes_scale(sphere, radius, radius, radius);
// NOTE: Soft normals are computed internally
mesh.vertices = (float *)malloc(sphere->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)malloc(sphere->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)malloc(sphere->ntriangles*3*3*sizeof(float));
mesh.vertices = (float *)RL_MALLOC(sphere->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)RL_MALLOC(sphere->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)RL_MALLOC(sphere->ntriangles*3*3*sizeof(float));
mesh.vertexCount = sphere->ntriangles*3;
mesh.triangleCount = sphere->ntriangles;
@ -1577,9 +1577,9 @@ RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices)
par_shapes_scale(sphere, radius, radius, radius);
// NOTE: Soft normals are computed internally
mesh.vertices = (float *)malloc(sphere->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)malloc(sphere->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)malloc(sphere->ntriangles*3*3*sizeof(float));
mesh.vertices = (float *)RL_MALLOC(sphere->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)RL_MALLOC(sphere->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)RL_MALLOC(sphere->ntriangles*3*3*sizeof(float));
mesh.vertexCount = sphere->ntriangles*3;
mesh.triangleCount = sphere->ntriangles;
@ -1635,9 +1635,9 @@ Mesh GenMeshCylinder(float radius, float height, int slices)
par_shapes_merge_and_free(cylinder, capTop);
par_shapes_merge_and_free(cylinder, capBottom);
mesh.vertices = (float *)malloc(cylinder->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)malloc(cylinder->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)malloc(cylinder->ntriangles*3*3*sizeof(float));
mesh.vertices = (float *)RL_MALLOC(cylinder->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)RL_MALLOC(cylinder->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)RL_MALLOC(cylinder->ntriangles*3*3*sizeof(float));
mesh.vertexCount = cylinder->ntriangles*3;
mesh.triangleCount = cylinder->ntriangles;
@ -1677,9 +1677,9 @@ Mesh GenMeshTorus(float radius, float size, int radSeg, int sides)
par_shapes_mesh *torus = par_shapes_create_torus(radSeg, sides, radius);
par_shapes_scale(torus, size/2, size/2, size/2);
mesh.vertices = (float *)malloc(torus->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)malloc(torus->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)malloc(torus->ntriangles*3*3*sizeof(float));
mesh.vertices = (float *)RL_MALLOC(torus->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)RL_MALLOC(torus->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)RL_MALLOC(torus->ntriangles*3*3*sizeof(float));
mesh.vertexCount = torus->ntriangles*3;
mesh.triangleCount = torus->ntriangles;
@ -1717,9 +1717,9 @@ Mesh GenMeshKnot(float radius, float size, int radSeg, int sides)
par_shapes_mesh *knot = par_shapes_create_trefoil_knot(radSeg, sides, radius);
par_shapes_scale(knot, size, size, size);
mesh.vertices = (float *)malloc(knot->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)malloc(knot->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)malloc(knot->ntriangles*3*3*sizeof(float));
mesh.vertices = (float *)RL_MALLOC(knot->ntriangles*3*3*sizeof(float));
mesh.texcoords = (float *)RL_MALLOC(knot->ntriangles*3*2*sizeof(float));
mesh.normals = (float *)RL_MALLOC(knot->ntriangles*3*3*sizeof(float));
mesh.vertexCount = knot->ntriangles*3;
mesh.triangleCount = knot->ntriangles;
@ -1764,9 +1764,9 @@ Mesh GenMeshHeightmap(Image heightmap, Vector3 size)
mesh.vertexCount = mesh.triangleCount*3;
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.vertices = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float));
mesh.normals = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float));
mesh.texcoords = (float *)RL_MALLOC(mesh.vertexCount*2*sizeof(float));
mesh.colors = NULL;
int vCounter = 0; // Used to count vertices float by float
@ -1848,7 +1848,7 @@ Mesh GenMeshHeightmap(Image heightmap, Vector3 size)
}
}
free(pixels);
RL_FREE(pixels);
// Upload vertex data to GPU (static mesh)
rlLoadMesh(&mesh, false);
@ -1878,9 +1878,9 @@ Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize)
float h = cubeSize.z;
float h2 = cubeSize.y;
Vector3 *mapVertices = (Vector3 *)malloc(maxTriangles*3*sizeof(Vector3));
Vector2 *mapTexcoords = (Vector2 *)malloc(maxTriangles*3*sizeof(Vector2));
Vector3 *mapNormals = (Vector3 *)malloc(maxTriangles*3*sizeof(Vector3));
Vector3 *mapVertices = (Vector3 *)RL_MALLOC(maxTriangles*3*sizeof(Vector3));
Vector2 *mapTexcoords = (Vector2 *)RL_MALLOC(maxTriangles*3*sizeof(Vector2));
Vector3 *mapNormals = (Vector3 *)RL_MALLOC(maxTriangles*3*sizeof(Vector3));
// Define the 6 normals of the cube, we will combine them accordingly later...
Vector3 n1 = { 1.0f, 0.0f, 0.0f };
@ -2167,9 +2167,9 @@ Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize)
mesh.vertexCount = vCounter;
mesh.triangleCount = vCounter/3;
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.vertices = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float));
mesh.normals = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float));
mesh.texcoords = (float *)RL_MALLOC(mesh.vertexCount*2*sizeof(float));
mesh.colors = NULL;
int fCounter = 0;
@ -2204,11 +2204,11 @@ Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize)
fCounter += 2;
}
free(mapVertices);
free(mapNormals);
free(mapTexcoords);
RL_FREE(mapVertices);
RL_FREE(mapNormals);
RL_FREE(mapTexcoords);
free(cubicmapPixels); // Free image pixel data
RL_FREE(cubicmapPixels); // Free image pixel data
// Upload vertex data to GPU (static mesh)
rlLoadMesh(&mesh, false);
@ -2250,11 +2250,11 @@ BoundingBox MeshBoundingBox(Mesh mesh)
// Implementation base don: https://answers.unity.com/questions/7789/calculating-tangents-vector4.html
void MeshTangents(Mesh *mesh)
{
if (mesh->tangents == NULL) mesh->tangents = (float *)malloc(mesh->vertexCount*4*sizeof(float));
if (mesh->tangents == NULL) mesh->tangents = (float *)RL_MALLOC(mesh->vertexCount*4*sizeof(float));
else TraceLog(LOG_WARNING, "Mesh tangents already exist");
Vector3 *tan1 = (Vector3 *)malloc(mesh->vertexCount*sizeof(Vector3));
Vector3 *tan2 = (Vector3 *)malloc(mesh->vertexCount*sizeof(Vector3));
Vector3 *tan1 = (Vector3 *)RL_MALLOC(mesh->vertexCount*sizeof(Vector3));
Vector3 *tan2 = (Vector3 *)RL_MALLOC(mesh->vertexCount*sizeof(Vector3));
for (int i = 0; i < mesh->vertexCount; i += 3)
{
@ -2318,8 +2318,8 @@ void MeshTangents(Mesh *mesh)
#endif
}
free(tan1);
free(tan2);
RL_FREE(tan1);
RL_FREE(tan2);
// Load a new tangent attributes buffer
mesh->vboId[LOC_VERTEX_TANGENT] = rlLoadAttribBuffer(mesh->vaoId, LOC_VERTEX_TANGENT, mesh->tangents, mesh->vertexCount*4*sizeof(float), false);
@ -2746,7 +2746,7 @@ static Model LoadOBJ(const char *fileName)
long length = ftell(objFile); // Get file size
fseek(objFile, 0, SEEK_SET); // Reset file pointer
data = (char *)malloc(length);
data = (char *)RL_MALLOC(length);
fread(data, length, 1, objFile);
dataLength = length;
@ -2763,12 +2763,12 @@ static Model LoadOBJ(const char *fileName)
// Init model meshes array
model.meshCount = meshCount;
model.meshes = (Mesh *)malloc(model.meshCount*sizeof(Mesh));
model.meshes = (Mesh *)RL_MALLOC(model.meshCount*sizeof(Mesh));
// Init model materials array
model.materialCount = materialCount;
model.materials = (Material *)malloc(model.materialCount*sizeof(Material));
model.meshMaterial = (int *)calloc(model.meshCount, sizeof(int));
model.materials = (Material *)RL_MALLOC(model.materialCount*sizeof(Material));
model.meshMaterial = (int *)RL_CALLOC(model.meshCount, sizeof(int));
/*
// Multiple meshes data reference
@ -2787,9 +2787,9 @@ static Model LoadOBJ(const char *fileName)
memset(&mesh, 0, sizeof(Mesh));
mesh.vertexCount = attrib.num_faces*3;
mesh.triangleCount = attrib.num_faces;
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.vertices = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float));
mesh.texcoords = (float *)RL_MALLOC(mesh.vertexCount*2*sizeof(float));
mesh.normals = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float));
int vCount = 0;
int vtCount = 0;
@ -2934,17 +2934,26 @@ static Model LoadIQM(const char *fileName)
typedef struct IQMTriangle {
unsigned int vertex[3];
} IQMTriangle;
// NOTE: Adjacency unused by default
typedef struct IQMAdjacency {
unsigned int triangle[3];
} IQMAdjacency;
typedef struct IQMJoint {
unsigned int name;
int parent;
float translate[3], rotate[4], scale[3];
} IQMJoint;
typedef struct IQMVertexArray {
unsigned int type;
unsigned int flags;
unsigned int format;
unsigned int size;
unsigned int offset;
} IQMVertexArray;
// NOTE: Below IQM structures are not used but listed for reference
/*
typedef struct IQMAdjacency {
unsigned int triangle[3];
} IQMAdjacency;
typedef struct IQMPose {
int parent;
@ -2960,19 +2969,11 @@ static Model LoadIQM(const char *fileName)
unsigned int flags;
} IQMAnim;
typedef struct IQMVertexArray {
unsigned int type;
unsigned int flags;
unsigned int format;
unsigned int size;
unsigned int offset;
} IQMVertexArray;
// NOTE: Bounds unused by default
typedef struct IQMBounds {
float bbmin[3], bbmax[3];
float xyradius, radius;
} IQMBounds;
*/
//-----------------------------------------------------------------------------------
// IQM vertex data types
@ -3028,12 +3029,12 @@ static Model LoadIQM(const char *fileName)
}
// Meshes data processing
imesh = malloc(sizeof(IQMMesh)*iqm.num_meshes);
imesh = RL_MALLOC(sizeof(IQMMesh)*iqm.num_meshes);
fseek(iqmFile, iqm.ofs_meshes, SEEK_SET);
fread(imesh, sizeof(IQMMesh)*iqm.num_meshes, 1, iqmFile);
model.meshCount = iqm.num_meshes;
model.meshes = malloc(model.meshCount*sizeof(Mesh));
model.meshes = RL_MALLOC(model.meshCount*sizeof(Mesh));
char name[MESH_NAME_LENGTH];
@ -3043,24 +3044,24 @@ static Model LoadIQM(const char *fileName)
fread(name, sizeof(char)*MESH_NAME_LENGTH, 1, iqmFile); // Mesh name not used...
model.meshes[i].vertexCount = imesh[i].num_vertexes;
model.meshes[i].vertices = malloc(sizeof(float)*model.meshes[i].vertexCount*3); // Default vertex positions
model.meshes[i].normals = malloc(sizeof(float)*model.meshes[i].vertexCount*3); // Default vertex normals
model.meshes[i].texcoords = malloc(sizeof(float)*model.meshes[i].vertexCount*2); // Default vertex texcoords
model.meshes[i].vertices = RL_MALLOC(sizeof(float)*model.meshes[i].vertexCount*3); // Default vertex positions
model.meshes[i].normals = RL_MALLOC(sizeof(float)*model.meshes[i].vertexCount*3); // Default vertex normals
model.meshes[i].texcoords = RL_MALLOC(sizeof(float)*model.meshes[i].vertexCount*2); // Default vertex texcoords
model.meshes[i].boneIds = malloc(sizeof(int)*model.meshes[i].vertexCount*4); // Up-to 4 bones supported!
model.meshes[i].boneWeights = malloc(sizeof(float)*model.meshes[i].vertexCount*4); // Up-to 4 bones supported!
model.meshes[i].boneIds = RL_MALLOC(sizeof(int)*model.meshes[i].vertexCount*4); // Up-to 4 bones supported!
model.meshes[i].boneWeights = RL_MALLOC(sizeof(float)*model.meshes[i].vertexCount*4); // Up-to 4 bones supported!
model.meshes[i].triangleCount = imesh[i].num_triangles;
model.meshes[i].indices = malloc(sizeof(unsigned short)*model.meshes[i].triangleCount*3);
model.meshes[i].indices = RL_MALLOC(sizeof(unsigned short)*model.meshes[i].triangleCount*3);
// Animated verted data, what we actually process for rendering
// NOTE: Animated vertex should be re-uploaded to GPU (if not using GPU skinning)
model.meshes[i].animVertices = malloc(sizeof(float)*model.meshes[i].vertexCount*3);
model.meshes[i].animNormals = malloc(sizeof(float)*model.meshes[i].vertexCount*3);
model.meshes[i].animVertices = RL_MALLOC(sizeof(float)*model.meshes[i].vertexCount*3);
model.meshes[i].animNormals = RL_MALLOC(sizeof(float)*model.meshes[i].vertexCount*3);
}
// Triangles data processing
tri = malloc(sizeof(IQMTriangle)*iqm.num_triangles);
tri = RL_MALLOC(sizeof(IQMTriangle)*iqm.num_triangles);
fseek(iqmFile, iqm.ofs_triangles, SEEK_SET);
fread(tri, sizeof(IQMTriangle)*iqm.num_triangles, 1, iqmFile);
@ -3079,7 +3080,7 @@ static Model LoadIQM(const char *fileName)
}
// Vertex arrays data processing
va = malloc(sizeof(IQMVertexArray)*iqm.num_vertexarrays);
va = RL_MALLOC(sizeof(IQMVertexArray)*iqm.num_vertexarrays);
fseek(iqmFile, iqm.ofs_vertexarrays, SEEK_SET);
fread(va, sizeof(IQMVertexArray)*iqm.num_vertexarrays, 1, iqmFile);
@ -3089,7 +3090,7 @@ static Model LoadIQM(const char *fileName)
{
case IQM_POSITION:
{
vertex = malloc(sizeof(float)*iqm.num_vertexes*3);
vertex = RL_MALLOC(sizeof(float)*iqm.num_vertexes*3);
fseek(iqmFile, va[i].offset, SEEK_SET);
fread(vertex, sizeof(float)*iqm.num_vertexes*3, 1, iqmFile);
@ -3106,7 +3107,7 @@ static Model LoadIQM(const char *fileName)
} break;
case IQM_NORMAL:
{
normal = malloc(sizeof(float)*iqm.num_vertexes*3);
normal = RL_MALLOC(sizeof(float)*iqm.num_vertexes*3);
fseek(iqmFile, va[i].offset, SEEK_SET);
fread(normal, sizeof(float)*iqm.num_vertexes*3, 1, iqmFile);
@ -3123,7 +3124,7 @@ static Model LoadIQM(const char *fileName)
} break;
case IQM_TEXCOORD:
{
text = malloc(sizeof(float)*iqm.num_vertexes*2);
text = RL_MALLOC(sizeof(float)*iqm.num_vertexes*2);
fseek(iqmFile, va[i].offset, SEEK_SET);
fread(text, sizeof(float)*iqm.num_vertexes*2, 1, iqmFile);
@ -3139,7 +3140,7 @@ static Model LoadIQM(const char *fileName)
} break;
case IQM_BLENDINDEXES:
{
blendi = malloc(sizeof(char)*iqm.num_vertexes*4);
blendi = RL_MALLOC(sizeof(char)*iqm.num_vertexes*4);
fseek(iqmFile, va[i].offset, SEEK_SET);
fread(blendi, sizeof(char)*iqm.num_vertexes*4, 1, iqmFile);
@ -3155,7 +3156,7 @@ static Model LoadIQM(const char *fileName)
} break;
case IQM_BLENDWEIGHTS:
{
blendw = malloc(sizeof(unsigned char)*iqm.num_vertexes*4);
blendw = RL_MALLOC(sizeof(unsigned char)*iqm.num_vertexes*4);
fseek(iqmFile,va[i].offset,SEEK_SET);
fread(blendw,sizeof(unsigned char)*iqm.num_vertexes*4,1,iqmFile);
@ -3173,13 +3174,13 @@ static Model LoadIQM(const char *fileName)
}
// Bones (joints) data processing
ijoint = malloc(sizeof(IQMJoint)*iqm.num_joints);
ijoint = RL_MALLOC(sizeof(IQMJoint)*iqm.num_joints);
fseek(iqmFile, iqm.ofs_joints, SEEK_SET);
fread(ijoint, sizeof(IQMJoint)*iqm.num_joints, 1, iqmFile);
model.boneCount = iqm.num_joints;
model.bones = malloc(sizeof(BoneInfo)*iqm.num_joints);
model.bindPose = malloc(sizeof(Transform)*iqm.num_joints);
model.bones = RL_MALLOC(sizeof(BoneInfo)*iqm.num_joints);
model.bindPose = RL_MALLOC(sizeof(Transform)*iqm.num_joints);
for (int i = 0; i < iqm.num_joints; i++)
{
@ -3216,15 +3217,15 @@ static Model LoadIQM(const char *fileName)
}
fclose(iqmFile);
free(imesh);
free(tri);
free(va);
free(vertex);
free(normal);
free(text);
free(blendi);
free(blendw);
free(ijoint);
RL_FREE(imesh);
RL_FREE(tri);
RL_FREE(va);
RL_FREE(vertex);
RL_FREE(normal);
RL_FREE(text);
RL_FREE(blendi);
RL_FREE(blendw);
RL_FREE(ijoint);
return model;
}
@ -3249,7 +3250,7 @@ static Model LoadGLTF(const char *fileName)
int size = ftell(gltfFile);
fseek(gltfFile, 0, SEEK_SET);
void *buffer = malloc(size);
void *buffer = RL_MALLOC(size);
fread(buffer, size, 1, gltfFile);
fclose(gltfFile);
@ -3259,7 +3260,7 @@ static Model LoadGLTF(const char *fileName)
cgltf_data *data;
cgltf_result result = cgltf_parse(&options, buffer, size, &data);
free(buffer);
RL_FREE(buffer);
if (result == cgltf_result_success)
{
@ -3270,7 +3271,7 @@ static Model LoadGLTF(const char *fileName)
// Process glTF data and map to model
model.meshCount = data->meshes_count;
model.meshes = malloc(model.meshCount*sizeof(Mesh));
model.meshes = RL_MALLOC(model.meshCount*sizeof(Mesh));
for (int i = 0; i < model.meshCount; i++)
{
@ -3282,11 +3283,11 @@ static Model LoadGLTF(const char *fileName)
model.meshes[i].triangleCount = data->meshes[i].primitives_count;
// data.meshes[i].weights not used (array of weights to be applied to the Morph Targets)
model.meshes[i].vertices = malloc(sizeof(float)*model.meshes[i].vertexCount*3); // Default vertex positions
model.meshes[i].normals = malloc(sizeof(float)*model.meshes[i].vertexCount*3); // Default vertex normals
model.meshes[i].texcoords = malloc(sizeof(float)*model.meshes[i].vertexCount*2); // Default vertex texcoords
model.meshes[i].vertices = RL_MALLOC(sizeof(float)*model.meshes[i].vertexCount*3); // Default vertex positions
model.meshes[i].normals = RL_MALLOC(sizeof(float)*model.meshes[i].vertexCount*3); // Default vertex normals
model.meshes[i].texcoords = RL_MALLOC(sizeof(float)*model.meshes[i].vertexCount*2); // Default vertex texcoords
model.meshes[i].indices = malloc(sizeof(unsigned short)*model.meshes[i].triangleCount*3);
model.meshes[i].indices = RL_MALLOC(sizeof(unsigned short)*model.meshes[i].triangleCount*3);
}
}

38
src/raudio.c
View File

@ -567,7 +567,7 @@ void SetMasterVolume(float volume)
// Create a new audio buffer. Initially filled with silence
AudioBuffer *CreateAudioBuffer(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, ma_uint32 bufferSizeInFrames, AudioBufferUsage usage)
{
AudioBuffer *audioBuffer = (AudioBuffer *)calloc(sizeof(*audioBuffer) + (bufferSizeInFrames*channels*ma_get_bytes_per_sample(format)), 1);
AudioBuffer *audioBuffer = (AudioBuffer *)RL_CALLOC(sizeof(*audioBuffer) + (bufferSizeInFrames*channels*ma_get_bytes_per_sample(format)), 1);
if (audioBuffer == NULL)
{
TraceLog(LOG_ERROR, "CreateAudioBuffer() : Failed to allocate memory for audio buffer");
@ -591,7 +591,7 @@ AudioBuffer *CreateAudioBuffer(ma_format format, ma_uint32 channels, ma_uint32 s
if (result != MA_SUCCESS)
{
TraceLog(LOG_ERROR, "CreateAudioBuffer() : Failed to create data conversion pipeline");
free(audioBuffer);
RL_FREE(audioBuffer);
return NULL;
}
@ -623,7 +623,7 @@ void DeleteAudioBuffer(AudioBuffer *audioBuffer)
}
UntrackAudioBuffer(audioBuffer);
free(audioBuffer);
RL_FREE(audioBuffer);
}
// Check if an audio buffer is playing
@ -863,7 +863,7 @@ Sound LoadSoundFromWave(Wave wave)
// Unload wave data
void UnloadWave(Wave wave)
{
if (wave.data != NULL) free(wave.data);
if (wave.data != NULL) RL_FREE(wave.data);
TraceLog(LOG_INFO, "Unloaded wave data from RAM");
}
@ -1017,7 +1017,7 @@ void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels)
return;
}
void *data = malloc(frameCount*channels*(sampleSize/8));
void *data = RL_MALLOC(frameCount*channels*(sampleSize/8));
frameCount = (ma_uint32)ma_convert_frames(data, formatOut, channels, sampleRate, wave->data, formatIn, wave->channels, wave->sampleRate, frameCountIn);
if (frameCount == 0)
@ -1030,7 +1030,7 @@ void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels)
wave->sampleSize = sampleSize;
wave->sampleRate = sampleRate;
wave->channels = channels;
free(wave->data);
RL_FREE(wave->data);
wave->data = data;
}
@ -1039,7 +1039,7 @@ Wave WaveCopy(Wave wave)
{
Wave newWave = { 0 };
newWave.data = malloc(wave.sampleCount*wave.sampleSize/8*wave.channels);
newWave.data = RL_MALLOC(wave.sampleCount*wave.sampleSize/8*wave.channels);
if (newWave.data != NULL)
{
@ -1064,11 +1064,11 @@ void WaveCrop(Wave *wave, int initSample, int finalSample)
{
int sampleCount = finalSample - initSample;
void *data = malloc(sampleCount*wave->sampleSize/8*wave->channels);
void *data = RL_MALLOC(sampleCount*wave->sampleSize/8*wave->channels);
memcpy(data, (unsigned char *)wave->data + (initSample*wave->channels*wave->sampleSize/8), sampleCount*wave->channels*wave->sampleSize/8);
free(wave->data);
RL_FREE(wave->data);
wave->data = data;
}
else TraceLog(LOG_WARNING, "Wave crop range out of bounds");
@ -1078,7 +1078,7 @@ void WaveCrop(Wave *wave, int initSample, int finalSample)
// NOTE: Returned sample values are normalized to range [-1..1]
float *GetWaveData(Wave wave)
{
float *samples = (float *)malloc(wave.sampleCount*wave.channels*sizeof(float));
float *samples = (float *)RL_MALLOC(wave.sampleCount*wave.channels*sizeof(float));
for (unsigned int i = 0; i < wave.sampleCount; i++)
{
@ -1100,7 +1100,7 @@ float *GetWaveData(Wave wave)
// Load music stream from file
Music LoadMusicStream(const char *fileName)
{
Music music = (MusicData *)malloc(sizeof(MusicData));
Music music = (MusicData *)RL_MALLOC(sizeof(MusicData));
bool musicLoaded = true;
#if defined(SUPPORT_FILEFORMAT_OGG)
@ -1228,7 +1228,7 @@ Music LoadMusicStream(const char *fileName)
if (false) {}
#endif
#if defined(SUPPORT_FILEFORMAT_FLAC)
else if (music->ctxType == MUSIC_AUDIO_FLAC) drflac_free(music->ctxFlac);
else if (music->ctxType == MUSIC_AUDIO_FLAC) drflac_RL_FREE(music->ctxFlac);
#endif
#if defined(SUPPORT_FILEFORMAT_MP3)
else if (music->ctxType == MUSIC_AUDIO_MP3) drmp3_uninit(&music->ctxMp3);
@ -1240,7 +1240,7 @@ Music LoadMusicStream(const char *fileName)
else if (music->ctxType == MUSIC_MODULE_MOD) jar_mod_unload(&music->ctxMod);
#endif
free(music);
RL_FREE(music);
music = NULL;
TraceLog(LOG_WARNING, "[%s] Music file could not be opened", fileName);
@ -1262,7 +1262,7 @@ void UnloadMusicStream(Music music)
if (false) {}
#endif
#if defined(SUPPORT_FILEFORMAT_FLAC)
else if (music->ctxType == MUSIC_AUDIO_FLAC) drflac_free(music->ctxFlac);
else if (music->ctxType == MUSIC_AUDIO_FLAC) drflac_RL_FREE(music->ctxFlac);
#endif
#if defined(SUPPORT_FILEFORMAT_MP3)
else if (music->ctxType == MUSIC_AUDIO_MP3) drmp3_uninit(&music->ctxMp3);
@ -1274,7 +1274,7 @@ void UnloadMusicStream(Music music)
else if (music->ctxType == MUSIC_MODULE_MOD) jar_mod_unload(&music->ctxMod);
#endif
free(music);
RL_FREE(music);
}
// Start music playing (open stream)
@ -1357,7 +1357,7 @@ void UpdateMusicStream(Music music)
unsigned int subBufferSizeInFrames = ((AudioBuffer *)music->stream.audioBuffer)->bufferSizeInFrames/2;
// NOTE: Using dynamic allocation because it could require more than 16KB
void *pcm = calloc(subBufferSizeInFrames*music->stream.channels*music->stream.sampleSize/8, 1);
void *pcm = RL_CALLOC(subBufferSizeInFrames*music->stream.channels*music->stream.sampleSize/8, 1);
int samplesCount = 0; // Total size of data steamed in L+R samples for xm floats, individual L or R for ogg shorts
@ -1427,7 +1427,7 @@ void UpdateMusicStream(Music music)
}
// Free allocated pcm data
free(pcm);
RL_FREE(pcm);
// Reset audio stream for looping
if (streamEnding)
@ -1750,7 +1750,7 @@ static Wave LoadWAV(const char *fileName)
else
{
// Allocate memory for data
wave.data = malloc(wavData.subChunkSize);
wave.data = RL_MALLOC(wavData.subChunkSize);
// Read in the sound data into the soundData variable
fread(wave.data, wavData.subChunkSize, 1, wavFile);
@ -1891,7 +1891,7 @@ static Wave LoadOGG(const char *fileName)
float totalSeconds = stb_vorbis_stream_length_in_seconds(oggFile);
if (totalSeconds > 10) TraceLog(LOG_WARNING, "[%s] Ogg audio length is larger than 10 seconds (%f), that's a big file in memory, consider music streaming", fileName, totalSeconds);
wave.data = (short *)malloc(wave.sampleCount*wave.channels*sizeof(short));
wave.data = (short *)RL_MALLOC(wave.sampleCount*wave.channels*sizeof(short));
// NOTE: Returns the number of samples to process (be careful! we ask for number of shorts!)
int numSamplesOgg = stb_vorbis_get_samples_short_interleaved(oggFile, info.channels, (short *)wave.data, wave.sampleCount*wave.channels);

11
src/raudio.h
View File

@ -56,7 +56,16 @@
//----------------------------------------------------------------------------------
// Defines and Macros
//----------------------------------------------------------------------------------
//...
// Allow custom memory allocators
#ifndef RL_MALLOC
#define RL_MALLOC(sz) malloc(sz)
#endif
#ifndef RL_CALLOC
#define RL_CALLOC(n,sz) calloc(n,sz)
#endif
#ifndef RL_FREE
#define RL_FREE(p) free(p)
#endif
//----------------------------------------------------------------------------------
// Types and Structures Definition

11
src/raylib.h
View File

@ -99,6 +99,17 @@
// Shader and material limits
#define MAX_SHADER_LOCATIONS 32 // Maximum number of predefined locations stored in shader struct
#define MAX_MATERIAL_MAPS 12 // Maximum number of texture maps stored in shader struct
// Allow custom memory allocators
#ifndef RL_MALLOC
#define RL_MALLOC(sz) malloc(sz)
#endif
#ifndef RL_CALLOC
#define RL_CALLOC(n,sz) calloc(n,sz)
#endif
#ifndef RL_FREE
#define RL_FREE(p) free(p)
#endif
// NOTE: MSC C++ compiler does not support compound literals (C99 feature)
// Plain structures in C++ (without constructors) can be initialized from { } initializers.

86
src/rlgl.h
View File

@ -1492,7 +1492,7 @@ void rlglInit(int width, int height)
glGetIntegerv(GL_NUM_EXTENSIONS, &numExt);
#if defined(_MSC_VER)
const char **extList = malloc(sizeof(const char *)*numExt);
const char **extList = RL_MALLOC(sizeof(const char *)*numExt);
#else
const char *extList[numExt];
#endif
@ -1504,7 +1504,7 @@ void rlglInit(int width, int height)
// NOTE: We have to duplicate string because glGetString() returns a const string
int len = strlen(extensions) + 1;
char *extensionsDup = (char *)malloc(len);
char *extensionsDup = (char *)RL_MALLOC(len);
strcpy(extensionsDup, extensions);
// NOTE: String could be splitted using strtok() function (string.h)
@ -1520,7 +1520,7 @@ void rlglInit(int width, int height)
extList[numExt] = strtok(NULL, " ");
}
free(extensionsDup); // Duplicated string must be deallocated
RL_FREE(extensionsDup); // Duplicated string must be deallocated
numExt -= 1;
#endif
@ -1595,7 +1595,7 @@ void rlglInit(int width, int height)
}
#if defined(_WIN32) && defined(_MSC_VER)
free(extList);
RL_FREE(extList);
#endif
#if defined(GRAPHICS_API_OPENGL_ES2)
@ -1640,7 +1640,7 @@ void rlglInit(int width, int height)
transformMatrix = MatrixIdentity();
// Init draw calls tracking system
draws = (DrawCall *)malloc(sizeof(DrawCall)*MAX_DRAWCALL_REGISTERED);
draws = (DrawCall *)RL_MALLOC(sizeof(DrawCall)*MAX_DRAWCALL_REGISTERED);
for (int i = 0; i < MAX_DRAWCALL_REGISTERED; i++)
{
@ -1710,7 +1710,7 @@ void rlglClose(void)
TraceLog(LOG_INFO, "[TEX ID %i] Unloaded texture data (base white texture) from VRAM", defaultTextureId);
free(draws);
RL_FREE(draws);
#endif
}
@ -2300,7 +2300,7 @@ void rlGenerateMipmaps(Texture2D *texture)
}
texture->mipmaps = mipmapCount + 1;
free(data); // Once mipmaps have been generated and data has been uploaded to GPU VRAM, we can discard RAM data
RL_FREE(data); // Once mipmaps have been generated and data has been uploaded to GPU VRAM, we can discard RAM data
TraceLog(LOG_WARNING, "[TEX ID %i] Mipmaps [%i] generated manually on CPU side", texture->id, texture->mipmaps);
}
@ -2735,18 +2735,18 @@ void rlDrawMesh(Mesh mesh, Material material, Matrix transform)
// Unload mesh data from CPU and GPU
void rlUnloadMesh(Mesh *mesh)
{
free(mesh->vertices);
free(mesh->texcoords);
free(mesh->normals);
free(mesh->colors);
free(mesh->tangents);
free(mesh->texcoords2);
free(mesh->indices);
RL_FREE(mesh->vertices);
RL_FREE(mesh->texcoords);
RL_FREE(mesh->normals);
RL_FREE(mesh->colors);
RL_FREE(mesh->tangents);
RL_FREE(mesh->texcoords2);
RL_FREE(mesh->indices);
free(mesh->animVertices);
free(mesh->animNormals);
free(mesh->boneWeights);
free(mesh->boneIds);
RL_FREE(mesh->animVertices);
RL_FREE(mesh->animNormals);
RL_FREE(mesh->boneWeights);
RL_FREE(mesh->boneIds);
rlDeleteBuffers(mesh->vboId[0]); // vertex
rlDeleteBuffers(mesh->vboId[1]); // texcoords
@ -2762,14 +2762,14 @@ void rlUnloadMesh(Mesh *mesh)
// Read screen pixel data (color buffer)
unsigned char *rlReadScreenPixels(int width, int height)
{
unsigned char *screenData = (unsigned char *)calloc(width*height*4, sizeof(unsigned char));
unsigned char *screenData = (unsigned char *)RL_CALLOC(width*height*4, sizeof(unsigned char));
// NOTE 1: glReadPixels returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer
// NOTE 2: We are getting alpha channel! Be careful, it can be transparent if not cleared properly!
glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, screenData);
// Flip image vertically!
unsigned char *imgData = (unsigned char *)malloc(width*height*sizeof(unsigned char)*4);
unsigned char *imgData = (unsigned char *)RL_MALLOC(width*height*sizeof(unsigned char)*4);
for (int y = height - 1; y >= 0; y--)
{
@ -2783,7 +2783,7 @@ unsigned char *rlReadScreenPixels(int width, int height)
}
}
free(screenData);
RL_FREE(screenData);
return imgData; // NOTE: image data should be freed
}
@ -2815,7 +2815,7 @@ void *rlReadTexturePixels(Texture2D texture)
if ((glInternalFormat != -1) && (texture.format < COMPRESSED_DXT1_RGB))
{
pixels = (unsigned char *)malloc(size);
pixels = (unsigned char *)RL_MALLOC(size);
glGetTexImage(GL_TEXTURE_2D, 0, glFormat, glType, pixels);
}
else TraceLog(LOG_WARNING, "Texture data retrieval not suported for pixel format");
@ -2841,7 +2841,7 @@ void *rlReadTexturePixels(Texture2D texture)
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture.id, 0);
// Allocate enough memory to read back our texture data
pixels = (unsigned char *)malloc(GetPixelDataSize(texture.width, texture.height, texture.format));
pixels = (unsigned char *)RL_MALLOC(GetPixelDataSize(texture.width, texture.height, texture.format));
// Get OpenGL internal formats and data type from our texture format
unsigned int glInternalFormat, glFormat, glType;
@ -2911,7 +2911,7 @@ char *LoadText(const char *fileName)
if (size > 0)
{
text = (char *)malloc(sizeof(char)*(size + 1));
text = (char *)RL_MALLOC(sizeof(char)*(size + 1));
int count = fread(text, sizeof(char), size, textFile);
text[count] = '\0';
}
@ -2938,8 +2938,8 @@ Shader LoadShader(const char *vsFileName, const char *fsFileName)
shader = LoadShaderCode(vShaderStr, fShaderStr);
if (vShaderStr != NULL) free(vShaderStr);
if (fShaderStr != NULL) free(fShaderStr);
if (vShaderStr != NULL) RL_FREE(vShaderStr);
if (fShaderStr != NULL) RL_FREE(fShaderStr);
return shader;
}
@ -3758,7 +3758,7 @@ static unsigned int CompileShader(const char *shaderStr, int type)
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
#if defined(_MSC_VER)
char *log = malloc(maxLength);
char *log = RL_MALLOC(maxLength);
#else
char log[maxLength];
#endif
@ -3767,7 +3767,7 @@ static unsigned int CompileShader(const char *shaderStr, int type)
TraceLog(LOG_INFO, "%s", log);
#if defined(_MSC_VER)
free(log);
RL_FREE(log);
#endif
}
else TraceLog(LOG_INFO, "[SHDR ID %i] Shader compiled successfully", shader);
@ -3814,7 +3814,7 @@ static unsigned int LoadShaderProgram(unsigned int vShaderId, unsigned int fShad
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
#if defined(_MSC_VER)
char *log = malloc(maxLength);
char *log = RL_MALLOC(maxLength);
#else
char log[maxLength];
#endif
@ -3823,7 +3823,7 @@ static unsigned int LoadShaderProgram(unsigned int vShaderId, unsigned int fShad
TraceLog(LOG_INFO, "%s", log);
#if defined(_MSC_VER)
free(log);
RL_FREE(log);
#endif
glDeleteProgram(program);
@ -3984,13 +3984,13 @@ static void LoadBuffersDefault(void)
//--------------------------------------------------------------------------------------------
for (int i = 0; i < MAX_BATCH_BUFFERING; i++)
{
vertexData[i].vertices = (float *)malloc(sizeof(float)*3*4*MAX_BATCH_ELEMENTS); // 3 float by vertex, 4 vertex by quad
vertexData[i].texcoords = (float *)malloc(sizeof(float)*2*4*MAX_BATCH_ELEMENTS); // 2 float by texcoord, 4 texcoord by quad
vertexData[i].colors = (unsigned char *)malloc(sizeof(unsigned char)*4*4*MAX_BATCH_ELEMENTS); // 4 float by color, 4 colors by quad
vertexData[i].vertices = (float *)RL_MALLOC(sizeof(float)*3*4*MAX_BATCH_ELEMENTS); // 3 float by vertex, 4 vertex by quad
vertexData[i].texcoords = (float *)RL_MALLOC(sizeof(float)*2*4*MAX_BATCH_ELEMENTS); // 2 float by texcoord, 4 texcoord by quad
vertexData[i].colors = (unsigned char *)RL_MALLOC(sizeof(unsigned char)*4*4*MAX_BATCH_ELEMENTS); // 4 float by color, 4 colors by quad
#if defined(GRAPHICS_API_OPENGL_33)
vertexData[i].indices = (unsigned int *)malloc(sizeof(unsigned int)*6*MAX_BATCH_ELEMENTS); // 6 int by quad (indices)
vertexData[i].indices = (unsigned int *)RL_MALLOC(sizeof(unsigned int)*6*MAX_BATCH_ELEMENTS); // 6 int by quad (indices)
#elif defined(GRAPHICS_API_OPENGL_ES2)
vertexData[i].indices = (unsigned short *)malloc(sizeof(unsigned short)*6*MAX_BATCH_ELEMENTS); // 6 int by quad (indices)
vertexData[i].indices = (unsigned short *)RL_MALLOC(sizeof(unsigned short)*6*MAX_BATCH_ELEMENTS); // 6 int by quad (indices)
#endif
for (int j = 0; j < (3*4*MAX_BATCH_ELEMENTS); j++) vertexData[i].vertices[j] = 0.0f;
@ -4266,10 +4266,10 @@ static void UnloadBuffersDefault(void)
if (vaoSupported) glDeleteVertexArrays(1, &vertexData[i].vaoId);
// Free vertex arrays memory from CPU (RAM)
free(vertexData[i].vertices);
free(vertexData[i].texcoords);
free(vertexData[i].colors);
free(vertexData[i].indices);
RL_FREE(vertexData[i].vertices);
RL_FREE(vertexData[i].texcoords);
RL_FREE(vertexData[i].colors);
RL_FREE(vertexData[i].indices);
}
}
@ -4444,7 +4444,7 @@ static int GenerateMipmaps(unsigned char *data, int baseWidth, int baseHeight)
// Generate mipmaps
// NOTE: Every mipmap data is stored after data
Color *image = (Color *)malloc(width*height*sizeof(Color));
Color *image = (Color *)RL_MALLOC(width*height*sizeof(Color));
Color *mipmap = NULL;
int offset = 0;
int j = 0;
@ -4481,13 +4481,13 @@ static int GenerateMipmaps(unsigned char *data, int baseWidth, int baseHeight)
j++;
}
free(image);
RL_FREE(image);
image = mipmap;
mipmap = NULL;
}
free(mipmap); // free mipmap data
RL_FREE(mipmap); // free mipmap data
return mipmapCount;
}
@ -4501,7 +4501,7 @@ static Color *GenNextMipmap(Color *srcData, int srcWidth, int srcHeight)
int width = srcWidth/2;
int height = srcHeight/2;
Color *mipmap = (Color *)malloc(width*height*sizeof(Color));
Color *mipmap = (Color *)RL_MALLOC(width*height*sizeof(Color));
// Scaling algorithm works perfectly (box-filter)
for (int y = 0; y < height; y++)

54
src/text.c
View File

@ -174,7 +174,7 @@ extern void LoadDefaultFont(void)
int imWidth = 128;
int imHeight = 128;
Color *imagePixels = (Color *)malloc(imWidth*imHeight*sizeof(Color));
Color *imagePixels = (Color *)RL_MALLOC(imWidth*imHeight*sizeof(Color));
for (int i = 0; i < imWidth*imHeight; i++) imagePixels[i] = BLANK; // Initialize array
@ -196,7 +196,7 @@ extern void LoadDefaultFont(void)
Image image = LoadImageEx(imagePixels, imWidth, imHeight);
ImageFormat(&image, UNCOMPRESSED_GRAY_ALPHA);
free(imagePixels);
RL_FREE(imagePixels);
defaultFont.texture = LoadTextureFromImage(image);
UnloadImage(image);
@ -206,7 +206,7 @@ extern void LoadDefaultFont(void)
// Allocate space for our characters info data
// NOTE: This memory should be freed at end! --> CloseWindow()
defaultFont.chars = (CharInfo *)malloc(defaultFont.charsCount*sizeof(CharInfo));
defaultFont.chars = (CharInfo *)RL_MALLOC(defaultFont.charsCount*sizeof(CharInfo));
int currentLine = 0;
int currentPosX = charsDivisor;
@ -249,7 +249,7 @@ extern void LoadDefaultFont(void)
extern void UnloadDefaultFont(void)
{
UnloadTexture(defaultFont.texture);
free(defaultFont.chars);
RL_FREE(defaultFont.chars);
}
#endif // SUPPORT_DEFAULT_FONT
@ -407,7 +407,7 @@ Font LoadFontFromImage(Image image, Color key, int firstChar)
// Create a new image with the processed color data (key color replaced by BLANK)
Image fontClear = LoadImageEx(pixels, image.width, image.height);
free(pixels); // Free pixels array memory
RL_FREE(pixels); // Free pixels array memory
// Create spritefont with all data parsed from image
Font spriteFont = { 0 };
@ -419,7 +419,7 @@ Font LoadFontFromImage(Image image, Color key, int firstChar)
// We got tempCharValues and tempCharsRecs populated with chars data
// Now we move temp data to sized charValues and charRecs arrays
spriteFont.chars = (CharInfo *)malloc(spriteFont.charsCount*sizeof(CharInfo));
spriteFont.chars = (CharInfo *)RL_MALLOC(spriteFont.charsCount*sizeof(CharInfo));
for (int i = 0; i < spriteFont.charsCount; i++)
{
@ -466,7 +466,7 @@ CharInfo *LoadFontData(const char *fileName, int fontSize, int *fontChars, int c
long size = ftell(fontFile); // Get file size
fseek(fontFile, 0, SEEK_SET); // Reset file pointer
unsigned char *fontBuffer = (unsigned char *)malloc(size);
unsigned char *fontBuffer = (unsigned char *)RL_MALLOC(size);
fread(fontBuffer, size, 1, fontFile);
fclose(fontFile);
@ -491,12 +491,12 @@ CharInfo *LoadFontData(const char *fileName, int fontSize, int *fontChars, int c
int genFontChars = false;
if (fontChars == NULL)
{
fontChars = (int *)malloc(charsCount*sizeof(int));
fontChars = (int *)RL_MALLOC(charsCount*sizeof(int));
for (int i = 0; i < charsCount; i++) fontChars[i] = i + 32;
genFontChars = true;
}
chars = (CharInfo *)malloc(charsCount*sizeof(CharInfo));
chars = (CharInfo *)RL_MALLOC(charsCount*sizeof(CharInfo));
// NOTE: Using simple packaging, one char after another
for (int i = 0; i < charsCount; i++)
@ -540,8 +540,8 @@ CharInfo *LoadFontData(const char *fileName, int fontSize, int *fontChars, int c
chars[i].advanceX *= scaleFactor;
}
free(fontBuffer);
if (genFontChars) free(fontChars);
RL_FREE(fontBuffer);
if (genFontChars) RL_FREE(fontChars);
}
else TraceLog(LOG_WARNING, "[%s] TTF file could not be opened", fileName);
#else
@ -572,7 +572,7 @@ Image GenImageFontAtlas(CharInfo *chars, int charsCount, int fontSize, int paddi
atlas.width = imageSize; // Atlas bitmap width
atlas.height = imageSize; // Atlas bitmap height
atlas.data = (unsigned char *)calloc(1, atlas.width*atlas.height); // Create a bitmap to store characters (8 bpp)
atlas.data = (unsigned char *)RL_CALLOC(1, atlas.width*atlas.height); // Create a bitmap to store characters (8 bpp)
atlas.format = UNCOMPRESSED_GRAYSCALE;
atlas.mipmaps = 1;
@ -619,11 +619,11 @@ Image GenImageFontAtlas(CharInfo *chars, int charsCount, int fontSize, int paddi
{
TraceLog(LOG_DEBUG, "Using Skyline packing algorythm!");
stbrp_context *context = (stbrp_context *)malloc(sizeof(*context));
stbrp_node *nodes = (stbrp_node *)malloc(charsCount*sizeof(*nodes));
stbrp_context *context = (stbrp_context *)RL_MALLOC(sizeof(*context));
stbrp_node *nodes = (stbrp_node *)RL_MALLOC(charsCount*sizeof(*nodes));
stbrp_init_target(context, atlas.width, atlas.height, nodes, charsCount);
stbrp_rect *rects = (stbrp_rect *)malloc(charsCount*sizeof(stbrp_rect));
stbrp_rect *rects = (stbrp_rect *)RL_MALLOC(charsCount*sizeof(stbrp_rect));
// Fill rectangles for packaging
for (int i = 0; i < charsCount; i++)
@ -655,16 +655,16 @@ Image GenImageFontAtlas(CharInfo *chars, int charsCount, int fontSize, int paddi
else TraceLog(LOG_WARNING, "Character could not be packed: %i", i);
}
free(rects);
free(nodes);
free(context);
RL_FREE(rects);
RL_FREE(nodes);
RL_FREE(context);
}
// TODO: Crop image if required for smaller size
// Convert image data from GRAYSCALE to GRAY_ALPHA
// WARNING: ImageAlphaMask(&atlas, atlas) does not work in this case, requires manual operation
unsigned char *dataGrayAlpha = (unsigned char *)malloc(imageSize*imageSize*sizeof(unsigned char)*2); // Two channels
unsigned char *dataGrayAlpha = (unsigned char *)RL_MALLOC(imageSize*imageSize*sizeof(unsigned char)*2); // Two channels
for (int i = 0, k = 0; i < atlas.width*atlas.height; i++, k += 2)
{
@ -672,7 +672,7 @@ Image GenImageFontAtlas(CharInfo *chars, int charsCount, int fontSize, int paddi
dataGrayAlpha[k + 1] = ((unsigned char *)atlas.data)[i];
}
free(atlas.data);
RL_FREE(atlas.data);
atlas.data = dataGrayAlpha;
atlas.format = UNCOMPRESSED_GRAY_ALPHA;
@ -688,10 +688,10 @@ void UnloadFont(Font font)
{
for (int i = 0; i < font.charsCount; i++)
{
free(font.chars[i].data);
RL_FREE(font.chars[i].data);
}
UnloadTexture(font.texture);
free(font.chars);
RL_FREE(font.chars);
TraceLog(LOG_DEBUG, "Unloaded sprite font data");
}
@ -1214,7 +1214,7 @@ const char *TextReplace(char *text, const char *replace, const char *by)
for (count = 0; (temp = strstr(insertPoint, replace)); count++) insertPoint = temp + replaceLen;
// Allocate returning string and point temp to it
temp = result = malloc(strlen(text) + (byLen - replaceLen)*count + 1);
temp = result = RL_MALLOC(strlen(text) + (byLen - replaceLen)*count + 1);
if (!result) return NULL; // Memory could not be allocated
@ -1245,7 +1245,7 @@ const char *TextInsert(const char *text, const char *insert, int position)
int textLen = strlen(text);
int insertLen = strlen(insert);
char *result = (char *)malloc(textLen + insertLen + 1);
char *result = (char *)RL_MALLOC(textLen + insertLen + 1);
for (int i = 0; i < position; i++) result[i] = text[i];
for (int i = position; i < insertLen + position; i++) result[i] = insert[i];
@ -1477,7 +1477,7 @@ static Font LoadBMFont(const char *fileName)
}
// NOTE: We need some extra space to avoid memory corruption on next allocations!
texPath = malloc(strlen(fileName) - strlen(lastSlash) + strlen(texFileName) + 4);
texPath = RL_MALLOC(strlen(fileName) - strlen(lastSlash) + strlen(texFileName) + 4);
// NOTE: strcat() and strncat() required a '\0' terminated string to work!
*texPath = '\0';
@ -1501,13 +1501,13 @@ static Font LoadBMFont(const char *fileName)
else font.texture = LoadTextureFromImage(imFont);
UnloadImage(imFont);
free(texPath);
RL_FREE(texPath);
// Fill font characters info data
font.baseSize = fontSize;
font.charsCount = charsCount;
font.chars = (CharInfo *)malloc(charsCount*sizeof(CharInfo));
font.chars = (CharInfo *)RL_MALLOC(charsCount*sizeof(CharInfo));
int charId, charX, charY, charWidth, charHeight, charOffsetX, charOffsetY, charAdvanceX;

181
src/textures.c
View File

@ -112,9 +112,14 @@
defined(SUPPORT_FILEFORMAT_GIF) || \
defined(SUPPORT_FILEFORMAT_PIC) || \
defined(SUPPORT_FILEFORMAT_HDR))
#define STBI_MALLOC RL_MALLOC
#define STBI_FREE RL_FREE
#define STBI_REALLOC(p,newsz) realloc(p,newsz)
#define STB_IMAGE_IMPLEMENTATION
#include "external/stb_image.h" // Required for: stbi_load_from_file()
// NOTE: Used to read image data (multiple formats support)
#include "external/stb_image.h" // Required for: stbi_load_from_file()
// NOTE: Used to read image data (multiple formats support)
#endif
#if defined(SUPPORT_IMAGE_EXPORT)
@ -305,7 +310,7 @@ Image LoadImageEx(Color *pixels, int width, int height)
int k = 0;
image.data = (unsigned char *)malloc(image.width*image.height*4*sizeof(unsigned char));
image.data = (unsigned char *)RL_MALLOC(image.width*image.height*4*sizeof(unsigned char));
for (int i = 0; i < image.width*image.height*4; i += 4)
{
@ -353,7 +358,7 @@ Image LoadImageRaw(const char *fileName, int width, int height, int format, int
unsigned int size = GetPixelDataSize(width, height, format);
image.data = malloc(size); // Allocate required memory in bytes
image.data = RL_MALLOC(size); // Allocate required memory in bytes
// NOTE: fread() returns num read elements instead of bytes,
// to get bytes we need to read (1 byte size, elements) instead of (x byte size, 1 element)
@ -364,7 +369,7 @@ Image LoadImageRaw(const char *fileName, int width, int height, int format, int
{
TraceLog(LOG_WARNING, "[%s] RAW image data can not be read, wrong requested format or size", fileName);
free(image.data);
RL_FREE(image.data);
}
else
{
@ -425,7 +430,7 @@ RenderTexture2D LoadRenderTexture(int width, int height)
// Unload image from CPU memory (RAM)
void UnloadImage(Image image)
{
free(image.data);
RL_FREE(image.data);
}
// Unload texture from GPU memory (VRAM)
@ -448,7 +453,7 @@ void UnloadRenderTexture(RenderTexture2D target)
// Get pixel data from image in the form of Color struct array
Color *GetImageData(Image image)
{
Color *pixels = (Color *)malloc(image.width*image.height*sizeof(Color));
Color *pixels = (Color *)RL_MALLOC(image.width*image.height*sizeof(Color));
if (image.format >= COMPRESSED_DXT1_RGB) TraceLog(LOG_WARNING, "Pixel data retrieval not supported for compressed image formats");
else
@ -563,7 +568,7 @@ Color *GetImageData(Image image)
// Get pixel data from image as Vector4 array (float normalized)
Vector4 *GetImageDataNormalized(Image image)
{
Vector4 *pixels = (Vector4 *)malloc(image.width*image.height*sizeof(Vector4));
Vector4 *pixels = (Vector4 *)RL_MALLOC(image.width*image.height*sizeof(Vector4));
if (image.format >= COMPRESSED_DXT1_RGB) TraceLog(LOG_WARNING, "Pixel data retrieval not supported for compressed image formats");
else
@ -797,7 +802,7 @@ void ExportImage(Image image, const char *fileName)
fclose(rawFile);
}
free(imgData);
RL_FREE(imgData);
#endif
if (success != 0) TraceLog(LOG_INFO, "Image exported successfully: %s", fileName);
@ -863,7 +868,7 @@ Image ImageCopy(Image image)
if (height < 1) height = 1;
}
newImage.data = malloc(size);
newImage.data = RL_MALLOC(size);
if (newImage.data != NULL)
{
@ -896,7 +901,7 @@ void ImageToPOT(Image *image, Color fillColor)
Color *pixelsPOT = NULL;
// Generate POT array from NPOT data
pixelsPOT = (Color *)malloc(potWidth*potHeight*sizeof(Color));
pixelsPOT = (Color *)RL_MALLOC(potWidth*potHeight*sizeof(Color));
for (int j = 0; j < potHeight; j++)
{
@ -909,15 +914,15 @@ void ImageToPOT(Image *image, Color fillColor)
TraceLog(LOG_WARNING, "Image converted to POT: (%ix%i) -> (%ix%i)", image->width, image->height, potWidth, potHeight);
free(pixels); // Free pixels data
free(image->data); // Free old image data
RL_FREE(pixels); // Free pixels data
RL_FREE(image->data); // Free old image data
int format = image->format; // Store image data format to reconvert later
// NOTE: Image size changes, new width and height
*image = LoadImageEx(pixelsPOT, potWidth, potHeight);
free(pixelsPOT); // Free POT pixels data
RL_FREE(pixelsPOT); // Free POT pixels data
ImageFormat(image, format); // Reconvert image to previous format
}
@ -932,7 +937,7 @@ void ImageFormat(Image *image, int newFormat)
{
Vector4 *pixels = GetImageDataNormalized(*image); // Supports 8 to 32 bit per channel
free(image->data); // WARNING! We loose mipmaps data --> Regenerated at the end...
RL_FREE(image->data); // WARNING! We loose mipmaps data --> Regenerated at the end...
image->data = NULL;
image->format = newFormat;
@ -942,7 +947,7 @@ void ImageFormat(Image *image, int newFormat)
{
case UNCOMPRESSED_GRAYSCALE:
{
image->data = (unsigned char *)malloc(image->width*image->height*sizeof(unsigned char));
image->data = (unsigned char *)RL_MALLOC(image->width*image->height*sizeof(unsigned char));
for (int i = 0; i < image->width*image->height; i++)
{
@ -952,7 +957,7 @@ void ImageFormat(Image *image, int newFormat)
} break;
case UNCOMPRESSED_GRAY_ALPHA:
{
image->data = (unsigned char *)malloc(image->width*image->height*2*sizeof(unsigned char));
image->data = (unsigned char *)RL_MALLOC(image->width*image->height*2*sizeof(unsigned char));
for (int i = 0; i < image->width*image->height*2; i += 2, k++)
{
@ -963,7 +968,7 @@ void ImageFormat(Image *image, int newFormat)
} break;
case UNCOMPRESSED_R5G6B5:
{
image->data = (unsigned short *)malloc(image->width*image->height*sizeof(unsigned short));
image->data = (unsigned short *)RL_MALLOC(image->width*image->height*sizeof(unsigned short));
unsigned char r = 0;
unsigned char g = 0;
@ -981,7 +986,7 @@ void ImageFormat(Image *image, int newFormat)
} break;
case UNCOMPRESSED_R8G8B8:
{
image->data = (unsigned char *)malloc(image->width*image->height*3*sizeof(unsigned char));
image->data = (unsigned char *)RL_MALLOC(image->width*image->height*3*sizeof(unsigned char));
for (int i = 0, k = 0; i < image->width*image->height*3; i += 3, k++)
{
@ -994,7 +999,7 @@ void ImageFormat(Image *image, int newFormat)
{
#define ALPHA_THRESHOLD 50
image->data = (unsigned short *)malloc(image->width*image->height*sizeof(unsigned short));
image->data = (unsigned short *)RL_MALLOC(image->width*image->height*sizeof(unsigned short));
unsigned char r = 0;
unsigned char g = 0;
@ -1014,7 +1019,7 @@ void ImageFormat(Image *image, int newFormat)
} break;
case UNCOMPRESSED_R4G4B4A4:
{
image->data = (unsigned short *)malloc(image->width*image->height*sizeof(unsigned short));
image->data = (unsigned short *)RL_MALLOC(image->width*image->height*sizeof(unsigned short));
unsigned char r = 0;
unsigned char g = 0;
@ -1034,7 +1039,7 @@ void ImageFormat(Image *image, int newFormat)
} break;
case UNCOMPRESSED_R8G8B8A8:
{
image->data = (unsigned char *)malloc(image->width*image->height*4*sizeof(unsigned char));
image->data = (unsigned char *)RL_MALLOC(image->width*image->height*4*sizeof(unsigned char));
for (int i = 0, k = 0; i < image->width*image->height*4; i += 4, k++)
{
@ -1048,7 +1053,7 @@ void ImageFormat(Image *image, int newFormat)
{
// WARNING: Image is converted to GRAYSCALE eqeuivalent 32bit
image->data = (float *)malloc(image->width*image->height*sizeof(float));
image->data = (float *)RL_MALLOC(image->width*image->height*sizeof(float));
for (int i = 0; i < image->width*image->height; i++)
{
@ -1057,7 +1062,7 @@ void ImageFormat(Image *image, int newFormat)
} break;
case UNCOMPRESSED_R32G32B32:
{
image->data = (float *)malloc(image->width*image->height*3*sizeof(float));
image->data = (float *)RL_MALLOC(image->width*image->height*3*sizeof(float));
for (int i = 0, k = 0; i < image->width*image->height*3; i += 3, k++)
{
@ -1068,7 +1073,7 @@ void ImageFormat(Image *image, int newFormat)
} break;
case UNCOMPRESSED_R32G32B32A32:
{
image->data = (float *)malloc(image->width*image->height*4*sizeof(float));
image->data = (float *)RL_MALLOC(image->width*image->height*4*sizeof(float));
for (int i = 0, k = 0; i < image->width*image->height*4; i += 4, k++)
{
@ -1081,7 +1086,7 @@ void ImageFormat(Image *image, int newFormat)
default: break;
}
free(pixels);
RL_FREE(pixels);
pixels = NULL;
// In case original image had mipmaps, generate mipmaps for formated image
@ -1286,7 +1291,7 @@ void ImageCrop(Image *image, Rectangle crop)
{
// Start the cropping process
Color *pixels = GetImageData(*image); // Get data as Color pixels array
Color *cropPixels = (Color *)malloc((int)crop.width*(int)crop.height*sizeof(Color));
Color *cropPixels = (Color *)RL_MALLOC((int)crop.width*(int)crop.height*sizeof(Color));
for (int j = (int)crop.y; j < (int)(crop.y + crop.height); j++)
{
@ -1296,7 +1301,7 @@ void ImageCrop(Image *image, Rectangle crop)
}
}
free(pixels);
RL_FREE(pixels);
int format = image->format;
@ -1304,7 +1309,7 @@ void ImageCrop(Image *image, Rectangle crop)
*image = LoadImageEx(cropPixels, (int)crop.width, (int)crop.height);
free(cropPixels);
RL_FREE(cropPixels);
// Reformat 32bit RGBA image to original format
ImageFormat(image, format);
@ -1341,7 +1346,7 @@ void ImageAlphaCrop(Image *image, float threshold)
Rectangle crop = { xMin, yMin, (xMax + 1) - xMin, (yMax + 1) - yMin };
free(pixels);
RL_FREE(pixels);
// Check for not empty image brefore cropping
if (!((xMax < xMin) || (yMax < yMin))) ImageCrop(image, crop);
@ -1355,7 +1360,7 @@ void ImageResize(Image *image, int newWidth, int newHeight)
{
// Get data as Color pixels array to work with it
Color *pixels = GetImageData(*image);
Color *output = (Color *)malloc(newWidth*newHeight*sizeof(Color));
Color *output = (Color *)RL_MALLOC(newWidth*newHeight*sizeof(Color));
// NOTE: Color data is casted to (unsigned char *), there shouldn't been any problem...
stbir_resize_uint8((unsigned char *)pixels, image->width, image->height, 0, (unsigned char *)output, newWidth, newHeight, 0, 4);
@ -1367,15 +1372,15 @@ void ImageResize(Image *image, int newWidth, int newHeight)
*image = LoadImageEx(output, newWidth, newHeight);
ImageFormat(image, format); // Reformat 32bit RGBA image to original format
free(output);
free(pixels);
RL_FREE(output);
RL_FREE(pixels);
}
// Resize and image to new size using Nearest-Neighbor scaling algorithm
void ImageResizeNN(Image *image,int newWidth,int newHeight)
{
Color *pixels = GetImageData(*image);
Color *output = (Color *)malloc(newWidth*newHeight*sizeof(Color));
Color *output = (Color *)RL_MALLOC(newWidth*newHeight*sizeof(Color));
// EDIT: added +1 to account for an early rounding problem
int xRatio = (int)((image->width << 16)/newWidth) + 1;
@ -1400,8 +1405,8 @@ void ImageResizeNN(Image *image,int newWidth,int newHeight)
*image = LoadImageEx(output, newWidth, newHeight);
ImageFormat(image, format); // Reformat 32bit RGBA image to original format
free(output);
free(pixels);
RL_FREE(output);
RL_FREE(pixels);
}
// Resize canvas and fill with color
@ -1555,7 +1560,7 @@ void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp)
{
Color *pixels = GetImageData(*image);
free(image->data); // free old image data
RL_FREE(image->data); // free old image data
if ((image->format != UNCOMPRESSED_R8G8B8) && (image->format != UNCOMPRESSED_R8G8B8A8))
{
@ -1573,7 +1578,7 @@ void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp)
}
// NOTE: We will store the dithered data as unsigned short (16bpp)
image->data = (unsigned short *)malloc(image->width*image->height*sizeof(unsigned short));
image->data = (unsigned short *)RL_MALLOC(image->width*image->height*sizeof(unsigned short));
Color oldPixel = WHITE;
Color newPixel = WHITE;
@ -1641,7 +1646,7 @@ void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp)
}
}
free(pixels);
RL_FREE(pixels);
}
}
@ -1652,7 +1657,7 @@ Color *ImageExtractPalette(Image image, int maxPaletteSize, int *extractCount)
#define COLOR_EQUAL(col1, col2) ((col1.r == col2.r)&&(col1.g == col2.g)&&(col1.b == col2.b)&&(col1.a == col2.a))
Color *pixels = GetImageData(image);
Color *palette = (Color *)malloc(maxPaletteSize*sizeof(Color));
Color *palette = (Color *)RL_MALLOC(maxPaletteSize*sizeof(Color));
int palCount = 0;
for (int i = 0; i < maxPaletteSize; i++) palette[i] = BLANK; // Set all colors to BLANK
@ -1689,7 +1694,7 @@ Color *ImageExtractPalette(Image image, int maxPaletteSize, int *extractCount)
}
}
free(pixels);
RL_FREE(pixels);
*extractCount = palCount;
@ -1799,8 +1804,8 @@ void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec)
*dst = LoadImageEx(dstPixels, (int)dst->width, (int)dst->height);
ImageFormat(dst, dst->format);
free(srcPixels);
free(dstPixels);
RL_FREE(srcPixels);
RL_FREE(dstPixels);
}
// Create an image from text (default font)
@ -1933,7 +1938,7 @@ void ImageDrawTextEx(Image *dst, Vector2 position, Font font, const char *text,
void ImageFlipVertical(Image *image)
{
Color *srcPixels = GetImageData(*image);
Color *dstPixels = (Color *)malloc(image->width*image->height*sizeof(Color));
Color *dstPixels = (Color *)RL_MALLOC(image->width*image->height*sizeof(Color));
for (int y = 0; y < image->height; y++)
{
@ -1947,8 +1952,8 @@ void ImageFlipVertical(Image *image)
ImageFormat(&processed, image->format);
UnloadImage(*image);
free(srcPixels);
free(dstPixels);
RL_FREE(srcPixels);
RL_FREE(dstPixels);
image->data = processed.data;
}
@ -1957,7 +1962,7 @@ void ImageFlipVertical(Image *image)
void ImageFlipHorizontal(Image *image)
{
Color *srcPixels = GetImageData(*image);
Color *dstPixels = (Color *)malloc(image->width*image->height*sizeof(Color));
Color *dstPixels = (Color *)RL_MALLOC(image->width*image->height*sizeof(Color));
for (int y = 0; y < image->height; y++)
{
@ -1971,8 +1976,8 @@ void ImageFlipHorizontal(Image *image)
ImageFormat(&processed, image->format);
UnloadImage(*image);
free(srcPixels);
free(dstPixels);
RL_FREE(srcPixels);
RL_FREE(dstPixels);
image->data = processed.data;
}
@ -1981,7 +1986,7 @@ void ImageFlipHorizontal(Image *image)
void ImageRotateCW(Image *image)
{
Color *srcPixels = GetImageData(*image);
Color *rotPixels = (Color *)malloc(image->width*image->height*sizeof(Color));
Color *rotPixels = (Color *)RL_MALLOC(image->width*image->height*sizeof(Color));
for (int y = 0; y < image->height; y++)
{
@ -1995,8 +2000,8 @@ void ImageRotateCW(Image *image)
ImageFormat(&processed, image->format);
UnloadImage(*image);
free(srcPixels);
free(rotPixels);
RL_FREE(srcPixels);
RL_FREE(rotPixels);
image->data = processed.data;
image->width = processed.width;
@ -2007,7 +2012,7 @@ void ImageRotateCW(Image *image)
void ImageRotateCCW(Image *image)
{
Color *srcPixels = GetImageData(*image);
Color *rotPixels = (Color *)malloc(image->width*image->height*sizeof(Color));
Color *rotPixels = (Color *)RL_MALLOC(image->width*image->height*sizeof(Color));
for (int y = 0; y < image->height; y++)
{
@ -2021,8 +2026,8 @@ void ImageRotateCCW(Image *image)
ImageFormat(&processed, image->format);
UnloadImage(*image);
free(srcPixels);
free(rotPixels);
RL_FREE(srcPixels);
RL_FREE(rotPixels);
image->data = processed.data;
image->width = processed.width;
@ -2059,7 +2064,7 @@ void ImageColorTint(Image *image, Color color)
Image processed = LoadImageEx(pixels, image->width, image->height);
ImageFormat(&processed, image->format);
UnloadImage(*image);
free(pixels);
RL_FREE(pixels);
image->data = processed.data;
}
@ -2082,7 +2087,7 @@ void ImageColorInvert(Image *image)
Image processed = LoadImageEx(pixels, image->width, image->height);
ImageFormat(&processed, image->format);
UnloadImage(*image);
free(pixels);
RL_FREE(pixels);
image->data = processed.data;
}
@ -2142,7 +2147,7 @@ void ImageColorContrast(Image *image, float contrast)
Image processed = LoadImageEx(pixels, image->width, image->height);
ImageFormat(&processed, image->format);
UnloadImage(*image);
free(pixels);
RL_FREE(pixels);
image->data = processed.data;
}
@ -2182,7 +2187,7 @@ void ImageColorBrightness(Image *image, int brightness)
Image processed = LoadImageEx(pixels, image->width, image->height);
ImageFormat(&processed, image->format);
UnloadImage(*image);
free(pixels);
RL_FREE(pixels);
image->data = processed.data;
}
@ -2212,7 +2217,7 @@ void ImageColorReplace(Image *image, Color color, Color replace)
Image processed = LoadImageEx(pixels, image->width, image->height);
ImageFormat(&processed, image->format);
UnloadImage(*image);
free(pixels);
RL_FREE(pixels);
image->data = processed.data;
}
@ -2221,13 +2226,13 @@ void ImageColorReplace(Image *image, Color color, Color replace)
// Generate image: plain color
Image GenImageColor(int width, int height, Color color)
{
Color *pixels = (Color *)calloc(width*height, sizeof(Color));
Color *pixels = (Color *)RL_CALLOC(width*height, sizeof(Color));
for (int i = 0; i < width*height; i++) pixels[i] = color;
Image image = LoadImageEx(pixels, width, height);
free(pixels);
RL_FREE(pixels);
return image;
}
@ -2236,7 +2241,7 @@ Image GenImageColor(int width, int height, Color color)
// Generate image: vertical gradient
Image GenImageGradientV(int width, int height, Color top, Color bottom)
{
Color *pixels = (Color *)malloc(width*height*sizeof(Color));
Color *pixels = (Color *)RL_MALLOC(width*height*sizeof(Color));
for (int j = 0; j < height; j++)
{
@ -2251,7 +2256,7 @@ Image GenImageGradientV(int width, int height, Color top, Color bottom)
}
Image image = LoadImageEx(pixels, width, height);
free(pixels);
RL_FREE(pixels);
return image;
}
@ -2259,7 +2264,7 @@ Image GenImageGradientV(int width, int height, Color top, Color bottom)
// Generate image: horizontal gradient
Image GenImageGradientH(int width, int height, Color left, Color right)
{
Color *pixels = (Color *)malloc(width*height*sizeof(Color));
Color *pixels = (Color *)RL_MALLOC(width*height*sizeof(Color));
for (int i = 0; i < width; i++)
{
@ -2274,7 +2279,7 @@ Image GenImageGradientH(int width, int height, Color left, Color right)
}
Image image = LoadImageEx(pixels, width, height);
free(pixels);
RL_FREE(pixels);
return image;
}
@ -2282,7 +2287,7 @@ Image GenImageGradientH(int width, int height, Color left, Color right)
// Generate image: radial gradient
Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer)
{
Color *pixels = (Color *)malloc(width*height*sizeof(Color));
Color *pixels = (Color *)RL_MALLOC(width*height*sizeof(Color));
float radius = (width < height)? (float)width/2.0f : (float)height/2.0f;
float centerX = (float)width/2.0f;
@ -2306,7 +2311,7 @@ Image GenImageGradientRadial(int width, int height, float density, Color inner,
}
Image image = LoadImageEx(pixels, width, height);
free(pixels);
RL_FREE(pixels);
return image;
}
@ -2314,7 +2319,7 @@ Image GenImageGradientRadial(int width, int height, float density, Color inner,
// Generate image: checked
Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2)
{
Color *pixels = (Color *)malloc(width*height*sizeof(Color));
Color *pixels = (Color *)RL_MALLOC(width*height*sizeof(Color));
for (int y = 0; y < height; y++)
{
@ -2326,7 +2331,7 @@ Image GenImageChecked(int width, int height, int checksX, int checksY, Color col
}
Image image = LoadImageEx(pixels, width, height);
free(pixels);
RL_FREE(pixels);
return image;
}
@ -2334,7 +2339,7 @@ Image GenImageChecked(int width, int height, int checksX, int checksY, Color col
// Generate image: white noise
Image GenImageWhiteNoise(int width, int height, float factor)
{
Color *pixels = (Color *)malloc(width*height*sizeof(Color));
Color *pixels = (Color *)RL_MALLOC(width*height*sizeof(Color));
for (int i = 0; i < width*height; i++)
{
@ -2343,7 +2348,7 @@ Image GenImageWhiteNoise(int width, int height, float factor)
}
Image image = LoadImageEx(pixels, width, height);
free(pixels);
RL_FREE(pixels);
return image;
}
@ -2351,7 +2356,7 @@ Image GenImageWhiteNoise(int width, int height, float factor)
// Generate image: perlin noise
Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale)
{
Color *pixels = (Color *)malloc(width*height*sizeof(Color));
Color *pixels = (Color *)RL_MALLOC(width*height*sizeof(Color));
for (int y = 0; y < height; y++)
{
@ -2374,7 +2379,7 @@ Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float
}
Image image = LoadImageEx(pixels, width, height);
free(pixels);
RL_FREE(pixels);
return image;
}
@ -2382,13 +2387,13 @@ Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float
// Generate image: cellular algorithm. Bigger tileSize means bigger cells
Image GenImageCellular(int width, int height, int tileSize)
{
Color *pixels = (Color *)malloc(width*height*sizeof(Color));
Color *pixels = (Color *)RL_MALLOC(width*height*sizeof(Color));
int seedsPerRow = width/tileSize;
int seedsPerCol = height/tileSize;
int seedsCount = seedsPerRow * seedsPerCol;
Vector2 *seeds = (Vector2 *)malloc(seedsCount*sizeof(Vector2));
Vector2 *seeds = (Vector2 *)RL_MALLOC(seedsCount*sizeof(Vector2));
for (int i = 0; i < seedsCount; i++)
{
@ -2431,10 +2436,10 @@ Image GenImageCellular(int width, int height, int tileSize)
}
}
free(seeds);
RL_FREE(seeds);
Image image = LoadImageEx(pixels, width, height);
free(pixels);
RL_FREE(pixels);
return image;
}
@ -2921,7 +2926,7 @@ static Image LoadDDS(const char *fileName)
{
if (ddsHeader.ddspf.flags == 0x40) // no alpha channel
{
image.data = (unsigned short *)malloc(image.width*image.height*sizeof(unsigned short));
image.data = (unsigned short *)RL_MALLOC(image.width*image.height*sizeof(unsigned short));
fread(image.data, image.width*image.height*sizeof(unsigned short), 1, ddsFile);
image.format = UNCOMPRESSED_R5G6B5;
@ -2930,7 +2935,7 @@ static Image LoadDDS(const char *fileName)
{
if (ddsHeader.ddspf.aBitMask == 0x8000) // 1bit alpha
{
image.data = (unsigned short *)malloc(image.width*image.height*sizeof(unsigned short));
image.data = (unsigned short *)RL_MALLOC(image.width*image.height*sizeof(unsigned short));
fread(image.data, image.width*image.height*sizeof(unsigned short), 1, ddsFile);
unsigned char alpha = 0;
@ -2947,7 +2952,7 @@ static Image LoadDDS(const char *fileName)
}
else if (ddsHeader.ddspf.aBitMask == 0xf000) // 4bit alpha
{
image.data = (unsigned short *)malloc(image.width*image.height*sizeof(unsigned short));
image.data = (unsigned short *)RL_MALLOC(image.width*image.height*sizeof(unsigned short));
fread(image.data, image.width*image.height*sizeof(unsigned short), 1, ddsFile);
unsigned char alpha = 0;
@ -2967,14 +2972,14 @@ static Image LoadDDS(const char *fileName)
if (ddsHeader.ddspf.flags == 0x40 && ddsHeader.ddspf.rgbBitCount == 24) // DDS_RGB, no compressed
{
// NOTE: not sure if this case exists...
image.data = (unsigned char *)malloc(image.width*image.height*3*sizeof(unsigned char));
image.data = (unsigned char *)RL_MALLOC(image.width*image.height*3*sizeof(unsigned char));
fread(image.data, image.width*image.height*3, 1, ddsFile);
image.format = UNCOMPRESSED_R8G8B8;
}
else if (ddsHeader.ddspf.flags == 0x41 && ddsHeader.ddspf.rgbBitCount == 32) // DDS_RGBA, no compressed
{
image.data = (unsigned char *)malloc(image.width*image.height*4*sizeof(unsigned char));
image.data = (unsigned char *)RL_MALLOC(image.width*image.height*4*sizeof(unsigned char));
fread(image.data, image.width*image.height*4, 1, ddsFile);
unsigned char blue = 0;
@ -3001,7 +3006,7 @@ static Image LoadDDS(const char *fileName)
TraceLog(LOG_DEBUG, "Pitch or linear size: %i", ddsHeader.pitchOrLinearSize);
image.data = (unsigned char *)malloc(size*sizeof(unsigned char));
image.data = (unsigned char *)RL_MALLOC(size*sizeof(unsigned char));
fread(image.data, size, 1, ddsFile);
@ -3098,7 +3103,7 @@ static Image LoadPKM(const char *fileName)
int size = image.width*image.height*bpp/8; // Total data size in bytes
image.data = (unsigned char *)malloc(size*sizeof(unsigned char));
image.data = (unsigned char *)RL_MALLOC(size*sizeof(unsigned char));
fread(image.data, size, 1, pkmFile);
@ -3192,7 +3197,7 @@ static Image LoadKTX(const char *fileName)
int dataSize;
fread(&dataSize, sizeof(unsigned int), 1, ktxFile);
image.data = (unsigned char *)malloc(dataSize*sizeof(unsigned char));
image.data = (unsigned char *)RL_MALLOC(dataSize*sizeof(unsigned char));
fread(image.data, dataSize, 1, ktxFile);
@ -3441,7 +3446,7 @@ static Image LoadPVR(const char *fileName)
}
int dataSize = image.width*image.height*bpp/8; // Total data size in bytes
image.data = (unsigned char *)malloc(dataSize*sizeof(unsigned char));
image.data = (unsigned char *)RL_MALLOC(dataSize*sizeof(unsigned char));
// Read data from file
fread(image.data, dataSize, 1, pvrFile);
@ -3518,7 +3523,7 @@ static Image LoadASTC(const char *fileName)
{
int dataSize = image.width*image.height*bpp/8; // Data size in bytes
image.data = (unsigned char *)malloc(dataSize*sizeof(unsigned char));
image.data = (unsigned char *)RL_MALLOC(dataSize*sizeof(unsigned char));
fread(image.data, dataSize, 1, astcFile);
if (bpp == 8) image.format = COMPRESSED_ASTC_4x4_RGBA;

6
src/utils.c
View File

@ -45,10 +45,10 @@
#include <android/asset_manager.h> // Required for: Android assets manager: AAsset, AAssetManager_open(), ...
#endif
#include <stdlib.h> // Required for: malloc(), free()
#include <stdio.h> // Required for: fopen(), fclose(), fputc(), fwrite(), printf(), fprintf(), funopen()
#include <stdlib.h> // Required for: exit()
#include <stdio.h> // Required for: printf(), sprintf()
#include <stdarg.h> // Required for: va_list, va_start(), vfprintf(), va_end()
#include <string.h> // Required for: strlen(), strrchr(), strcmp()
#include <string.h> // Required for: strcpy(), strcat()
#define MAX_TRACELOG_BUFFER_SIZE 128 // Max length of one trace-log message