Make lovrRelease non-generic;

We know what type we're releasing 99% of the time, we don't need to
play a guessing game in lovrRelease, just have the caller say which
destructor to use.

There is lovrGenericRelease for situations where we need it, which
does the slower lookup of the destructor.

src/api/audio.c

@@ -112,7 +112,7 @@ static int l_lovrAudioNewMicrophone(lua_State* L) {
   int channelCount = luaL_optinteger(L, 5, 1);
   Microphone* microphone = lovrMicrophoneCreate(name, samples, sampleRate, bitDepth, channelCount);
   luax_pushobject(L, microphone);
-  lovrRelease(microphone);
+  lovrRelease(Microphone, microphone);
   return 1;
 }
 
@@ -131,12 +131,12 @@ static int l_lovrAudioNewSource(lua_State* L) {
       } else {
         Blob* blob = luax_readblob(L, 1, "Source");
         soundData = lovrSoundDataCreateFromBlob(blob);
-        lovrRelease(blob);
+        lovrRelease(Blob, blob);
       }
 
       lovrAssert(soundData, "Could not create static Source");
       source = lovrSourceCreateStatic(soundData);
-      lovrRelease(soundData);
+      lovrRelease(SoundData, soundData);
     }
   } else {
     if (stream) {
@@ -146,13 +146,13 @@ static int l_lovrAudioNewSource(lua_State* L) {
       stream = lovrAudioStreamCreate(blob, 4096);
       lovrAssert(stream, "Could not create stream Source");
       source = lovrSourceCreateStream(stream);
-      lovrRelease(blob);
-      lovrRelease(stream);
+      lovrRelease(Blob, blob);
+      lovrRelease(AudioStream, stream);
     }
   }
 
   luax_pushobject(L, source);
-  lovrRelease(source);
+  lovrRelease(Source, source);
   return 1;
 }
 

src/api/data.c

@@ -31,7 +31,7 @@ static int l_lovrDataNewBlob(lua_State* L) {
   const char* name = luaL_optstring(L, 2, "");
   Blob* blob = lovrBlobCreate(data, size, name);
   luax_pushobject(L, blob);
-  lovrRelease(blob);
+  lovrRelease(Blob, blob);
   return 1;
 }
 
@@ -40,8 +40,8 @@ static int l_lovrDataNewAudioStream(lua_State* L) {
   int bufferSize = luaL_optinteger(L, 2, 4096);
   AudioStream* stream = lovrAudioStreamCreate(blob, bufferSize);
   luax_pushobject(L, stream);
-  lovrRelease(blob);
-  lovrRelease(stream);
+  lovrRelease(Blob, blob);
+  lovrRelease(AudioStream, stream);
   return 1;
 }
 
@@ -49,8 +49,8 @@ static int l_lovrDataNewModelData(lua_State* L) {
   Blob* blob = luax_readblob(L, 1, "Model");
   ModelData* modelData = lovrModelDataCreate(blob);
   luax_pushobject(L, modelData);
-  lovrRelease(blob);
-  lovrRelease(modelData);
+  lovrRelease(Blob, blob);
+  lovrRelease(ModelData, modelData);
   return 1;
 }
 
@@ -67,8 +67,8 @@ static int l_lovrDataNewRasterizer(lua_State* L) {
 
   Rasterizer* rasterizer = lovrRasterizerCreate(blob, size);
   luax_pushobject(L, rasterizer);
-  lovrRelease(blob);
-  lovrRelease(rasterizer);
+  lovrRelease(Blob, blob);
+  lovrRelease(Rasterizer, rasterizer);
   return 1;
 }
 
@@ -80,7 +80,7 @@ static int l_lovrDataNewSoundData(lua_State* L) {
     int channelCount = luaL_optinteger(L, 4, 2);
     SoundData* soundData = lovrSoundDataCreate(samples, sampleRate, bitDepth, channelCount);
     luax_pushobject(L, soundData);
-    lovrRelease(soundData);
+    lovrRelease(SoundData, soundData);
     return 1;
   }
 
@@ -88,15 +88,15 @@ static int l_lovrDataNewSoundData(lua_State* L) {
   if (audioStream) {
     SoundData* soundData = lovrSoundDataCreateFromAudioStream(audioStream);
     luax_pushobject(L, soundData);
-    lovrRelease(soundData);
+    lovrRelease(SoundData, soundData);
     return 1;
   }
 
   Blob* blob = luax_readblob(L, 1, "SoundData");
   SoundData* soundData = lovrSoundDataCreateFromBlob(blob);
   luax_pushobject(L, soundData);
-  lovrRelease(blob);
-  lovrRelease(soundData);
+  lovrRelease(Blob, blob);
+  lovrRelease(SoundData, soundData);
   return 1;
 }
 
@@ -111,11 +111,11 @@ static int l_lovrDataNewTextureData(lua_State* L) {
     Blob* blob = luax_readblob(L, 1, "Texture");
     bool flip = lua_isnoneornil(L, 2) ? true : lua_toboolean(L, 2);
     textureData = lovrTextureDataCreateFromBlob(blob, flip);
-    lovrRelease(blob);
+    lovrRelease(Blob, blob);
   }
 
   luax_pushobject(L, textureData);
-  lovrRelease(textureData);
+  lovrRelease(TextureData, textureData);
   return 1;
 }
 

src/api/event.c

