Simplify refcounting;

src/api/audio.c

@@ -77,7 +77,7 @@ int l_lovrAudioNewSource(lua_State* L) {
   } else {
     Blob* blob = luax_readblob(L, 1, "Source");
     stream = lovrAudioStreamCreate(blob, 4096);
-    lovrRelease(&blob->ref);
+    lovrRelease(blob);
     if (!stream) {
       luaL_error(L, "Could not decode Ogg audio source at '%s'", luaL_checkstring(L, 1));
       return 0;
@@ -86,7 +86,7 @@ int l_lovrAudioNewSource(lua_State* L) {
 
   Source* source = lovrSourceCreate(stream);
   luax_pushtype(L, Source, source);
-  lovrRelease(&source->ref);
+  lovrRelease(source);
   return 1;
 }
 

src/api/data.c

@@ -32,7 +32,7 @@ int l_lovrDataNewBlob(lua_State* L) {
   const char* name = luaL_optstring(L, 2, "");
   Blob* blob = lovrBlobCreate(data, size, name);
   luax_pushtype(L, Blob, blob);
-  lovrRelease(&blob->ref);
+  lovrRelease(blob);
   return 1;
 }
 
@@ -41,8 +41,8 @@ int l_lovrDataNewAudioStream(lua_State* L) {
   size_t bufferSize = luaL_optinteger(L, 2, 4096);
   AudioStream* stream = lovrAudioStreamCreate(blob, bufferSize);
   luax_pushtype(L, AudioStream, stream);
-  lovrRelease(&blob->ref);
-  lovrRelease(&stream->ref);
+  lovrRelease(blob);
+  lovrRelease(stream);
   return 1;
 }
 
@@ -50,8 +50,8 @@ int l_lovrDataNewModelData(lua_State* L) {
   Blob* blob = luax_readblob(L, 1, "Model");
   ModelData* modelData = lovrModelDataCreate(blob);
   luax_pushtype(L, ModelData, modelData);
-  lovrRelease(&blob->ref);
-  lovrRelease(&modelData->ref);
+  lovrRelease(blob);
+  lovrRelease(modelData);
   return 1;
 }
 
@@ -68,12 +68,8 @@ int l_lovrDataNewRasterizer(lua_State* L) {
 
   Rasterizer* rasterizer = lovrRasterizerCreate(blob, size);
   luax_pushtype(L, Rasterizer, rasterizer);
-
-  if (blob) {
-    lovrRelease(&blob->ref);
-  }
-
-  lovrRelease(&rasterizer->ref);
+  lovrRelease(blob);
+  lovrRelease(rasterizer);
   return 1;
 }
 
@@ -86,11 +82,11 @@ int l_lovrDataNewTextureData(lua_State* L) {
   } else {
     Blob* blob = luax_readblob(L, 1, "Texture");
     textureData = lovrTextureDataFromBlob(blob);
-    lovrRelease(&blob->ref);
+    lovrRelease(blob);
   }
 
   luax_pushtype(L, TextureData, textureData);
-  lovrRelease(&textureData->ref);
+  lovrRelease(textureData);
   return 1;
 }
 
@@ -101,7 +97,7 @@ int l_lovrDataNewVertexData(lua_State* L) {
   luax_checkvertexformat(L, 2, &format);
   VertexData* vertexData = lovrVertexDataCreate(count, format.count > 0 ? &format : NULL, true);
   luax_pushtype(L, VertexData, vertexData);
-  lovrRelease(&vertexData->ref);
+  lovrRelease(vertexData);
   return 1;
 }
 

src/api/event.c

@@ -38,12 +38,12 @@ static int nextEvent(lua_State* L) {
 
     case EVENT_CONTROLLER_ADDED:
       luax_pushtype(L, Controller, event.data.controlleradded.controller);
-      lovrRelease(&event.data.controlleradded.controller->ref);
+      lovrRelease(event.data.controlleradded.controller);
       return 2;
 
     case EVENT_CONTROLLER_REMOVED:
       luax_pushtype(L, Controller, event.data.controllerremoved.controller);
-      lovrRelease(&event.data.controlleradded.controller->ref);
+      lovrRelease(event.data.controlleradded.controller);
       return 2;
 
     case EVENT_CONTROLLER_PRESSED:

src/api/filesystem.c

@@ -8,7 +8,7 @@
 Blob* luax_readblob(lua_State* L, int index, const char* debug) {
   if (lua_type(L, index) == LUA_TUSERDATA) {
     Blob* blob = luax_checktype(L, index, Blob);
-    lovrRetain(&blob->ref);
+    lovrRetain(blob);
     return blob;
   } else {
     const char* path = luaL_checkstring(L, index);
@@ -259,7 +259,7 @@ int l_lovrFilesystemNewBlob(lua_State* L) {
   lovrAssert(data, "Could not load file '%s'", path);
   Blob* blob = lovrBlobCreate((void*) data, size, path);
   luax_pushtype(L, Blob, blob);
-  lovrRelease(&blob->ref);
+  lovrRelease(blob);
   return 1;
 }
 

src/api/graphics.c

@@ -87,7 +87,7 @@ static TextureData* luax_checktexturedata(lua_State* L, int index) {
   } else {
     Blob* blob = luax_readblob(L, index, "Texture");
     TextureData* textureData = lovrTextureDataFromBlob(blob);
-    lovrRelease(&blob->ref);
+    lovrRelease(blob);
     return textureData;
   }
 }
@@ -904,15 +904,12 @@ int l_lovrGraphicsNewFont(lua_State* L) {
     }
 
     rasterizer = lovrRasterizerCreate(blob, size);
-
-    if (blob) {
-      lovrRelease(&blob->ref);
-    }
+    lovrRelease(blob);
   }
 
   Font* font = lovrFontCreate(rasterizer);
   luax_pushtype(L, Font, font);
-  lovrRelease(&font->ref);
+  lovrRelease(font);
   return 1;
 }
 
@@ -924,10 +921,10 @@ int l_lovrGraphicsNewMaterial(lua_State* L) {
   if (lua_type(L, index) == LUA_TSTRING) {
     Blob* blob = luax_readblob(L, index++, "Texture");
     TextureData* textureData = lovrTextureDataFromBlob(blob);
-    lovrRelease(&blob->ref);
+    lovrRelease(blob);
     Texture* texture = lovrTextureCreate(TEXTURE_2D, &textureData, 1, true, true);
     lovrMaterialSetTexture(material, TEXTURE_DIFFUSE, texture);
-    lovrRelease(&texture->ref);
+    lovrRelease(texture);
   } else if (lua_isuserdata(L, index)) {
     Texture* texture = luax_checktypeof(L, index, Texture);
     lovrMaterialSetTexture(material, TEXTURE_DIFFUSE, texture);
@@ -1006,7 +1003,7 @@ int l_lovrGraphicsNewMesh(lua_State* L) {
   }
 
   luax_pushtype(L, Mesh, mesh);
-  lovrRelease(&mesh->ref);
+  lovrRelease(mesh);
   return 1;
 }
 
@@ -1018,7 +1015,7 @@ int l_lovrGraphicsNewModel(lua_State* L) {
   } else {
     Blob* blob = luax_readblob(L, 1, "Model");
     modelData = lovrModelDataCreate(blob);
-    lovrRelease(&blob->ref);
+    lovrRelease(blob);
   }
 
   Model* model = lovrModelCreate(modelData);
@@ -1031,16 +1028,16 @@ int l_lovrGraphicsNewModel(lua_State* L) {
       Material* material = lovrMaterialCreate(false);
       lovrMaterialSetTexture(material, TEXTURE_DIFFUSE, texture);
       lovrModelSetMaterial(model, material);
-      lovrRelease(&blob->ref);
-      lovrRelease(&texture->ref);
-      lovrRelease(&material->ref);
+      lovrRelease(blob);
+      lovrRelease(texture);
+      lovrRelease(material);
     } else {
       lovrModelSetMaterial(model, luax_checktype(L, 2, Material));
     }
   }
 
   luax_pushtype(L, Model, model);
-  lovrRelease(&model->ref);
+  lovrRelease(model);
   return 1;
 }
 
