lpnf
/
lovr
mirror of https://github.com/bjornbytes/lovr.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add wrappers for malloc functions;

This commit is contained in:
bjorn 2024-03-11 14:38:00 -07:00
parent 2d7b636a90
commit d097d9819d
32 changed files with 330 additions and 456 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/api/api.c
View File

@ -521,9 +521,8 @@ int luax_readmesh(lua_State* L, int index, float** vertices, uint32_t* vertexCou
lovrCheck(*vertexCount > 0, "Invalid mesh data: vertex count is zero");
lovrCheck(*indexCount > 0, "Invalid mesh data: index count is zero");
lovrCheck(*indexCount % 3 == 0, "Index count must be a multiple of 3");
*vertices = malloc(sizeof(float) * *vertexCount * 3);
*indices = malloc(sizeof(uint32_t) * *indexCount);
lovrAssert(vertices && indices, "Out of memory");
*vertices = lovrMalloc(sizeof(float) * *vertexCount * 3);
*indices = lovrMalloc(sizeof(uint32_t) * *indexCount);
*shouldFree = true;
if (nested) {

4
src/api/l_audio.c
View File

@ -200,8 +200,8 @@ static int l_lovrAudioSetGeometry(lua_State* L) {
AudioMaterial material = luax_checkenum(L, index, AudioMaterial, "generic");
bool success = lovrAudioSetGeometry(vertices, indices, vertexCount, indexCount, material);
if (shouldFree) {
free(vertices);
free(indices);
lovrFree(vertices);
lovrFree(indices);
}
lua_pushboolean(L, success);
return 1;

9
src/api/l_data.c
View File

@ -79,19 +79,16 @@ static int l_lovrDataNewBlob(lua_State* L) {
int isize = lua_tonumber(L, 1);
lovrCheck(isize > 0, "Blob size must be positive");
size = (size_t) isize;
data = calloc(1, size);
lovrAssert(data, "Out of memory");
data = lovrCalloc(size);
} else if (type == LUA_TSTRING) {
const char* str = luaL_checklstring(L, 1, &size);
data = malloc(size + 1);
lovrAssert(data, "Out of memory");
data = lovrMalloc(size + 1);
memcpy(data, str, size);
data[size] = '\0';
} else {
Blob* blob = luax_checktype(L, 1, Blob);
size = blob->size;
data = malloc(size);
lovrAssert(data, "Out of memory");
data = lovrMalloc(size);
memcpy(data, blob->data, size);
}
const char* name = luaL_optstring(L, 2, "");

8
src/api/l_event.c
View File

@ -55,8 +55,7 @@ void luax_checkvariant(lua_State* L, int index, Variant* variant) {
memcpy(variant->value.ministring.data, string, length);
} else {
variant->type = TYPE_STRING;
variant->value.string.pointer = malloc(length + 1);
lovrAssert(variant->value.string.pointer, "Out of memory");
variant->value.string.pointer = lovrMalloc(length + 1);
memcpy(variant->value.string.pointer, string, length);
variant->value.string.pointer[length] = '\0';
variant->value.string.length = length;
@ -92,8 +91,7 @@ void luax_checkvariant(lua_State* L, int index, Variant* variant) {
if (v) {
if (type == V_MAT4) {
variant->type = TYPE_MATRIX;
variant->value.matrix.data = malloc(16 * sizeof(float));
lovrAssert(variant->value.matrix.data, "Out of memory");
variant->value.matrix.data = lovrMalloc(16 * sizeof(float));
memcpy(variant->value.matrix.data, v, 16 * sizeof(float));
break;
} else {
@ -205,7 +203,7 @@ static int nextEvent(lua_State* L) {
luax_pushtype(L, Thread, event.data.thread.thread);
lua_pushstring(L, event.data.thread.error);
lovrRelease(event.data.thread.thread, lovrThreadDestroy);
free(event.data.thread.error);
lovrFree(event.data.thread.error);
return 3;
#endif

4
src/api/l_filesystem.c
View File

@ -74,7 +74,7 @@ static int luax_loadfile(lua_State* L, const char* path, const char* debug, cons
return 2;
}
int status = luax_loadbufferx(L, buffer, size, debug, mode);
free(buffer);
lovrFree(buffer);
switch (status) {
case LUA_ERRMEM: return luaL_error(L, "Memory allocation error: %s", lua_tostring(L, -1));
case LUA_ERRSYNTAX: return luaL_error(L, "Syntax error: %s", lua_tostring(L, -1));
@ -315,7 +315,7 @@ static int l_lovrFilesystemRead(lua_State* L) {
return 1;
}
lua_pushlstring(L, data, size);
free(data);
lovrFree(data);
return 1;
}

7
src/api/l_filesystem_file.c
View File

@ -41,17 +41,16 @@ static int l_lovrFileRead(lua_State* L) {
size = lovrFileGetSize(file) - lovrFileTell(file);
}
size_t count;
void* data = malloc(size);
lovrAssert(data, "Out of memory");
void* data = lovrMalloc(size);
bool success = lovrFileRead(file, data, size, &count);
if (success) {
lua_pushlstring(L, data, count);
lua_pushnumber(L, count);
free(data);
lovrFree(data);
return 2;
} else {
lua_pushnil(L);
free(data);
lovrFree(data);
return 1;
}
}

27
src/api/l_graphics.c
View File

@ -305,19 +305,14 @@ static void luax_writeshadercache(void) {
return;
}
void* data = malloc(size);
if (!data) {
return;
}
void* data = lovrMalloc(size);
lovrGraphicsGetShaderCache(data, &size);
if (size > 0) {
luax_writefile(".lovrshadercache", data, size);
}
free(data);
lovrFree(data);
}
static int l_lovrGraphicsInitialize(lua_State* L) {
@ -366,7 +361,7 @@ static int l_lovrGraphicsInitialize(lua_State* L) {
luax_atexit(L, luax_writeshadercache);
}
free(config.cacheData);
lovrFree(config.cacheData);
return 0;
}
@ -394,8 +389,7 @@ static int l_lovrGraphicsSubmit(lua_State* L) {
uint32_t count = 0;
Pass* stack[8];
Pass** passes = (size_t) length > COUNTOF(stack) ? malloc(length * sizeof(Pass*)) : stack;
lovrAssert(passes, "Out of memory");
Pass** passes = (size_t) length > COUNTOF(stack) ? lovrMalloc(length * sizeof(Pass*)) : stack;
if (table) {
for (int i = 0; i < length; i++) {
@ -414,7 +408,7 @@ static int l_lovrGraphicsSubmit(lua_State* L) {
}
lovrGraphicsSubmit(passes, count);
if (passes != stack) free(passes);
if (passes != stack) lovrFree(passes);
lua_pushboolean(L, true);
return 1;
}
@ -750,8 +744,7 @@ static int l_lovrGraphicsNewTexture(lua_State* L) {
info.mipmaps = 1;
} else if (lua_istable(L, 1)) {
info.imageCount = luax_len(L, index++);
images = info.imageCount > COUNTOF(stack) ? malloc(info.imageCount * sizeof(Image*)) : stack;
lovrAssert(images, "Out of memory");
images = info.imageCount > COUNTOF(stack) ? lovrMalloc(info.imageCount * sizeof(Image*)) : stack;
if (info.imageCount == 0) {
info.layers = 6;
@ -870,7 +863,7 @@ static int l_lovrGraphicsNewTexture(lua_State* L) {
}
if (images != stack) {
free(images);
lovrFree(images);
}
luax_pushtype(L, Texture, texture);
@ -1035,7 +1028,7 @@ static int l_lovrGraphicsCompileShader(lua_State* L) {
lovrGraphicsCompileShader(inputs, outputs, count, luax_readfile);
for (uint32_t i = 0; i < count; i++) {
if (shouldFree[i] && outputs[i].code != inputs[i].code) free((void*) inputs[i].code);
if (shouldFree[i] && outputs[i].code != inputs[i].code) lovrFree((void*) inputs[i].code);
Blob* blob = lovrBlobCreate((void*) outputs[i].code, outputs[i].size, "Shader code");
luax_pushtype(L, Blob, blob);
lovrRelease(blob, lovrBlobDestroy);
@ -1106,8 +1099,8 @@ static int l_lovrGraphicsNewShader(lua_State* L) {
lovrRelease(shader, lovrShaderDestroy);
for (uint32_t i = 0; i < info.stageCount; i++) {
if (shouldFree[i]) free((void*) source[i].code);
if (source[i].code != compiled[i].code) free((void*) compiled[i].code);
if (shouldFree[i]) lovrFree((void*) source[i].code);
if (source[i].code != compiled[i].code) lovrFree((void*) compiled[i].code);
}
arr_free(&flags);

12
src/api/l_graphics_font.c
View File

@ -7,8 +7,7 @@
ColoredString* luax_checkcoloredstrings(lua_State* L, int index, uint32_t* count, ColoredString* stack) {
if (lua_istable(L, index)) {
*count = luax_len(L, index) / 2;
ColoredString* strings = malloc(*count * sizeof(*strings));
lovrAssert(strings, "Out of memory");
ColoredString* strings = lovrMalloc(*count * sizeof(*strings));
for (uint32_t i = 0; i < *count; i++) {
lua_rawgeti(L, index, i * 2 + 1);
lua_rawgeti(L, index, i * 2 + 2);
@ -123,7 +122,7 @@ static int l_lovrFontGetLines(lua_State* L) {
float wrap = luax_checkfloat(L, 3);
lua_newtable(L);
lovrFontGetLines(font, strings, 1, wrap, online, L);
if (strings != &stack) free(strings);
if (strings != &stack) lovrFree(strings);
return 1;
}
@ -139,8 +138,7 @@ static int l_lovrFontGetVertices(lua_State* L) {
for (uint32_t i = 0; i < count; i++) {
totalLength += strings[i].length;
}
GlyphVertex* vertices = malloc(totalLength * 4 * sizeof(GlyphVertex));
lovrAssert(vertices, "Out of memory");
GlyphVertex* vertices = lovrMalloc(totalLength * 4 * sizeof(GlyphVertex));
uint32_t glyphCount, lineCount;
Material* material;
lovrFontGetVertices(font, strings, count, wrap, halign, valign, vertices, &glyphCount, &lineCount, &material, false);
@ -159,8 +157,8 @@ static int l_lovrFontGetVertices(lua_State* L) {
lua_rawseti(L, -2, i + 1);
}
luax_pushtype(L, Material, material);
if (strings != &stack) free(strings);
free(vertices);
if (strings != &stack) lovrFree(strings);
lovrFree(vertices);
return 2;
}

2
src/api/l_graphics_pass.c
View File

@ -943,7 +943,7 @@ static int l_lovrPassText(lua_State* L) {
HorizontalAlign halign = luax_checkenum(L, index++, HorizontalAlign, "center");
VerticalAlign valign = luax_checkenum(L, index++, VerticalAlign, "middle");
lovrPassText(pass, strings, count, transform, wrap, halign, valign);
if (strings != &stack) free(strings);
if (strings != &stack) lovrFree(strings);
return 0;
}

15
src/api/l_physics_shapes.c
View File

@ -81,9 +81,8 @@ Shape* luax_newmeshshape(lua_State* L, int index) {
if (!shouldFree) {
float* v = vertices;
uint32_t* i = indices;
vertices = malloc(3 * vertexCount * sizeof(float));
indices = malloc(indexCount * sizeof(uint32_t));
lovrAssert(vertices && indices, "Out of memory");
vertices = lovrMalloc(3 * vertexCount * sizeof(float));
indices = lovrMalloc(indexCount * sizeof(uint32_t));
memcpy(vertices, v, 3 * vertexCount * sizeof(float));
memcpy(indices, i, indexCount * sizeof(uint32_t));
}
@ -99,8 +98,7 @@ Shape* luax_newterrainshape(lua_State* L, int index) {
return lovrTerrainShapeCreate(vertices, 2, 2, horizontalScale, 1.f);
} else if (type == LUA_TFUNCTION) {
uint32_t samples = luax_optu32(L, index + 1, 100);
float* vertices = malloc(sizeof(float) * samples * samples);
lovrAssert(vertices, "Out of memory");
float* vertices = lovrMalloc(sizeof(float) * samples * samples);
for (uint32_t i = 0; i < samples * samples; i++) {
float x = horizontalScale * (-.5f + ((float) (i % samples)) / samples);
float z = horizontalScale * (-.5f + ((float) (i / samples)) / samples);
@ -113,15 +111,14 @@ Shape* luax_newterrainshape(lua_State* L, int index) {
lua_pop(L, 1);
}
TerrainShape* shape = lovrTerrainShapeCreate(vertices, samples, samples, horizontalScale, 1.f);
free(vertices);
lovrFree(vertices);
return shape;
} else if (type == LUA_TUSERDATA) {
Image* image = luax_checktype(L, index, Image);
uint32_t imageWidth = lovrImageGetWidth(image, 0);
uint32_t imageHeight = lovrImageGetHeight(image, 0);
float verticalScale = luax_optfloat(L, index + 1, 1.f);
float* vertices = malloc(sizeof(float) * imageWidth * imageHeight);
lovrAssert(vertices, "Out of memory");
float* vertices = lovrMalloc(sizeof(float) * imageWidth * imageHeight);
for (uint32_t y = 0; y < imageHeight; y++) {
for (uint32_t x = 0; x < imageWidth; x++) {
float pixel[4];
@ -130,7 +127,7 @@ Shape* luax_newterrainshape(lua_State* L, int index) {
}
}
TerrainShape* shape = lovrTerrainShapeCreate(vertices, imageWidth, imageHeight, horizontalScale, verticalScale);
free(vertices);
lovrFree(vertices);
return shape;
} else {
luax_typeerror(L, index, "Image, number, or function");

7
src/api/l_thread.c
View File

@ -30,9 +30,9 @@ static char* threadRunner(Thread* thread, Blob* body, Variant* arguments, uint32
// Error handling
size_t length;
const char* message = lua_tolstring(L, -1, &length);
char* error = message ? malloc(length + 1) : NULL;
if (error) {
if (message) {
char* error = lovrMalloc(length + 1);
memcpy(error, message, length + 1);
lua_close(L);
return error;
@ -48,8 +48,7 @@ static int l_lovrThreadNewThread(lua_State* L) {
size_t length;
const char* str = luaL_checklstring(L, 1, &length);
if (memchr(str, '\n', MIN(1024, length))) {
void* data = malloc(length + 1);
lovrAssert(data, "Out of memory");
void* data = lovrMalloc(length + 1);
memcpy(data, str, length + 1);
blob = lovrBlobCreate(data, length, "thread code");
} else {

21
src/modules/audio/audio.c
View File

@ -229,7 +229,7 @@ void lovrAudioDestroy(void) {
if (atomic_fetch_sub(&state.ref, 1) != 1) return;
for (size_t i = 0; i < 2; i++) {
ma_device_uninit(&state.devices[i]);
free(state.deviceInfo[i]);
lovrFree(state.deviceInfo[i]);
}
Source* source;
FOREACH_SOURCE(source) lovrRelease(source, lovrSourceDestroy);
@ -267,8 +267,7 @@ bool lovrAudioGetDevice(AudioType type, AudioDevice* device) {
}
if (!state.deviceInfo[type]) {
state.deviceInfo[type] = malloc(sizeof(ma_device_info));
lovrAssert(state.deviceInfo[type], "Out of memory");
state.deviceInfo[type] = lovrMalloc(sizeof(ma_device_info));
}
ma_device_info* info = state.deviceInfo[type];
@ -408,8 +407,7 @@ void lovrAudioSetAbsorption(float absorption[3]) {
Source* lovrSourceCreate(Sound* sound, bool pitchable, bool spatial, uint32_t effects) {
lovrCheck(lovrSoundGetChannelLayout(sound) != CHANNEL_AMBISONIC, "Ambisonic Sources are not currently supported");
Source* source = calloc(1, sizeof(Source));
lovrAssert(source, "Out of memory");
Source* source = lovrCalloc(sizeof(Source));
source->ref = 1;
source->index = ~0u;
source->sound = sound;
@ -432,8 +430,7 @@ Source* lovrSourceCreate(Sound* sound, bool pitchable, bool spatial, uint32_t ef
config.allowDynamicSampleRate = pitchable;
if (pitchable || config.formatIn != config.formatOut || config.channelsIn != config.channelsOut || config.sampleRateIn != config.sampleRateOut) {
source->converter = malloc(sizeof(ma_data_converter));
lovrAssert(source->converter, "Out of memory");
source->converter = lovrMalloc(sizeof(ma_data_converter));
ma_result status = ma_data_converter_init(&config, NULL, source->converter);
lovrAssert(status == MA_SUCCESS, "Problem creating Source data converter: %s (%d)", ma_result_description(status), status);
}
@ -442,8 +439,7 @@ Source* lovrSourceCreate(Sound* sound, bool pitchable, bool spatial, uint32_t ef
}
Source* lovrSourceClone(Source* source) {
Source* clone = calloc(1, sizeof(Source));
lovrAssert(clone, "Out of memory");
Source* clone = lovrCalloc(sizeof(Source));
clone->ref = 1;
clone->index = ~0u;
clone->sound = source->sound;
@ -460,8 +456,7 @@ Source* lovrSourceClone(Source* source) {
clone->pitchable = source->pitchable;
clone->spatial = source->spatial;
if (source->converter) {
clone->converter = malloc(sizeof(ma_data_converter));
lovrAssert(clone->converter, "Out of memory");
clone->converter = lovrMalloc(sizeof(ma_data_converter));
ma_data_converter_config config = ma_data_converter_config_init_default();
config.formatIn = source->converter->formatIn;
config.formatOut = source->converter->formatOut;
@ -480,8 +475,8 @@ void lovrSourceDestroy(void* ref) {
Source* source = ref;
lovrRelease(source->sound, lovrSoundDestroy);
ma_data_converter_uninit(source->converter, NULL);
free(source->converter);
free(source);
lovrFree(source->converter);
lovrFree(source);
}
Sound* lovrSourceGetSound(Source* source) {

12
src/modules/audio/spatializer_phonon.c
View File

@ -150,8 +150,7 @@ bool phonon_init(void) {
state.renderingSettings.frameSize = BUFFER_SIZE;
state.renderingSettings.convolutionType = IPL_CONVOLUTIONTYPE_PHONON;
state.scratchpad = malloc(BUFFER_SIZE * 4 * sizeof(float));
if (!state.scratchpad) return phonon_destroy(), false;
state.scratchpad = lovrMalloc(BUFFER_SIZE * 4 * sizeof(float));
IPLHrtfParams hrtfParams = {
.type = IPL_HRTFDATABASETYPE_DEFAULT
@ -167,7 +166,7 @@ bool phonon_init(void) {
}
void phonon_destroy(void) {
if (state.scratchpad) free(state.scratchpad);
if (state.scratchpad) lovrFree(state.scratchpad);
for (size_t i = 0; i < MAX_SOURCES; i++) {
if (state.binauralEffect[i]) phonon_iplDestroyBinauralEffect(&state.binauralEffect[i]);
if (state.directSoundEffect[i]) phonon_iplDestroyDirectSoundEffect(&state.directSoundEffect[i]);
@ -334,8 +333,7 @@ bool phonon_setGeometry(float* vertices, uint32_t* indices, uint32_t vertexCount
.irradianceMinDistance = .1f
};
IPLint32* triangleMaterials = malloc(indexCount / 3 * sizeof(IPLint32));
if (!triangleMaterials) goto fail;
IPLint32* triangleMaterials = lovrMalloc(indexCount / 3 * sizeof(IPLint32));
for (uint32_t i = 0; i < indexCount / 3; i++) {
triangleMaterials[i] = material;
@ -356,11 +354,11 @@ bool phonon_setGeometry(float* vertices, uint32_t* indices, uint32_t vertexCount
status = phonon_iplCreateEnvironmentalRenderer(state.context, state.environment, state.renderingSettings, AMBISONIC, NULL, NULL, &state.environmentalRenderer);
if (status != IPL_STATUS_SUCCESS) goto fail;
free(triangleMaterials);
lovrFree(triangleMaterials);
return true;
fail:
free(triangleMaterials);
lovrFree(triangleMaterials);
if (state.mesh) phonon_iplDestroyStaticMesh(&state.mesh);
if (state.scene) phonon_iplDestroyScene(&state.scene);
if (state.environment) phonon_iplDestroyEnvironment(&state.environment);

7
src/modules/data/blob.c
View File

@ -3,8 +3,7 @@
#include <stdlib.h>
Blob* lovrBlobCreate(void* data, size_t size, const char* name) {
Blob* blob = calloc(1, sizeof(Blob));
lovrAssert(blob, "Out of memory");
Blob* blob = lovrMalloc(sizeof(Blob));
blob->ref = 1;
blob->data = data;
blob->size = size;
@ -14,6 +13,6 @@ Blob* lovrBlobCreate(void* data, size_t size, const char* name) {
void lovrBlobDestroy(void* ref) {
Blob* blob = ref;
free(blob->data);
free(blob);
lovrFree(blob->data);
lovrFree(blob);
}

25
src/modules/data/image.c
View File

@ -83,9 +83,8 @@ Image* lovrImageCreateRaw(uint32_t width, uint32_t height, TextureFormat format,
lovrCheck(width > 0 && height > 0, "Image dimensions must be positive");
lovrCheck(format < FORMAT_BC1, "Blank images cannot be compressed");
size_t size = measure(width, height, format);
void* data = malloc(size);
Image* image = calloc(1, sizeof(Image));
lovrAssert(image && data, "Out of memory");
void* data = lovrMalloc(size);
Image* image = lovrCalloc(sizeof(Image));
image->ref = 1;
image->flags = srgb ? IMAGE_SRGB : 0;
image->width = width;
@ -120,7 +119,7 @@ Image* lovrImageCreateFromFile(Blob* blob) {
void lovrImageDestroy(void* ref) {
Image* image = ref;
lovrRelease(image->blob, lovrBlobDestroy);
free(image);
lovrFree(image);
}
bool lovrImageIsSRGB(Image* image) {
@ -350,8 +349,7 @@ Blob* lovrImageEncode(Image* image) {
size += 4 + strlen("IHDR") + sizeof(header) + 4;
size += 4 + strlen("IDAT") + idatSize + 4;
size += 4 + strlen("IEND") + 4;
uint8_t* data = malloc(size);
lovrAssert(data, "Out of memory");
uint8_t* data = lovrMalloc(size);
crc_init();
uint32_t crc;
@ -790,8 +788,7 @@ static Image* loadDDS(Blob* blob) {
lovrCheck(~header->flags & DDSD_DEPTH, "Loading 3D DDS images is not supported");
uint32_t levels = MAX(1, header->mipmapCount);
Image* image = calloc(1, offsetof(Image, mipmaps) + levels * sizeof(Mipmap));
lovrAssert(image, "Out of memory");
Image* image = lovrCalloc(offsetof(Image, mipmaps) + levels * sizeof(Mipmap));
image->ref = 1;
image->flags = flags;
image->width = header->width;
@ -870,8 +867,7 @@ static Image* loadASTC(Blob* blob) {
return NULL;
}
Image* image = calloc(1, sizeof(Image));
lovrAssert(image, "Out of memory");
Image* image = lovrCalloc(sizeof(Image));
image->ref = 1;
image->width = width;
image->height = height;
@ -934,8 +930,7 @@ static Image* loadKTX1(Blob* blob) {
uint32_t layers = MAX(header.numberOfArrayElements, 1);
uint32_t levels = MAX(header.numberOfMipmapLevels, 1);
Image* image = calloc(1, offsetof(Image, mipmaps) + levels * sizeof(Mipmap));
lovrAssert(image, "Out of memory");
Image* image = lovrCalloc(offsetof(Image, mipmaps) + levels * sizeof(Mipmap));
image->ref = 1;
image->width = header.pixelWidth;
image->height = header.pixelHeight;
@ -1084,8 +1079,7 @@ static Image* loadKTX2(Blob* blob) {
uint32_t layers = MAX(header->layerCount, 1);
uint32_t levels = MAX(header->levelCount, 1);
Image* image = calloc(1, offsetof(Image, mipmaps) + levels * sizeof(Mipmap));
lovrAssert(image, "Out of memory");
Image* image = lovrCalloc(offsetof(Image, mipmaps) + levels * sizeof(Mipmap));
image->ref = 1;
image->width = header->pixelWidth;
image->height = header->pixelHeight;
@ -1194,8 +1188,7 @@ static Image* loadSTB(Blob* blob) {
size_t size = measure(width, height, format);
Image* image = calloc(1, sizeof(Image));
lovrAssert(image, "Out of memory");
Image* image = lovrCalloc(sizeof(Image));
image->ref = 1;
image->flags = flags;
image->width = width;

26
src/modules/data/modelData.c
View File

@ -21,8 +21,7 @@ static void* nullIO(const char* path, size_t* count) {
}
ModelData* lovrModelDataCreate(Blob* source, ModelDataIO* io) {
ModelData* model = calloc(1, sizeof(ModelData));
lovrAssert(model, "Out of memory");
ModelData* model = lovrCalloc(sizeof(ModelData));
model->ref = 1;
if (!io) {
@ -55,11 +54,11 @@ void lovrModelDataDestroy(void* ref) {
map_free(&model->animationMap);
map_free(&model->materialMap);
map_free(&model->nodeMap);
free(model->vertices);
free(model->indices);
free(model->metadata);
free(model->data);
free(model);
lovrFree(model->vertices);
lovrFree(model->indices);
lovrFree(model->metadata);
lovrFree(model->data);
lovrFree(model);
}
// Batches allocations for all the ModelData arrays
@ -84,8 +83,7 @@ void lovrModelDataAllocate(ModelData* model) {
totalSize += sizes[14] = model->charCount * sizeof(char);
size_t offset = 0;
char* p = model->data = calloc(1, totalSize);
lovrAssert(model->data, "Out of memory");
char* p = model->data = lovrCalloc(totalSize);
model->blobs = (Blob**) (p + offset), offset += sizes[0];
model->buffers = (ModelBuffer*) (p + offset), offset += sizes[1];
model->images = (Image**) (p + offset), offset += sizes[2];
@ -389,8 +387,7 @@ void lovrModelDataGetBoundingSphere(ModelData* model, float sphere[4]) {
}
uint32_t pointCount = totalPrimitiveCount * 8;
float* points = malloc(pointCount * 3 * sizeof(float));
lovrAssert(points, "Out of memory");
float* points = lovrMalloc(pointCount * 3 * sizeof(float));
uint32_t pointIndex = 0;
boundingSphereHelper(model, model->rootNode, &pointIndex, points, (float[16]) MAT4_IDENTITY);
@ -445,7 +442,7 @@ void lovrModelDataGetBoundingSphere(ModelData* model, float sphere[4]) {
model->boundingSphere[1] = y;
model->boundingSphere[2] = z;
model->boundingSphere[3] = r;
free(points);
lovrFree(points);
}
memcpy(sphere, model->boundingSphere, sizeof(model->boundingSphere));
@ -562,9 +559,8 @@ void lovrModelDataGetTriangles(ModelData* model, float** vertices, uint32_t** in
if (vertices && !model->vertices) {
uint32_t baseIndex = 0;
model->vertices = malloc(model->totalVertexCount * 3 * sizeof(float));
model->indices = malloc(model->totalIndexCount * sizeof(uint32_t));
lovrAssert(model->vertices && model->indices, "Out of memory");
model->vertices = lovrMalloc(model->totalVertexCount * 3 * sizeof(float));
model->indices = lovrMalloc(model->totalIndexCount * sizeof(uint32_t));
*vertices = model->vertices;
*indices = model->indices;
collectVertices(model, model->rootNode, vertices, indices, &baseIndex, (float[16]) MAT4_IDENTITY);

39
src/modules/data/modelData_gltf.c
View File

@ -88,10 +88,7 @@ static void* decodeBase64(char* str, size_t length, size_t* decodedLength) {
length -= s - str;
int padding = (s[length - 1] == '=') + (s[length - 2] == '=');
*decodedLength = length / 4 * 3 - padding;
uint8_t* data = malloc(*decodedLength);
if (!data) {
return NULL;
}
uint8_t* data = lovrMalloc(*decodedLength);
uint32_t num = 0;
uint32_t bits = 0;
@ -113,7 +110,7 @@ static void* decodeBase64(char* str, size_t length, size_t* decodedLength) {
} else if (c == '=') {
break;
} else {
free(data);
lovrFree(data);
return NULL;
}
@ -241,8 +238,7 @@ ModelData* lovrModelDataInitGltf(ModelData* model, Blob* source, ModelDataIO* io
binOffset = 0;
}
model->metadata = malloc(jsonLength);
lovrAssert(model->metadata, "Out of memory");
model->metadata = lovrMalloc(jsonLength);
memcpy(model->metadata, json, jsonLength);
model->metadataSize = jsonLength;
model->metadataType = META_GLTF_JSON;
@ -271,7 +267,7 @@ ModelData* lovrModelDataInitGltf(ModelData* model, Blob* source, ModelDataIO* io
}
if (tokenCount <= 0 || tokens[0].type != JSMN_OBJECT) {
free(heapTokens);
lovrFree(heapTokens);
return NULL;
}
@ -325,8 +321,7 @@ ModelData* lovrModelDataInitGltf(ModelData* model, Blob* source, ModelDataIO* io
}
}
animationSamplers = malloc(samplerCount * sizeof(gltfAnimationSampler));
lovrAssert(animationSamplers, "Out of memory");
animationSamplers = lovrMalloc(samplerCount * sizeof(gltfAnimationSampler));
gltfAnimationSampler* sampler = animationSamplers;
for (int i = (token++)->size; i > 0; i--) {
for (int k = (token++)->size; k > 0; k--) {
@ -369,8 +364,7 @@ ModelData* lovrModelDataInitGltf(ModelData* model, Blob* source, ModelDataIO* io
} else if (STR_EQ(key, "images")) {
model->imageCount = token->size;
images = malloc(model->imageCount * sizeof(gltfImage));
lovrAssert(images, "Out of memory");
images = lovrMalloc(model->imageCount * sizeof(gltfImage));
gltfImage* image = images;
for (int i = (token++)->size; i > 0; i--, image++) {
image->bufferView = ~0u;
@ -388,8 +382,7 @@ ModelData* lovrModelDataInitGltf(ModelData* model, Blob* source, ModelDataIO* io
}
} else if (STR_EQ(key, "textures")) {
textures = malloc(token->size * sizeof(gltfTexture));
lovrAssert(textures, "Out of memory");
textures = lovrMalloc(token->size * sizeof(gltfTexture));
gltfTexture* texture = textures;
for (int i = (token++)->size; i > 0; i--, texture++) {
texture->image = ~0u;
@ -433,8 +426,7 @@ ModelData* lovrModelDataInitGltf(ModelData* model, Blob* source, ModelDataIO* io
} else if (STR_EQ(key, "meshes")) {
info.meshes = token;
meshes = malloc(token->size * sizeof(gltfMesh));
lovrAssert(meshes, "Out of memory");
meshes = lovrMalloc(token->size * sizeof(gltfMesh));
gltfMesh* mesh = meshes;
model->primitiveCount = 0;
model->blendShapeCount = 0;
@ -500,8 +492,7 @@ ModelData* lovrModelDataInitGltf(ModelData* model, Blob* source, ModelDataIO* io
} else if (STR_EQ(key, "scenes")) {
info.scenes = token;
info.sceneCount = token->size;
scenes = malloc(info.sceneCount * sizeof(gltfScene));
lovrAssert(scenes, "Out of memory");
scenes = lovrMalloc(info.sceneCount * sizeof(gltfScene));
gltfScene* scene = scenes;
for (int i = (token++)->size; i > 0; i--, scene++) {
for (int k = (token++)->size; k > 0; k--) {
@ -1058,11 +1049,11 @@ ModelData* lovrModelDataInitGltf(ModelData* model, Blob* source, ModelDataIO* io
model->rootNode = scenes[rootScene].node;
}
free(animationSamplers);
free(meshes);
free(images);
free(textures);
free(scenes);
free(heapTokens);
lovrFree(animationSamplers);
lovrFree(meshes);
lovrFree(images);
lovrFree(textures);
lovrFree(scenes);
lovrFree(heapTokens);
return model;
}

2
src/modules/data/modelData_obj.c
View File

@ -101,7 +101,7 @@ static void parseMtl(char* path, char* base, ModelDataIO* io, arr_image_t* image
data = newline + 1;
}
free(p);
lovrFree(p);
}
ModelData* lovrModelDataInitObj(ModelData* model, Blob* source, ModelDataIO* io) {

3
src/modules/data/modelData_stl.c
View File

@ -17,8 +17,7 @@ static ModelData* lovrModelDataInitStlBinary(ModelData* model, Blob* source, Mod
uint32_t vertexCount = triangleCount * 3;
size_t vertexBufferSize = vertexCount * 6 * sizeof(float);
float* vertices = malloc(vertexBufferSize);
lovrAssert(vertices, "Out of memory");
float* vertices = lovrMalloc(vertexBufferSize);
model->blobCount = 1;
model->bufferCount = 1;

5
src/modules/data/rasterizer.c
View File

@ -19,8 +19,7 @@ struct Rasterizer {
};
Rasterizer* lovrRasterizerCreate(Blob* blob, float size) {
Rasterizer* rasterizer = calloc(1, sizeof(Rasterizer));
lovrAssert(rasterizer, "Out of memory");
Rasterizer* rasterizer = lovrCalloc(sizeof(Rasterizer));
rasterizer->ref = 1;
stbtt_fontinfo* font = &rasterizer->font;
@ -47,7 +46,7 @@ Rasterizer* lovrRasterizerCreate(Blob* blob, float size) {
void lovrRasterizerDestroy(void* ref) {
Rasterizer* rasterizer = ref;
lovrRelease(rasterizer->blob, lovrBlobDestroy);
free(rasterizer);
lovrFree(rasterizer);
}
float lovrRasterizerGetFontSize(Rasterizer* rasterizer) {

38
src/modules/data/sound.c
View File

@ -78,8 +78,7 @@ static uint32_t lovrSoundReadMp3(Sound* sound, uint32_t offset, uint32_t count,
// Sound
Sound* lovrSoundCreateRaw(uint32_t frames, SampleFormat format, ChannelLayout layout, uint32_t sampleRate, Blob* blob) {
Sound* sound = calloc(1, sizeof(Sound));
lovrAssert(sound, "Out of memory");
Sound* sound = lovrCalloc(sizeof(Sound));
sound->ref = 1;
sound->frames = frames;
sound->format = format;
@ -87,8 +86,7 @@ Sound* lovrSoundCreateRaw(uint32_t frames, SampleFormat format, ChannelLayout la
sound->sampleRate = sampleRate;
sound->read = lovrSoundReadRaw;
size_t size = frames * lovrSoundGetStride(sound);
void* data = calloc(1, size);
lovrAssert(data, "Out of memory");
void* data = lovrCalloc(size);
sound->blob = lovrBlobCreate(data, size, "Sound");
if (blob) {
@ -99,19 +97,16 @@ Sound* lovrSoundCreateRaw(uint32_t frames, SampleFormat format, ChannelLayout la
}
Sound* lovrSoundCreateStream(uint32_t frames, SampleFormat format, ChannelLayout layout, uint32_t sampleRate) {
Sound* sound = calloc(1, sizeof(Sound));
lovrAssert(sound, "Out of memory");
Sound* sound = lovrCalloc(sizeof(Sound));
sound->ref = 1;
sound->frames = frames;
sound->format = format;
sound->layout = layout;
sound->sampleRate = sampleRate;
sound->read = lovrSoundReadStream;
sound->stream = malloc(sizeof(ma_pcm_rb));
lovrAssert(sound->stream, "Out of memory");
sound->stream = lovrMalloc(sizeof(ma_pcm_rb));
size_t size = frames * lovrSoundGetStride(sound);
void* data = malloc(size);
lovrAssert(data, "Out of memory");
void* data = lovrMalloc(size);
sound->blob = lovrBlobCreate(data, size, NULL);
ma_result status = ma_pcm_rb_init(miniaudioFormats[format], lovrSoundGetChannelCount(sound), frames, data, NULL, sound->stream);
lovrAssert(status == MA_SUCCESS, "Failed to create ring buffer for streamed Sound: %s (%d)", ma_result_description(status), status);
@ -135,8 +130,7 @@ static bool loadOgg(Sound* sound, Blob* blob, bool decode) {
uint32_t channels = lovrSoundGetChannelCount(sound);
lovrAssert(sound->frames * channels <= INT_MAX, "Decoded OGG file has too many samples");
size_t size = sound->frames * lovrSoundGetStride(sound);
void* data = calloc(1, size);
lovrAssert(data, "Out of memory");
void* data = lovrCalloc(size);
sound->blob = lovrBlobCreate(data, size, "Sound");
if (stb_vorbis_get_samples_float_interleaved(sound->decoder, channels, data, (int) size / sizeof(float)) < (int) sound->frames) {
lovrThrow("Could not decode vorbis from '%s'", blob->name);
@ -229,8 +223,7 @@ static bool loadWAV(Sound* sound, Blob* blob, bool decode) {
// Conversion
size_t samples = sound->frames * lovrSoundGetChannelCount(sound);
size_t bytes = sound->frames * lovrSoundGetStride(sound);
void* raw = malloc(bytes);
lovrAssert(raw, "Out of memory");
void* raw = lovrMalloc(bytes);
if (pcm && wav->sampleSize == 24) {
float* out = raw;
const uint8_t* in = (const uint8_t*) data;
@ -296,10 +289,9 @@ static bool loadMP3(Sound* sound, Blob* blob, bool decode) {
sound->read = lovrSoundReadRaw;
return true;
} else {
mp3dec_ex_t* decoder = sound->decoder = malloc(sizeof(mp3dec_ex_t));
lovrAssert(decoder, "Out of memory");
mp3dec_ex_t* decoder = sound->decoder = lovrMalloc(sizeof(mp3dec_ex_t));
if (mp3dec_ex_open_buf(sound->decoder, blob->data, blob->size, MP3D_SEEK_TO_SAMPLE)) {
free(sound->decoder);
lovrFree(sound->decoder);
lovrThrow("Could not load mp3 from '%s'", blob->name);
}
sound->format = SAMPLE_F32;
@ -314,8 +306,7 @@ static bool loadMP3(Sound* sound, Blob* blob, bool decode) {
}
Sound* lovrSoundCreateFromFile(Blob* blob, bool decode) {
Sound* sound = calloc(1, sizeof(Sound));
lovrAssert(sound, "Out of memory");
Sound* sound = lovrCalloc(sizeof(Sound));
sound->ref = 1;
if (loadOgg(sound, blob, decode)) return sound;
@ -326,8 +317,7 @@ Sound* lovrSoundCreateFromFile(Blob* blob, bool decode) {
}
Sound* lovrSoundCreateFromCallback(SoundCallback read, void *callbackMemo, SoundDestroyCallback callbackMemoDestroy, SampleFormat format, uint32_t sampleRate, ChannelLayout layout, uint32_t maxFrames) {
Sound* sound = calloc(1, sizeof(Sound));
lovrAssert(sound, "Out of memory");
Sound* sound = lovrCalloc(sizeof(Sound));
sound->ref = 1;
sound->read = read;
sound->format = format;
@ -344,10 +334,10 @@ void lovrSoundDestroy(void* ref) {
if (sound->callbackMemoDestroy) sound->callbackMemoDestroy(sound);
lovrRelease(sound->blob, lovrBlobDestroy);
if (sound->read == lovrSoundReadOgg) stb_vorbis_close(sound->decoder);
if (sound->read == lovrSoundReadMp3) mp3dec_ex_close(sound->decoder), free(sound->decoder);
if (sound->read == lovrSoundReadMp3) mp3dec_ex_close(sound->decoder), lovrFree(sound->decoder);
ma_pcm_rb_uninit(sound->stream);
free(sound->stream);
free(sound);
lovrFree(sound->stream);
lovrFree(sound);
}
Blob* lovrSoundGetBlob(Sound* sound) {

7
src/modules/event/event.c
View File

@ -13,9 +13,9 @@ static struct {
void lovrVariantDestroy(Variant* variant) {
switch (variant->type) {
case TYPE_STRING: free(variant->value.string.pointer); return;
case TYPE_STRING: lovrFree(variant->value.string.pointer); return;
case TYPE_OBJECT: lovrRelease(variant->value.object.pointer, variant->value.object.destructor); return;
case TYPE_MATRIX: free(variant->value.matrix.data); return;
case TYPE_MATRIX: lovrFree(variant->value.matrix.data); return;
default: return;
}
}
@ -51,8 +51,7 @@ void lovrEventPush(Event event) {
if (event.type == EVENT_THREAD_ERROR) {
lovrRetain(event.data.thread.thread);
size_t length = strlen(event.data.thread.error);
char* copy = malloc(length + 1);
lovrAssert(copy, "Out of memory");
char* copy = lovrMalloc(length + 1);
memcpy(copy, event.data.thread.error, length);
copy[length] = '\0';
event.data.thread.error = copy;

35
src/modules/filesystem/filesystem.c
View File

@ -310,8 +310,7 @@ void* lovrFilesystemRead(const char* p, size_t* size) {
}
*size = (size_t) bytes;
void* data = malloc(*size);
lovrAssert(data, "Out of memory");
void* data = lovrMalloc(*size);
if (archive->read(archive, &handle, data, *size, size)) {
archive->close(archive, &handle);
@ -737,8 +736,7 @@ static bool zip_open(Archive* archive, const char* path, Handle* handle) {
}
if (handle->node->compressed) {
zip_stream* stream = handle->stream = malloc(sizeof(zip_stream));
lovrAssert(stream, "Out of memory");
zip_stream* stream = handle->stream = lovrMalloc(sizeof(zip_stream));
tinfl_init(&stream->decompressor);
stream->inputCursor = 0;
stream->outputCursor = 0;
@ -752,7 +750,7 @@ static bool zip_open(Archive* archive, const char* path, Handle* handle) {
}
static bool zip_close(Archive* archive, Handle* handle) {
free(handle->stream);
lovrFree(handle->stream);
return true;
}
@ -906,8 +904,7 @@ static void zip_list(Archive* archive, const char* path, fs_list_cb callback, vo
// Archive
Archive* lovrArchiveCreate(const char* path, const char* mountpoint, const char* root) {
Archive* archive = calloc(1, sizeof(Archive));
lovrAssert(archive, "Out of memory");
Archive* archive = lovrCalloc(sizeof(Archive));
archive->ref = 1;
if (dir_init(archive, path, root)) {
@ -927,20 +924,18 @@ Archive* lovrArchiveCreate(const char* path, const char* mountpoint, const char*
archive->stat = zip_stat;
archive->list = zip_list;
} else {
free(archive);
lovrFree(archive);
return NULL;
}
if (mountpoint) {
size_t length = strlen(mountpoint);
archive->mountpoint = malloc(length + 1);
lovrAssert(archive->mountpoint, "Out of memory");
archive->mountpoint = lovrMalloc(length + 1);
archive->mountLength = normalize(mountpoint, length, archive->mountpoint);
}
archive->pathLength = strlen(path);
archive->path = malloc(archive->pathLength + 1);
lovrAssert(archive->path, "Out of memory");
archive->path = lovrMalloc(archive->pathLength + 1);
memcpy(archive->path, path, archive->pathLength + 1);
return archive;
@ -949,9 +944,9 @@ Archive* lovrArchiveCreate(const char* path, const char* mountpoint, const char*
void lovrArchiveDestroy(void* ref) {
Archive* archive = ref;
if (archive->data) zip_free(archive);
free(archive->mountpoint);
free(archive->path);
free(archive);
lovrFree(archive->mountpoint);
lovrFree(archive->path);
lovrFree(archive);
}
// File
@ -990,16 +985,14 @@ File* lovrFileCreate(const char* p, OpenMode mode, const char** error) {
}
}
File* file = calloc(1, sizeof(File));
lovrAssert(file, "Out of memory");
File* file = lovrCalloc(sizeof(File));
file->ref = 1;
file->mode = mode;
file->handle = handle;
file->archive = archive;
lovrRetain(archive);
file->path = malloc(length + 1);
lovrAssert(file->path, "Out of memory");
file->path = lovrMalloc(length + 1);
memcpy(file->path, path, length + 1);
return file;
@ -1009,8 +1002,8 @@ void lovrFileDestroy(void* ref) {
File* file = ref;
if (file->archive) file->archive->close(file->archive, &file->handle);
lovrRelease(file->archive, lovrArchiveDestroy);
free(file->path);
free(file);
lovrFree(file->path);
lovrFree(file);
}
const char* lovrFileGetPath(File* file) {

262
src/modules/graphics/graphics.c
View File

@ -653,8 +653,8 @@ bool lovrGraphicsInit(GraphicsConfig* config) {
gpu_config gpu = {
.debug = config->debug,
.fnLog = onMessage,
.fnAlloc = malloc,
.fnFree = free,
.fnAlloc = lovrMalloc,
.fnFree = lovrFree,
.engineName = "LOVR",
.engineVersion = { LOVR_VERSION_MAJOR, LOVR_VERSION_MINOR, LOVR_VERSION_PATCH },
.device = &state.device,
@ -858,7 +858,7 @@ void lovrGraphicsDestroy(void) {
readback = next;
}
if (state.timestamps) gpu_tally_destroy(state.timestamps);
free(state.timestamps);
lovrFree(state.timestamps);
lovrRelease(state.window, lovrTextureDestroy);
lovrRelease(state.windowPass, lovrPassDestroy);
lovrRelease(state.defaultFont, lovrFontDestroy);
@ -877,14 +877,14 @@ void lovrGraphicsDestroy(void) {
freeBlock(&state.bufferAllocators[GPU_BUFFER_STATIC], block->view.block);
}
gpu_bundle_pool_destroy(block->bundlePool);
free(block->list);
free(block->bundlePool);
free(block->bundles);
lovrFree(block->list);
lovrFree(block->bundlePool);
lovrFree(block->bundles);
}
arr_free(&state.materialBlocks);
for (size_t i = 0; i < state.scratchTextures.length; i++) {
gpu_texture_destroy(state.scratchTextures.data[i].texture);
free(state.scratchTextures.data[i].texture);
lovrFree(state.scratchTextures.data[i].texture);
}
arr_free(&state.scratchTextures);
for (size_t i = 0; i < state.pipelineCount; i++) {
@ -896,7 +896,7 @@ void lovrGraphicsDestroy(void) {
if (state.passLookup.values[i] != MAP_NIL) {
gpu_pass* pass = (gpu_pass*) (uintptr_t) state.passLookup.values[i];
gpu_pass_destroy(pass);
free(pass);
lovrFree(pass);
}
}
map_free(&state.passLookup);
@ -905,7 +905,7 @@ void lovrGraphicsDestroy(void) {
while (block) {
gpu_buffer_destroy(block->handle);
BufferBlock* next = block->next;
free(block);
lovrFree(block);
block = next;
}
@ -913,7 +913,7 @@ void lovrGraphicsDestroy(void) {
if (current) {
gpu_buffer_destroy(current->handle);
free(current);
lovrFree(current);
}
}
for (size_t i = 0; i < state.layouts.length; i++) {
@ -921,13 +921,13 @@ void lovrGraphicsDestroy(void) {
while (pool) {
BundlePool* next = pool->next;
gpu_bundle_pool_destroy(pool->gpu);
free(pool->gpu);
free(pool->bundles);
free(pool);
lovrFree(pool->gpu);
lovrFree(pool->bundles);
lovrFree(pool);
pool = next;
}
gpu_layout_destroy(state.layouts.data[i].gpu);
free(state.layouts.data[i].gpu);
lovrFree(state.layouts.data[i].gpu);
}
arr_free(&state.layouts);
gpu_destroy();
@ -1358,8 +1358,7 @@ static void recordRenderPass(Pass* pass, gpu_stream* stream) {
if (pass->tally.buffer && pass->tally.count > 0) {
if (!pass->tally.gpu) {
pass->tally.gpu = malloc(gpu_sizeof_tally());
lovrAssert(pass->tally.gpu, "Out of memory");
pass->tally.gpu = lovrMalloc(gpu_sizeof_tally());
gpu_tally_init(pass->tally.gpu, &(gpu_tally_info) {
.type = GPU_TALLY_PIXEL,
.count = MAX_TALLIES * state.limits.renderSize[2]
@ -1666,8 +1665,7 @@ void lovrGraphicsSubmit(Pass** passes, uint32_t count) {
TimingInfo* times = NULL;
if (state.timingEnabled && count > 0) {
times = malloc(count * sizeof(TimingInfo));
lovrAssert(times, "Out of memory");
times = lovrMalloc(count * sizeof(TimingInfo));
for (uint32_t i = 0; i < count; i++) {
times[i].pass = passes[i];
@ -1680,8 +1678,7 @@ void lovrGraphicsSubmit(Pass** passes, uint32_t count) {
if (state.timestamps) {
gpu_tally_destroy(state.timestamps);
} else {
state.timestamps = malloc(gpu_sizeof_tally());
lovrAssert(state.timestamps, "Out of memory");
state.timestamps = lovrMalloc(gpu_sizeof_tally());
}
gpu_tally_info info = {
@ -1896,9 +1893,7 @@ Buffer* lovrBufferCreate(const BufferInfo* info, void** data) {
charCount = ALIGN(charCount, 8);
Buffer* buffer = calloc(1, sizeof(Buffer) + charCount + fieldCount * sizeof(DataField));
lovrAssert(buffer, "Out of memory");
Buffer* buffer = lovrCalloc(sizeof(Buffer) + charCount + fieldCount * sizeof(DataField));
buffer->ref = 1;
buffer->info = *info;
buffer->info.fieldCount = fieldCount;
@ -1980,7 +1975,7 @@ void lovrBufferDestroy(void* ref) {
if (buffer->block != allocator->current && atomic_fetch_sub(&buffer->block->ref, 1) == 1) {
freeBlock(allocator, buffer->block);
}
free(buffer);
lovrFree(buffer);
}
const BufferInfo* lovrBufferGetInfo(Buffer* buffer) {
@ -2050,9 +2045,7 @@ Texture* lovrGraphicsGetWindowTexture(void) {
width *= density;
height *= density;
state.window = calloc(1, sizeof(Texture));
lovrAssert(state.window, "Out of memory");
state.window = lovrCalloc(sizeof(Texture));
state.window->ref = 1;
state.window->gpu = NULL;
state.window->renderView = NULL;
@ -2148,8 +2141,7 @@ Texture* lovrTextureCreate(const TextureInfo* info) {
lovrCheck((info->format < FORMAT_BC1 || info->format > FORMAT_BC7) || state.features.textureBC, "%s textures are not supported on this GPU", "BC");
lovrCheck(info->format < FORMAT_ASTC_4x4 || state.features.textureASTC, "%s textures are not supported on this GPU", "ASTC");
Texture* texture = calloc(1, sizeof(Texture) + gpu_sizeof_texture());
lovrAssert(texture, "Out of memory");
Texture* texture = lovrCalloc(sizeof(Texture) + gpu_sizeof_texture());
texture->ref = 1;
texture->gpu = (gpu_texture*) (texture + 1);
texture->root = texture;
@ -2233,8 +2225,7 @@ Texture* lovrTextureCreate(const TextureInfo* info) {
.levelCount = 1
};
texture->renderView = malloc(gpu_sizeof_texture());
lovrAssert(texture->renderView, "Out of memory");
texture->renderView = lovrMalloc(gpu_sizeof_texture());
gpu_texture_init_view(texture->renderView, &view);
}
}
@ -2248,8 +2239,7 @@ Texture* lovrTextureCreate(const TextureInfo* info) {
.srgb = false
};
texture->storageView = malloc(gpu_sizeof_texture());
lovrAssert(texture->storageView, "Out of memory");
texture->storageView = lovrMalloc(gpu_sizeof_texture());
gpu_texture_init_view(texture->storageView, &view);
} else {
texture->storageView = texture->gpu;
@ -2285,8 +2275,7 @@ Texture* lovrTextureCreateView(Texture* parent, const TextureViewInfo* info) {
lovrCheck(info->levelCount == 1 || base->type != TEXTURE_3D, "Views of volume textures may only have a single mipmap level");
lovrCheck(info->layerCount % 6 == 0 || info->type != TEXTURE_CUBE, "Cubemap layer count must be a multiple of 6");
Texture* texture = calloc(1, sizeof(Texture) + gpu_sizeof_texture());
lovrAssert(texture, "Out of memory");
Texture* texture = lovrCalloc(sizeof(Texture) + gpu_sizeof_texture());
texture->ref = 1;
texture->gpu = (gpu_texture*) (texture + 1);
texture->info = *base;
@ -2330,8 +2319,7 @@ Texture* lovrTextureCreateView(Texture* parent, const TextureViewInfo* info) {
.levelCount = 1
};
texture->renderView = malloc(gpu_sizeof_texture());
lovrAssert(texture->renderView, "Out of memory");
texture->renderView = lovrMalloc(gpu_sizeof_texture());
gpu_texture_init_view(texture->renderView, &subview);
}
}
@ -2348,8 +2336,7 @@ Texture* lovrTextureCreateView(Texture* parent, const TextureViewInfo* info) {
.levelCount = info->levelCount
};
texture->storageView = malloc(gpu_sizeof_texture());
lovrAssert(texture->storageView, "Out of memory");
texture->storageView = lovrMalloc(gpu_sizeof_texture());
gpu_texture_init_view(texture->storageView, &subview);
} else {
texture->storageView = texture->gpu;
@ -2369,7 +2356,7 @@ void lovrTextureDestroy(void* ref) {
if (texture->storageView && texture->storageView != texture->gpu) gpu_texture_destroy(texture->storageView);
if (texture->gpu) gpu_texture_destroy(texture->gpu);
}
free(texture);
lovrFree(texture);
}
const TextureInfo* lovrTextureGetInfo(Texture* texture) {
@ -2535,8 +2522,7 @@ Sampler* lovrSamplerCreate(const SamplerInfo* info) {
lovrCheck(info->range[1] < 0.f || info->range[1] >= info->range[0], "Invalid Sampler mipmap range");
lovrCheck(info->anisotropy <= state.limits.anisotropy, "Sampler anisotropy (%f) exceeds anisotropy limit (%f)", info->anisotropy, state.limits.anisotropy);
Sampler* sampler = calloc(1, sizeof(Sampler) + gpu_sizeof_sampler());
lovrAssert(sampler, "Out of memory");
Sampler* sampler = lovrCalloc(sizeof(Sampler) + gpu_sizeof_sampler());
sampler->ref = 1;
sampler->gpu = (gpu_sampler*) (sampler + 1);
sampler->info = *info;
@ -2561,7 +2547,7 @@ Sampler* lovrSamplerCreate(const SamplerInfo* info) {
void lovrSamplerDestroy(void* ref) {
Sampler* sampler = ref;
gpu_sampler_destroy(sampler->gpu);
free(sampler);
lovrFree(sampler);
}
const SamplerInfo* lovrSamplerGetInfo(Sampler* sampler) {
@ -2715,8 +2701,7 @@ void lovrGraphicsCompileShader(ShaderSource* stages, ShaderSource* outputs, uint
void* words = glslang_program_SPIRV_get_ptr(program);
size_t size = glslang_program_SPIRV_get_size(program) * 4;
void* data = malloc(size);
lovrAssert(data, "Out of memory");
void* data = lovrMalloc(size);
memcpy(data, words, size);
outputs[i].stage = source->stage;
@ -2850,8 +2835,7 @@ Shader* lovrGraphicsGetDefaultShader(DefaultShader type) {
}
Shader* lovrShaderCreate(const ShaderInfo* info) {
Shader* shader = calloc(1, sizeof(Shader) + gpu_sizeof_shader());
lovrAssert(shader, "Out of memory");
Shader* shader = lovrCalloc(sizeof(Shader) + gpu_sizeof_shader());
shader->ref = 1;
shader->gpu = (gpu_shader*) (shader + 1);
shader->info = *info;
@ -2911,16 +2895,11 @@ Shader* lovrShaderCreate(const ShaderInfo* info) {
}
// Allocate memory
shader->resources = malloc(maxResources * sizeof(ShaderResource));
shader->fields = malloc(maxFields * sizeof(DataField));
shader->names = malloc(maxChars);
shader->flags = malloc(maxSpecConstants * sizeof(gpu_shader_flag));
shader->flagLookup = malloc(maxSpecConstants * sizeof(uint32_t));
lovrAssert(shader->resources, "Out of memory");
lovrAssert(shader->fields, "Out of memory");
lovrAssert(shader->names, "Out of memory");
lovrAssert(shader->flags, "Out of memory");
lovrAssert(shader->flagLookup, "Out of memory");
shader->resources = lovrMalloc(maxResources * sizeof(ShaderResource));
shader->fields = lovrMalloc(maxFields * sizeof(DataField));
shader->names = lovrMalloc(maxChars);
shader->flags = lovrMalloc(maxSpecConstants * sizeof(gpu_shader_flag));
shader->flagLookup = lovrMalloc(maxSpecConstants * sizeof(uint32_t));
// Workgroup size
if (info->type == SHADER_COMPUTE) {
@ -2936,8 +2915,7 @@ Shader* lovrShaderCreate(const ShaderInfo* info) {
// Vertex attributes
if (info->type == SHADER_GRAPHICS && spv[0].attributeCount > 0) {
shader->attributeCount = spv[0].attributeCount;
shader->attributes = malloc(shader->attributeCount * sizeof(ShaderAttribute));
lovrAssert(shader->attributes, "Out of memory");
shader->attributes = lovrMalloc(shader->attributeCount * sizeof(ShaderAttribute));
for (uint32_t i = 0; i < shader->attributeCount; i++) {
shader->attributes[i].location = spv[0].attributes[i].location;
shader->attributes[i].hash = (uint32_t) hash64(spv[0].attributes[i].name, strlen(spv[0].attributes[i].name));
@ -3240,8 +3218,7 @@ Shader* lovrShaderCreate(const ShaderInfo* info) {
}
Shader* lovrShaderClone(Shader* parent, ShaderFlag* flags, uint32_t count) {
Shader* shader = calloc(1, sizeof(Shader) + gpu_sizeof_shader());
lovrAssert(shader, "Out of memory");
Shader* shader = lovrCalloc(sizeof(Shader) + gpu_sizeof_shader());
shader->ref = 1;
lovrRetain(parent);
shader->parent = parent;
@ -3264,9 +3241,8 @@ Shader* lovrShaderClone(Shader* parent, ShaderFlag* flags, uint32_t count) {
shader->uniforms = parent->uniforms;
shader->fields = parent->fields;
shader->names = parent->names;
shader->flags = malloc(shader->flagCount * sizeof(gpu_shader_flag));
shader->flagLookup = malloc(shader->flagCount * sizeof(uint32_t));
lovrAssert(shader->flags && shader->flagLookup, "Out of memory");
shader->flags = lovrMalloc(shader->flagCount * sizeof(gpu_shader_flag));
shader->flagLookup = lovrMalloc(shader->flagCount * sizeof(uint32_t));
memcpy(shader->flags, parent->flags, shader->flagCount * sizeof(gpu_shader_flag));
memcpy(shader->flagLookup, parent->flagLookup, shader->flagCount * sizeof(uint32_t));
lovrShaderInit(shader);
@ -3279,14 +3255,14 @@ void lovrShaderDestroy(void* ref) {
lovrRelease(shader->parent, lovrShaderDestroy);
} else {
gpu_shader_destroy(shader->gpu);
free(shader->attributes);
free(shader->resources);
free(shader->fields);
free(shader->names);
lovrFree(shader->attributes);
lovrFree(shader->resources);
lovrFree(shader->fields);
lovrFree(shader->names);
}
free(shader->flags);
free(shader->flagLookup);
free(shader);
lovrFree(shader->flags);
lovrFree(shader->flagLookup);
lovrFree(shader);
}
const ShaderInfo* lovrShaderGetInfo(Shader* shader) {
@ -3357,10 +3333,9 @@ Material* lovrMaterialCreate(const MaterialInfo* info) {
lovrAssert(state.materialBlocks.length < UINT16_MAX, "Out of memory");
state.materialBlock = state.materialBlocks.length++;
block = &state.materialBlocks.data[state.materialBlock];
block->list = malloc(MATERIALS_PER_BLOCK * sizeof(Material));
block->bundlePool = malloc(gpu_sizeof_bundle_pool());
block->bundles = malloc(MATERIALS_PER_BLOCK * gpu_sizeof_bundle());
lovrAssert(block->list && block->bundlePool && block->bundles, "Out of memory");
block->list = lovrMalloc(MATERIALS_PER_BLOCK * sizeof(Material));
block->bundlePool = lovrMalloc(gpu_sizeof_bundle_pool());
block->bundles = lovrMalloc(MATERIALS_PER_BLOCK * gpu_sizeof_bundle());
for (uint32_t i = 0; i < MATERIALS_PER_BLOCK; i++) {
block->list[i].next = i + 1;
@ -3488,8 +3463,7 @@ Font* lovrGraphicsGetDefaultFont(void) {
}
Font* lovrFontCreate(const FontInfo* info) {
Font* font = calloc(1, sizeof(Font));
lovrAssert(font, "Out of memory");
Font* font = lovrCalloc(sizeof(Font));
font->ref = 1;
font->info = *info;
lovrRetain(info->rasterizer);
@ -3524,7 +3498,7 @@ void lovrFontDestroy(void* ref) {
arr_free(&font->glyphs);
map_free(&font->glyphLookup);
map_free(&font->kerning);
free(font);
lovrFree(font);
}
const FontInfo* lovrFontGetInfo(Font* font) {
@ -3980,8 +3954,7 @@ Mesh* lovrMeshCreate(const MeshInfo* info, void** vertices) {
lovrCheck(attribute->type < TYPE_INDEX16 || attribute->type > TYPE_INDEX32, "Mesh attributes can not use index types");
}
Mesh* mesh = calloc(1, sizeof(Mesh));
lovrAssert(mesh, "Out of memory");
Mesh* mesh = lovrCalloc(sizeof(Mesh));
mesh->ref = 1;
mesh->vertexBuffer = buffer;
mesh->storage = info->storage;
@ -3990,8 +3963,7 @@ Mesh* lovrMeshCreate(const MeshInfo* info, void** vertices) {
if (info->vertexBuffer) {
lovrRetain(info->vertexBuffer);
} else if (mesh->storage == MESH_CPU) {
mesh->vertices = vertices ? malloc(buffer->info.size) : calloc(1, buffer->info.size);
lovrAssert(mesh->vertices, "Out of memory");
mesh->vertices = vertices ? lovrMalloc(buffer->info.size) : lovrCalloc(buffer->info.size);
if (vertices) {
*vertices = mesh->vertices;
@ -4011,9 +3983,9 @@ void lovrMeshDestroy(void* ref) {
lovrRelease(mesh->vertexBuffer, lovrBufferDestroy);
lovrRelease(mesh->indexBuffer, lovrBufferDestroy);
lovrRelease(mesh->material, lovrMaterialDestroy);
free(mesh->vertices);
free(mesh->indices);
free(mesh);
lovrFree(mesh->vertices);
lovrFree(mesh->indices);
lovrFree(mesh);
}
const DataField* lovrMeshGetVertexFormat(Mesh* mesh) {
@ -4143,8 +4115,7 @@ void lovrMeshGetTriangles(Mesh* mesh, float** vertices, uint32_t** indices, uint
lovrCheck(position, "Mesh has no VertexPosition attribute with vec3 type");
const DataField* format = lovrMeshGetVertexFormat(mesh);
*vertices = malloc(format->length * 3 * sizeof(float));
lovrAssert(*vertices, "Out of memory");
*vertices = lovrMalloc(format->length * 3 * sizeof(float));
for (uint32_t i = 0; i < format->length; i++) {
vec3_init(*vertices, position);
@ -4154,8 +4125,7 @@ void lovrMeshGetTriangles(Mesh* mesh, float** vertices, uint32_t** indices, uint
if (mesh->indexCount > 0) {
*indexCount = mesh->indexCount;
*indices = malloc(*indexCount * sizeof(uint32_t));
lovrAssert(*indices, "Out of memory");
*indices = lovrMalloc(*indexCount * sizeof(uint32_t));
if (mesh->indexBuffer->info.format[1].type == TYPE_U16 || mesh->indexBuffer->info.format[1].type == TYPE_INDEX16) {
for (uint32_t i = 0; i < mesh->indexCount; i++) {
*indices[i] = (uint32_t) ((uint16_t*) mesh->indices)[i];
@ -4165,8 +4135,7 @@ void lovrMeshGetTriangles(Mesh* mesh, float** vertices, uint32_t** indices, uint
}
} else {
*indexCount = format->length;
*indices = malloc(*indexCount * sizeof(uint32_t));
lovrAssert(*indices, "Out of memory");
*indices = lovrMalloc(*indexCount * sizeof(uint32_t));
lovrCheck(format->length >= 3 && format->length % 3 == 0, "Mesh vertex count must be divisible by 3");
for (uint32_t i = 0; i < format->length; i++) {
**indices = i;
@ -4283,8 +4252,7 @@ static void lovrMeshFlush(Mesh* mesh) {
Model* lovrModelCreate(const ModelInfo* info) {
ModelData* data = info->data;
Model* model = calloc(1, sizeof(Model));
lovrAssert(model, "Out of memory");
Model* model = lovrCalloc(sizeof(Model));
model->ref = 1;
model->info = *info;
lovrRetain(info->data);
@ -4295,9 +4263,8 @@ Model* lovrModelCreate(const ModelInfo* info) {
// Materials and Textures
if (info->materials) {
model->textures = calloc(data->imageCount, sizeof(Texture*));
model->materials = malloc(data->materialCount * sizeof(Material*));
lovrAssert(model->textures && model->materials, "Out of memory");
model->textures = lovrCalloc(data->imageCount * sizeof(Texture*));
model->materials = lovrMalloc(data->materialCount * sizeof(Material*));
for (uint32_t i = 0; i < data->materialCount; i++) {
MaterialInfo material;
ModelMaterial* properties = &data->materials[i];
@ -4439,9 +4406,8 @@ Model* lovrModelCreate(const ModelInfo* info) {
qsort(primitiveOrder, data->primitiveCount, sizeof(uint64_t), u64cmp);
// Draws
model->draws = calloc(data->primitiveCount, sizeof(DrawInfo));
model->boundingBoxes = malloc(data->primitiveCount * 6 * sizeof(float));
lovrAssert(model->draws && model->boundingBoxes, "Out of memory");
model->draws = lovrCalloc(data->primitiveCount * sizeof(DrawInfo));
model->boundingBoxes = lovrMalloc(data->primitiveCount * 6 * sizeof(float));
for (uint32_t i = 0, vertexCursor = 0, indexCursor = 0; i < data->primitiveCount; i++) {
ModelPrimitive* primitive = &data->primitives[primitiveOrder[i] & ~0u];
ModelAttribute* position = primitive->attributes[ATTR_POSITION];
@ -4515,9 +4481,8 @@ Model* lovrModelCreate(const ModelInfo* info) {
}
}
model->blendGroups = malloc(model->blendGroupCount * sizeof(BlendGroup));
model->blendShapeWeights = malloc(data->blendShapeCount * sizeof(float));
lovrAssert(model->blendGroups && model->blendShapeWeights, "Out of memory");
model->blendGroups = lovrMalloc(model->blendGroupCount * sizeof(BlendGroup));
model->blendShapeWeights = lovrMalloc(data->blendShapeCount * sizeof(float));
BlendGroup* group = model->blendGroups;
@ -4552,9 +4517,8 @@ Model* lovrModelCreate(const ModelInfo* info) {
}
// Transforms
model->localTransforms = malloc(sizeof(NodeTransform) * data->nodeCount);
model->globalTransforms = malloc(16 * sizeof(float) * data->nodeCount);
lovrAssert(model->localTransforms && model->globalTransforms, "Out of memory");
model->localTransforms = lovrMalloc(sizeof(NodeTransform) * data->nodeCount);
model->globalTransforms = lovrMalloc(16 * sizeof(float) * data->nodeCount);
lovrModelResetNodeTransforms(model);
tempPop(&state.allocator, stack);
@ -4564,8 +4528,7 @@ Model* lovrModelCreate(const ModelInfo* info) {
Model* lovrModelClone(Model* parent) {
ModelData* data = parent->info.data;
Model* model = calloc(1, sizeof(Model));
lovrAssert(model, "Out of memory");
Model* model = lovrCalloc(sizeof(Model));
model->ref = 1;
model->parent = parent;
model->info = parent->info;
@ -4602,21 +4565,18 @@ Model* lovrModelClone(Model* parent) {
}, 1);
}
model->draws = malloc(data->primitiveCount * sizeof(DrawInfo));
lovrAssert(model->draws, "Out of memory");
model->draws = lovrMalloc(data->primitiveCount * sizeof(DrawInfo));
for (uint32_t i = 0; i < data->primitiveCount; i++) {
model->draws[i] = parent->draws[i];
model->draws[i].vertex.buffer = model->vertexBuffer;
}
model->blendShapeWeights = malloc(data->blendShapeCount * sizeof(float));
lovrAssert(model->blendShapeWeights, "Out of memory");
model->blendShapeWeights = lovrMalloc(data->blendShapeCount * sizeof(float));
lovrModelResetBlendShapes(model);
model->localTransforms = malloc(sizeof(NodeTransform) * data->nodeCount);
model->globalTransforms = malloc(16 * sizeof(float) * data->nodeCount);
lovrAssert(model->localTransforms && model->globalTransforms, "Out of memory");
model->localTransforms = lovrMalloc(sizeof(NodeTransform) * data->nodeCount);
model->globalTransforms = lovrMalloc(16 * sizeof(float) * data->nodeCount);
lovrModelResetNodeTransforms(model);
return model;
@ -4627,12 +4587,12 @@ void lovrModelDestroy(void* ref) {
if (model->parent) {
lovrRelease(model->parent, lovrModelDestroy);
lovrRelease(model->vertexBuffer, lovrBufferDestroy);
free(model->localTransforms);
free(model->globalTransforms);
free(model->blendShapeWeights);
free(model->meshes);
free(model->draws);
free(model);
lovrFree(model->localTransforms);
lovrFree(model->globalTransforms);
lovrFree(model->blendShapeWeights);
lovrFree(model->meshes);
lovrFree(model->draws);
lovrFree(model);
return;
}
ModelData* data = model->info.data;
@ -4643,8 +4603,8 @@ void lovrModelDestroy(void* ref) {
for (uint32_t i = 0; i < data->imageCount; i++) {
lovrRelease(model->textures[i], lovrTextureDestroy);
}
free(model->materials);
free(model->textures);
lovrFree(model->materials);
lovrFree(model->textures);
}
lovrRelease(model->rawVertexBuffer, lovrBufferDestroy);
lovrRelease(model->vertexBuffer, lovrBufferDestroy);
@ -4652,14 +4612,14 @@ void lovrModelDestroy(void* ref) {
lovrRelease(model->blendBuffer, lovrBufferDestroy);
lovrRelease(model->skinBuffer, lovrBufferDestroy);
lovrRelease(model->info.data, lovrModelDataDestroy);
free(model->localTransforms);
free(model->globalTransforms);
free(model->boundingBoxes);
free(model->blendShapeWeights);
free(model->blendGroups);
free(model->meshes);
free(model->draws);
free(model);
lovrFree(model->localTransforms);
lovrFree(model->globalTransforms);
lovrFree(model->boundingBoxes);
lovrFree(model->blendShapeWeights);
lovrFree(model->blendGroups);
lovrFree(model->meshes);
lovrFree(model->draws);
lovrFree(model);
}
const ModelInfo* lovrModelGetInfo(Model* model) {
@ -4854,8 +4814,7 @@ Mesh* lovrModelGetMesh(Model* model, uint32_t index) {
lovrCheck(index < data->primitiveCount, "Invalid mesh index '%d' (Model has %d mesh%s)", index + 1, data->primitiveCount, data->primitiveCount == 1 ? "" : "es");
if (!model->meshes) {
model->meshes = calloc(data->primitiveCount, sizeof(Mesh*));
lovrAssert(model->meshes, "Out of memory");
model->meshes = lovrCalloc(data->primitiveCount * sizeof(Mesh*));
}
if (!model->meshes[index]) {
@ -5026,8 +4985,7 @@ static void lovrModelAnimateVertices(Model* model) {
static Readback* lovrReadbackCreate(ReadbackType type) {
beginFrame();
Readback* readback = calloc(1, sizeof(Readback));
lovrAssert(readback, "Out of memory");
Readback* readback = lovrCalloc(sizeof(Readback));
readback->ref = 1;
readback->tick = state.tick;
readback->type = type;
@ -5045,8 +5003,7 @@ Readback* lovrReadbackCreateBuffer(Buffer* buffer, uint32_t offset, uint32_t ext
lovrCheck(!buffer->info.format || extent % buffer->info.format->stride == 0, "Readback size must be a multiple of Buffer's stride");
Readback* readback = lovrReadbackCreate(READBACK_BUFFER);
readback->buffer = buffer;
void* data = malloc(extent);
lovrAssert(data, "Out of memory");
void* data = lovrMalloc(extent);
readback->blob = lovrBlobCreate(data, extent, "Readback");
readback->view = getBuffer(GPU_BUFFER_DOWNLOAD, extent, 4);
lovrRetain(buffer);
@ -5097,11 +5054,11 @@ void lovrReadbackDestroy(void* ref) {
for (uint32_t i = 0; i < readback->count; i++) {
lovrRelease(readback->times[i].pass, lovrPassDestroy);
}
free(readback->times);
lovrFree(readback->times);
break;
default: break;
}
free(readback);
lovrFree(readback);
}
bool lovrReadbackIsComplete(Readback* readback) {
@ -5220,8 +5177,7 @@ Pass* lovrGraphicsGetWindowPass(void) {
}
Pass* lovrPassCreate(void) {
Pass* pass = calloc(1, sizeof(Pass));
lovrAssert(pass, "Out of memory");
Pass* pass = lovrCalloc(sizeof(Pass));
pass->ref = 1;
pass->allocator.limit = 1 << 28;
@ -5251,7 +5207,7 @@ void lovrPassDestroy(void* ref) {
freeBlock(&state.bufferAllocators[GPU_BUFFER_STREAM], pass->buffers.current);
}
os_vm_free(pass->allocator.memory, pass->allocator.limit);
free(pass);
lovrFree(pass);
}
void lovrPassReset(Pass* pass) {
@ -7348,8 +7304,7 @@ static BufferBlock* getBlock(gpu_buffer_type type, uint32_t size) {
return block;
}
block = malloc(sizeof(BufferBlock) + gpu_sizeof_buffer());
lovrAssert(block, "Out of memory");
block = lovrMalloc(sizeof(BufferBlock) + gpu_sizeof_buffer());
block->handle = (gpu_buffer*) (block + 1);
block->size = MAX(size, 1 << 22);
block->next = NULL;
@ -7507,8 +7462,7 @@ static gpu_pass* getPass(Canvas* canvas) {
uint64_t value = map_get(&state.passLookup, hash);
if (value == MAP_NIL) {
gpu_pass* pass = malloc(gpu_sizeof_pass());
lovrAssert(pass, "Out of memory");
gpu_pass* pass = lovrMalloc(gpu_sizeof_pass());
gpu_pass_init(pass, &info);
map_set(&state.passLookup, hash, (uint64_t) (uintptr_t) pass);
return pass;
@ -7532,8 +7486,7 @@ static size_t getLayout(gpu_slot* slots, uint32_t count) {
.count = count
};
gpu_layout* handle = malloc(gpu_sizeof_layout());
lovrAssert(handle, "Out of memory");
gpu_layout* handle = lovrMalloc(gpu_sizeof_layout());
gpu_layout_init(handle, &info);
Layout layout = {
@ -7574,10 +7527,9 @@ static gpu_bundle* getBundle(size_t layoutIndex, gpu_binding* bindings, uint32_t
}
// If no pool was available, make a new one
pool = malloc(sizeof(BundlePool));
gpu_bundle_pool* gpu = malloc(gpu_sizeof_bundle_pool());
gpu_bundle* bundles = malloc(POOL_SIZE * gpu_sizeof_bundle());
lovrAssert(pool && gpu && bundles, "Out of memory");
pool = lovrMalloc(sizeof(BundlePool));
gpu_bundle_pool* gpu = lovrMalloc(gpu_sizeof_bundle_pool());
gpu_bundle* bundles = lovrMalloc(POOL_SIZE * gpu_sizeof_bundle());
pool->gpu = gpu;
pool->bundles = bundles;
pool->cursor = 1;
@ -7624,8 +7576,7 @@ static gpu_texture* getScratchTexture(gpu_stream* stream, Canvas* canvas, Textur
} else {
arr_expand(&state.scratchTextures, 1);
scratch = &state.scratchTextures.data[state.scratchTextures.length++];
scratch->texture = calloc(1, gpu_sizeof_texture());
lovrAssert(scratch->texture, "Out of memory");
scratch->texture = lovrCalloc(gpu_sizeof_texture());
}
gpu_texture_info info = {
@ -8020,11 +7971,10 @@ static void onMessage(void* context, const char* message, bool severe) {
if (!state.defaultTexture) { // Hacky way to determine if initialization has completed
const char* format = "This program requires a graphics card with support for Vulkan 1.1, but no device was found or it failed to initialize properly. The error message was:\n\n%s";
size_t size = snprintf(NULL, 0, format, message) + 1;
char* string = malloc(size);
lovrAssert(string, "Out of memory");
char* string = lovrMalloc(size);
snprintf(string, size, format, message);
os_window_message_box(string);
free(string);
lovrFree(string);
exit(1);
}
#endif

37
src/modules/headset/headset_openxr.c
View File

@ -581,8 +581,7 @@ static bool openxr_init(HeadsetConfig* config) {
XR_INIT(result, "Failed to query extensions");
}
XrExtensionProperties* extensionProperties = calloc(extensionCount, sizeof(*extensionProperties));
lovrAssert(extensionProperties, "Out of memory");
XrExtensionProperties* extensionProperties = lovrCalloc(extensionCount * sizeof(*extensionProperties));
for (uint32_t i = 0; i < extensionCount; i++) extensionProperties[i].type = XR_TYPE_EXTENSION_PROPERTIES;
xrEnumerateInstanceExtensionProperties(NULL, extensionCount, &extensionCount, extensionProperties);
@ -631,7 +630,7 @@ static bool openxr_init(HeadsetConfig* config) {
}
}
free(extensionProperties);
lovrFree(extensionProperties);
#ifdef __ANDROID__
XrInstanceCreateInfoAndroidKHR androidInfo = {
@ -725,8 +724,7 @@ static bool openxr_init(HeadsetConfig* config) {
// Blend modes
XR_INIT(xrEnumerateEnvironmentBlendModes(state.instance, state.system, XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO, 0, &state.blendModeCount, NULL), "Failed to query blend modes");
state.blendModes = malloc(state.blendModeCount * sizeof(XrEnvironmentBlendMode));
lovrAssert(state.blendModes, "Out of memory");
state.blendModes = lovrMalloc(state.blendModeCount * sizeof(XrEnvironmentBlendMode));
XR_INIT(xrEnumerateEnvironmentBlendModes(state.instance, state.system, XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO, state.blendModeCount, &state.blendModeCount, state.blendModes), "Failed to query blend modes");
state.blendMode = state.blendModes[0];
}
@ -1468,8 +1466,7 @@ static void openxr_start(void) {
if (state.features.refreshRate) {
XR(xrEnumerateDisplayRefreshRatesFB(state.session, 0, &state.refreshRateCount, NULL), "Failed to query refresh rates");
state.refreshRates = malloc(state.refreshRateCount * sizeof(float));
lovrAssert(state.refreshRates, "Out of memory");
state.refreshRates = lovrMalloc(state.refreshRateCount * sizeof(float));
XR(xrEnumerateDisplayRefreshRatesFB(state.session, state.refreshRateCount, &state.refreshRateCount, state.refreshRates), "Failed to query refresh rates");
}
}
@ -2090,8 +2087,7 @@ static ModelData* openxr_newModelDataFB(XrHandTrackerEXT tracker, bool animated)
totalSize += sizes[9] = ALIGN(jointCount * 16 * sizeof(float), alignment);
// Allocate
char* meshData = malloc(totalSize);
if (!meshData) return NULL;
char* meshData = lovrMalloc(totalSize);
// Write offseted pointers to the mesh struct, to be filled in by the second call
size_t offset = 0;
@ -2110,12 +2106,11 @@ static ModelData* openxr_newModelDataFB(XrHandTrackerEXT tracker, bool animated)
// Populate the data
result = xrGetHandMeshFB(tracker, &mesh);
if (XR_FAILED(result)) {
free(meshData);
lovrFree(meshData);
return NULL;
}
ModelData* model = calloc(1, sizeof(ModelData));
lovrAssert(model, "Out of memory");
ModelData* model = lovrCalloc(sizeof(ModelData));
model->ref = 1;
model->blobCount = 1;
model->bufferCount = 6;
@ -2127,8 +2122,7 @@ static ModelData* openxr_newModelDataFB(XrHandTrackerEXT tracker, bool animated)
model->nodeCount = 2 + jointCount;
lovrModelDataAllocate(model);
model->metadata = malloc(sizeof(XrHandTrackerEXT));
lovrAssert(model->metadata, "Out of memory");
model->metadata = lovrMalloc(sizeof(XrHandTrackerEXT));
*((XrHandTrackerEXT*)model->metadata) = tracker;
model->metadataSize = sizeof(XrHandTrackerEXT);
model->metadataType = META_HANDTRACKING_FB;
@ -2271,11 +2265,10 @@ static ModelData* openxr_newModelDataMSFT(XrControllerModelKeyMSFT modelKey, boo
return NULL;
}
unsigned char* modelData = malloc(size);
if (!modelData) return NULL;
unsigned char* modelData = lovrMalloc(size);
if (XR_FAILED(xrLoadControllerModelMSFT(state.session, modelKey, size, &size, modelData))) {
free(modelData);
lovrFree(modelData);
return NULL;
}
@ -2298,11 +2291,10 @@ static ModelData* openxr_newModelDataMSFT(XrControllerModelKeyMSFT modelKey, boo
return false;
}
free(model->metadata);
lovrFree(model->metadata);
model->metadataType = META_CONTROLLER_MSFT;
model->metadataSize = sizeof(MetadataControllerMSFT) + sizeof(uint32_t) * properties.nodeCountOutput;
model->metadata = malloc(model->metadataSize);
lovrAssert(model->metadata, "Out of memory");
model->metadata = lovrMalloc(model->metadataSize);
MetadataControllerMSFT* metadata = model->metadata;
metadata->modelKey = modelKey;
@ -2451,8 +2443,7 @@ static bool openxr_animate(Model* model) {
}
static Layer* openxr_newLayer(uint32_t width, uint32_t height) {
Layer* layer = calloc(1, sizeof(Layer));
lovrAssert(layer, "Out of memory");
Layer* layer = lovrCalloc(sizeof(Layer));
layer->ref = 1;
layer->width = width;
layer->height = height;
@ -2488,7 +2479,7 @@ static void openxr_destroyLayer(void* ref) {
Layer* layer = ref;
swapchain_destroy(&layer->swapchain);
lovrRelease(layer->pass, lovrPassDestroy);
free(layer);
lovrFree(layer);
}
static Layer** openxr_getLayers(uint32_t* count) {

4
src/modules/headset/headset_simulator.c
View File

@ -272,7 +272,7 @@ static bool simulator_animate(struct Model* model) {
}
static Layer* simulator_newLayer(uint32_t width, uint32_t height) {
Layer* layer = calloc(1, sizeof(Layer));
Layer* layer = lovrCalloc(sizeof(Layer));
layer->ref = 1;
layer->textureWidth = width;
layer->textureWeight = height;
@ -281,7 +281,7 @@ static Layer* simulator_newLayer(uint32_t width, uint32_t height) {
static void simulator_destroyLayer(void* ref) {
Layer* layer = ref;
free(layer);
lovrFree(layer);
}
static Layer** simulator_getLayers(uint32_t* count) {

15
src/modules/math/math.c
View File

@ -129,8 +129,7 @@ static void evaluate(float* restrict P, size_t n, float t, vec4 p) {
}
Curve* lovrCurveCreate(void) {
Curve* curve = calloc(1, sizeof(Curve));
lovrAssert(curve, "Out of memory");
Curve* curve = lovrCalloc(sizeof(Curve));
curve->ref = 1;
arr_init(&curve->points, arr_alloc);
arr_reserve(&curve->points, 16);
@ -140,7 +139,7 @@ Curve* lovrCurveCreate(void) {
void lovrCurveDestroy(void* ref) {
Curve* curve = ref;
arr_free(&curve->points);
free(curve);
lovrFree(curve);
}
void lovrCurveEvaluate(Curve* curve, float t, vec4 p) {
@ -227,8 +226,7 @@ static const size_t vectorComponents[] = {
};
Pool* lovrPoolCreate(void) {
Pool* pool = calloc(1, sizeof(Pool));
lovrAssert(pool, "Out of memory");
Pool* pool = lovrCalloc(sizeof(Pool));
pool->ref = 1;
pool->data = os_vm_init((1 << 24) * sizeof(float));
lovrPoolGrow(pool, 1 << 12);
@ -238,7 +236,7 @@ Pool* lovrPoolCreate(void) {
void lovrPoolDestroy(void* ref) {
Pool* pool = ref;
os_vm_free(pool->data, (1 << 24) * sizeof(float));
free(pool);
lovrFree(pool);
}
void lovrPoolGrow(Pool* pool, size_t count) {
@ -300,8 +298,7 @@ static uint64_t wangHash64(uint64_t key) {
// Use an 'Xorshift*' variant, as shown here: http://xorshift.di.unimi.it
RandomGenerator* lovrRandomGeneratorCreate(void) {
RandomGenerator* generator = calloc(1, sizeof(RandomGenerator));
lovrAssert(generator, "Out of memory");
RandomGenerator* generator = lovrCalloc(sizeof(RandomGenerator));
generator->ref = 1;
Seed seed = { .b32 = { .lo = 0xCBBF7A44, .hi = 0x0139408D } };
lovrRandomGeneratorSetSeed(generator, seed);
@ -310,7 +307,7 @@ RandomGenerator* lovrRandomGeneratorCreate(void) {
}
void lovrRandomGeneratorDestroy(void* ref) {
free(ref);
lovrFree(ref);
}
Seed lovrRandomGeneratorGetSeed(RandomGenerator* generator) {

52
src/modules/physics/physics_jolt.c
View File

@ -110,8 +110,7 @@ void lovrPhysicsDestroy(void) {
}
World* lovrWorldCreate(float xg, float yg, float zg, bool allowSleep, const char** tags, uint32_t tagCount) {
World* world = calloc(1, sizeof(World));
lovrAssert(world, "Out of memory");
World* world = lovrCalloc(sizeof(World));
world->collision_steps = 1;
world->ref = 1;
@ -149,7 +148,7 @@ World* lovrWorldCreate(float xg, float yg, float zg, bool allowSleep, const char
lovrWorldSetGravity(world, xg, yg, zg);
for (uint32_t i = 0; i < tagCount; i++) {
size_t size = strlen(tags[i]) + 1;
world->tags[i] = malloc(size);
world->tags[i] = lovrMalloc(size);
memcpy(world->tags[i], tags[i], size);
}
return world;
@ -160,12 +159,12 @@ void lovrWorldDestroy(void* ref) {
lovrWorldDestroyData(world);
// todo: free up overlaps/contacts (once their allocation is implemented)
for (uint32_t i = 0; i < MAX_TAGS - 1 && world->tags[i]; i++) {
free(world->tags[i]);
lovrFree(world->tags[i]);
}
if (world->tags[15]) {
free(world->tags[15]);
lovrFree(world->tags[15]);
}
free(world);
lovrFree(world);
}
void lovrWorldDestroyData(World* world) {
@ -394,8 +393,7 @@ bool lovrWorldIsCollisionEnabledBetween(World* world, const char* tag1, const ch
Collider* lovrColliderCreate(World* world, float x, float y, float z) {
// todo: crashes when too many are added
Collider* collider = calloc(1, sizeof(Collider));
lovrAssert(collider, "Out of memory");
Collider* collider = lovrCalloc(sizeof(Collider));
collider->ref = 1;
collider->world = world;
collider->tag = UNTAGGED;
@ -437,7 +435,7 @@ void lovrColliderDestroy(void* ref) {
lovrColliderDestroyData(collider);
arr_free(&collider->shapes);
arr_free(&collider->joints);
free(collider);
lovrFree(collider);
}
void lovrColliderDestroyData(Collider* collider) {
@ -862,7 +860,7 @@ void lovrColliderGetAABB(Collider* collider, float aabb[6]) {
void lovrShapeDestroy(void* ref) {
Shape* shape = ref;
lovrShapeDestroyData(shape);
free(shape);
lovrFree(shape);
}
void lovrShapeDestroyData(Shape* shape) {
@ -939,8 +937,7 @@ void lovrShapeGetAABB(Shape* shape, float aabb[6]) {
SphereShape* lovrSphereShapeCreate(float radius) {
lovrCheck(radius > 0.f, "SphereShape radius must be positive");
SphereShape* sphere = calloc(1, sizeof(SphereShape));
lovrAssert(sphere, "Out of memory");
SphereShape* sphere = lovrCalloc(sizeof(SphereShape));
sphere->ref = 1;
sphere->type = SHAPE_SPHERE;
sphere->shape = (JPH_Shape *) JPH_SphereShape_Create(radius);
@ -957,8 +954,7 @@ void lovrSphereShapeSetRadius(SphereShape* sphere, float radius) {
}
BoxShape* lovrBoxShapeCreate(float w, float h, float d) {
BoxShape* box = calloc(1, sizeof(BoxShape));
lovrAssert(box, "Out of memory");
BoxShape* box = lovrCalloc(sizeof(BoxShape));
box->ref = 1;
box->type = SHAPE_BOX;
const JPH_Vec3 halfExtent = {
@ -985,8 +981,7 @@ void lovrBoxShapeSetDimensions(BoxShape* box, float w, float h, float d) {
CapsuleShape* lovrCapsuleShapeCreate(float radius, float length) {
lovrCheck(radius > 0.f && length > 0.f, "CapsuleShape dimensions must be positive");
CapsuleShape* capsule = calloc(1, sizeof(CapsuleShape));
lovrAssert(capsule, "Out of memory");
CapsuleShape* capsule = lovrCalloc(sizeof(CapsuleShape));
capsule->ref = 1;
capsule->type = SHAPE_CAPSULE;
capsule->shape = (JPH_Shape *) JPH_CapsuleShape_Create(length / 2, radius);
@ -1013,8 +1008,7 @@ void lovrCapsuleShapeSetLength(CapsuleShape* capsule, float length) {
CylinderShape* lovrCylinderShapeCreate(float radius, float length) {
lovrCheck(radius > 0.f && length > 0.f, "CylinderShape dimensions must be positive");
CylinderShape* Cylinder = calloc(1, sizeof(CylinderShape));
lovrAssert(Cylinder, "Out of memory");
CylinderShape* Cylinder = lovrCalloc(sizeof(CylinderShape));
Cylinder->ref = 1;
Cylinder->type = SHAPE_CYLINDER;
Cylinder->shape = (JPH_Shape *) JPH_CylinderShape_Create(length / 2.f, radius);
@ -1040,13 +1034,12 @@ void lovrCylinderShapeSetLength(CylinderShape* cylinder, float length) {
}
MeshShape* lovrMeshShapeCreate(int vertexCount, float vertices[], int indexCount, uint32_t indices[]) {
MeshShape* mesh = calloc(1, sizeof(MeshShape));
lovrAssert(mesh, "Out of memory");
MeshShape* mesh = lovrCalloc(sizeof(MeshShape));
mesh->ref = 1;
mesh->type = SHAPE_MESH;
int triangleCount = indexCount / 3;
JPH_IndexedTriangle * indexedTriangles = malloc(triangleCount * sizeof(JPH_IndexedTriangle));
JPH_IndexedTriangle * indexedTriangles = lovrMalloc(triangleCount * sizeof(JPH_IndexedTriangle));
for (int i = 0; i < triangleCount; i++) {
indexedTriangles[i].i1 = indices[i * 3 + 0];
indexedTriangles[i].i2 = indices[i * 3 + 1];
@ -1065,8 +1058,7 @@ MeshShape* lovrMeshShapeCreate(int vertexCount, float vertices[], int indexCount
TerrainShape* lovrTerrainShapeCreate(float* vertices, uint32_t widthSamples, uint32_t depthSamples, float horizontalScale, float verticalScale) {
lovrCheck(widthSamples == depthSamples, "Jolt needs terrain width and depth to be the same");
TerrainShape* terrain = calloc(1, sizeof(TerrainShape));
lovrAssert(terrain, "Out of memory");
TerrainShape* terrain = lovrCalloc(sizeof(TerrainShape));
terrain->ref = 1;
terrain->type = SHAPE_TERRAIN;
const JPH_Vec3 offset = {
@ -1127,7 +1119,7 @@ void lovrJointGetAnchors(Joint* joint, float anchor1[3], float anchor2[3]) {
void lovrJointDestroy(void* ref) {
Joint* joint = ref;
lovrJointDestroyData(joint);
free(joint);
lovrFree(joint);
}
void lovrJointDestroyData(Joint* joint) {
@ -1198,8 +1190,7 @@ void lovrJointSetEnabled(Joint* joint, bool enable) {
BallJoint* lovrBallJointCreate(Collider* a, Collider* b, float anchor[3]) {
lovrCheck(a->world == b->world, "Joint bodies must exist in same World");
BallJoint* joint = calloc(1, sizeof(BallJoint));
lovrAssert(joint, "Out of memory");
BallJoint* joint = lovrCalloc(sizeof(BallJoint));
joint->ref = 1;
joint->type = JOINT_BALL;
@ -1256,8 +1247,7 @@ void lovrBallJointSetTightness(Joint* joint, float tightness) {
DistanceJoint* lovrDistanceJointCreate(Collider* a, Collider* b, float anchor1[3], float anchor2[3]) {
lovrCheck(a->world == b->world, "Joint bodies must exist in same World");
DistanceJoint* joint = calloc(1, sizeof(DistanceJoint));
lovrAssert(joint, "Out of memory");
DistanceJoint* joint = lovrCalloc(sizeof(DistanceJoint));
joint->ref = 1;
joint->type = JOINT_DISTANCE;
@ -1325,8 +1315,7 @@ void lovrDistanceJointSetTightness(Joint* joint, float tightness) {
HingeJoint* lovrHingeJointCreate(Collider* a, Collider* b, float anchor[3], float axis[3]) {
lovrCheck(a->world == b->world, "Joint bodies must exist in the same World");
HingeJoint* joint = calloc(1, sizeof(HingeJoint));
lovrAssert(joint, "Out of memory");
HingeJoint* joint = lovrCalloc(sizeof(HingeJoint));
joint->ref = 1;
joint->type = JOINT_HINGE;
@ -1419,8 +1408,7 @@ void lovrHingeJointSetUpperLimit(HingeJoint* joint, float limit) {
SliderJoint* lovrSliderJointCreate(Collider* a, Collider* b, float axis[3]) {
lovrCheck(a->world == b->world, "Joint bodies must exist in the same World");
SliderJoint* joint = calloc(1, sizeof(SliderJoint));
lovrAssert(joint, "Out of memory");
SliderJoint* joint = lovrCalloc(sizeof(SliderJoint));
joint->ref = 1;
joint->type = JOINT_SLIDER;

52
src/modules/physics/physics_ode.c
View File

@ -158,8 +158,7 @@ void lovrPhysicsDestroy(void) {
}
World* lovrWorldCreate(float xg, float yg, float zg, bool allowSleep, const char** tags, uint32_t tagCount) {
World* world = calloc(1, sizeof(World));
lovrAssert(world, "Out of memory");
World* world = lovrCalloc(sizeof(World));
world->ref = 1;
world->id = dWorldCreate();
world->space = dHashSpaceCreate(0);
@ -170,7 +169,7 @@ World* lovrWorldCreate(float xg, float yg, float zg, bool allowSleep, const char
lovrWorldSetSleepingAllowed(world, allowSleep);
for (uint32_t i = 0; i < tagCount; i++) {
size_t size = strlen(tags[i]) + 1;
world->tags[i] = malloc(size);
world->tags[i] = lovrMalloc(size);
memcpy(world->tags[i], tags[i], size);
}
memset(world->masks, 0xff, sizeof(world->masks));
@ -182,9 +181,9 @@ void lovrWorldDestroy(void* ref) {
lovrWorldDestroyData(world);
arr_free(&world->overlaps);
for (uint32_t i = 0; i < MAX_TAGS && world->tags[i]; i++) {
free(world->tags[i]);
lovrFree(world->tags[i]);
}
free(world);
lovrFree(world);
}
void lovrWorldDestroyData(World* world) {
@ -441,8 +440,7 @@ bool lovrWorldIsCollisionEnabledBetween(World* world, const char* tag1, const ch
}
Collider* lovrColliderCreate(World* world, float x, float y, float z) {
Collider* collider = calloc(1, sizeof(Collider));
lovrAssert(collider, "Out of memory");
Collider* collider = lovrCalloc(sizeof(Collider));
collider->ref = 1;
collider->body = dBodyCreate(world->id);
collider->world = world;
@ -474,7 +472,7 @@ void lovrColliderDestroy(void* ref) {
lovrColliderDestroyData(collider);
arr_free(&collider->shapes);
arr_free(&collider->joints);
free(collider);
lovrFree(collider);
}
void lovrColliderDestroyData(Collider* collider) {
@ -854,7 +852,7 @@ void lovrColliderGetAABB(Collider* collider, float aabb[6]) {
void lovrShapeDestroy(void* ref) {
Shape* shape = ref;
lovrShapeDestroyData(shape);
free(shape);
lovrFree(shape);
}
void lovrShapeDestroyData(Shape* shape) {
@ -862,8 +860,8 @@ void lovrShapeDestroyData(Shape* shape) {
if (shape->type == SHAPE_MESH) {
dTriMeshDataID dataID = dGeomTriMeshGetData(shape->id);
dGeomTriMeshDataDestroy(dataID);
free(shape->vertices);
free(shape->indices);
lovrFree(shape->vertices);
lovrFree(shape->indices);
} else if (shape->type == SHAPE_TERRAIN) {
dHeightfieldDataID dataID = dGeomHeightfieldGetHeightfieldData(shape->id);
dGeomHeightfieldDataDestroy(dataID);
@ -1003,8 +1001,7 @@ void lovrShapeGetAABB(Shape* shape, float aabb[6]) {
SphereShape* lovrSphereShapeCreate(float radius) {
lovrCheck(radius > 0.f, "SphereShape radius must be positive");
SphereShape* sphere = calloc(1, sizeof(SphereShape));
lovrAssert(sphere, "Out of memory");
SphereShape* sphere = lovrCalloc(sizeof(SphereShape));
sphere->ref = 1;
sphere->type = SHAPE_SPHERE;
sphere->id = dCreateSphere(0, radius);
@ -1022,8 +1019,7 @@ void lovrSphereShapeSetRadius(SphereShape* sphere, float radius) {
}
BoxShape* lovrBoxShapeCreate(float w, float h, float d) {
BoxShape* box = calloc(1, sizeof(BoxShape));
lovrAssert(box, "Out of memory");
BoxShape* box = lovrCalloc(sizeof(BoxShape));
box->ref = 1;
box->type = SHAPE_BOX;
box->id = dCreateBox(0, w, h, d);
@ -1046,8 +1042,7 @@ void lovrBoxShapeSetDimensions(BoxShape* box, float w, float h, float d) {
CapsuleShape* lovrCapsuleShapeCreate(float radius, float length) {
lovrCheck(radius > 0.f && length > 0.f, "CapsuleShape dimensions must be positive");
CapsuleShape* capsule = calloc(1, sizeof(CapsuleShape));
lovrAssert(capsule, "Out of memory");
CapsuleShape* capsule = lovrCalloc(sizeof(CapsuleShape));
capsule->ref = 1;
capsule->type = SHAPE_CAPSULE;
capsule->id = dCreateCapsule(0, radius, length);
@ -1079,8 +1074,7 @@ void lovrCapsuleShapeSetLength(CapsuleShape* capsule, float length) {
CylinderShape* lovrCylinderShapeCreate(float radius, float length) {
lovrCheck(radius > 0.f && length > 0.f, "CylinderShape dimensions must be positive");
CylinderShape* cylinder = calloc(1, sizeof(CylinderShape));
lovrAssert(cylinder, "Out of memory");
CylinderShape* cylinder = lovrCalloc(sizeof(CylinderShape));
cylinder->ref = 1;
cylinder->type = SHAPE_CYLINDER;
cylinder->id = dCreateCylinder(0, radius, length);
@ -1111,8 +1105,7 @@ void lovrCylinderShapeSetLength(CylinderShape* cylinder, float length) {
}
MeshShape* lovrMeshShapeCreate(int vertexCount, float* vertices, int indexCount, dTriIndex* indices) {
MeshShape* mesh = calloc(1, sizeof(MeshShape));
lovrAssert(mesh, "Out of memory");
MeshShape* mesh = lovrCalloc(sizeof(MeshShape));
mesh->ref = 1;
dTriMeshDataID dataID = dGeomTriMeshDataCreate();
dGeomTriMeshDataBuildSingle(dataID, vertices, 3 * sizeof(float), vertexCount, indices, indexCount, 3 * sizeof(dTriIndex));
@ -1127,8 +1120,7 @@ MeshShape* lovrMeshShapeCreate(int vertexCount, float* vertices, int indexCount,
TerrainShape* lovrTerrainShapeCreate(float* vertices, uint32_t widthSamples, uint32_t depthSamples, float horizontalScale, float verticalScale) {
const float thickness = 10.f;
TerrainShape* terrain = calloc(1, sizeof(TerrainShape));
lovrAssert(terrain, "Out of memory");
TerrainShape* terrain = lovrCalloc(sizeof(TerrainShape));
terrain->ref = 1;
dHeightfieldDataID dataID = dGeomHeightfieldDataCreate();
dGeomHeightfieldDataBuildSingle(dataID, vertices, 1, horizontalScale, horizontalScale,
@ -1142,7 +1134,7 @@ TerrainShape* lovrTerrainShapeCreate(float* vertices, uint32_t widthSamples, uin
void lovrJointDestroy(void* ref) {
Joint* joint = ref;
lovrJointDestroyData(joint);
free(joint);
lovrFree(joint);
}
void lovrJointDestroyData(Joint* joint) {
@ -1191,8 +1183,7 @@ void lovrJointSetEnabled(Joint* joint, bool enable) {
BallJoint* lovrBallJointCreate(Collider* a, Collider* b, float anchor[3]) {
lovrCheck(a->world == b->world, "Joint bodies must exist in same World");
BallJoint* joint = calloc(1, sizeof(BallJoint));
lovrAssert(joint, "Out of memory");
BallJoint* joint = lovrCalloc(sizeof(BallJoint));
joint->ref = 1;
joint->type = JOINT_BALL;
joint->id = dJointCreateBall(a->world->id, 0);
@ -1237,8 +1228,7 @@ void lovrBallJointSetTightness(Joint* joint, float tightness) {
DistanceJoint* lovrDistanceJointCreate(Collider* a, Collider* b, float anchor1[3], float anchor2[3]) {
lovrCheck(a->world == b->world, "Joint bodies must exist in same World");
DistanceJoint* joint = calloc(1, sizeof(DistanceJoint));
lovrAssert(joint, "Out of memory");
DistanceJoint* joint = lovrCalloc(sizeof(DistanceJoint));
joint->ref = 1;
joint->type = JOINT_DISTANCE;
joint->id = dJointCreateDBall(a->world->id, 0);
@ -1292,8 +1282,7 @@ void lovrDistanceJointSetTightness(Joint* joint, float tightness) {
HingeJoint* lovrHingeJointCreate(Collider* a, Collider* b, float anchor[3], float axis[3]) {
lovrCheck(a->world == b->world, "Joint bodies must exist in same World");
HingeJoint* joint = calloc(1, sizeof(HingeJoint));
lovrAssert(joint, "Out of memory");
HingeJoint* joint = lovrCalloc(sizeof(HingeJoint));
joint->ref = 1;
joint->type = JOINT_HINGE;
joint->id = dJointCreateHinge(a->world->id, 0);
@ -1355,8 +1344,7 @@ void lovrHingeJointSetUpperLimit(HingeJoint* joint, float limit) {
SliderJoint* lovrSliderJointCreate(Collider* a, Collider* b, float axis[3]) {
lovrCheck(a->world == b->world, "Joint bodies must exist in the same world");
SliderJoint* joint = calloc(1, sizeof(SliderJoint));
lovrAssert(joint, "Out of memory");
SliderJoint* joint = lovrCalloc(sizeof(SliderJoint));
joint->ref = 1;
joint->type = JOINT_SLIDER;
joint->id = dJointCreateSlider(a->world->id, 0);

14
src/modules/thread/thread.c
View File

@ -110,8 +110,7 @@ static int threadFunction(void* data) {
}
Thread* lovrThreadCreate(ThreadFunction* function, Blob* body) {
Thread* thread = calloc(1, sizeof(Thread));
lovrAssert(thread, "Out of memory");
Thread* thread = lovrCalloc(sizeof(Thread));
thread->ref = 1;
thread->body = body;
thread->function = function;
@ -125,8 +124,8 @@ void lovrThreadDestroy(void* ref) {
mtx_destroy(&thread->lock);
if (thread->handle) thrd_detach(thread->handle);
lovrRelease(thread->body, lovrBlobDestroy);
free(thread->error);
free(thread);
lovrFree(thread->error);
lovrFree(thread);
}
void lovrThreadStart(Thread* thread, Variant* arguments, uint32_t argumentCount) {
@ -136,7 +135,7 @@ void lovrThreadStart(Thread* thread, Variant* arguments, uint32_t argumentCount)
return;
}
free(thread->error);
lovrFree(thread->error);
thread->error = NULL;
lovrCheck(argumentCount <= MAX_THREAD_ARGUMENTS, "Too many Thread arguments (max is %d)", MAX_THREAD_ARGUMENTS);
@ -170,8 +169,7 @@ const char* lovrThreadGetError(Thread* thread) {
// Channel
Channel* lovrChannelCreate(uint64_t hash) {
Channel* channel = calloc(1, sizeof(Channel));
lovrAssert(channel, "Out of memory");
Channel* channel = lovrCalloc(sizeof(Channel));
channel->ref = 1;
arr_init(&channel->messages, arr_alloc);
mtx_init(&channel->lock, mtx_plain);
@ -186,7 +184,7 @@ void lovrChannelDestroy(void* ref) {
arr_free(&channel->messages);
mtx_destroy(&channel->lock);
cnd_destroy(&channel->cond);
free(channel);
lovrFree(channel);
}
bool lovrChannelPush(Channel* channel, Variant* variant, double timeout, uint64_t* id) {

24
src/util.c
View File

@ -2,6 +2,30 @@
#include <string.h>
#include <stdlib.h>
#include <stdatomic.h>
#include <stdio.h>
// Allocation
void* lovrMalloc(size_t size) {
void* data = malloc(size);
if (!data) fprintf(stderr, "Out of memory"), abort();
return data;
}
void* lovrCalloc(size_t size) {
void* data = calloc(1, size);
if (!data) fprintf(stderr, "Out of memory"), abort();
return data;
}
void* lovrRealloc(void* old, size_t size) {
void* data = realloc(old, size);
if (!data) fprintf(stderr, "Out of memory"), abort();
return data;
}
void lovrFree(void* data) {
free(data);
}
// Error handling
static LOVR_THREAD_LOCAL errorFn* lovrErrorCallback;

6
src/util.h
View File

@ -33,6 +33,12 @@
#define CHECK_SIZEOF(T) int(*_o)[sizeof(T)]=1
#define BREAK() __asm("int $3")
// Allocation
void* lovrMalloc(size_t size);
void* lovrCalloc(size_t size);
void* lovrRealloc(void* data, size_t size);
void lovrFree(void* data);
// Error handling
typedef void errorFn(void*, const char*, va_list);
void lovrSetErrorCallback(errorFn* callback, void* userdata);