mirror of
https://github.com/UberGames/rpgxEF.git
synced 2025-02-23 12:31:15 +00:00
593 lines
10 KiB
C
593 lines
10 KiB
C
// vector lib for Lua
|
|
|
|
#include "g_lua.h"
|
|
|
|
#if(defined(CG_LUA) || defined(G_LUA))
|
|
|
|
#include "lua.h"
|
|
#include "lauxlib.h"
|
|
#include "lualib.h"
|
|
|
|
/***
|
|
A module implementing vectors.
|
|
@module vector
|
|
*/
|
|
|
|
/***
|
|
Create a new vector.
|
|
@function New
|
|
@return A new vector with x = y = z = 0.
|
|
*/
|
|
static int Vector_New(lua_State *L) {
|
|
vec_t *v;
|
|
|
|
v = (vec_t *)lua_newuserdata(L, sizeof(vec3_t));
|
|
|
|
luaL_getmetatable(L, "game.vector");
|
|
lua_setmetatable(L, -2);
|
|
|
|
VectorClear(v);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/***
|
|
Create a new vector with the given values.
|
|
@function Construct
|
|
@param x X value.
|
|
@param y Y value.
|
|
@param z Z value.
|
|
@return A new vector with given values for x, y, and z.
|
|
*/
|
|
static int Vector_Construct(lua_State *L) {
|
|
vec_t *v;
|
|
float x = luaL_optnumber(L, 1, 0);
|
|
float y = luaL_optnumber(L, 2, 0);
|
|
float z = luaL_optnumber(L, 3, 0);
|
|
|
|
v = (vec_t *)lua_newuserdata(L, sizeof(vec3_t));
|
|
|
|
luaL_getmetatable(L, "game.vector");
|
|
lua_setmetatable(L, -2);
|
|
|
|
v[0] = x;
|
|
v[1] = y;
|
|
v[2] = z;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/***
|
|
Set vector to given values.
|
|
@function Set
|
|
@param x New x value.
|
|
@param y New y value.
|
|
@param z New z value.
|
|
*/
|
|
static int Vector_Set(lua_State *L) {
|
|
vec_t *v;
|
|
|
|
v = Lua_GetVector(L, 1);
|
|
|
|
v[0] = luaL_optnumber(L, 2, 0);
|
|
v[1] = luaL_optnumber(L, 3, 0);
|
|
v[2] = luaL_optnumber(L, 4, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***
|
|
Clears the vector which means x = y = z = 0.
|
|
@function Clear
|
|
*/
|
|
static int Vector_Clear(lua_State * L)
|
|
{
|
|
vec_t *a;
|
|
|
|
a = Lua_GetVector(L, 1);
|
|
|
|
VectorClear(a);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int Vector_X(lua_State* L) {
|
|
vec_t* vec;
|
|
|
|
LUA_DEBUG("BEGIN - vector.X");
|
|
|
|
vec = Lua_GetVector(L, 1);
|
|
if(vec == NULL) {
|
|
LUA_DEBUG("ERROR - vector.X - vector NULL");
|
|
return 1;
|
|
}
|
|
|
|
lua_pushnumber(L, vec[0]);
|
|
|
|
LUA_DEBUG("END - vector.X");
|
|
return 1;
|
|
}
|
|
|
|
static int Vector_SetX(lua_State* L) {
|
|
vec_t* vec;
|
|
float value;
|
|
|
|
LUA_DEBUG("BEGIN - vector.SetX");
|
|
|
|
vec = Lua_GetVector(L, 1);
|
|
if(vec == NULL) {
|
|
LUA_DEBUG("ERROR - vector.SetX - vector NULL");
|
|
return 1;
|
|
}
|
|
|
|
if(lua_isnumber(L, 2)) {
|
|
value = lua_tonumber(L, 2);
|
|
|
|
vec[0] = value;
|
|
} else {
|
|
LUA_DEBUG("ERROR - vector.SetX - second arg is not a number");
|
|
return 1;
|
|
}
|
|
|
|
LUA_DEBUG("END - vector.SetX");
|
|
return 1;
|
|
}
|
|
|
|
static int Vector_Y(lua_State* L) {
|
|
vec_t* vec;
|
|
|
|
LUA_DEBUG("BEGIN - vector.Y");
|
|
|
|
vec = Lua_GetVector(L, 1);
|
|
if(vec == NULL) {
|
|
LUA_DEBUG("ERROR - vector.Y - vector NULL");
|
|
return 1;
|
|
}
|
|
|
|
lua_pushnumber(L, vec[1]);
|
|
|
|
LUA_DEBUG("END - vector.Y");
|
|
return 1;
|
|
}
|
|
|
|
static int Vector_SetY(lua_State* L) {
|
|
vec_t* vec;
|
|
float value;
|
|
|
|
LUA_DEBUG("BEGIN - vector.SetY");
|
|
|
|
vec = Lua_GetVector(L, 1);
|
|
if(vec == NULL) {
|
|
LUA_DEBUG("ERROR - vector.SetY - vector NULL");
|
|
return 1;
|
|
}
|
|
|
|
if(lua_isnumber(L, 2)) {
|
|
value = lua_tonumber(L, 2);
|
|
|
|
vec[1] = value;
|
|
} else {
|
|
LUA_DEBUG("ERROR - vector.SetY - second arg is not a number");
|
|
return 1;
|
|
}
|
|
|
|
LUA_DEBUG("END - vector.SetY");
|
|
return 1;
|
|
}
|
|
|
|
static int Vector_Z(lua_State* L) {
|
|
vec_t* vec;
|
|
|
|
LUA_DEBUG("BEGIN - vector.Z");
|
|
|
|
vec = Lua_GetVector(L, 1);
|
|
if(vec == NULL) {
|
|
LUA_DEBUG("ERROR - vector.Z - vector NULL");
|
|
return 1;
|
|
}
|
|
|
|
lua_pushnumber(L, vec[2]);
|
|
|
|
LUA_DEBUG("END - vector.Z");
|
|
return 1;
|
|
}
|
|
|
|
static int Vector_SetZ(lua_State* L) {
|
|
vec_t* vec;
|
|
float value;
|
|
|
|
LUA_DEBUG("BEGIN - vector.SetZ");
|
|
|
|
vec = Lua_GetVector(L, 1);
|
|
if(vec == NULL) {
|
|
LUA_DEBUG("ERROR - vector.SetZ - vector NULL");
|
|
return 1;
|
|
}
|
|
|
|
if(lua_isnumber(L, 2)) {
|
|
value = lua_tonumber(L, 2);
|
|
|
|
vec[2] = value;
|
|
} else {
|
|
LUA_DEBUG("ERROR - vector.SetZ - second arg is not a number");
|
|
return 1;
|
|
}
|
|
|
|
LUA_DEBUG("END - vector.SetZ");
|
|
return 1;
|
|
}
|
|
|
|
/***
|
|
Add vector b to vector a and return the result.
|
|
@function Add
|
|
@param a Vector.
|
|
@param b Vector.
|
|
@return Result.
|
|
*/
|
|
static int Vector_Add(lua_State *L) {
|
|
vec_t *a, *b;
|
|
vec3_t c;
|
|
|
|
a = Lua_GetVector(L, 1);
|
|
b = Lua_GetVector(L, 2);
|
|
|
|
VectorAdd(a, b, c);
|
|
|
|
Lua_PushVector(L, c);
|
|
return 0;
|
|
}
|
|
|
|
/***
|
|
Substract vector b from vector a and return the result.
|
|
@function Subtract
|
|
@param a Vector.
|
|
@param b Vector.
|
|
@return Result.
|
|
*/
|
|
static int Vector_Subtract(lua_State *L) {
|
|
vec_t *a, *b;
|
|
vec3_t c;
|
|
|
|
a = Lua_GetVector(L, 1);
|
|
b = Lua_GetVector(L, 2);
|
|
|
|
VectorSubtract(a, b, c);
|
|
|
|
Lua_PushVector(L, c);
|
|
return 0;
|
|
}
|
|
|
|
/***
|
|
Scale vector a by value b and return the result.
|
|
@function Scale.
|
|
@param a Vector.
|
|
@param b Scaling factor.
|
|
@return Result.
|
|
*/
|
|
static int Vector_Scale(lua_State *L) {
|
|
vec_t *a, b;
|
|
vec3_t c;
|
|
|
|
a = Lua_GetVector(L, 1);
|
|
b = luaL_checknumber(L, 2);
|
|
|
|
VectorScale(a,b,c);
|
|
|
|
Lua_PushVector(L, c);
|
|
return 0;
|
|
}
|
|
|
|
/***
|
|
Get the length of the vector.
|
|
@function Length
|
|
@return Length of given vector.
|
|
*/
|
|
static int Vector_Length(lua_State *L) {
|
|
vec_t *a;
|
|
vec_t len;
|
|
|
|
a = Lua_GetVector(L,1);
|
|
|
|
len = VectorLength(a);
|
|
lua_pushnumber(L, len);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***
|
|
Normalize a vector.
|
|
@function Normalize
|
|
@return Vector length.
|
|
*/
|
|
static int Vector_Normalize(lua_State *L) {
|
|
vec_t *a;
|
|
vec_t len;
|
|
|
|
a = Lua_GetVector(L, 1);
|
|
|
|
len = VectorNormalize(a);
|
|
lua_pushnumber(L, len);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***
|
|
Normalize a vector (fast method).
|
|
@function NormalizeFast
|
|
@return Vector length.
|
|
*/
|
|
static int Vector_NormalizeFast(lua_State *L) {
|
|
vec_t *a;
|
|
|
|
a = Lua_GetVector(L, 1);
|
|
|
|
VectorNormalizeFast(a);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***
|
|
Rotates point around a given vector.
|
|
@function RotatePointAround
|
|
@param dir Vector to rotate around (must be normalized).
|
|
@param point Point to be rotated.
|
|
@param degrees How many degrees to rotate.
|
|
@param dest Point after rotation.
|
|
*/
|
|
static int Vector_RotatePointAround(lua_State *L) {
|
|
vec_t *dst, *dir, *point;
|
|
vec_t degrees;
|
|
|
|
dst = Lua_GetVector(L, 1);
|
|
dir = Lua_GetVector(L, 2);
|
|
point = Lua_GetVector(L, 3);
|
|
degrees = luaL_checknumber(L, 4);
|
|
|
|
RotatePointAroundVector(dst, dir, point, degrees);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***
|
|
Finds a vector perpendicular to the source vector.
|
|
@function Perpendicular
|
|
@param src Source vector.
|
|
@param dest A vector that is perpendicular to src (the result is stored here)
|
|
*/
|
|
static int Vector_Perpendicular(lua_State *L) {
|
|
vec_t *dst, *src;
|
|
|
|
dst = Lua_GetVector(L, 1);
|
|
src = Lua_GetVector(L, 2);
|
|
|
|
PerpendicularVector(dst, src);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***
|
|
Convert a vector to angles.
|
|
@function VecToAngles
|
|
@param vector Vector.
|
|
@param angles Vector the results are stored in.
|
|
*/
|
|
static int Vector_VecToAngles(lua_State *L) {
|
|
vec_t *v, *t;
|
|
|
|
v = Lua_GetVector(L, 1);
|
|
t = Lua_GetVector(L, 2);
|
|
|
|
vectoangles(v, t);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***
|
|
Calculate forward, right, and up vectors from given angles.
|
|
@function AngleVectors
|
|
@param angles Angles.
|
|
@param fwd Vector to store forward.
|
|
@param right Vector to store right.
|
|
@param up Vector to store up.
|
|
*/
|
|
static int Vector_AngleVectors(lua_State *L) {
|
|
vec_t *v, *fwd, *right, *up;
|
|
|
|
v = Lua_GetVector(L, 1);
|
|
fwd = Lua_GetVector(L, 2);
|
|
right = Lua_GetVector(L, 3);
|
|
up = Lua_GetVector(L, 4);
|
|
|
|
AngleVectors(v, fwd, right, up);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if 0
|
|
static int Vector_Index(lua_State *L) {
|
|
vec_t *v;
|
|
const char *i;
|
|
|
|
v = Lua_GetVector(L, 1);
|
|
i = luaL_checkstring(L, 2);
|
|
|
|
switch(*i) {
|
|
case '0': case 'x': case 'r': lua_pushnumber(L, v[0]); break;
|
|
case '1': case 'y': case 'g': lua_pushnumber(L, v[1]); break;
|
|
case '2': case 'z': case 'b': lua_pushnumber(L, v[2]); break;
|
|
default: lua_pushnil(L); break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int Vector_NewIndex(lua_State *L) {
|
|
vec_t *v;
|
|
const char *i;
|
|
vec_t t;
|
|
|
|
v = Lua_GetVector(L, 1);
|
|
i = luaL_checkstring(L, 2);
|
|
t = luaL_checknumber(L, 3);
|
|
|
|
switch(*i) {
|
|
case '0': case 'x': case 'r': v[0] = t; break;
|
|
case '1': case 'y': case 'g': v[1] = t; break;
|
|
case '2': case 'z': case 'b': v[2] = t; break;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
static int Vector_AddOperator(lua_State *L) {
|
|
vec_t *a, *b;
|
|
vec3_t c;
|
|
|
|
a = Lua_GetVector(L, 1);
|
|
b = Lua_GetVector(L, 2);
|
|
|
|
VectorAdd(a, b, c);
|
|
|
|
Lua_PushVector(L, c);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Vector_SubOperator(lua_State *L) {
|
|
vec_t *a, *b;
|
|
vec3_t c;
|
|
|
|
a = Lua_GetVector(L, 1);
|
|
b = Lua_GetVector(L, 2);
|
|
|
|
VectorSubtract(a, b, c);
|
|
|
|
Lua_PushVector(L, c);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Vector_DotOperator(lua_State *L) {
|
|
vec_t *a, *b;
|
|
|
|
a = Lua_GetVector(L, 1);
|
|
b = Lua_GetVector(L, 2);
|
|
|
|
lua_pushnumber(L, DotProduct(a,b));
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Vector_NegateOperator(lua_State *L) {
|
|
vec_t *a;
|
|
vec3_t b;
|
|
|
|
a = Lua_GetVector(L, 1);
|
|
|
|
VectorNegate(a, b);
|
|
|
|
Lua_PushVector(L, b);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Vector_GC(lua_State *L) {
|
|
return 0;
|
|
}
|
|
|
|
static int Vector_ToString(lua_State *L) {
|
|
vec_t *vec;
|
|
|
|
vec = Lua_GetVector(L,1);
|
|
lua_pushstring(L, va("(%i %i %i)", (int)vec[0], (int)vec[1], (int)vec[2]));
|
|
|
|
return 1;
|
|
}
|
|
|
|
static const luaL_Reg vector_ctor[] = {
|
|
{ "New", Vector_New },
|
|
{ "Construct", Vector_Construct },
|
|
{ "RotatePointAround", Vector_RotatePointAround },
|
|
{ "Perpendicular", Vector_Perpendicular },
|
|
{ "VecToAngles", Vector_VecToAngles },
|
|
{ "AngleVectors", Vector_AngleVectors },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
static const luaL_Reg vector_meta[] = {
|
|
//{ "__index", Vector_Index },
|
|
//{ "__newindex", Vector_NewIndex },
|
|
{ "__add", Vector_AddOperator },
|
|
{ "__sub", Vector_SubOperator },
|
|
{ "__mul", Vector_DotOperator },
|
|
{ "__unm", Vector_NegateOperator },
|
|
{ "__gc", Vector_GC },
|
|
{ "__tostring", Vector_ToString },
|
|
{ "Set", Vector_Set },
|
|
{ "Length", Vector_Length },
|
|
{ "Normalize", Vector_Normalize },
|
|
{ "NormalizeFast", Vector_NormalizeFast },
|
|
{ "Add", Vector_Add },
|
|
{ "Subtract", Vector_Subtract },
|
|
{ "Scale", Vector_Scale },
|
|
{ "Clear", Vector_Clear },
|
|
{ "X", Vector_X },
|
|
{ "Y", Vector_Y },
|
|
{ "Z", Vector_Z },
|
|
{ "SetX", Vector_SetX },
|
|
{ "SetY", Vector_SetY },
|
|
{ "SetZ", Vector_SetZ },
|
|
{NULL, NULL }
|
|
};
|
|
|
|
int Luaopen_Vector(lua_State *L) {
|
|
luaL_newmetatable(L, "game.vector");
|
|
|
|
lua_pushstring(L, "__index");
|
|
lua_pushvalue(L, -2);
|
|
lua_settable(L, -3);
|
|
|
|
luaL_register(L, NULL, vector_meta);
|
|
luaL_register(L, "vector", vector_ctor);
|
|
|
|
return 1;
|
|
}
|
|
|
|
void Lua_PushVector(lua_State *L, vec3_t v) {
|
|
vec_t *vec;
|
|
|
|
vec = (vec_t *)lua_newuserdata(L, sizeof(vec3_t));
|
|
|
|
luaL_getmetatable(L, "game.vector");
|
|
lua_setmetatable(L, -2);
|
|
|
|
VectorCopy(v, vec);
|
|
}
|
|
|
|
vec_t *Lua_GetVector(lua_State * L, int argNum)
|
|
{
|
|
void *ud;
|
|
|
|
ud = luaL_checkudata(L, argNum, "game.vector");
|
|
luaL_argcheck(L, ud != NULL, argNum, "`vector' expected");
|
|
return (vec_t *) ud;
|
|
}
|
|
|
|
int Lua_IsVector(lua_State * L, int idx)
|
|
{
|
|
void *ud;
|
|
|
|
if(lua_isuserdata(L, idx))
|
|
{
|
|
if(lua_getmetatable(L, idx))
|
|
{
|
|
ud = luaL_checkudata(L, idx, "game.vector");
|
|
return (ud != NULL);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|