Merge branch 'master' into dev

src/api/l_graphics.c

@@ -1581,7 +1581,7 @@ static int l_lovrGraphicsNewComputeShader(lua_State* L) {
 
 static int l_lovrGraphicsNewShaderBlock(lua_State* L) {
   arr_uniform_t uniforms;
-  arr_init(&uniforms, realloc);
+  arr_init(&uniforms, arr_alloc);
 
   BlockType type = luax_checkenum(L, 1, BlockType, NULL);
 

src/core/util.c

@@ -52,6 +52,17 @@ void lovrRelease(void* object, void (*destructor)(void*)) {
   }
 }
 
+// Dynamic Array
+// Default malloc-based allocator for arr_t (like realloc except well-defined when size is 0)
+void* arr_alloc(void* data, size_t size) {
+  if (size > 0) {
+    return realloc(data, size);
+  } else {
+    free(data);
+    return NULL;
+  }
+}
+
 // UTF-8
 // https://github.com/starwing/luautf8
 size_t utf8_decode(const char *s, const char *e, unsigned *pch) {

src/core/util.h

@@ -76,6 +76,8 @@ typedef void* arr_allocator(void* data, size_t size);
 #define arr_splice(a, i, n) memmove((a)->data + (i), (a)->data + ((i) + n), ((a)->length - (i) - (n)) * sizeof(*(a)->data)), (a)->length -= n
 #define arr_clear(a) (a)->length = 0
 
+void* arr_alloc(void* data, size_t size);
+
 static inline void _arr_reserve(void** data, size_t n, size_t* capacity, size_t stride, arr_allocator* allocator) {
   if (*capacity >= n) return;
   if (*capacity == 0) *capacity = 1;

src/modules/data/modelData_obj.c

@@ -110,16 +110,16 @@ ModelData* lovrModelDataInitObj(ModelData* model, Blob* source, ModelDataIO* io)
   arr_t(float) normals;
   arr_t(float) uvs;
 
-  arr_init(&groups, realloc);
-  arr_init(&images, realloc);
-  arr_init(&materials, realloc);
+  arr_init(&groups, arr_alloc);
+  arr_init(&images, arr_alloc);
+  arr_init(&materials, arr_alloc);
   map_init(&materialMap, 0);
-  arr_init(&vertexBlob, realloc);
-  arr_init(&indexBlob, realloc);
+  arr_init(&vertexBlob, arr_alloc);
+  arr_init(&indexBlob, arr_alloc);
   map_init(&vertexMap, 0);
-  arr_init(&positions, realloc);
-  arr_init(&normals, realloc);
-  arr_init(&uvs, realloc);
+  arr_init(&positions, arr_alloc);
+  arr_init(&normals, arr_alloc);
+  arr_init(&uvs, arr_alloc);
 
   arr_push(&groups, ((objGroup) { .material = -1 }));
 

src/modules/event/event.c

@@ -21,7 +21,7 @@ void lovrVariantDestroy(Variant* variant) {
 
 bool lovrEventInit() {
   if (state.initialized) return false;
-  arr_init(&state.events, realloc);
+  arr_init(&state.events, arr_alloc);
   return state.initialized = true;
 }
 

src/modules/filesystem/filesystem.c

@@ -111,7 +111,7 @@ bool lovrFilesystemInit(const char* archive) {
   if (state.initialized) return false;
   state.initialized = true;
 
-  arr_init(&state.archives, realloc);
+  arr_init(&state.archives, arr_alloc);
   arr_reserve(&state.archives, 2);
 
   lovrFilesystemSetRequirePath("?.lua;?/init.lua");
@@ -168,7 +168,7 @@ bool lovrFilesystemMount(const char* path, const char* mountpoint, bool append,
   }
 
   Archive archive;
-  arr_init(&archive.strings, realloc);
+  arr_init(&archive.strings, arr_alloc);
 
   if (!dir_init(&archive, path, mountpoint, root) && !zip_init(&archive, path, mountpoint, root)) {
     arr_free(&archive.strings);
@@ -593,7 +593,7 @@ static void zip_close(Archive* archive) {
 static bool zip_init(Archive* archive, const char* filename, const char* mountpoint, const char* root) {
   char path[LOVR_PATH_MAX];
   memset(&archive->lookup, 0, sizeof(archive->lookup));
-  arr_init(&archive->nodes, realloc);
+  arr_init(&archive->nodes, arr_alloc);
 
   // mmap the zip file, try to parse it, and figure out how many files there are
   archive->zip.data = fs_map(filename, &archive->zip.size);

src/modules/graphics/font.c

@@ -73,7 +73,7 @@ Font* lovrFontCreate(Rasterizer* rasterizer, uint32_t padding, double spread, Fi
   font->atlas.width = 256;
   font->atlas.height = 256;
   font->atlas.padding = atlasPadding;
-  arr_init(&font->atlas.glyphs, realloc);
+  arr_init(&font->atlas.glyphs, arr_alloc);
   map_init(&font->atlas.glyphMap, 0);
 
   // Set initial atlas size

src/modules/graphics/opengl.c

@@ -1351,7 +1351,7 @@ void lovrGpuInit(void (*getProcAddress(const char*))(void), bool debug) {
 #endif
 
   for (int i = 0; i < MAX_BARRIERS; i++) {
-    arr_init(&state.incoherents[i], realloc);
+    arr_init(&state.incoherents[i], arr_alloc);
   }
 
   Image* image = lovrImageCreate(1, 1, NULL, 0xff, FORMAT_RGBA);
@@ -2414,7 +2414,7 @@ static void lovrShaderSetupUniforms(Shader* shader) {
   lovrAssert((size_t) blockCount <= MAX_BLOCK_BUFFERS, "Shader has too many uniform blocks (%d) the max is %d", blockCount, MAX_BLOCK_BUFFERS);
   map_init(&shader->blockMap, blockCount);
   arr_block_t* uniformBlocks = &shader->blocks[BLOCK_UNIFORM];
-  arr_init(uniformBlocks, realloc);
+  arr_init(uniformBlocks, arr_alloc);
   arr_reserve(uniformBlocks, (size_t) blockCount);
   for (int i = 0; i < blockCount; i++) {
     UniformBlock block = { .slot = i, .source = NULL };
@@ -2426,12 +2426,12 @@ static void lovrShaderSetupUniforms(Shader* shader) {
     int blockId = (i << 1) + BLOCK_UNIFORM;
     map_set(&shader->blockMap, hash64(name, length), blockId);
     arr_push(uniformBlocks, block);
-    arr_init(&uniformBlocks->data[uniformBlocks->length - 1].uniforms, realloc);
+    arr_init(&uniformBlocks->data[uniformBlocks->length - 1].uniforms, arr_alloc);
   }
 
   // Shader storage buffers and their buffer variables
   arr_block_t* computeBlocks = &shader->blocks[BLOCK_COMPUTE];
-  arr_init(computeBlocks, realloc);
+  arr_init(computeBlocks, arr_alloc);
 #ifndef LOVR_WEBGL
   if ((GLAD_GL_ARB_shader_storage_buffer_object && GLAD_GL_ARB_program_interface_query) || GLAD_GL_ES_VERSION_3_1) {
 
@@ -2447,7 +2447,7 @@ static void lovrShaderSetupUniforms(Shader* shader) {
 #else
       glShaderStorageBlockBinding(program, i, block.slot);
 #endif
-      arr_init(&block.uniforms, realloc);
+      arr_init(&block.uniforms, arr_alloc);
 
       GLsizei length;
       char name[LOVR_MAX_UNIFORM_LENGTH];
@@ -2489,7 +2489,7 @@ static void lovrShaderSetupUniforms(Shader* shader) {
   int imageSlot = 0;
   glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &uniformCount);
   map_init(&shader->uniformMap, 0);
-  arr_init(&shader->uniforms, realloc);
+  arr_init(&shader->uniforms, arr_alloc);
   for (uint32_t i = 0; i < (uint32_t) uniformCount; i++) {
     Uniform uniform;
     GLenum glType;
@@ -2913,7 +2913,7 @@ ShaderBlock* lovrShaderBlockCreate(BlockType type, Buffer* buffer, arr_uniform_t
   lovrAssert(block, "Out of memory");
   block->ref = 1;
 
-  arr_init(&block->uniforms, realloc);
+  arr_init(&block->uniforms, arr_alloc);
   map_init(&block->uniformMap, (uint32_t) uniforms->length);
 
   arr_append(&block->uniforms, uniforms->data, uniforms->length);

src/modules/headset/headset_oculus.c

@@ -85,7 +85,7 @@ static ovrInputState* refreshButtons(void) {
 
 
 static bool oculus_init(float supersample, float offset, uint32_t msaa, bool overlay) {
-  arr_init(&state.textures, realloc);
+  arr_init(&state.textures, arr_alloc);
 
   ovrResult result = ovr_Initialize(NULL);
   if (OVR_FAILURE(result)) {

src/modules/headset/headset_openxr.c

@@ -727,13 +727,17 @@ static bool getButtonState(Device device, DeviceButton button, bool* value, bool
 
   switch (button) {
     case BUTTON_TRIGGER: info.action = state.actions[ACTION_TRIGGER_DOWN + touch]; break;
-    case BUTTON_THUMBREST: info.action = state.actions[ACTION_THUMBREST_DOWN + touch]; break;
+    case BUTTON_THUMBREST: info.action = touch ? state.actions[ACTION_THUMBREST_TOUCH] : XR_NULL_HANDLE; break;
     case BUTTON_TOUCHPAD: info.action = state.actions[ACTION_TRACKPAD_DOWN + touch]; break;
     case BUTTON_MENU: info.action = state.actions[ACTION_MENU_DOWN + touch]; break;
     case BUTTON_GRIP: info.action = state.actions[ACTION_GRIP_DOWN + touch]; break;
     default: return false;
   }
 
+  if (!info.action) {
+    return false;
+  }
+
   XrActionStateBoolean actionState = { .type = XR_TYPE_ACTION_STATE_BOOLEAN };
   XR(xrGetActionStateBoolean(state.session, &info, &actionState));
   *value = actionState.currentState;

src/modules/math/curve.c

@@ -53,7 +53,7 @@ Curve* lovrCurveCreate(void) {
   Curve* curve = calloc(1, sizeof(Curve));
   lovrAssert(curve, "Out of memory");
   curve->ref = 1;
-  arr_init(&curve->points, realloc);
+  arr_init(&curve->points, arr_alloc);
   arr_reserve(&curve->points, 16);
   return curve;
 }

src/modules/physics/physics.c

@@ -82,7 +82,7 @@ World* lovrWorldCreate(float xg, float yg, float zg, bool allowSleep, const char
   world->space = dHashSpaceCreate(0);
   dHashSpaceSetLevels(world->space, -4, 8);
   world->contactGroup = dJointGroupCreate(0);
-  arr_init(&world->overlaps, realloc);
+  arr_init(&world->overlaps, arr_alloc);
   lovrWorldSetGravity(world, xg, yg, zg);
   lovrWorldSetSleepingAllowed(world, allowSleep);
   for (uint32_t i = 0; i < tagCount; i++) {
@@ -322,8 +322,8 @@ Collider* lovrColliderCreate(World* world, float x, float y, float z) {
   collider->restitution = 0;
   collider->tag = NO_TAG;
   dBodySetData(collider->body, collider);
-  arr_init(&collider->shapes, realloc);
-  arr_init(&collider->joints, realloc);
+  arr_init(&collider->shapes, arr_alloc);
+  arr_init(&collider->joints, arr_alloc);
 
   lovrColliderSetPosition(collider, x, y, z);
 

src/modules/thread/channel.c

@@ -21,7 +21,7 @@ Channel* lovrChannelCreate(uint64_t hash) {
   Channel* channel = calloc(1, sizeof(Channel));
   lovrAssert(channel, "Out of memory");
   channel->ref = 1;
-  arr_init(&channel->messages, realloc);
+  arr_init(&channel->messages, arr_alloc);
   mtx_init(&channel->lock, mtx_plain | mtx_timed);
   cnd_init(&channel->cond);
   channel->hash = hash;

src/resources/openxr_actions.h

@@ -27,7 +27,6 @@ enum {
   ACTION_GRIP_DOWN,
   ACTION_GRIP_TOUCH,
   ACTION_GRIP_AXIS,
-  ACTION_THUMBREST_DOWN,
   ACTION_THUMBREST_TOUCH,
   ACTION_VIBRATE,
   MAX_ACTIONS