@@ -104,7 +104,7 @@ static int nextEvent(lua_State* L) {
     case EVENT_CONTROLLER_ADDED:
     case EVENT_CONTROLLER_REMOVED:
       luax_pushobject(L, event.data.controller.controller);
-      lovrRelease(event.data.controller.controller);
+      lovrRelease(Controller, event.data.controller.controller);
       return 2;
 
     case EVENT_CONTROLLER_PRESSED:

src/api/filesystem.c

@@ -281,7 +281,7 @@ static int l_lovrFilesystemNewBlob(lua_State* L) {
   lovrAssert(data, "Could not load file '%s'", path);
   Blob* blob = lovrBlobCreate((void*) data, size, path);
   luax_pushobject(L, blob);
-  lovrRelease(blob);
+  lovrRelease(Blob, blob);
   return 1;
 }
 

src/api/graphics.c

@@ -275,7 +275,7 @@ static TextureData* luax_checktexturedata(lua_State* L, int index, bool flip) {
   if (!textureData) {
     Blob* blob = luax_readblob(L, index, "Texture");
     textureData = lovrTextureDataCreateFromBlob(blob, flip);
-    lovrRelease(blob);
+    lovrRelease(Blob, blob);
   }
 
   return textureData;
@@ -324,7 +324,7 @@ static int l_lovrGraphicsCreateWindow(lua_State* L) {
 
   lovrGraphicsCreateWindow(&flags);
   luax_atexit(L, lovrGraphicsDestroy); // The lua_State that creates the window shall be the one to destroy it
-  lovrRelease(textureData);
+  lovrRelease(TextureData, textureData);
   return 0;
 }
 
@@ -908,7 +908,7 @@ static int l_lovrGraphicsNewAnimator(lua_State* L) {
   Model* model = luax_checktype(L, 1, Model);
   Animator* animator = lovrAnimatorCreate(model->data);
   luax_pushobject(L, animator);
-  lovrRelease(animator);
+  lovrRelease(Animator, animator);
   return 1;
 }
 
@@ -967,8 +967,8 @@ static int l_lovrGraphicsNewShaderBlock(lua_State* L) {
   ShaderBlock* block = lovrShaderBlockCreate(type, buffer, &uniforms);
   luax_pushobject(L, block);
   vec_deinit(&uniforms);
-  lovrRelease(buffer);
-  lovrRelease(block);
+  lovrRelease(Buffer, buffer);
+  lovrRelease(ShaderBlock, block);
   return 1;
 }
 
@@ -1061,12 +1061,12 @@ static int l_lovrGraphicsNewCanvas(lua_State* L) {
   if (attachmentCount > 0) {
     lovrCanvasSetAttachments(canvas, attachments, attachmentCount);
     if (anonymous) {
-      lovrRelease(attachments[0].texture);
+      lovrRelease(Texture, attachments[0].texture);
     }
   }
 
   luax_pushobject(L, canvas);
-  lovrRelease(canvas);
+  lovrRelease(Canvas, canvas);
   return 1;
 }
 
@@ -1085,13 +1085,13 @@ static int l_lovrGraphicsNewFont(lua_State* L) {
     }
 
     rasterizer = lovrRasterizerCreate(blob, size);
-    lovrRelease(blob);
+    lovrRelease(Blob, blob);
   }
 
   Font* font = lovrFontCreate(rasterizer);
   luax_pushobject(L, font);
-  lovrRelease(rasterizer);
-  lovrRelease(font);
+  lovrRelease(Rasterizer, rasterizer);
+  lovrRelease(Font, font);
   return 1;
 }
 
@@ -1105,9 +1105,9 @@ static int l_lovrGraphicsNewMaterial(lua_State* L) {
     TextureData* textureData = lovrTextureDataCreateFromBlob(blob, true);
     Texture* texture = lovrTextureCreate(TEXTURE_2D, &textureData, 1, true, true, 0);
     lovrMaterialSetTexture(material, TEXTURE_DIFFUSE, texture);
-    lovrRelease(blob);
-    lovrRelease(textureData);
-    lovrRelease(texture);
+    lovrRelease(Blob, blob);
+    lovrRelease(TextureData, textureData);
+    lovrRelease(Texture, texture);
   } else if (lua_isuserdata(L, index)) {
     Texture* texture = luax_checktexture(L, index);
     lovrMaterialSetTexture(material, TEXTURE_DIFFUSE, texture);
@@ -1120,7 +1120,7 @@ static int l_lovrGraphicsNewMaterial(lua_State* L) {
   }
 
   luax_pushobject(L, material);
-  lovrRelease(material);
+  lovrRelease(Material, material);
   return 1;
 }
 
@@ -1258,10 +1258,10 @@ static int l_lovrGraphicsNewMesh(lua_State* L) {
   }
 
   lovrBufferMarkRange(vertexBuffer, 0, count * stride);
-  lovrRelease(vertexBuffer);
+  lovrRelease(Buffer, vertexBuffer);
 
   luax_pushobject(L, mesh);
-  lovrRelease(mesh);
+  lovrRelease(Mesh, mesh);
   return 1;
 }
 
@@ -1271,13 +1271,13 @@ static int l_lovrGraphicsNewModel(lua_State* L) {
   if (!modelData) {
     Blob* blob = luax_readblob(L, 1, "Model");
     modelData = lovrModelDataCreate(blob);
-    lovrRelease(blob);
+    lovrRelease(Blob, blob);
   }
 
   Model* model = lovrModelCreate(modelData);
   luax_pushobject(L, model);
-  lovrRelease(modelData);
-  lovrRelease(model);
+  lovrRelease(ModelData, modelData);
+  lovrRelease(Model, model);
   return 1;
 }
 
@@ -1313,7 +1313,7 @@ static int l_lovrGraphicsNewShader(lua_State* L) {
   const char* fragmentSource = lua_tostring(L, 2);
   Shader* shader = lovrShaderCreateGraphics(vertexSource, fragmentSource);
   luax_pushobject(L, shader);
-  lovrRelease(shader);
+  lovrRelease(Shader, shader);
   return 1;
 }
 
@@ -1322,7 +1322,7 @@ static int l_lovrGraphicsNewComputeShader(lua_State* L) {
   const char* source = lua_tostring(L, 1);
   Shader* shader = lovrShaderCreateCompute(source);
   luax_pushobject(L, shader);
-  lovrRelease(shader);
+  lovrRelease(Shader, shader);
   return 1;
 }
 