@@ -1063,7 +1060,7 @@ int l_lovrGraphicsNewShader(lua_State* L) {
   const char* fragmentSource = lua_tostring(L, 2);
   Shader* shader = lovrShaderCreate(vertexSource, fragmentSource);
   luax_pushtype(L, Shader, shader);
-  lovrRelease(&shader->ref);
+  lovrRelease(shader);
   return 1;
 }
 
@@ -1120,7 +1117,7 @@ int l_lovrGraphicsNewTexture(lua_State* L) {
   }
 
   luax_pushtype(L, Texture, texture);
-  lovrRelease(&texture->ref);
+  lovrRelease(texture);
   return 1;
 }
 

src/api/math.c

@@ -26,7 +26,7 @@ int l_lovrMathNewRandomGenerator(lua_State* L) {
     lovrRandomGeneratorSetSeed(generator, seed);
   }
   luax_pushtype(L, RandomGenerator, generator);
-  lovrRelease(&generator->ref);
+  lovrRelease(generator);
   return 1;
 }
 
@@ -35,7 +35,7 @@ int l_lovrMathNewTransform(lua_State* L) {
   luax_readtransform(L, 1, matrix, 0);
   Transform* transform = lovrTransformCreate(matrix);
   luax_pushtype(L, Transform, transform);
-  lovrRelease(&transform->ref);
+  lovrRelease(transform);
   return 1;
 }
 

src/api/thread.c

