rm MatrixType;

src/api.h

@@ -86,7 +86,6 @@ extern map_int_t JointTypes;
 extern map_int_t MaterialColors;
 extern map_int_t MaterialScalars;
 extern map_int_t MaterialTextures;
-extern map_int_t MatrixTypes;
 extern map_int_t MeshDrawModes;
 extern map_int_t MeshUsages;
 extern map_int_t PolygonWindings;

src/api/graphics.c

@@ -24,7 +24,6 @@ map_int_t HorizontalAligns;
 map_int_t MaterialColors;
 map_int_t MaterialScalars;
 map_int_t MaterialTextures;
-map_int_t MatrixTypes;
 map_int_t MeshDrawModes;
 map_int_t MeshUsages;
 map_int_t StencilActions;
@@ -34,16 +33,6 @@ map_int_t VerticalAligns;
 map_int_t Windings;
 map_int_t WrapModes;
 
-static int luax_optmatrixtype(lua_State* L, int index, MatrixType* type) {
-  if (lua_type(L, index) == LUA_TSTRING) {
-    *type = *(MatrixType*) luax_checkenum(L, index++, &MatrixTypes, "matrix type");
-  } else {
-    *type = MATRIX_MODEL;
-  }
-
-  return index;
-}
-
 static uint32_t luax_readvertices(lua_State* L, int index) {
   bool isTable = lua_istable(L, index);
 
@@ -178,10 +167,6 @@ int l_lovrGraphicsInit(lua_State* L) {
   map_set(&MaterialTextures, "normal", TEXTURE_NORMAL);
   map_set(&MaterialTextures, "environment", TEXTURE_ENVIRONMENT_MAP);
 
-  map_init(&MatrixTypes);
-  map_set(&MatrixTypes, "model", MATRIX_MODEL);
-  map_set(&MatrixTypes, "view", MATRIX_VIEW);
-
   map_init(&MeshDrawModes);
   map_set(&MeshDrawModes, "points", MESH_POINTS);
   map_set(&MeshDrawModes, "lines", MESH_LINES);
@@ -627,42 +612,34 @@ int l_lovrGraphicsOrigin(lua_State* L) {
 }
 
 int l_lovrGraphicsTranslate(lua_State* L) {
-  MatrixType type;
-  int i = luax_optmatrixtype(L, 1, &type);
-  float x = luaL_checknumber(L, i++);
-  float y = luaL_checknumber(L, i++);
-  float z = luaL_checknumber(L, i++);
-  lovrGraphicsTranslate(type, x, y, z);
+  float x = luaL_checknumber(L, 1);
+  float y = luaL_checknumber(L, 2);
+  float z = luaL_checknumber(L, 3);
+  lovrGraphicsTranslate(x, y, z);
   return 0;
 }
 
 int l_lovrGraphicsRotate(lua_State* L) {
-  MatrixType type;
-  int i = luax_optmatrixtype(L, 1, &type);
-  float angle = luaL_checknumber(L, i++);
-  float axisX = luaL_optnumber(L, i++, 0);
-  float axisY = luaL_optnumber(L, i++, 1);
-  float axisZ = luaL_optnumber(L, i++, 0);
-  lovrGraphicsRotate(type, angle, axisX, axisY, axisZ);
+  float angle = luaL_checknumber(L, 1);
+  float axisX = luaL_optnumber(L, 2, 0);
+  float axisY = luaL_optnumber(L, 3, 1);
+  float axisZ = luaL_optnumber(L, 4, 0);
+  lovrGraphicsRotate(angle, axisX, axisY, axisZ);
   return 0;
 }
 
 int l_lovrGraphicsScale(lua_State* L) {
-  MatrixType type;
-  int i = luax_optmatrixtype(L, 1, &type);
-  float x = luaL_checknumber(L, i++);
-  float y = luaL_optnumber(L, i++, x);
-  float z = luaL_optnumber(L, i++, x);
-  lovrGraphicsScale(type, x, y, z);
+  float x = luaL_checknumber(L, 1);
+  float y = luaL_optnumber(L, 2, x);
+  float z = luaL_optnumber(L, 3, x);
+  lovrGraphicsScale(x, y, z);
   return 0;
 }
 
 int l_lovrGraphicsTransform(lua_State* L) {
-  MatrixType type;
-  int i = luax_optmatrixtype(L, 1, &type);
   float transform[16];
-  luax_readtransform(L, i++, transform, 3);
-  lovrGraphicsMatrixTransform(type, transform);
+  luax_readtransform(L, 1, transform, 3);
+  lovrGraphicsMatrixTransform(transform);
   return 0;
 }
 

src/graphics/graphics.c

@@ -115,7 +115,7 @@ void lovrGraphicsPrepare(Material* material, float* pose) {
     shader = state.defaultShaders[state.defaultShader] = lovrShaderCreateDefault(state.defaultShader);
   }
 
-  mat4 model = state.transforms[state.transform][MATRIX_MODEL];
+  mat4 model = state.transforms[state.transform];
   lovrShaderSetMatrix(shader, "lovrModel", model, 16);
 
   float* views = state.layers[state.layer].views;
@@ -597,24 +597,23 @@ void lovrGraphicsPop() {
 }
 
 void lovrGraphicsOrigin() {
-  mat4_identity(state.transforms[state.transform][MATRIX_MODEL]);
-  mat4_identity(state.transforms[state.transform][MATRIX_VIEW]);
+  mat4_identity(state.transforms[state.transform]);
 }
 
-void lovrGraphicsTranslate(MatrixType type, float x, float y, float z) {
-  mat4_translate(state.transforms[state.transform][type], x, y, z);
+void lovrGraphicsTranslate(float x, float y, float z) {
+  mat4_translate(state.transforms[state.transform], x, y, z);
 }
 
-void lovrGraphicsRotate(MatrixType type, float angle, float ax, float ay, float az) {
-  mat4_rotate(state.transforms[state.transform][type], angle, ax, ay, az);
+void lovrGraphicsRotate(float angle, float ax, float ay, float az) {
+  mat4_rotate(state.transforms[state.transform], angle, ax, ay, az);
 }
 
-void lovrGraphicsScale(MatrixType type, float x, float y, float z) {
-  mat4_scale(state.transforms[state.transform][type], x, y, z);
+void lovrGraphicsScale(float x, float y, float z) {
+  mat4_scale(state.transforms[state.transform], x, y, z);
 }
 
-void lovrGraphicsMatrixTransform(MatrixType type, mat4 transform) {
-  mat4_multiply(state.transforms[state.transform][type], transform);
+void lovrGraphicsMatrixTransform(mat4 transform) {
+  mat4_multiply(state.transforms[state.transform], transform);
 }
 
 // Primitives
@@ -1015,7 +1014,7 @@ void lovrGraphicsSkybox(Texture* texture, float angle, float ax, float ay, float
 
   lovrGraphicsPush();
   lovrGraphicsOrigin();
-  lovrGraphicsRotate(MATRIX_MODEL, angle, ax, ay, az);
+  lovrGraphicsRotate(angle, ax, ay, az);
   lovrGraphicsSetWinding(WINDING_COUNTERCLOCKWISE);
 
   if (texture->type == TEXTURE_CUBE) {
@@ -1100,9 +1099,9 @@ void lovrGraphicsPrint(const char* str, mat4 transform, float wrap, HorizontalAl
   lovrMeshWriteIndices(state.mesh, 0, 0);
 
   lovrGraphicsPush();
-  lovrGraphicsMatrixTransform(MATRIX_MODEL, transform);
-  lovrGraphicsScale(MATRIX_MODEL, scale, scale, scale);
-  lovrGraphicsTranslate(MATRIX_MODEL, 0, offsety, 0);
+  lovrGraphicsMatrixTransform(transform);
+  lovrGraphicsScale(scale, scale, scale);
+  lovrGraphicsTranslate(0, offsety, 0);
   lovrGraphicsSetDefaultShader(SHADER_FONT);
   Material* material = lovrGraphicsGetDefaultMaterial();
   lovrMaterialSetTexture(material, TEXTURE_DIFFUSE, font->texture);

src/graphics/graphics.h

@@ -70,11 +70,6 @@ typedef enum {
   STENCIL_INVERT = GL_INVERT
 } StencilAction;
 
-typedef enum {
-  MATRIX_MODEL,
-  MATRIX_VIEW
-} MatrixType;
-
 typedef struct {
   float projections[32];
   float views[32];
@@ -103,7 +98,7 @@ typedef struct {
   Material* defaultMaterial;
   Font* defaultFont;
   Texture* defaultTexture;
-  float transforms[MAX_TRANSFORMS + INTERNAL_TRANSFORMS][2][16];
+  float transforms[MAX_TRANSFORMS + INTERNAL_TRANSFORMS][16];
   int transform;
   Color backgroundColor;
   BlendMode blendMode;
@@ -189,10 +184,10 @@ void lovrGraphicsSetWireframe(bool wireframe);
 void lovrGraphicsPush();
 void lovrGraphicsPop();
 void lovrGraphicsOrigin();
-void lovrGraphicsTranslate(MatrixType type, float x, float y, float z);
-void lovrGraphicsRotate(MatrixType type, float angle, float ax, float ay, float az);
-void lovrGraphicsScale(MatrixType type, float x, float y, float z);
-void lovrGraphicsMatrixTransform(MatrixType type, mat4 transform);
+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 lovrGraphicsMatrixTransform(mat4 transform);
 
 // Primitives
 void lovrGraphicsPoints(uint32_t count);

src/graphics/mesh.c

@@ -141,7 +141,7 @@ void lovrMeshDraw(Mesh* mesh, mat4 transform, float* pose, int instances) {
 
   if (transform) {
     lovrGraphicsPush();
-    lovrGraphicsMatrixTransform(MATRIX_MODEL, transform);
+    lovrGraphicsMatrixTransform(transform);
   }
 
   lovrGraphicsPrepare(mesh->material, pose);

src/graphics/model.c

@@ -9,7 +9,7 @@ static void renderNode(Model* model, int nodeIndex, int instances) {
 
   if (node->primitives.length > 0) {
     lovrGraphicsPush();
-    lovrGraphicsMatrixTransform(MATRIX_MODEL, model->nodeTransforms[nodeIndex]);
+    lovrGraphicsMatrixTransform(model->nodeTransforms[nodeIndex]);
 
     float globalInverse[16];
     if (model->animator) {
@@ -160,7 +160,7 @@ void lovrModelDraw(Model* model, mat4 transform, int instances) {
   }
 
   lovrGraphicsPush();
-  lovrGraphicsMatrixTransform(MATRIX_MODEL, transform);
+  lovrGraphicsMatrixTransform(transform);
   renderNode(model, 0, instances);
   lovrGraphicsPop();
 }