mirror of https://github.com/bjornbytes/lovr.git
rm Transform;
This commit is contained in:
parent
c7934b3b13
commit
2aadc9bde1
|
@ -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
|
||||
|
|
|
@ -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[];
|
||||
|
|
|
@ -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>
|
||||
|
|
|
@ -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++) {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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,12 +45,6 @@ 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);
|
||||
|
@ -65,7 +59,6 @@ static int luax_writenodetransform(lua_State* L, mat4 m, int transformIndex) {
|
|||
lua_pushnumber(L, az);
|
||||
return 10;
|
||||
}
|
||||
}
|
||||
|
||||
int l_lovrModelDataGetLocalNodeTransform(lua_State* L) {
|
||||
ModelData* modelData = luax_checktype(L, 1, ModelData);
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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 }
|
||||
};
|
|
@ -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);
|
||||
}
|
|
@ -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);
|
Loading…
Reference in New Issue