@@ -1402,13 +1402,13 @@ static int l_lovrGraphicsNewTexture(lua_State* L) {
         lovrTextureAllocate(texture, textureData->width, textureData->height, depth, textureData->format);
       }
       lovrTextureReplacePixels(texture, textureData, 0, 0, i, 0);
-      lovrRelease(textureData);
+      lovrRelease(TextureData, textureData);
       lua_pop(L, 1);
     }
   }
 
   luax_pushobject(L, texture);
-  lovrRelease(texture);
+  lovrRelease(Texture, texture);
   return 1;
 }
 

src/api/math.c

@@ -103,7 +103,7 @@ static int l_lovrMathNewCurve(lua_State* L) {
   }
 
   luax_pushobject(L, curve);
-  lovrRelease(curve);
+  lovrRelease(Curve, curve);
   return 1;
 }
 
@@ -111,7 +111,7 @@ static int l_lovrMathNewPool(lua_State* L) {
   size_t size = luaL_optinteger(L, 1, DEFAULT_POOL_SIZE);
   Pool* pool = lovrPoolCreate(size);
   luax_pushobject(L, pool);
-  lovrRelease(pool);
+  lovrRelease(Pool, pool);
   return 1;
 }
 
@@ -122,7 +122,7 @@ static int l_lovrMathNewRandomGenerator(lua_State* L) {
     lovrRandomGeneratorSetSeed(generator, seed);
   }
   luax_pushobject(L, generator);
-  lovrRelease(generator);
+  lovrRelease(RandomGenerator, generator);
   return 1;
 }
 

src/api/physics.c

@@ -40,7 +40,7 @@ static int l_lovrPhysicsNewWorld(lua_State* L) {
   }
   World* world = lovrWorldCreate(xg, yg, zg, allowSleep, tags, tagCount);
   luax_pushobject(L, world);
-  lovrRelease(world);
+  lovrRelease(World, world);
   return 1;
 }
 
@@ -52,7 +52,7 @@ static int l_lovrPhysicsNewBallJoint(lua_State* L) {
   float z = luax_checkfloat(L, 5);
   BallJoint* joint = lovrBallJointCreate(a, b, x, y, z);
   luax_pushobject(L, joint);
-  lovrRelease(joint);
+  lovrRelease(Joint, joint);
   return 1;
 }
 
@@ -62,7 +62,7 @@ static int l_lovrPhysicsNewBoxShape(lua_State* L) {
   float z = luax_optfloat(L, 3, x);
   BoxShape* box = lovrBoxShapeCreate(x, y, z);
   luax_pushobject(L, box);
-  lovrRelease(box);
+  lovrRelease(Shape, box);
   return 1;
 }
 
@@ -71,7 +71,7 @@ static int l_lovrPhysicsNewCapsuleShape(lua_State* L) {
   float length = luax_optfloat(L, 2, 1.f);
   CapsuleShape* capsule = lovrCapsuleShapeCreate(radius, length);
   luax_pushobject(L, capsule);
-  lovrRelease(capsule);
+  lovrRelease(Shape, capsule);
   return 1;
 }
 
@@ -80,7 +80,7 @@ static int l_lovrPhysicsNewCylinderShape(lua_State* L) {
   float length = luax_optfloat(L, 2, 1.f);
   CylinderShape* cylinder = lovrCylinderShapeCreate(radius, length);
   luax_pushobject(L, cylinder);
-  lovrRelease(cylinder);
+  lovrRelease(Shape, cylinder);
   return 1;
 }
 
@@ -95,7 +95,7 @@ static int l_lovrPhysicsNewDistanceJoint(lua_State* L) {
   float z2 = luax_checkfloat(L, 8);
   DistanceJoint* joint = lovrDistanceJointCreate(a, b, x1, y1, z1, x2, y2, z2);
   luax_pushobject(L, joint);
-  lovrRelease(joint);
+  lovrRelease(Joint, joint);
   return 1;
 }
 
@@ -110,7 +110,7 @@ static int l_lovrPhysicsNewHingeJoint(lua_State* L) {
   float az = luax_checkfloat(L, 8);
   HingeJoint* joint = lovrHingeJointCreate(a, b, x, y, z, ax, ay, az);
   luax_pushobject(L, joint);
-  lovrRelease(joint);
+  lovrRelease(Joint, joint);
   return 1;
 }
 
@@ -122,7 +122,7 @@ static int l_lovrPhysicsNewSliderJoint(lua_State* L) {
   float az = luax_checkfloat(L, 5);
   SliderJoint* joint = lovrSliderJointCreate(a, b, ax, ay, az);
   luax_pushobject(L, joint);
-  lovrRelease(joint);
+  lovrRelease(Joint, joint);
   return 1;
 }
 
@@ -130,7 +130,7 @@ static int l_lovrPhysicsNewSphereShape(lua_State* L) {
   float radius = luax_optfloat(L, 1, 1.f);
   SphereShape* sphere = lovrSphereShapeCreate(radius);
   luax_pushobject(L, sphere);
-  lovrRelease(sphere);
+  lovrRelease(Shape, sphere);
   return 1;
 }
 

src/api/thread.c

