rm Transform;

CMakeLists.txt

@@ -480,12 +480,10 @@ if(LOVR_ENABLE_MATH)
     src/math/curve.c
     src/math/pool.c
     src/math/randomGenerator.c
-    src/math/transform.c
     src/api/math.c
     src/api/types/curve.c
     src/api/types/pool.c
     src/api/types/randomGenerator.c
-    src/api/types/transform.c
     src/api/types/vec3.c
     src/api/types/quat.c
     src/api/types/mat4.c

src/api.h

@@ -57,7 +57,6 @@ extern const luaL_Reg lovrSphereShape[];
 extern const luaL_Reg lovrTexture[];
 extern const luaL_Reg lovrTextureData[];
 extern const luaL_Reg lovrThread[];
-extern const luaL_Reg lovrTransform[];
 extern const luaL_Reg lovrVec3[];
 extern const luaL_Reg lovrVertexData[];
 extern const luaL_Reg lovrWorld[];

src/api/graphics.c

@@ -13,7 +13,6 @@
 #include "data/textureData.h"
 #include "data/vertexData.h"
 #include "filesystem/filesystem.h"
-#include "math/transform.h"
 #include "util.h"
 #define _USE_MATH_DEFINES
 #include <math.h>

src/api/math.c

@@ -5,7 +5,6 @@
 #include "math/curve.h"
 #include "math/pool.h"
 #include "math/randomGenerator.h"
