mat4_setTransform;

src/graphics/graphics.c

@@ -344,17 +344,6 @@ void lovrGraphicsScale(float x, float y, float z) {
   mat4_scale(state.transforms[state.transform], x, y, z);
 }
 
-void lovrGraphicsTransform(float tx, float ty, float tz, float sx, float sy, float sz, float angle, float ax, float ay, float az) {
-
-  // M *= T * S * R
-  float transform[16];
-  mat4_identity(transform);
-  mat4_translate(transform, tx, ty, tz);
-  mat4_scale(transform, sx, sy, sz);
-  mat4_rotate(transform, angle, ax, ay, az);
-  lovrGraphicsMatrixTransform(transform);
-}
-
 void lovrGraphicsMatrixTransform(mat4 transform) {
   mat4_multiply(state.transforms[state.transform], transform);
 }
@@ -451,8 +440,11 @@ void lovrGraphicsPlane(DrawMode mode, Texture* texture, float x, float y, float
   // Angle between normal vector and the normal vector of the default geometry (dot product)
   float theta = acos(nz);
 
+  float transform[16];
+  mat4_setTransform(transform, x, y, z, size, theta, cx, cy, cz);
+
   lovrGraphicsPush();
-  lovrGraphicsTransform(x, y, z, size, size, size, theta, cx, cy, cz);
+  lovrGraphicsMatrixTransform(transform);
 
   if (mode == DRAW_MODE_LINE) {
     float points[] = {

src/graphics/graphics.h

@@ -124,7 +124,6 @@ void lovrGraphicsOrigin();
 void lovrGraphicsTranslate(float x, float y, float z);
 void lovrGraphicsRotate(float angle, float ax, float ay, float az);
 void lovrGraphicsScale(float x, float y, float z);
-void lovrGraphicsTransform(float tx, float ty, float tz, float sx, float sy, float sz, float angle, float ax, float ay, float az);
 void lovrGraphicsMatrixTransform(mat4 transform);
 
 // Primitives

src/lovr/types/transform.c

@@ -11,10 +11,7 @@ void luax_readtransform(lua_State* L, int i, mat4 m) {
     float ax = luaL_optnumber(L, i++, 0);
     float ay = luaL_optnumber(L, i++, 1);
     float az = luaL_optnumber(L, i++, 0);
-    mat4_identity(m);
+    mat4_setTransform(m, x, y, z, s, angle, ax, ay, az);
-    mat4_translate(m, x, y, z);
-    mat4_scale(m, s, s, s);
-    mat4_rotate(m, angle, ax, ay, az);
   } else if (lua_isnoneornil(L, i)) {
     mat4_identity(m);
   } else {
@@ -31,7 +28,9 @@ const luaL_Reg lovrTransform[] = {
   { "translate", l_lovrTransformTranslate },
   { "rotate", l_lovrTransformRotate },
   { "scale", l_lovrTransformScale },
-  { "transform", l_lovrTransformTransformPoint },
+  { "setTransformation", l_lovrTransformSetTransformation },
+  { "transformPoint", l_lovrTransformTransformPoint },
+  { "inverseTransformPoint", l_lovrTransformInverseTransformPoint },
   { NULL, NULL }
 };
 
@@ -93,6 +92,14 @@ int l_lovrTransformScale(lua_State* L) {
   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);
+  lua_pushvalue(L, 1);
+  return 1;
+}
+
 int l_lovrTransformTransformPoint(lua_State* L) {
   Transform* transform = luax_checktype(L, 1, Transform);
   float point[3] = {

src/lovr/types/transform.h

@@ -14,5 +14,6 @@ int l_lovrTransformOrigin(lua_State* L);
 int l_lovrTransformTranslate(lua_State* L);
 int l_lovrTransformRotate(lua_State* L);
 int l_lovrTransformScale(lua_State* L);
+int l_lovrTransformSetTransformation(lua_State* L);
 int l_lovrTransformTransformPoint(lua_State* L);
 int l_lovrTransformInverseTransformPoint(lua_State* L);

src/math/mat4.c

@@ -188,6 +188,13 @@ mat4 mat4_scale(mat4 m, float x, float y, float z) {
   return m;
 }
 
+mat4 mat4_setTransform(mat4 m, float x, float y, float z, float s, float angle, float ax, float ay, float az) {
+  mat4_identity(m);
+  mat4_translate(m, x, y, z);
+  mat4_scale(m, s, s, s);
+  return mat4_rotate(m, angle, ax, ay, az);
+}
+
 mat4 mat4_orthographic(mat4 m, float left, float right, float top, float bottom, float near, float far) {
   float rl = right - left;
   float tb = top - bottom;

src/math/mat4.h

@@ -11,6 +11,7 @@ mat4 mat4_translate(mat4 m, float x, float y, float z);
 mat4 mat4_rotate(mat4 m, float angle, float x, float y, float z);
 mat4 mat4_rotateQuat(mat4 m, quat q);
 mat4 mat4_scale(mat4 m, float x, float y, float z);
+mat4 mat4_setTransform(mat4 m, float x, float y, float z, float s, float angle, float ax, float ay, float az);
 mat4 mat4_orthographic(mat4 m, float left, float right, float top, float bottom, float near, float far);
 mat4 mat4_perspective(mat4 m, float near, float far, float fov, float aspect);
 void mat4_transform(mat4 m, vec3 v);

src/math/transform.c

@@ -31,22 +31,27 @@ mat4 lovrTransformInverse(Transform* transform) {
 }
 
 void lovrTransformApply(Transform* transform, Transform* other) {
+  transform->isDirty = 1;
   mat4_multiply(transform->matrix, other->matrix);
 }
 
 void lovrTransformOrigin(Transform* transform) {
+  transform->isDirty = 1;
   mat4_identity(transform->matrix);
 }
 
 void lovrTransformTranslate(Transform* transform, float x, float y, float z) {
+  transform->isDirty = 1;
   mat4_translate(transform->matrix, x, y, z);
 }
 
 void lovrTransformRotate(Transform* transform, float angle, float x, float y, float z) {
+  transform->isDirty = 1;
   mat4_rotate(transform->matrix, angle, x, y, z);
 }
 
 void lovrTransformScale(Transform* transform, float x, float y, float z) {
+  transform->isDirty = 1;
   mat4_scale(transform->matrix, x, y, z);
 }