@@ -28,7 +28,7 @@ static int threadRunner(void* data) {
   mtx_lock(&thread->lock);
   thread->running = false;
   mtx_unlock(&thread->lock);
-  lovrRelease(thread);
+  lovrRelease(Thread, thread);
 
   if (thread->error) {
     lovrEventPush((Event) {
@@ -47,7 +47,7 @@ static int l_lovrThreadNewThread(lua_State* L) {
   const char* body = luaL_checkstring(L, 1);
   Thread* thread = lovrThreadCreate(threadRunner, body);
   luax_pushobject(L, thread);
-  lovrRelease(thread);
+  lovrRelease(Thread, thread);
   return 1;
 }
 

src/api/types/audioStream.c

@@ -9,7 +9,7 @@ static int l_lovrAudioStreamDecode(lua_State* L) {
     SoundData* soundData = lovrSoundDataCreate(samples / stream->channelCount, stream->sampleRate, stream->bitDepth, stream->channelCount);
     memcpy(soundData->blob.data, stream->buffer, samples * (stream->bitDepth / 8));
     luax_pushobject(L, soundData);
-    lovrRelease(soundData);
+    lovrRelease(SoundData, soundData);
   } else {
     lua_pushnil(L);
   }

src/api/types/canvas.c

@@ -67,7 +67,7 @@ static int l_lovrCanvasNewTextureData(lua_State* L) {
   lovrAssert(index >= 0 && index < count, "Can not create a TextureData from Texture #%d of Canvas (it only has %d textures)", index, count);
   TextureData* textureData = lovrCanvasNewTextureData(canvas, index);
   luax_pushobject(L, textureData);
-  lovrRelease(textureData);
+  lovrRelease(TextureData, textureData);
   return 1;
 }
 

src/api/types/controller.c

@@ -107,8 +107,8 @@ static int l_lovrControllerNewModel(lua_State* L) {
   if (modelData) {
     Model* model = lovrModelCreate(modelData);
     luax_pushobject(L, model);
-    lovrRelease(modelData);
-    lovrRelease(model);
+    lovrRelease(ModelData, modelData);
+    lovrRelease(Model, model);
   } else {
     lua_pushnil(L);
   }

src/api/types/microphone.c

@@ -17,7 +17,7 @@ static int l_lovrMicrophoneGetData(lua_State* L) {
   Microphone* microphone = luax_checktype(L, 1, Microphone);
   SoundData* soundData = lovrMicrophoneGetData(microphone);
   luax_pushobject(L, soundData);
-  lovrRelease(soundData);
+  lovrRelease(SoundData, soundData);
   return 1;
 }
 

src/api/types/world.c

@@ -44,7 +44,7 @@ static int l_lovrWorldNewCollider(lua_State* L) {
   float z = luax_optfloat(L, 4, 0.f);
   Collider* collider = lovrColliderCreate(world, x, y, z);
   luax_pushobject(L, collider);
-  lovrRelease(collider);
+  lovrRelease(Collider, collider);
   return 1;
 }
 
@@ -60,8 +60,8 @@ static int l_lovrWorldNewBoxCollider(lua_State* L) {
   BoxShape* shape = lovrBoxShapeCreate(sx, sy, sz);
   lovrColliderAddShape(collider, shape);
   luax_pushobject(L, collider);
-  lovrRelease(collider);
-  lovrRelease(shape);
+  lovrRelease(Collider, collider);
+  lovrRelease(Shape, shape);
   return 1;
 }
 
@@ -76,8 +76,8 @@ static int l_lovrWorldNewCapsuleCollider(lua_State* L) {
   CapsuleShape* shape = lovrCapsuleShapeCreate(radius, length);
   lovrColliderAddShape(collider, shape);
   luax_pushobject(L, collider);
-  lovrRelease(collider);
-  lovrRelease(shape);
+  lovrRelease(Collider, collider);
+  lovrRelease(Shape, shape);
   return 1;
 }
 
@@ -92,8 +92,8 @@ static int l_lovrWorldNewCylinderCollider(lua_State* L) {
   CylinderShape* shape = lovrCylinderShapeCreate(radius, length);
   lovrColliderAddShape(collider, shape);
   luax_pushobject(L, collider);
-  lovrRelease(collider);
-  lovrRelease(shape);
+  lovrRelease(Collider, collider);
+  lovrRelease(Shape, shape);
   return 1;
 }
 
@@ -107,8 +107,8 @@ static int l_lovrWorldNewSphereCollider(lua_State* L) {
   SphereShape* shape = lovrSphereShapeCreate(radius);
   lovrColliderAddShape(collider, shape);
   luax_pushobject(L, collider);
-  lovrRelease(collider);
-  lovrRelease(shape);
+  lovrRelease(Collider, collider);
+  lovrRelease(Shape, shape);
   return 1;
 }
 

src/audio/audio.c

@@ -52,7 +52,7 @@ void lovrAudioDestroy() {
   alcDestroyContext(state.context);
   alcCloseDevice(state.device);
   for (int i = 0; i < state.sources.length; i++) {
-    lovrRelease(state.sources.data[i]);
+    lovrRelease(Source, state.sources.data[i]);
   }
   vec_deinit(&state.sources);
   memset(&state, 0, sizeof(AudioState));
@@ -79,7 +79,7 @@ void lovrAudioUpdate() {
     } else if (isStopped) {
       lovrAudioStreamRewind(source->stream);
       vec_splice(&state.sources, i, 1);
-      lovrRelease(source);
+      lovrRelease(Source, source);
     }
   }
 }

src/audio/source.c

@@ -35,8 +35,8 @@ void lovrSourceDestroy(void* ref) {
   Source* source = ref;
   alDeleteSources(1, &source->id);
   alDeleteBuffers(source->type == SOURCE_STATIC ? 1 : SOURCE_BUFFERS, source->buffers);
-  lovrRelease(source->soundData);
-  lovrRelease(source->stream);
+  lovrRelease(SoundData, source->soundData);
+  lovrRelease(AudioStream, source->stream);
 }
 
 SourceType lovrSourceGetType(Source* source) {

src/data/audioStream.c

@@ -26,7 +26,7 @@ AudioStream* lovrAudioStreamInit(AudioStream* stream, Blob* blob, int bufferSize
 void lovrAudioStreamDestroy(void* ref) {
   AudioStream* stream = ref;
   stb_vorbis_close(stream->decoder);
-  lovrRelease(stream->blob);
+  lovrRelease(Blob, stream->blob);
   free(stream->buffer);
 }
 

src/data/modelData.c

@@ -14,10 +14,10 @@ ModelData* lovrModelDataInit(ModelData* model, Blob* source) {
 void lovrModelDataDestroy(void* ref) {
   ModelData* model = ref;
   for (int i = 0; i < model->blobCount; i++) {
-    lovrRelease(model->blobs[i]);
+    lovrRelease(Blob, model->blobs[i]);
   }
   for (int i = 0; i < model->textureCount; i++) {
-    lovrRelease(model->textures[i]);
+    lovrRelease(TextureData, model->textures[i]);
   }
   free(model->data);
 }

src/data/modelData_gltf.c

@@ -600,7 +600,7 @@ ModelData* lovrModelDataInitGltf(ModelData* model, Blob* source) {
           Blob* blob = lovrBlobCreate(buffer->data, buffer->size, NULL);
           *texture = lovrTextureDataCreateFromBlob(blob, false);
           blob->data = NULL; // XXX Blob data ownership
-          lovrRelease(blob);
+          lovrRelease(Blob, blob);
         } else if (STR_EQ(key, "uri")) {
           size_t size = 0;
           gltfString uri = NOM_STR(json, token);
@@ -611,7 +611,7 @@ ModelData* lovrModelDataInitGltf(ModelData* model, Blob* source) {
           lovrAssert(data && size > 0, "Unable to read texture from '%s'", filename);
           Blob* blob = lovrBlobCreate(data, size, NULL);
           *texture = lovrTextureDataCreateFromBlob(blob, false);
-          lovrRelease(blob);
+          lovrRelease(Blob, blob);
           *root = '\0';
         } else {
           token += NOM_VALUE(json, token);

src/data/modelData_obj.c

@@ -66,7 +66,7 @@ static void parseMtl(char* path, vec_void_t* textures, vec_material_t* materials
       material->filters[TEXTURE_DIFFUSE].mode = FILTER_TRILINEAR;
       material->wraps[TEXTURE_DIFFUSE] = (TextureWrap) { .s = WRAP_REPEAT, .t = WRAP_REPEAT };
       vec_push(textures, texture);
-      lovrRelease(blob);
+      lovrRelease(Blob, blob);
     } else {
       char* newline = memchr(s, '\n', length);
       lineLength = newline - s + 1;

src/data/rasterizer.c

@@ -33,7 +33,7 @@ Rasterizer* lovrRasterizerInit(Rasterizer* rasterizer, Blob* blob, float size) {
 
 void lovrRasterizerDestroy(void* ref) {
   Rasterizer* rasterizer = ref;
-  lovrRelease(rasterizer->blob);
+  lovrRelease(Blob, rasterizer->blob);
 }
 
 bool lovrRasterizerHasGlyph(Rasterizer* rasterizer, uint32_t character) {

src/data/textureData.c

@@ -259,7 +259,7 @@ bool lovrTextureDataEncode(TextureData* textureData, const char* filename) {
 
 void lovrTextureDataDestroy(void* ref) {
   TextureData* textureData = ref;
-  lovrRelease(textureData->source);
+  lovrRelease(Blob, textureData->source);
   vec_deinit(&textureData->mipmaps);
   lovrBlobDestroy(ref);
 }

src/event/event.c

@@ -8,7 +8,7 @@ static EventState state;
 void lovrVariantDestroy(Variant* variant) {
   switch (variant->type) {
     case TYPE_STRING: free(variant->value.string); return;
-    case TYPE_OBJECT: lovrRelease(variant->value.ref); return;
+    case TYPE_OBJECT: lovrGenericRelease(variant->value.ref); return;
     default: return;
   }
 }

src/graphics/animator.c

@@ -34,7 +34,7 @@ Animator* lovrAnimatorInit(Animator* animator, ModelData* data) {
 
 void lovrAnimatorDestroy(void* ref) {
   Animator* animator = ref;
-  lovrRelease(animator->data);
+  lovrRelease(ModelData, animator->data);
   vec_deinit(&animator->tracks);
 }
 

src/graphics/canvas.c

@@ -34,7 +34,7 @@ void lovrCanvasSetAttachments(Canvas* canvas, Attachment* attachments, int count
   }
 
   for (int i = 0; i < canvas->attachmentCount; i++) {
-    lovrRelease(canvas->attachments[i].texture);
+    lovrRelease(Texture, canvas->attachments[i].texture);
   }
 
   memcpy(canvas->attachments, attachments, count * sizeof(Attachment));

src/graphics/font.c

@@ -51,13 +51,13 @@ Font* lovrFontInit(Font* font, Rasterizer* rasterizer) {
 
 void lovrFontDestroy(void* ref) {
   Font* font = ref;
-  lovrRelease(font->rasterizer);
-  lovrRelease(font->texture);
+  lovrRelease(Rasterizer, font->rasterizer);
+  lovrRelease(Texture, font->texture);
   const char* key;
   map_iter_t iter = map_iter(&font->atlas.glyphs);
   while ((key = map_next(&font->atlas.glyphs, &iter)) != NULL) {
     Glyph* glyph = map_get(&font->atlas.glyphs, key);
-    lovrRelease(glyph->data);
+    lovrRelease(TextureData, glyph->data);
   }
   map_deinit(&font->atlas.glyphs);
   map_deinit(&font->kerning);
@@ -342,10 +342,10 @@ void lovrFontExpandTexture(Font* font) {
 // TODO we only need the TextureData here to clear the texture, but it's a big waste of memory.
 // Could look into using glClearTexImage when supported to make this more efficient.
 void lovrFontCreateTexture(Font* font) {
-  lovrRelease(font->texture);
+  lovrRelease(Texture, font->texture);
   TextureData* textureData = lovrTextureDataCreate(font->atlas.width, font->atlas.height, 0x0, FORMAT_RGB);
   font->texture = lovrTextureCreate(TEXTURE_2D, &textureData, 1, false, false, 0);
   lovrTextureSetFilter(font->texture, (TextureFilter) { .mode = FILTER_BILINEAR });
   lovrTextureSetWrap(font->texture, (TextureWrap) { .s = WRAP_CLAMP, .t = WRAP_CLAMP });
-  lovrRelease(textureData);
+  lovrRelease(TextureData, textureData);
 }

src/graphics/graphics.c

@@ -160,19 +160,19 @@ void lovrGraphicsDestroy() {
   lovrGraphicsSetFont(NULL);
   lovrGraphicsSetCanvas(NULL);
   for (int i = 0; i < MAX_DEFAULT_SHADERS; i++) {
-    lovrRelease(state.defaultShaders[i]);
+    lovrRelease(Shader, state.defaultShaders[i]);
   }
   for (int i = 0; i < MAX_BUFFER_ROLES; i++) {
-    lovrRelease(state.buffers[i]);
+    lovrRelease(Buffer, state.buffers[i]);
     for (int j = 0; j < MAX_LOCKS; j++) {
       lovrGpuDestroyLock(state.locks[i][j]);
     }
   }
-  lovrRelease(state.mesh);
-  lovrRelease(state.instancedMesh);
-  lovrRelease(state.identityBuffer);
-  lovrRelease(state.defaultMaterial);
-  lovrRelease(state.defaultFont);
+  lovrRelease(Mesh, state.mesh);
+  lovrRelease(Mesh, state.instancedMesh);
+  lovrRelease(Buffer, state.identityBuffer);
+  lovrRelease(Material, state.defaultMaterial);
+  lovrRelease(Font, state.defaultFont);
   lovrGpuDestroy();
   memset(&state, 0, sizeof(GraphicsState));
 }
@@ -306,7 +306,7 @@ void lovrGraphicsSetCanvas(Canvas* canvas) {
   }
 
   lovrRetain(canvas);
-  lovrRelease(state.canvas);
+  lovrRelease(Canvas, state.canvas);
   state.canvas = canvas;
 }
 
@@ -349,7 +349,7 @@ Font* lovrGraphicsGetFont() {
     if (!state.defaultFont) {
       Rasterizer* rasterizer = lovrRasterizerCreate(NULL, 32);
       state.defaultFont = lovrFontCreate(rasterizer);
-      lovrRelease(rasterizer);
+      lovrRelease(Rasterizer, rasterizer);
     }
 
     lovrGraphicsSetFont(state.defaultFont);
@@ -360,7 +360,7 @@ Font* lovrGraphicsGetFont() {
 
 void lovrGraphicsSetFont(Font* font) {
   lovrRetain(font);
-  lovrRelease(state.font);
+  lovrRelease(Font, state.font);
   state.font = font;
 }
 
@@ -392,7 +392,7 @@ Shader* lovrGraphicsGetShader() {
 void lovrGraphicsSetShader(Shader* shader) {
   lovrAssert(!shader || lovrShaderGetType(shader) == SHADER_GRAPHICS, "Compute shaders can not be set as the active shader");
   lovrRetain(shader);
-  lovrRelease(state.shader);
+  lovrRelease(Shader, state.shader);
   state.shader = shader;
 }
 

src/graphics/material.c

@@ -25,7 +25,7 @@ void lovrMaterialDestroy(void* ref) {
   Material* material = ref;
   lovrGraphicsFlushMaterial(material);
   for (int i = 0; i < MAX_MATERIAL_TEXTURES; i++) {
-    lovrRelease(material->textures[i]);
+    lovrRelease(Texture, material->textures[i]);
   }
 }
 
@@ -75,7 +75,7 @@ void lovrMaterialSetTexture(Material* material, MaterialTexture textureType, Tex
   if (material->textures[textureType] != texture) {
     lovrGraphicsFlushMaterial(material);
     lovrRetain(texture);
-    lovrRelease(material->textures[textureType]);
+    lovrRelease(Texture, material->textures[textureType]);
     material->textures[textureType] = texture;
   }
 }

src/graphics/mesh.c

@@ -38,7 +38,7 @@ void lovrMeshDetachAttribute(Mesh* mesh, const char* name) {
   lovrAssert(index, "No attached attribute named '%s' was found", name);
   MeshAttribute* attribute = &mesh->attributes[*index];
   lovrGraphicsFlushMesh(mesh);
-  lovrRelease(attribute->buffer);
+  lovrRelease(Buffer, attribute->buffer);
   map_remove(&mesh->attributeMap, name);
   mesh->attributeNames[*index][0] = '\0';
   memmove(mesh->attributeNames + *index, mesh->attributeNames + *index + 1, (mesh->attributeCount - *index - 1) * MAX_ATTRIBUTE_NAME_LENGTH * sizeof(char));
@@ -100,6 +100,6 @@ Material* lovrMeshGetMaterial(Mesh* mesh) {
 
 void lovrMeshSetMaterial(Mesh* mesh, Material* material) {
   lovrRetain(material);
-  lovrRelease(mesh->material);
+  lovrRelease(Material, mesh->material);
   mesh->material = material;
 }

src/graphics/model.c

@@ -187,12 +187,12 @@ Model* lovrModelInit(Model* model, ModelData* data) {
 void lovrModelDestroy(void* ref) {
   Model* model = ref;
   for (int i = 0; i < model->data->bufferCount; i++) {
-    lovrRelease(model->buffers[i]);
+    lovrRelease(Buffer, model->buffers[i]);
   }
   for (int i = 0; i < model->data->primitiveCount; i++) {
-    lovrRelease(model->meshes[i]);
+    lovrRelease(Mesh, model->meshes[i]);
   }
-  lovrRelease(model->data);
+  lovrRelease(ModelData, model->data);
 }
 
 void lovrModelDraw(Model* model, mat4 transform, int instances) {
@@ -207,7 +207,7 @@ Animator* lovrModelGetAnimator(Model* model) {
 void lovrModelSetAnimator(Model* model, Animator* animator) {
   if (model->animator != animator) {
     lovrRetain(animator);
-    lovrRelease(model->animator);
+    lovrRelease(Animator, model->animator);
     model->animator = animator;
   }
 }
@@ -218,7 +218,7 @@ Material* lovrModelGetMaterial(Model* model) {
 
 void lovrModelSetMaterial(Model* model, Material* material) {
   lovrRetain(material);
-  lovrRelease(model->userMaterial);
+  lovrRelease(Material, model->userMaterial);
   model->userMaterial = material;
 }
 

src/graphics/opengl.c

@@ -323,7 +323,7 @@ static Texture* lovrGpuGetDefaultTexture() {
   if (!state.defaultTexture) {
     TextureData* textureData = lovrTextureDataCreate(1, 1, 0xff, FORMAT_RGBA);
     state.defaultTexture = lovrTextureCreate(TEXTURE_2D, &textureData, 1, true, false, 0);
-    lovrRelease(textureData);
+    lovrRelease(TextureData, textureData);
   }
 
   return state.defaultTexture;
@@ -453,7 +453,7 @@ static void lovrGpuBindTexture(Texture* texture, int slot) {
 
   if (texture != state.textures[slot]) {
     lovrRetain(texture);
-    lovrRelease(state.textures[slot]);
+    lovrRelease(Texture, state.textures[slot]);
     state.textures[slot] = texture;
     if (state.activeTexture != slot) {
       glActiveTexture(GL_TEXTURE0 + slot);
@@ -481,7 +481,7 @@ static void lovrGpuBindImage(Image* image, int slot) {
     int slice = layered ? 0 : image->slice;
 
     lovrRetain(texture);
-    lovrRelease(state.images[slot].texture);
+    lovrRelease(Texture, state.images[slot].texture);
     glBindImageTexture(slot, texture->id, image->mipmap, layered, slice, glAccess, glFormat);
     memcpy(state.images + slot, image, sizeof(Image));
   }
@@ -994,12 +994,12 @@ void lovrGpuInit(bool srgb, getProcAddressProc getProcAddress) {
 }
 
 void lovrGpuDestroy() {
-  lovrRelease(state.defaultTexture);
+  lovrRelease(Texture, state.defaultTexture);
   for (int i = 0; i < MAX_TEXTURES; i++) {
-    lovrRelease(state.textures[i]);
+    lovrRelease(Texture, state.textures[i]);
   }
   for (int i = 0; i < MAX_IMAGES; i++) {
-    lovrRelease(state.images[i].texture);
+    lovrRelease(Texture, state.images[i].texture);
   }
   for (int i = 0; i < MAX_BARRIERS; i++) {
     vec_deinit(&state.incoherents[i]);
@@ -1482,9 +1482,9 @@ void lovrCanvasDestroy(void* ref) {
     glDeleteFramebuffers(1, &canvas->resolveBuffer);
   }
   for (int i = 0; i < canvas->attachmentCount; i++) {
-    lovrRelease(canvas->attachments[i].texture);
+    lovrRelease(Texture, canvas->attachments[i].texture);
   }
-  lovrRelease(canvas->depth.texture);
+  lovrRelease(Texture, canvas->depth.texture);
 }
 
 void lovrCanvasResolve(Canvas* canvas) {
@@ -1952,7 +1952,7 @@ void lovrShaderDestroy(void* ref) {
   for (BlockType type = BLOCK_UNIFORM; type <= BLOCK_COMPUTE; type++) {
     UniformBlock* block; int i;
     vec_foreach_ptr(&shader->blocks[type], block, i) {
-      lovrRelease(block->source);
+      lovrRelease(Buffer, block->source);
     }
   }
   vec_deinit(&shader->uniforms);
@@ -1981,19 +1981,19 @@ void lovrMeshDestroy(void* ref) {
   lovrGraphicsFlushMesh(mesh);
   glDeleteVertexArrays(1, &mesh->vao);
   for (int i = 0; i < mesh->attributeCount; i++) {
-    lovrRelease(mesh->attributes[i].buffer);
+    lovrRelease(Buffer, mesh->attributes[i].buffer);
   }
   map_deinit(&mesh->attributeMap);
-  lovrRelease(mesh->vertexBuffer);
-  lovrRelease(mesh->indexBuffer);
-  lovrRelease(mesh->material);
+  lovrRelease(Buffer, mesh->vertexBuffer);
+  lovrRelease(Buffer, mesh->indexBuffer);
+  lovrRelease(Material, mesh->material);
 }
 
 void lovrMeshSetIndexBuffer(Mesh* mesh, Buffer* buffer, uint32_t indexCount, size_t indexSize, size_t offset) {
   if (mesh->indexBuffer != buffer || mesh->indexCount != indexCount || mesh->indexSize != indexSize) {
     lovrGraphicsFlushMesh(mesh);
     lovrRetain(buffer);
-    lovrRelease(mesh->indexBuffer);
+    lovrRelease(Buffer, mesh->indexBuffer);
     mesh->indexBuffer = buffer;
     mesh->indexCount = indexCount;
     mesh->indexSize = indexSize;

src/graphics/shader.c

@@ -148,7 +148,7 @@ void lovrShaderSetBlock(Shader* shader, const char* name, Buffer* buffer, size_t
   if (block->source != buffer || block->offset != offset || block->size != size) {
     lovrGraphicsFlushShader(shader);
     lovrRetain(buffer);
-    lovrRelease(block->source);
+    lovrRelease(Buffer, block->source);
     block->access = access;
     block->source = buffer;
     block->offset = offset;
@@ -195,7 +195,7 @@ ShaderBlock* lovrShaderBlockInit(ShaderBlock* block, BlockType type, Buffer* buf
 
 void lovrShaderBlockDestroy(void* ref) {
   ShaderBlock* block = ref;
-  lovrRelease(block->buffer);
+  lovrRelease(Buffer, block->buffer);
   vec_deinit(&block->uniforms);
   map_deinit(&block->uniformMap);
 }

src/headset/desktop.c

@@ -60,7 +60,7 @@ static bool desktopInit(float offset, int msaa) {
 static void desktopDestroy(void) {
   Controller *controller; int i;
   vec_foreach(&state.controllers, controller, i) {
-    lovrRelease(controller);
+    lovrRelease(Controller, controller);
   }
   vec_deinit(&state.controllers);
   memset(&state, 0, sizeof(state));

src/headset/openvr.c

@@ -180,7 +180,7 @@ static bool openvrInit(float offset, int msaa) {
 }
 
 static void openvrDestroy(void) {
-  lovrRelease(state.canvas);
+  lovrRelease(Canvas, state.canvas);
   for (int i = 0; i < 16; i++) {
     if (state.deviceModels[i]) {
       state.renderModels->FreeRenderModel(state.deviceModels[i]);
@@ -193,7 +193,7 @@ static void openvrDestroy(void) {
   }
   Controller* controller; int i;
   vec_foreach(&state.controllers, controller, i) {
-    lovrRelease(controller);
+    lovrRelease(Controller, controller);
   }
   vec_deinit(&state.boundsGeometry);
   vec_deinit(&state.controllers);
@@ -497,7 +497,7 @@ static void openvrRenderTo(void (*callback)(void*), void* userdata) {
     lovrTextureAllocate(texture, width * 2, height, 1, FORMAT_RGBA);
     lovrTextureSetFilter(texture, lovrGraphicsGetDefaultFilter());
     lovrCanvasSetAttachments(state.canvas, &(Attachment) { texture, 0, 0 }, 1);
-    lovrRelease(texture);
+    lovrRelease(Texture, texture);
   }
 
   Camera camera = { .canvas = state.canvas, .viewMatrix = { MAT4_IDENTITY, MAT4_IDENTITY } };
@@ -555,7 +555,7 @@ static void openvrUpdate(float dt) {
             lovrRetain(controller);
             lovrEventPush((Event) { .type = EVENT_CONTROLLER_REMOVED, .data.controller = { controller, 0 } });
             vec_swapsplice(&state.controllers, i, 1);
-            lovrRelease(controller);
+            lovrRelease(Controller, controller);
             break;
           }
         }

src/luax.c

@@ -12,7 +12,7 @@ static int luax_meta__tostring(lua_State* L) {
 }
 
 static int luax_meta__gc(lua_State* L) {
-  lovrRelease(*(Ref**) lua_touserdata(L, 1));
+  lovrGenericRelease(*(Ref**) lua_touserdata(L, 1));
   return 0;
 }
 

src/math/math.c

@@ -18,7 +18,7 @@ bool lovrMathInit() {
 
 void lovrMathDestroy() {
   if (!state.initialized) return;
-  lovrRelease(state.generator);
+  lovrRelease(RandomGenerator, state.generator);
   memset(&state, 0, sizeof(MathState));
 }
 

src/physics/physics.c

@@ -316,7 +316,7 @@ void lovrColliderDestroyData(Collider* collider) {
   vec_void_t* joints = lovrColliderGetJoints(collider);
   Joint* joint; int j;
   vec_foreach(joints, joint, j) {
-    lovrRelease(joint);
+    lovrRelease(Joint, joint);
   }
 
   dBodyDestroy(collider->body);
@@ -328,7 +328,7 @@ void lovrColliderDestroyData(Collider* collider) {
   collider->next = collider->prev = NULL;
 
   // If the Collider is destroyed, the world lets go of its reference to this Collider
-  lovrRelease(collider);
+  lovrRelease(Collider, collider);
 }
 
 World* lovrColliderGetWorld(Collider* collider) {
@@ -353,7 +353,7 @@ void lovrColliderRemoveShape(Collider* collider, Shape* shape) {
     dSpaceRemove(collider->world->space, shape->id);
     dGeomSetBody(shape->id, 0);
     shape->collider = NULL;
-    lovrRelease(shape);
+    lovrRelease(Shape, shape);
   }
 }
 

src/thread/channel.c

@@ -61,7 +61,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);
+        lovrRelease(Channel, channel);
       }
       channel->received++;
       cnd_broadcast(&channel->cond);
@@ -110,7 +110,7 @@ void lovrChannelClear(Channel* channel) {
     if (variant.type == TYPE_STRING) {
       free(variant.value.string);
     } else if (variant.type == TYPE_OBJECT) {
-      lovrRelease(variant.value.ref);
+      lovrGenericRelease(variant.value.ref);
     }
   }
   channel->received = channel->sent;

src/thread/thread.c

@@ -16,7 +16,7 @@ void lovrThreadModuleDestroy() {
   map_iter_t iter = map_iter(&state.channels);
   while ((key = map_next(&state.channels, &iter)) != NULL) {
     Channel* channel = *(Channel**) map_get(&state.channels, key);
-    lovrRelease(channel);
+    lovrRelease(Channel, channel);
   }
   map_deinit(&state.channels);
   state.initialized = false;

src/util.h

@@ -110,4 +110,5 @@ uint32_t nextPo2(uint32_t x);
 #define lovrAssert(c, ...) if (!(c)) { lovrThrow(__VA_ARGS__); }
 #define lovrAlloc(T) (T*) _lovrAlloc(sizeof(T), T_ ## T)
 #define lovrRetain(r) if (r && ++(((Ref*) r)->count) >= 0xff) lovrThrow("Ref count overflow")
-#define lovrRelease(r) if (r && --(((Ref*) r)->count) <= 0) lovrTypeInfo[((Ref*) r)->type].destructor(r), free(r)
+#define lovrRelease(T, r) if (r && --(((Ref*) r)->count) == 0) lovr ## T ## Destroy(r), free(r)
+#define lovrGenericRelease(r) if (r && --(((Ref*) r)->count) == 0) lovrTypeInfo[((Ref*) r)->type].destructor(r), free(r)