-#include "math/transform.h"
 
 static const char* lovrMathTypeNames[] = {
   [MATH_VEC3] = "vec3",
@@ -117,15 +116,6 @@ static int l_lovrMathNewRandomGenerator(lua_State* L) {
   return 1;
 }
 
-static int l_lovrMathNewTransform(lua_State* L) {
-  float matrix[16];
-  luax_readtransform(L, 1, matrix, 3);
-  Transform* transform = lovrTransformCreate(matrix);
-  luax_pushobject(L, transform);
-  lovrRelease(transform);
-  return 1;
-}
-
 static int l_lovrMathLookAt(lua_State* L) {
   float from[3] = { luaL_checknumber(L, 1), luaL_checknumber(L, 2), luaL_checknumber(L, 3) };
   float to[3] = { luaL_checknumber(L, 4), luaL_checknumber(L, 5), luaL_checknumber(L, 6) };
@@ -253,7 +243,6 @@ static const luaL_Reg lovrMath[] = {
   { "newCurve", l_lovrMathNewCurve },
   { "newPool", l_lovrMathNewPool },
   { "newRandomGenerator", l_lovrMathNewRandomGenerator },
-  { "newTransform", l_lovrMathNewTransform },
   { "orientationToDirection", l_lovrMathOrientationToDirection },
   { "lookAt", l_lovrMathLookAt },
   { "noise", l_lovrMathNoise },
@@ -297,7 +286,6 @@ int luaopen_lovr_math(lua_State* L) {
   luax_registertype(L, "Curve", lovrCurve);
   luax_registertype(L, "Pool", lovrPool);
   luax_registertype(L, "RandomGenerator", lovrRandomGenerator);
-  luax_registertype(L, "Transform", lovrTransform);
 
   // Store every math type metatable in the registry and register it as a type
   for (int i = 0; i < MAX_MATH_TYPES; i++) {

src/api/math.h

@@ -9,7 +9,6 @@ int luax_readvec3(lua_State* L, int index, vec3 v, const char* expected);
 int luax_readscale(lua_State* L, int index, vec3 v, int components, const char* expected);
 int luax_readquat(lua_State* L, int index, quat q, const char* expected);
 int luax_readmat4(lua_State* L, int index, mat4 m, int scaleComponents, const char* expected);
-int luax_readtransform(lua_State* L, int index, mat4 transform, int scaleComponents);
 int luax_pushvec3(lua_State* L, vec3 v, int outIndex);
 int luax_pushquat(lua_State* L, quat q, int outIndex);
 int luax_pushpose(lua_State* L, float x, float y, float z, float angle, float ax, float ay, float az, int outIndex);

src/api/types/modelData.c

@@ -1,6 +1,6 @@
 #include "api.h"
 #include "data/modelData.h"
-#include "math/transform.h"
+#include "lib/math.h"
 
 int l_lovrModelDataGetVertexData(lua_State* L) {
   ModelData* modelData = luax_checktype(L, 1, ModelData);
@@ -45,26 +45,19 @@ int l_lovrModelDataGetNodeName(lua_State* L) {
 }
 
 static int luax_writenodetransform(lua_State* L, mat4 m, int transformIndex) {
-  Transform* transform = luax_totype(L, transformIndex, Transform);
-  if (transform) {
-    lovrTransformSetMatrix(transform, m);
-    lua_settop(L, transformIndex);
-    return 1;
-  } else {
-    float x, y, z, sx, sy, sz, angle, ax, ay, az;
-    mat4_getTransform(m, &x, &y, &z, &sx, &sy, &sz, &angle, &ax, &ay, &az);
-    lua_pushnumber(L, x);
-    lua_pushnumber(L, y);
-    lua_pushnumber(L, z);
-    lua_pushnumber(L, sx);
-    lua_pushnumber(L, sy);
-    lua_pushnumber(L, sz);
-    lua_pushnumber(L, angle);
-    lua_pushnumber(L, ax);
-    lua_pushnumber(L, ay);
-    lua_pushnumber(L, az);
-    return 10;
-  }
+  float x, y, z, sx, sy, sz, angle, ax, ay, az;
+  mat4_getTransform(m, &x, &y, &z, &sx, &sy, &sz, &angle, &ax, &ay, &az);
+  lua_pushnumber(L, x);
+  lua_pushnumber(L, y);
+  lua_pushnumber(L, z);
+  lua_pushnumber(L, sx);
+  lua_pushnumber(L, sy);
+  lua_pushnumber(L, sz);
+  lua_pushnumber(L, angle);
+  lua_pushnumber(L, ax);
+  lua_pushnumber(L, ay);
+  lua_pushnumber(L, az);
+  return 10;
 }
 
 int l_lovrModelDataGetLocalNodeTransform(lua_State* L) {

src/api/types/shader.c

@@ -2,7 +2,6 @@
 #include "api/graphics.h"
 #include "api/math.h"
 #include "graphics/shader.h"
-#include "math/transform.h"
 
 struct TempData {
   void* data;
@@ -89,7 +88,7 @@ int luax_checkuniform(lua_State* L, int index, const Uniform* uniform, void* des
   } else {
     luaL_checktype(L, index, LUA_TTABLE);
     lua_rawgeti(L, index, 1);
-    bool wrappedTable = lua_istable(L, -1) || luax_totype(L, -1, Transform);
+    bool wrappedTable = !lua_isnumber(L, -1);
     lua_pop(L, 1);
 
     if (wrappedTable) {

src/api/types/shaderBlock.c

@@ -1,7 +1,6 @@
 #include "api.h"
 #include "api/graphics.h"
 #include "graphics/shader.h"
-#include "math/transform.h"
 
 int l_lovrShaderBlockIsWritable(lua_State* L) {
   ShaderBlock* block = luax_checktype(L, 1, ShaderBlock);

src/api/types/transform.c

@@ -1,203 +0,0 @@
-#include "api.h"
-#include "math/transform.h"
-
-int luax_readtransform(lua_State* L, int index, mat4 m, int scaleComponents) {
-  if (lua_isnumber(L, index)) {
-    float x = luaL_optnumber(L, index++, 0);
-    float y = luaL_optnumber(L, index++, 0);
-    float z = luaL_optnumber(L, index++, 0);
-    float scale[3] = { 1., 1., 1. };
-    if (scaleComponents == 1) {
-      scale[0] = scale[1] = scale[2] = luaL_optnumber(L, index++, 1);
-    } else {
-      for (int i = 0; i < scaleComponents; i++) {
-        scale[i] = luaL_optnumber(L, index++, 1);
-      }
-    }
-    float angle = luaL_optnumber(L, index++, 0);
-    float ax = luaL_optnumber(L, index++, 0);
-    float ay = luaL_optnumber(L, index++, 1);
-    float az = luaL_optnumber(L, index++, 0);
-    mat4_setTransform(m, x, y, z, scale[0], scale[1], scale[2], angle, ax, ay, az);
-    return index;
-  } else if (lua_isnoneornil(L, index)) {
-    mat4_identity(m);
-    return index;
-  } else {
-    Transform* transform = luax_checktype(L, index, Transform);
-    mat4_init(m, transform->matrix);
-    return ++index;
-  }
-}
-
-int l_lovrTransformGetMatrix(lua_State* L) {
-  Transform* transform = luax_checktype(L, 1, Transform);
-  bool table = lua_istable(L, 2);
-  lua_settop(L, 2);
-
-  float matrix[16];
-  lovrTransformGetMatrix(transform, matrix);
-
-  for (int i = 0; i < 16; i++) {
-    lua_pushnumber(L, matrix[i]);
-    if (table) {
-      lua_rawseti(L, 2, i + 1);
-    }
-  }
-
-  return table ? 1 : 16;
-}
-
-int l_lovrTransformSetMatrix(lua_State* L) {
-  Transform* transform = luax_checktype(L, 1, Transform);
-
-  float matrix[16];
-  if (lua_istable(L, 2)) {
-    for (int i = 0; i < 16; i++) {
-      lua_rawgeti(L, 2, i + 1);
-      matrix[i] = luaL_checknumber(L, -1);
-      lua_pop(L, 1);
-    }
-  } else {
-    for (int i = 0; i < 16; i++) {
-      matrix[i] = luaL_checknumber(L, 2 + i);
-    }
-  }
-
-  lovrTransformSetMatrix(transform, matrix);
-  return 0;
-}
-
-int l_lovrTransformClone(lua_State* L) {
-  Transform* transform = luax_checktype(L, 1, Transform);
-  Transform* clone = lovrTransformCreate(transform->matrix);
-  luax_pushobject(L, clone);
-  lovrRelease(clone);
-  return 1;
-}
-
-int l_lovrTransformInverse(lua_State* L) {
-  Transform* transform = luax_checktype(L, 1, Transform);
-  Transform* inverse = lovrTransformCreate(lovrTransformInverse(transform));
-  luax_pushobject(L, inverse);
-  lovrRelease(inverse);
-  return 1;
-}
-
-int l_lovrTransformApply(lua_State* L) {
-  Transform* transform = luax_checktype(L, 1, Transform);
-  Transform* other = luax_checktype(L, 2, Transform);
-  lovrTransformApply(transform, other);
-  lua_pushvalue(L, 1);
-  return 1;
-}
-
-int l_lovrTransformOrigin(lua_State* L) {
-  lovrTransformOrigin(luax_checktype(L, 1, Transform));
-  lua_pushvalue(L, 1);
-  return 1;
-}
-
-int l_lovrTransformTranslate(lua_State* L) {
-  Transform* transform = luax_checktype(L, 1, Transform);
-  float x = luaL_checknumber(L, 2);
-  float y = luaL_checknumber(L, 3);
-  float z = luaL_checknumber(L, 4);
-  lovrTransformTranslate(transform, x, y, z);
-  lua_pushvalue(L, 1);
-  return 1;
-}
-
-int l_lovrTransformRotate(lua_State* L) {
-  Transform* transform = luax_checktype(L, 1, Transform);
-  float angle = luaL_checknumber(L, 2);
-  float x = luaL_checknumber(L, 3);
-  float y = luaL_checknumber(L, 4);
-  float z = luaL_checknumber(L, 5);
-  lovrTransformRotate(transform, angle, x, y, z);
-  lua_pushvalue(L, 1);
-  return 1;
-}
-
-int l_lovrTransformScale(lua_State* L) {
-  Transform* transform = luax_checktype(L, 1, Transform);
-  float x = luaL_checknumber(L, 2);
-  float y = lua_gettop(L) > 2 ? luaL_checknumber(L, 3) : x;
-  float z = lua_gettop(L) > 2 ? luaL_checknumber(L, 4) : x;
-  lovrTransformScale(transform, x, y, z);
-  lua_pushvalue(L, 1);
-  return 1;
-}
-
-int l_lovrTransformSetOrthographic(lua_State* L) {
-  Transform* transform = luax_checktype(L, 1, Transform);
-  float left = luaL_checknumber(L, 2);
-  float right = luaL_checknumber(L, 3);
-  float top = luaL_checknumber(L, 4);
-  float bottom = luaL_checknumber(L, 5);
-  float clipNear = luaL_checknumber(L, 6);
-  float clipFar = luaL_checknumber(L, 7);
-  mat4_orthographic(transform->matrix, left, right, top, bottom, clipNear, clipFar);
-  lua_pushvalue(L, 1);
-  return 1;
-}
-
-int l_lovrTransformSetPerspective(lua_State* L) {
-  Transform* transform = luax_checktype(L, 1, Transform);
-  float clipNear = luaL_checknumber(L, 2);
-  float clipFar = luaL_checknumber(L, 3);
-  float fov = luaL_checknumber(L, 4);
-  float aspect = luaL_checknumber(L, 5);
-  mat4_perspective(transform->matrix, clipNear, clipFar, fov, aspect);
-  lua_pushvalue(L, 1);
-  return 1;
-}
-
-int l_lovrTransformSetTransformation(lua_State* L) {
-  Transform* transform = luax_checktype(L, 1, Transform);
-  lovrTransformOrigin(transform); // Dirty the Transform
-  luax_readtransform(L, 2, transform->matrix, 3);
-  lua_pushvalue(L, 1);
-  return 1;
-}
-
-int l_lovrTransformTransformPoint(lua_State* L) {
-  Transform* transform = luax_checktype(L, 1, Transform);
-  float x = luaL_checknumber(L, 2);
-  float y = luaL_checknumber(L, 3);
-  float z = luaL_checknumber(L, 4);
-  lovrTransformTransformPoint(transform, &x, &y, &z);
-  lua_pushnumber(L, x);
-  lua_pushnumber(L, y);
-  lua_pushnumber(L, z);
-  return 3;
-}
-
-int l_lovrTransformInverseTransformPoint(lua_State* L) {
-  Transform* transform = luax_checktype(L, 1, Transform);
-  float x = luaL_checknumber(L, 2);
-  float y = luaL_checknumber(L, 3);
-  float z = luaL_checknumber(L, 4);
-  lovrTransformInverseTransformPoint(transform, &x, &y, &z);
-  lua_pushnumber(L, x);
-  lua_pushnumber(L, y);
-  lua_pushnumber(L, z);
-  return 3;
-}
-
-const luaL_Reg lovrTransform[] = {
-  { "getMatrix", l_lovrTransformGetMatrix },
-  { "setMatrix", l_lovrTransformSetMatrix },
-  { "clone", l_lovrTransformClone },
-  { "inverse", l_lovrTransformInverse },
-  { "apply", l_lovrTransformApply },
-  { "origin", l_lovrTransformOrigin },
-  { "translate", l_lovrTransformTranslate },
-  { "rotate", l_lovrTransformRotate },
-  { "scale", l_lovrTransformScale },
-  { "setOrthographic", l_lovrTransformSetOrthographic },
-  { "setPerspective", l_lovrTransformSetPerspective },
-  { "transformPoint", l_lovrTransformTransformPoint },
-  { "inverseTransformPoint", l_lovrTransformInverseTransformPoint },
-  { NULL, NULL }
-};

src/math/transform.c

@@ -1,68 +0,0 @@
-#include "transform.h"
-#include <stdlib.h>
-
-Transform* lovrTransformCreate(mat4 transfrom) {
-  Transform* transform = lovrAlloc(Transform, free);
-  if (!transform) return NULL;
-
-  transform->isDirty = true;
-
-  if (transfrom) {
-    mat4_set(transform->matrix, transfrom);
-  } else {
-    mat4_identity(transform->matrix);
-  }
-
-  return transform;
-}
-
-void lovrTransformGetMatrix(Transform* transform, mat4 m) {
-  mat4_set(m, transform->matrix);
-}
-
-void lovrTransformSetMatrix(Transform* transform, mat4 m) {
-  transform->isDirty = true;
-  mat4_set(transform->matrix, m);
-}
-
-mat4 lovrTransformInverse(Transform* transform) {
-  if (transform->isDirty) {
-    transform->isDirty = false;
-    mat4_invert(mat4_set(transform->inverse, transform->matrix));
-  }
-
-  return transform->inverse;
-}
-
-void lovrTransformApply(Transform* transform, Transform* other) {
-  transform->isDirty = true;
-  mat4_multiply(transform->matrix, other->matrix);
-}
-
-void lovrTransformOrigin(Transform* transform) {
-  transform->isDirty = true;
-  mat4_identity(transform->matrix);
-}
-
-void lovrTransformTranslate(Transform* transform, float x, float y, float z) {
-  transform->isDirty = true;
-  mat4_translate(transform->matrix, x, y, z);
-}
-
-void lovrTransformRotate(Transform* transform, float angle, float x, float y, float z) {
-  transform->isDirty = true;
-  mat4_rotate(transform->matrix, angle, x, y, z);
-}
-
-void lovrTransformScale(Transform* transform, float x, float y, float z) {
-  transform->isDirty = true;
-  mat4_scale(transform->matrix, x, y, z);
-}
-
-void lovrTransformTransformPoint(Transform* transform, float* x, float* y, float* z) {
-  mat4_transform(transform->matrix, x, y, z);
-}
-
-void lovrTransformInverseTransformPoint(Transform* transform, float* x, float* y, float* z) {
-  mat4_transform(lovrTransformInverse(transform), x, y, z);
-}

src/math/transform.h

@@ -1,24 +0,0 @@
-#include "util.h"
-#include "lib/math.h"
-#include <stdbool.h>
-
-#pragma once
-
-typedef struct Transform {
-  Ref ref;
-  float matrix[16];
-  float inverse[16];
-  bool isDirty;
-} Transform;
-
-Transform* lovrTransformCreate(mat4 transfrom);
-void lovrTransformGetMatrix(Transform* transform, mat4 m);
-void lovrTransformSetMatrix(Transform* transform, mat4 m);
-void lovrTransformApply(Transform* transform, Transform* other);
-mat4 lovrTransformInverse(Transform* transform);
-void lovrTransformOrigin(Transform* transform);
-void lovrTransformTranslate(Transform* transform, float x, float y, float z);
-void lovrTransformRotate(Transform* transform, float angle, float x, float y, float z);
-void lovrTransformScale(Transform* transform, float x, float y, float z);
-void lovrTransformTransformPoint(Transform* transform, float* x, float* y, float* z);
-void lovrTransformInverseTransformPoint(Transform* transform, float* x, float* y, float* z);