@@ -5,7 +5,7 @@
 static int threadRunner(void* data) {
   Thread* thread = (Thread*) data;
 
-  lovrRetain(&thread->ref);
+  lovrRetain(thread);
   mtx_lock(&thread->lock);
   thread->running = true;
   thread->error = NULL;
@@ -24,7 +24,7 @@ static int threadRunner(void* data) {
   mtx_lock(&thread->lock);
   thread->running = false;
   mtx_unlock(&thread->lock);
-  lovrRelease(&thread->ref);
+  lovrRelease(thread);
 
   if (thread->error) {
     Event event;
@@ -52,7 +52,7 @@ int l_lovrThreadNewThread(lua_State* L) {
   const char* body = luaL_checkstring(L, 1);
   Thread* thread = lovrThreadCreate(threadRunner, body);
   luax_pushtype(L, Thread, thread);
-  lovrRelease(&thread->ref);
+  lovrRelease(thread);
   return 1;
 }
 
@@ -60,7 +60,7 @@ int l_lovrThreadGetChannel(lua_State* L) {
   const char* name = luaL_checkstring(L, 1);
   Channel* channel = lovrThreadGetChannel(name);
   luax_pushtype(L, Channel, channel);
-  lovrRelease(&channel->ref);
+  lovrRelease(channel);
   return 1;
 }
 

src/api/types/controller.c

@@ -86,7 +86,7 @@ int l_lovrControllerNewModel(lua_State* L) {
   if (modelData) {
     Model* model = lovrModelCreate(modelData);
     luax_pushtype(L, Model, model);
-    lovrRelease(&model->ref);
+    lovrRelease(model);
   } else {
     lua_pushnil(L);
   }

src/api/types/transform.c

@@ -68,7 +68,7 @@ int l_lovrTransformClone(lua_State* L) {
   Transform* transform = luax_checktype(L, 1, Transform);
   Transform* clone = lovrTransformCreate(transform->matrix);
   luax_pushtype(L, Transform, clone);
-  lovrRelease(&clone->ref);
+  lovrRelease(clone);
   return 1;
 }
 
@@ -76,7 +76,7 @@ int l_lovrTransformInverse(lua_State* L) {
   Transform* transform = luax_checktype(L, 1, Transform);
   Transform* inverse = lovrTransformCreate(lovrTransformInverse(transform));
   luax_pushtype(L, Transform, inverse);
-  lovrRelease(&inverse->ref);
+  lovrRelease(inverse);
   return 1;
 }
 

src/audio/audio.c

@@ -61,14 +61,14 @@ void lovrAudioUpdate() {
     } else if (isStopped) {
       lovrAudioStreamRewind(source->stream);
       vec_splice(&state.sources, i, 1);
-      lovrRelease(&source->ref);
+      lovrRelease(source);
     }
   }
 }
 
 void lovrAudioAdd(Source* source) {
   if (!lovrAudioHas(source)) {
-    lovrRetain(&source->ref);
+    lovrRetain(source);
     vec_push(&state.sources, source);
   }
 }

src/audio/source.c

@@ -35,16 +35,16 @@ Source* lovrSourceCreate(AudioStream* stream) {
   source->isLooping = false;
   alGenSources(1, &source->id);
   alGenBuffers(SOURCE_BUFFERS, source->buffers);
-  lovrRetain(&stream->ref);
+  lovrRetain(stream);
 
   return source;
 }
 
-void lovrSourceDestroy(const Ref* ref) {
-  Source* source = (Source*) ref;
+void lovrSourceDestroy(void* ref) {
+  Source* source = ref;
   alDeleteSources(1, &source->id);
   alDeleteBuffers(SOURCE_BUFFERS, source->buffers);
-  lovrRelease(&source->stream->ref);
+  lovrRelease(source->stream);
   free(source);
 }
 

src/audio/source.h

@@ -22,7 +22,7 @@ typedef struct {
 } Source;
 
 Source* lovrSourceCreate(AudioStream* stream);
-void lovrSourceDestroy(const Ref* ref);
+void lovrSourceDestroy(void* ref);
 int lovrSourceGetBitDepth(Source* source);
 int lovrSourceGetChannelCount(Source* source);
 void lovrSourceGetCone(Source* source, float* innerAngle, float* outerAngle, float* outerGain);

src/data/audioStream.c

@@ -24,15 +24,15 @@ AudioStream* lovrAudioStreamCreate(Blob* blob, size_t bufferSize) {
   stream->bufferSize = stream->channelCount * bufferSize * sizeof(short);
   stream->buffer = malloc(stream->bufferSize);
   stream->blob = blob;
-  lovrRetain(&blob->ref);
+  lovrRetain(blob);
 
   return stream;
 }
 
-void lovrAudioStreamDestroy(const Ref* ref) {
-  AudioStream* stream = (AudioStream*) ref;
+void lovrAudioStreamDestroy(void* ref) {
+  AudioStream* stream = ref;
   stb_vorbis_close(stream->decoder);
-  lovrRelease(&stream->blob->ref);
+  lovrRelease(stream->blob);
   free(stream->buffer);
   free(stream);
 }

src/data/audioStream.h

@@ -16,7 +16,7 @@ typedef struct {
 } AudioStream;
 
 AudioStream* lovrAudioStreamCreate(Blob* blob, size_t bufferSize);
-void lovrAudioStreamDestroy(const Ref* ref);
+void lovrAudioStreamDestroy(void* ref);
 int lovrAudioStreamDecode(AudioStream* stream);
 void lovrAudioStreamRewind(AudioStream* stream);
 void lovrAudioStreamSeek(AudioStream* stream, int sample);

src/data/blob.c

@@ -12,8 +12,8 @@ Blob* lovrBlobCreate(void* data, size_t size, const char* name) {
   return blob;
 }
 
-void lovrBlobDestroy(const Ref* ref) {
-  Blob* blob = (Blob*) ref;
+void lovrBlobDestroy(void* ref) {
+  Blob* blob = ref;
   free(blob->data);
   free(blob);
 }

src/data/blob.h

@@ -11,4 +11,4 @@ typedef struct {
 } Blob;
 
 Blob* lovrBlobCreate(void* data, size_t size, const char* name);
-void lovrBlobDestroy(const Ref* ref);
+void lovrBlobDestroy(void* ref);

src/data/modelData.c

@@ -241,7 +241,7 @@ static void assimpFileClose(struct aiFileIO* io, struct aiFile* assimpFile) {
   if (assimpFile->UserData != blob) {
     File* file = (File*) assimpFile->UserData;
     lovrFileClose(file);
-    lovrRelease(&file->ref);
+    lovrRelease(file);
   }
   free(assimpFile);
 }
@@ -503,8 +503,8 @@ ModelData* lovrModelDataCreate(Blob* blob) {
   return modelData;
 }
 
-void lovrModelDataDestroy(const Ref* ref) {
-  ModelData* modelData = (ModelData*) ref;
+void lovrModelDataDestroy(void* ref) {
+  ModelData* modelData = ref;
 
   for (int i = 0; i < modelData->nodeCount; i++) {
     vec_deinit(&modelData->nodes[i].children);
@@ -529,16 +529,13 @@ void lovrModelDataDestroy(const Ref* ref) {
   }
 
   for (int i = 0; i < modelData->textures.length; i++) {
-    TextureData* textureData = modelData->textures.data[i];
-    if (textureData) {
-      lovrRelease(&textureData->ref);
-    }
+    lovrRelease(modelData->textures.data[i]);
   }
 
   vec_deinit(&modelData->textures);
   map_deinit(&modelData->nodeMap);
 
-  lovrRelease(&modelData->vertexData->ref);
+  lovrRelease(modelData->vertexData);
 
   free(modelData->nodes);
   free(modelData->primitives);

src/data/modelData.h

@@ -88,5 +88,5 @@ typedef struct {
 } ModelData;
 
 ModelData* lovrModelDataCreate(Blob* blob);
-void lovrModelDataDestroy(const Ref* ref);
+void lovrModelDataDestroy(void* ref);
 void lovrModelDataGetAABB(ModelData* modelData, float aabb[6]);

src/data/rasterizer.c

@@ -69,7 +69,7 @@ Rasterizer* lovrRasterizerCreate(Blob* blob, int size) {
   FT_Error err = FT_Err_Ok;
   if (blob) {
     err = err || FT_New_Memory_Face(ft, blob->data, blob->size, 0, &face);
-    lovrRetain(&blob->ref);
+    lovrRetain(blob);
   } else {
     err = err || FT_New_Memory_Face(ft, Cabin_ttf, Cabin_ttf_len, 0, &face);
   }
@@ -92,12 +92,10 @@ Rasterizer* lovrRasterizerCreate(Blob* blob, int size) {
   return rasterizer;
 }
 
-void lovrRasterizerDestroy(const Ref* ref) {
-  Rasterizer* rasterizer = (Rasterizer*) ref;
+void lovrRasterizerDestroy(void* ref) {
+  Rasterizer* rasterizer = ref;
   FT_Done_Face(rasterizer->ftHandle);
-  if (rasterizer->blob) {
-    lovrRelease(&rasterizer->blob->ref);
-  }
+  lovrRelease(rasterizer->blob);
   free(rasterizer);
 }
 

src/data/rasterizer.h

@@ -36,7 +36,7 @@ typedef struct {
 typedef map_t(Glyph) map_glyph_t;
 
 Rasterizer* lovrRasterizerCreate(Blob* blob, int size);
-void lovrRasterizerDestroy(const Ref* ref);
+void lovrRasterizerDestroy(void* ref);
 bool lovrRasterizerHasGlyph(Rasterizer* fontData, uint32_t character);
 bool lovrRasterizerHasGlyphs(Rasterizer* fontData, const char* str);
 void lovrRasterizerLoadGlyph(Rasterizer* fontData, uint32_t character, Glyph* glyph);

src/data/textureData.c

@@ -161,7 +161,7 @@ TextureData* lovrTextureDataFromBlob(Blob* blob) {
 
   if (!parseDDS(blob->data, blob->size, textureData)) {
     textureData->blob = blob;
-    lovrRetain(&blob->ref);
+    lovrRetain(blob);
     return textureData;
   }
 
@@ -227,11 +227,9 @@ bool lovrTextureDataEncode(TextureData* textureData, const char* filename) {
   return success;
 }
 
-void lovrTextureDataDestroy(const Ref* ref) {
-  TextureData* textureData = (TextureData*) ref;
-  if (textureData->blob) {
-    lovrRelease(&textureData->blob->ref);
-  }
+void lovrTextureDataDestroy(void* ref) {
+  TextureData* textureData = ref;
+  lovrRelease(textureData->blob);
   vec_deinit(&textureData->mipmaps);
   free(textureData->data);
   free(textureData);

src/data/textureData.h

@@ -49,4 +49,4 @@ TextureData* lovrTextureDataFromBlob(Blob* blob);
 Color lovrTextureDataGetPixel(TextureData* textureData, int x, int y);
 void lovrTextureDataSetPixel(TextureData* textureData, int x, int y, Color color);
 bool lovrTextureDataEncode(TextureData* textureData, const char* filename);
-void lovrTextureDataDestroy(const Ref* ref);
+void lovrTextureDataDestroy(void* ref);

src/data/vertexData.c

@@ -41,8 +41,8 @@ VertexData* lovrVertexDataCreate(uint32_t count, VertexFormat* format, bool allo
   return vertexData;
 }
 
-void lovrVertexDataDestroy(const Ref* ref) {
-  VertexData* vertexData = (VertexData*) ref;
+void lovrVertexDataDestroy(void* ref) {
+  VertexData* vertexData = ref;
   if (vertexData->data.raw) {
     free(vertexData->data.raw);
   }

src/data/vertexData.h

@@ -49,4 +49,4 @@ void vertexFormatInit(VertexFormat* format);
 void vertexFormatAppend(VertexFormat* format, const char* name, AttributeType type, int count);
 
 VertexData* lovrVertexDataCreate(uint32_t count, VertexFormat* format, bool allocate);
-void lovrVertexDataDestroy(const Ref* ref);
+void lovrVertexDataDestroy(void* ref);

src/filesystem/file.c

@@ -11,8 +11,8 @@ File* lovrFileCreate(const char* path) {
   return file;
 }
 
-void lovrFileDestroy(const Ref* ref) {
-  File* file = (File*) ref;
+void lovrFileDestroy(void* ref) {
+  File* file = ref;
   if (file->handle) {
     PHYSFS_close(file->handle);
   }

src/filesystem/file.h

@@ -16,7 +16,7 @@ typedef struct {
 } File;
 
 File* lovrFileCreate(const char* filename);
-void lovrFileDestroy(const Ref* ref);
+void lovrFileDestroy(void* ref);
 int lovrFileOpen(File* file, FileMode mode);
 void lovrFileClose(File* file);
 size_t lovrFileRead(File* file, void* data, size_t bytes);

src/filesystem/filesystem.c

@@ -269,6 +269,6 @@ size_t lovrFilesystemWrite(const char* path, const char* content, size_t size, b
   lovrFileOpen(file, append ? OPEN_APPEND : OPEN_WRITE);
   size_t bytesWritten = lovrFileWrite(file, (void*) content, size);
   lovrFileClose(file);
-  lovrRelease(&file->ref);
+  lovrRelease(file);
   return bytesWritten;
 }

src/graphics/animator.c

@@ -17,7 +17,7 @@ Animator* lovrAnimatorCreate(ModelData* modelData) {
   Animator* animator = lovrAlloc(sizeof(Animator), lovrAnimatorDestroy);
   if (!animator) return NULL;
 
-  lovrRetain(&modelData->ref);
+  lovrRetain(modelData);
   animator->modelData = modelData;
   map_init(&animator->trackMap);
   vec_init(&animator->trackList);
@@ -43,9 +43,9 @@ Animator* lovrAnimatorCreate(ModelData* modelData) {
   return animator;
 }
 
-void lovrAnimatorDestroy(const Ref* ref) {
-  Animator* animator = (Animator*) ref;
-  lovrRelease(&animator->modelData->ref);
+void lovrAnimatorDestroy(void* ref) {
+  Animator* animator = ref;
+  lovrRelease(animator->modelData);
   map_deinit(&animator->trackMap);
   vec_deinit(&animator->trackList);
   free(animator);

src/graphics/animator.h

@@ -27,7 +27,7 @@ typedef struct {
 } Animator;
 
 Animator* lovrAnimatorCreate(ModelData* modelData);
-void lovrAnimatorDestroy(const Ref* ref);
+void lovrAnimatorDestroy(void* ref);
 void lovrAnimatorReset(Animator* animator);
 void lovrAnimatorUpdate(Animator* animator, float dt);
 bool lovrAnimatorEvaluate(Animator* animator, const char* bone, mat4 transform);

src/graphics/canvas.c

@@ -83,8 +83,8 @@ Canvas* lovrCanvasCreate(int width, int height, TextureFormat format, int msaa,
   return canvas;
 }
 
-void lovrCanvasDestroy(const Ref* ref) {
-  Canvas* canvas = (Canvas*) ref;
+void lovrCanvasDestroy(void* ref) {
+  Canvas* canvas = ref;
   glDeleteFramebuffers(1, &canvas->framebuffer);
   if (canvas->resolveFramebuffer) {
     glDeleteFramebuffers(1, &canvas->resolveFramebuffer);

src/graphics/canvas.h

@@ -15,6 +15,6 @@ typedef struct {
 bool lovrCanvasSupportsFormat(TextureFormat format);
 
 Canvas* lovrCanvasCreate(int width, int height, TextureFormat format, int msaa, bool depth, bool stencil);
-void lovrCanvasDestroy(const Ref* ref);
+void lovrCanvasDestroy(void* ref);
 TextureFormat lovrCanvasGetFormat(Canvas* canvas);
 int lovrCanvasGetMSAA(Canvas* canvas);

src/graphics/font.c

@@ -26,7 +26,7 @@ Font* lovrFontCreate(Rasterizer* rasterizer) {
   Font* font = lovrAlloc(sizeof(Font), lovrFontDestroy);
   if (!font) return NULL;
 
-  lovrRetain(&rasterizer->ref);
+  lovrRetain(rasterizer);
   font->rasterizer = rasterizer;
   font->texture = NULL;
   font->lineHeight = 1.f;
@@ -53,10 +53,10 @@ Font* lovrFontCreate(Rasterizer* rasterizer) {
   return font;
 }
 
-void lovrFontDestroy(const Ref* ref) {
-  Font* font = (Font*) ref;
-  lovrRelease(&font->rasterizer->ref);
-  lovrRelease(&font->texture->ref);
+void lovrFontDestroy(void* ref) {
+  Font* font = ref;
+  lovrRelease(font->rasterizer);
+  lovrRelease(font->texture);
   map_deinit(&font->atlas.glyphs);
   map_deinit(&font->kerning);
   free(font);
@@ -313,10 +313,7 @@ void lovrFontExpandTexture(Font* font) {
 }
 
 void lovrFontCreateTexture(Font* font) {
-  if (font->texture) {
-    lovrRelease(&font->texture->ref);
-  }
-
+  lovrRelease(font->texture);
   int maxTextureSize = lovrGraphicsGetLimits().textureSize;
   if (font->atlas.width > maxTextureSize || font->atlas.height > maxTextureSize) {
     lovrThrow("Font texture atlas overflow: exceeded %d x %d", maxTextureSize, maxTextureSize);

src/graphics/font.h

@@ -41,7 +41,7 @@ typedef struct {
 } Font;
 
 Font* lovrFontCreate(Rasterizer* rasterizer);
-void lovrFontDestroy(const Ref* ref);
+void lovrFontDestroy(void* ref);
 void lovrFontRender(Font* font, const char* str, float wrap, HorizontalAlign halign, VerticalAlign valign, vec_float_t* vertices, float* offsety);
 float lovrFontGetWidth(Font* font, const char* string, float wrap);
 float lovrFontGetHeight(Font* font);

src/graphics/graphics.c

@@ -44,11 +44,11 @@ void lovrGraphicsDestroy() {
   lovrGraphicsSetShader(NULL);
   lovrGraphicsSetFont(NULL);
   for (int i = 0; i < DEFAULT_SHADER_COUNT; i++) {
-    if (state.defaultShaders[i]) lovrRelease(&state.defaultShaders[i]->ref);
+    lovrRelease(state.defaultShaders[i]);
   }
-  if (state.defaultMaterial) lovrRelease(&state.defaultMaterial->ref);
-  if (state.defaultFont) lovrRelease(&state.defaultFont->ref);
-  if (state.defaultTexture) lovrRelease(&state.defaultTexture->ref);
+  lovrRelease(state.defaultMaterial);
+  lovrRelease(state.defaultFont);
+  lovrRelease(state.defaultTexture);
   glDeleteVertexArrays(1, &state.streamVAO);
   glDeleteBuffers(1, &state.streamVBO);
   glDeleteBuffers(1, &state.streamIBO);
@@ -360,11 +360,11 @@ void lovrGraphicsSetCanvas(Canvas** canvas, int count) {
   }
 
   for (int i = 0; i < count; i++) {
-    lovrRetain(&canvas[i]->texture.ref);
+    lovrRetain(&canvas[i]->texture);
   }
 
   for (int i = 0; i < state.canvasCount; i++) {
-    lovrRelease(&state.canvas[i]->texture.ref);
+    lovrRelease(&state.canvas[i]->texture);
   }
 
   if (count == 0) {
@@ -458,15 +458,9 @@ Font* lovrGraphicsGetFont() {
 }
 
 void lovrGraphicsSetFont(Font* font) {
-  if (state.font) {
-    lovrRelease(&state.font->ref);
-  }
-
+  lovrRetain(font);
+  lovrRelease(state.font);
   state.font = font;
-
-  if (font) {
-    lovrRetain(&state.font->ref);
-  }
 }
 
 bool lovrGraphicsIsGammaCorrect() {
@@ -516,15 +510,9 @@ Shader* lovrGraphicsGetShader() {
 
 void lovrGraphicsSetShader(Shader* shader) {
   if (shader != state.shader) {
-    if (state.shader) {
-      lovrRelease(&state.shader->ref);
-    }
-
+    lovrRetain(shader);
+    lovrRelease(state.shader);
     state.shader = shader;
-
-    if (shader) {
-      lovrRetain(&state.shader->ref);
-    }
   }
 }
 
@@ -1238,14 +1226,11 @@ void lovrGraphicsBindTexture(Texture* texture, TextureType type, int slot) {
   }
 
   if (texture != state.textures[slot]) {
-    if (state.textures[slot]) {
-      lovrRelease(&state.textures[slot]->ref);
-    }
-
+    lovrRetain(texture);
+    lovrRelease(state.textures[slot]);
     state.textures[slot] = texture;
     glActiveTexture(GL_TEXTURE0 + slot);
     glBindTexture(type, texture->id);
-    lovrRetain(&texture->ref);
   }
 }
 

src/graphics/material.c

@@ -22,12 +22,10 @@ Material* lovrMaterialCreate(bool isDefault) {
   return material;
 }
 
-void lovrMaterialDestroy(const Ref* ref) {
-  Material* material = (Material*) ref;
+void lovrMaterialDestroy(void* ref) {
+  Material* material = ref;
   for (int i = 0; i < MAX_MATERIAL_TEXTURES; i++) {
-    if (material->textures[i]) {
-      lovrRelease(&material->textures[i]->ref);
-    }
+    lovrRelease(material->textures[i]);
   }
   free(material);
 }
@@ -54,14 +52,8 @@ Texture* lovrMaterialGetTexture(Material* material, MaterialTexture textureType)
 
 void lovrMaterialSetTexture(Material* material, MaterialTexture textureType, Texture* texture) {
   if (texture != material->textures[textureType]) {
-    if (material->textures[textureType]) {
-      lovrRelease(&material->textures[textureType]->ref);
-    }
-
+    lovrRetain(texture);
+    lovrRelease(material->textures[textureType]);
     material->textures[textureType] = texture;
-
-    if (texture) {
-      lovrRetain(&texture->ref);
-    }
   }
 }

src/graphics/material.h

@@ -36,7 +36,7 @@ typedef struct {
 } Material;
 
 Material* lovrMaterialCreate(bool isDefault);
-void lovrMaterialDestroy(const Ref* ref);
+void lovrMaterialDestroy(void* ref);
 float lovrMaterialGetScalar(Material* material, MaterialScalar scalarType);
 void lovrMaterialSetScalar(Material* material, MaterialScalar scalarType, float value);
 Color lovrMaterialGetColor(Material* material, MaterialColor colorType);

src/graphics/mesh.c

@@ -81,12 +81,10 @@ Mesh* lovrMeshCreate(uint32_t count, VertexFormat* format, MeshDrawMode drawMode
   return mesh;
 }
 
-void lovrMeshDestroy(const Ref* ref) {
-  Mesh* mesh = (Mesh*) ref;
-  if (mesh->material) {
-    lovrRelease(&mesh->material->ref);
-  }
-  lovrRelease(&mesh->vertexData->ref);
+void lovrMeshDestroy(void* ref) {
+  Mesh* mesh = ref;
+  lovrRelease(mesh->material);
+  lovrRelease(mesh->vertexData);
   glDeleteBuffers(1, &mesh->vbo);
   glDeleteBuffers(1, &mesh->ibo);
   glDeleteVertexArrays(1, &mesh->vao);
@@ -221,15 +219,9 @@ Material* lovrMeshGetMaterial(Mesh* mesh) {
 
 void lovrMeshSetMaterial(Mesh* mesh, Material* material) {
   if (mesh->material != material) {
-    if (mesh->material) {
-      lovrRelease(&mesh->material->ref);
-    }
-
+    lovrRetain(material);
+    lovrRelease(mesh->material);
     mesh->material = material;
-
-    if (material) {
-      lovrRetain(&material->ref);
-    }
   }
 }
 

src/graphics/mesh.h

@@ -46,7 +46,7 @@ typedef struct {
 } Mesh;
 
 Mesh* lovrMeshCreate(uint32_t count, VertexFormat* format, MeshDrawMode drawMode, MeshUsage usage);
-void lovrMeshDestroy(const Ref* ref);
+void lovrMeshDestroy(void* ref);
 void lovrMeshDraw(Mesh* mesh, mat4 transform, float* pose, int instances);
 VertexFormat* lovrMeshGetVertexFormat(Mesh* mesh);
 MeshDrawMode lovrMeshGetDrawMode(Mesh* mesh);

src/graphics/model.c

@@ -53,7 +53,7 @@ Model* lovrModelCreate(ModelData* modelData) {
   Model* model = lovrAlloc(sizeof(Model), lovrModelDestroy);
   if (!model) return NULL;
 
-  lovrRetain(&modelData->ref);
+  lovrRetain(modelData);
   model->modelData = modelData;
   model->aabbDirty = true;
   model->animator = NULL;
@@ -120,26 +120,20 @@ Model* lovrModelCreate(ModelData* modelData) {
   return model;
 }
 
-void lovrModelDestroy(const Ref* ref) {
-  Model* model = (Model*) ref;
+void lovrModelDestroy(void* ref) {
+  Model* model = ref;
   for (int i = 0; i < model->modelData->textures.length; i++) {
-    if (model->textures[i]) {
-      lovrRelease(&model->textures[i]->ref);
-    }
+    lovrRelease(model->textures[i]);
   }
   for (int i = 0; i < model->modelData->materialCount; i++) {
-    lovrRelease(&model->materials[i]->ref);
-  }
-  if (model->animator) {
-    lovrRelease(&model->animator->ref);
-  }
-  if (model->material) {
-    lovrRelease(&model->material->ref);
+    lovrRelease(model->materials[i]);
   }
+  lovrRelease(model->animator);
+  lovrRelease(model->material);
   free(model->textures);
   free(model->materials);
-  lovrRelease(&model->modelData->ref);
-  lovrRelease(&model->mesh->ref);
+  lovrRelease(model->modelData);
+  lovrRelease(model->mesh);
   free(model->nodeTransforms);
   free(model);
 }
@@ -185,15 +179,9 @@ Animator* lovrModelGetAnimator(Model* model) {
 
 void lovrModelSetAnimator(Model* model, Animator* animator) {
   if (model->animator != animator) {
-    if (model->animator) {
-      lovrRelease(&model->animator->ref);
-    }
-
+    lovrRetain(animator);
+    lovrRelease(model->animator);
     model->animator = animator;
-
-    if (animator) {
-      lovrRetain(&animator->ref);
-    }
   }
 }
 
@@ -207,15 +195,9 @@ Material* lovrModelGetMaterial(Model* model) {
 
 void lovrModelSetMaterial(Model* model, Material* material) {
   if (model->material != material) {
-    if (model->material) {
-      lovrRelease(&model->material->ref);
-    }
-
+    lovrRetain(material);
+    lovrRelease(model->material);
     model->material = material;
-
-    if (material) {
-      lovrRetain(&material->ref);
-    }
   }
 }
 

src/graphics/model.h

@@ -25,7 +25,7 @@ typedef struct {
 } Model;
 
 Model* lovrModelCreate(ModelData* modelData);
-void lovrModelDestroy(const Ref* ref);
+void lovrModelDestroy(void* ref);
 void lovrModelDraw(Model* model, mat4 transform, int instances);
 Animator* lovrModelGetAnimator(Model* model);
 void lovrModelSetAnimator(Model* model, Animator* animator);

src/graphics/shader.c

@@ -257,8 +257,8 @@ Shader* lovrShaderCreateDefault(DefaultShader type) {
   }
 }
 
-void lovrShaderDestroy(const Ref* ref) {
-  Shader* shader = (Shader*) ref;
+void lovrShaderDestroy(void* ref) {
+  Shader* shader = ref;
   glDeleteProgram(shader->program);
   map_deinit(&shader->uniforms);
   free(shader);

src/graphics/shader.h

@@ -64,7 +64,7 @@ typedef struct {
 
 Shader* lovrShaderCreate(const char* vertexSource, const char* fragmentSource);
 Shader* lovrShaderCreateDefault(DefaultShader type);
-void lovrShaderDestroy(const Ref* ref);
+void lovrShaderDestroy(void* ref);
 void lovrShaderBind(Shader* shader);
 int lovrShaderGetAttributeId(Shader* shader, const char* name);
 Uniform* lovrShaderGetUniform(Shader* shader, const char* name);

src/graphics/texture.c

@@ -109,12 +109,10 @@ Texture* lovrTextureCreate(TextureType type, TextureData** slices, int sliceCoun
   return texture;
 }
 
-void lovrTextureDestroy(const Ref* ref) {
-  Texture* texture = (Texture*) ref;
+void lovrTextureDestroy(void* ref) {
+  Texture* texture = ref;
   for (int i = 0; i < texture->sliceCount; i++) {
-    if (&texture->slices[i]) {
-      lovrRelease(&texture->slices[i]->ref);
-    }
+    lovrRelease(texture->slices[i]);
   }
   glDeleteTextures(1, &texture->id);
   free(texture->slices);
@@ -126,11 +124,8 @@ TextureType lovrTextureGetType(Texture* texture) {
 }
 
 void lovrTextureReplacePixels(Texture* texture, TextureData* textureData, int slice) {
-  lovrRetain(&textureData->ref);
-  if (texture->slices[slice]) {
-    lovrRelease(&texture->slices[slice]->ref);
-  }
-
+  lovrRetain(textureData);
+  lovrRelease(texture->slices[slice]);
   texture->slices[slice] = textureData;
 
   if (!texture->allocated) {

src/graphics/texture.h

@@ -55,7 +55,7 @@ GLenum lovrTextureFormatGetGLInternalFormat(TextureFormat format, bool srgb);
 bool lovrTextureFormatIsCompressed(TextureFormat format);
 
 Texture* lovrTextureCreate(TextureType type, TextureData** slices, int count, bool srgb, bool mipmaps);
-void lovrTextureDestroy(const Ref* ref);
+void lovrTextureDestroy(void* ref);
 TextureType lovrTextureGetType(Texture* texture);
 void lovrTextureReplacePixels(Texture* texture, TextureData* data, int slice);
 TextureFilter lovrTextureGetFilter(Texture* texture);

src/headset/fake.c

@@ -165,7 +165,7 @@ static bool fakeInit() {
   vec3_set(state.pos, 0, 0, 0);
 
   vec_init(&state.controllers);
-  Controller* controller = lovrAlloc(sizeof(Controller), lovrControllerDestroy);
+  Controller* controller = lovrAlloc(sizeof(Controller), free);
   controller->id = 0;
   vec_push(&state.controllers, controller);
 
@@ -181,7 +181,7 @@ static void fakeDestroy() {
   int i;
   Controller *controller;
   vec_foreach(&state.controllers, controller, i) {
-    lovrRelease(&controller->ref);
+    lovrRelease(controller);
   }
   vec_deinit(&state.controllers);
 

src/headset/headset.c

@@ -1,11 +1,6 @@
 #include "headset/headset.h"
 #include "event/event.h"
 
-void lovrControllerDestroy(const Ref* ref) {
-  Controller* controller = (Controller*) ref;
-  free(controller);
-}
-
 static HeadsetInterface* headset = NULL;
 static bool initialized = false;
 

src/headset/headset.h

@@ -128,5 +128,3 @@ void lovrHeadsetControllerVibrate(Controller* controller, float duration, float
 ModelData* lovrHeadsetControllerNewModelData(Controller* controller);
 void lovrHeadsetRenderTo(headsetRenderCallback callback, void* userdata);
 void lovrHeadsetUpdate(float dt);
-
-void lovrControllerDestroy(const Ref* ref);

src/headset/openvr.c

@@ -64,7 +64,7 @@ static Controller* openvrAddController(unsigned int deviceIndex) {
     }
   }
 
-  controller = lovrAlloc(sizeof(Controller), lovrControllerDestroy);
+  controller = lovrAlloc(sizeof(Controller), free);
   controller->id = deviceIndex;
   vec_push(&state.controllers, controller);
   return controller;
@@ -84,10 +84,10 @@ static void openvrRefreshControllers() {
       EventType type = EVENT_CONTROLLER_REMOVED;
       EventData data = { .controllerremoved = { controller } };
       Event event = { .type = type, .data = data };
-      lovrRetain(&controller->ref);
+      lovrRetain(controller);
       lovrEventPush(event);
       vec_splice(&state.controllers, i, 1);
-      lovrRelease(&controller->ref);
+      lovrRelease(controller);
     }
   }
 
@@ -99,7 +99,7 @@ static void openvrRefreshControllers() {
       EventType type = EVENT_CONTROLLER_ADDED;
       EventData data = { .controlleradded = { controller } };
       Event event = { .type = type, .data = data };
-      lovrRetain(&controller->ref);
+      lovrRetain(controller);
       lovrEventPush(event);
     }
   }
@@ -329,9 +329,7 @@ static bool openvrInit() {
 static void openvrDestroy() {
   if (!state.initialized) return;
   state.initialized = false;
-  if (state.canvas) {
-    lovrRelease(&state.canvas->texture.ref);
-  }
+  lovrRelease(&state.canvas->texture);
   for (int i = 0; i < 16; i++) {
     if (state.deviceModels[i]) {
       state.renderModels->FreeRenderModel(state.deviceModels[i]);
@@ -344,7 +342,7 @@ static void openvrDestroy() {
   }
   Controller* controller; int i;
   vec_foreach(&state.controllers, controller, i) {
-    lovrRelease(&controller->ref);
+    lovrRelease(controller);
   }
   vec_deinit(&state.controllers);
   lovrEventRemovePump(openvrPoll);
@@ -727,19 +725,11 @@ static void openvrRenderTo(headsetRenderCallback callback, void* userdata) {
     Color oldColor = lovrGraphicsGetColor();
     lovrGraphicsSetColor((Color) { 1, 1, 1, 1 });
     Shader* lastShader = lovrGraphicsGetShader();
-
-    if (lastShader) {
-      lovrRetain(&lastShader->ref);
-    }
-
+    lovrRetain(lastShader);
     lovrGraphicsSetShader(NULL);
     lovrGraphicsPlaneFullscreen(&state.canvas->texture);
     lovrGraphicsSetShader(lastShader);
-
-    if (lastShader) {
-      lovrRelease(&lastShader->ref);
-    }
-
+    lovrRelease(lastShader);
     lovrGraphicsSetColor(oldColor);
   }
 }

src/headset/webvr.c

@@ -66,7 +66,7 @@ static void webvrDestroy() {
   Controller* controller;
   int i;
   vec_foreach(&state.controllers, controller, i) {
-    lovrRelease(&controller->ref);
+    lovrRelease(controller);
   }
 
   vec_deinit(&state.controllers);
@@ -167,12 +167,12 @@ static vec_controller_t* webvrGetControllers() {
 
   while (state.controllers.length > controllerCount) {
     Controller* controller = vec_last(&state.controllers);
-    lovrRelease(&controller->ref);
+    lovrRelease(controller);
     vec_pop(&state.controllers);
   }
 
   while (state.controllers.length < controllerCount) {
-    Controller* controller = lovrAlloc(sizeof(Controller), lovrControllerDestroy);
+    Controller* controller = lovrAlloc(sizeof(Controller), free);
     controller->id = state.controllers.length;
     vec_push(&state.controllers, controller);
   }

src/math/math.c

@@ -16,7 +16,7 @@ void lovrMathInit() {
 
 void lovrMathDestroy() {
   if (!state.initialized) return;
-  lovrRandomGeneratorDestroy(&state.generator->ref);
+  lovrRelease(state.generator);
   memset(&state, 0, sizeof(MathState));
 }
 

src/math/randomGenerator.c

@@ -22,7 +22,7 @@ static uint64_t wangHash64(uint64_t key) {
 // Use an 'Xorshift*' variant, as shown here: http://xorshift.di.unimi.it
 
 RandomGenerator* lovrRandomGeneratorCreate() {
-  RandomGenerator* generator = lovrAlloc(sizeof(RandomGenerator), lovrRandomGeneratorDestroy);
+  RandomGenerator* generator = lovrAlloc(sizeof(RandomGenerator), free);
   if (!generator) return NULL;
 
   Seed seed = { .b32 = { .lo = 0xCBBF7A44, .hi = 0x0139408D } };
@@ -32,11 +32,6 @@ RandomGenerator* lovrRandomGeneratorCreate() {
   return generator;
 }
 
-void lovrRandomGeneratorDestroy(const Ref* ref) {
-  RandomGenerator* generator = (RandomGenerator*) ref;
-  free(generator);
-}
-
 Seed lovrRandomGeneratorGetSeed(RandomGenerator* generator) {
   return generator->seed;
 }

src/math/randomGenerator.h

@@ -21,7 +21,6 @@ typedef struct {
 } RandomGenerator;
 
 RandomGenerator* lovrRandomGeneratorCreate();
-void lovrRandomGeneratorDestroy(const Ref* ref);
 Seed lovrRandomGeneratorGetSeed(RandomGenerator* generator);
 void lovrRandomGeneratorSetSeed(RandomGenerator* generator, Seed seed);
 void lovrRandomGeneratorGetState(RandomGenerator* generator, char* state, size_t length);

src/math/transform.c

@@ -3,7 +3,7 @@
 #include <stdlib.h>
 
 Transform* lovrTransformCreate(mat4 transfrom) {
-  Transform* transform = lovrAlloc(sizeof(Transform), lovrTransformDestroy);
+  Transform* transform = lovrAlloc(sizeof(Transform), free);
   if (!transform) return NULL;
 
   transform->isDirty = true;
@@ -17,11 +17,6 @@ Transform* lovrTransformCreate(mat4 transfrom) {
   return transform;
 }
 
-void lovrTransformDestroy(const Ref* ref) {
-  Transform* transform = (Transform*) ref;
-  free(transform);
-}
-
 void lovrTransformGetMatrix(Transform* transform, mat4 m) {
   mat4_set(m, transform->matrix);
 }

src/math/transform.h

@@ -12,7 +12,6 @@ typedef struct Transform {
 } Transform;
 
 Transform* lovrTransformCreate(mat4 transfrom);
-void lovrTransformDestroy(const Ref* ref);
 void lovrTransformGetMatrix(Transform* transform, mat4 m);
 void lovrTransformSetMatrix(Transform* transform, mat4 m);
 void lovrTransformApply(Transform* transform, Transform* other);

src/physics/physics.c

@@ -66,8 +66,8 @@ World* lovrWorldCreate(float xg, float yg, float zg, bool allowSleep, const char
   return world;
 }
 
-void lovrWorldDestroy(const Ref* ref) {
-  World* world = (World*) ref;
+void lovrWorldDestroy(void* ref) {
+  World* world = ref;
   lovrWorldDestroyData(world);
   vec_deinit(&world->overlaps);
   free(world);
@@ -285,8 +285,8 @@ Collider* lovrColliderCreate(World* world, float x, float y, float z) {
   return collider;
 }
 
-void lovrColliderDestroy(const Ref* ref) {
-  Collider* collider = (Collider*) ref;
+void lovrColliderDestroy(void* ref) {
+  Collider* collider = ref;
   vec_deinit(&collider->shapes);
   vec_deinit(&collider->joints);
   lovrColliderDestroyData(collider);
@@ -628,8 +628,8 @@ void lovrColliderGetAABB(Collider* collider, float aabb[6]) {
   }
 }
 
-void lovrShapeDestroy(const Ref* ref) {
-  Shape* shape = (Shape*) ref;
+void lovrShapeDestroy(void* ref) {
+  Shape* shape = ref;
   lovrShapeDestroyData(shape);
   free(shape);
 }
@@ -855,8 +855,8 @@ void lovrCylinderShapeSetLength(CylinderShape* cylinder, float length) {
   dGeomCylinderSetParams(cylinder->id, lovrCylinderShapeGetRadius(cylinder), length);
 }
 
-void lovrJointDestroy(const Ref* ref) {
-  Joint* joint = (Joint*) ref;
+void lovrJointDestroy(void* ref) {
+  Joint* joint = ref;
   lovrJointDestroyData(joint);
   free(joint);
 }

src/physics/physics.h

@@ -84,7 +84,7 @@ void lovrPhysicsInit();
 void lovrPhysicsDestroy();
 
 World* lovrWorldCreate(float xg, float yg, float zg, bool allowSleep, const char** tags, int tagCount);
-void lovrWorldDestroy(const Ref* ref);
+void lovrWorldDestroy(void* ref);
 void lovrWorldDestroyData(World* world);
 void lovrWorldUpdate(World* world, float dt, CollisionResolver resolver, void* userdata);
 void lovrWorldComputeOverlaps(World* world);
@@ -105,7 +105,7 @@ int lovrWorldEnableCollisionBetween(World* world, const char* tag1, const char*
 int lovrWorldIsCollisionEnabledBetween(World* world, const char* tag1, const char* tag);
 
 Collider* lovrColliderCreate(World* world, float x, float y, float z);
-void lovrColliderDestroy(const Ref* ref);
+void lovrColliderDestroy(void* ref);
 void lovrColliderDestroyData(Collider* collider);
 World* lovrColliderGetWorld(Collider* collider);
 void lovrColliderAddShape(Collider* collider, Shape* shape);
@@ -156,7 +156,7 @@ void lovrColliderGetLinearVelocityFromLocalPoint(Collider* collider, float x, fl
 void lovrColliderGetLinearVelocityFromWorldPoint(Collider* collider, float wx, float wy, float wz, float* vx, float* vy, float* vz);
 void lovrColliderGetAABB(Collider* collider, float aabb[6]);
 
-void lovrShapeDestroy(const Ref* ref);
+void lovrShapeDestroy(void* ref);
 void lovrShapeDestroyData(Shape* shape);
 ShapeType lovrShapeGetType(Shape* shape);
 Collider* lovrShapeGetCollider(Shape* shape);
@@ -191,7 +191,7 @@ void lovrCylinderShapeSetRadius(CylinderShape* cylinder, float radius);
 float lovrCylinderShapeGetLength(CylinderShape* cylinder);
 void lovrCylinderShapeSetLength(CylinderShape* cylinder, float length);
 
-void lovrJointDestroy(const Ref* ref);
+void lovrJointDestroy(void* ref);
 void lovrJointDestroyData(Joint* joint);
 JointType lovrJointGetType(Joint* joint);
 void lovrJointGetColliders(Joint* joint, Collider** a, Collider** b);

src/thread/channel.c

@@ -16,8 +16,8 @@ Channel* lovrChannelCreate() {
   return channel;
 }
 
-void lovrChannelDestroy(const Ref* ref) {
-  Channel* channel = (Channel*) ref;
+void lovrChannelDestroy(void* ref) {
+  Channel* channel = ref;
   lovrChannelClear(channel);
   vec_deinit(&channel->messages);
   mtx_destroy(&channel->lock);
@@ -28,7 +28,7 @@ void lovrChannelDestroy(const Ref* ref) {
 bool lovrChannelPush(Channel* channel, Variant variant, double timeout, uint64_t* id) {
   mtx_lock(&channel->lock);
   if (channel->messages.length == 0) {
-    lovrRetain(&channel->ref);
+    lovrRetain(channel);
   }
   vec_insert(&channel->messages, 0, variant);
   *id = ++channel->sent;
@@ -69,7 +69,7 @@ bool lovrChannelPop(Channel* channel, Variant* variant, double timeout) {
     if (channel->messages.length > 0) {
       *variant = vec_pop(&channel->messages);
       if (channel->messages.length == 0) {
-        lovrRelease(&channel->ref);
+        lovrRelease(channel);
       }
       channel->received++;
       cnd_broadcast(&channel->cond);

src/thread/channel.h

@@ -39,7 +39,7 @@ typedef struct {
 } Channel;
 
 Channel* lovrChannelCreate();
-void lovrChannelDestroy(const Ref* ref);
+void lovrChannelDestroy(void* ref);
 bool lovrChannelPush(Channel* channel, Variant variant, double timeout, uint64_t* id);
 bool lovrChannelPop(Channel* channel, Variant* variant, double timeout);
 bool lovrChannelPeek(Channel* channel, Variant* variant);

src/thread/thread.c

@@ -42,8 +42,8 @@ Thread* lovrThreadCreate(int (*runner)(void*), const char* body) {
   return thread;
 }
 
-void lovrThreadDestroy(const Ref* ref) {
-  Thread* thread = (Thread*) ref;
+void lovrThreadDestroy(void* ref) {
+  Thread* thread = ref;
   mtx_destroy(&thread->lock);
   thrd_detach(thread->handle);
   free(thread);

src/thread/thread.h

@@ -26,7 +26,7 @@ void lovrThreadDeinit();
 Channel* lovrThreadGetChannel(const char* name);
 
 Thread* lovrThreadCreate(int (*runner)(void*), const char* body);
-void lovrThreadDestroy(const Ref* ref);
+void lovrThreadDestroy(void* ref);
 void lovrThreadStart(Thread* thread);
 void lovrThreadWait(Thread* thread);
 const char* lovrThreadGetError(Thread* thread);

src/util.c

@@ -34,19 +34,20 @@ void lovrSleep(double seconds) {
 #endif
 }
 
-void* lovrAlloc(size_t size, void (*destructor)(const Ref* ref)) {
+void* lovrAlloc(size_t size, void (*destructor)(void* object)) {
   void* object = malloc(size);
   if (!object) return NULL;
   *((Ref*) object) = (Ref) { destructor, 1 };
   return object;
 }
 
-void lovrRetain(const Ref* ref) {
-  ((Ref*) ref)->count++;
+void lovrRetain(void* object) {
+  if (object) ((Ref*) object)->count++;
 }
 
-void lovrRelease(const Ref* ref) {
-  if (--((Ref*) ref)->count == 0 && ref->free) ref->free(ref);
+void lovrRelease(void* object) {
+  Ref* ref = object;
+  if (ref && --ref->count == 0) ref->free(object);
 }
 
 // https://github.com/starwing/luautf8

src/util.h

@@ -11,7 +11,7 @@
 typedef vec_t(unsigned int) vec_uint_t;
 
 typedef struct ref {
-  void (*free)(const struct ref* ref);
+  void (*free)(void* object);
   int count;
 } Ref;
 
@@ -24,7 +24,7 @@ extern _Thread_local jmp_buf* lovrCatch;
 
 void lovrThrow(const char* format, ...);
 void lovrSleep(double seconds);
-void* lovrAlloc(size_t size, void (*destructor)(const Ref* ref));
-void lovrRetain(const Ref* ref);
-void lovrRelease(const Ref* ref);
+void* lovrAlloc(size_t size, void (*destructor)(void* object));
+void lovrRetain(void* object);
+void lovrRelease(void* object);
 size_t utf8_decode(const char *s, const char *e, unsigned *pch);