Simple game engine with complete export to scripting language
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 

440 lines
10 KiB

#include "ScriptSystem_Math.h"
#include "Utilities/MersenneTwister.h"
#include <cmath>
namespace BlueCore
{
static MTRand mtrand;
//------------------------------------------------------------------------------
static SQInteger _sin(HSQUIRRELVM v)
{
SQFloat f;
sq_getfloat (v, 2, &f );
sq_pushfloat (v, ( SQFloat ) sin (f ) );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _cos(HSQUIRRELVM v)
{
SQFloat f;
sq_getfloat (v, 2, &f );
sq_pushfloat (v, ( SQFloat ) cos (f ) );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _tan(HSQUIRRELVM v)
{
SQFloat f;
sq_getfloat (v, 2, &f );
sq_pushfloat (v, ( SQFloat ) tan (f ) );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _sqrt(HSQUIRRELVM v)
{
SQFloat f;
sq_getfloat (v, 2, &f );
sq_pushfloat (v, ( SQFloat ) sqrt (f ) );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _trunc(HSQUIRRELVM v)
{
SQFloat f;
sq_getfloat (v, 2, &f );
sq_pushfloat (v, ( SQFloat ) f - fmod(f, 1.0) );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _floor(HSQUIRRELVM v)
{
SQFloat f;
sq_getfloat (v, 2, &f );
sq_pushfloat (v, ( SQFloat ) floor (f ) );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _ceil(HSQUIRRELVM v)
{
SQFloat f;
sq_getfloat (v, 2, &f );
sq_pushfloat (v, ( SQFloat ) ceil (f ) );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _rand(HSQUIRRELVM v)
{
sq_pushfloat (v, mtrand.rand() );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _seed_rand(HSQUIRRELVM v)
{
SQInteger seed;
sq_getinteger(v, 2, &seed );
mtrand.seed(seed );
return 0;
}
//------------------------------------------------------------------------------
static void _setup_basic_math (HSQUIRRELVM vm)
{
sq_pushroottable (vm);
sq_pushstring (vm, "sin", -1);
sq_newclosure (vm, _sin, 0);
sq_setparamscheck (vm, 2, ".n");
sq_newslot (vm, -3, false);
sq_pushstring (vm, "cos", -1);
sq_newclosure (vm, _cos, 0);
sq_setparamscheck (vm, 2, ".n");
sq_newslot (vm, -3, false);
sq_pushstring (vm, "tan", -1);
sq_newclosure (vm, _tan, 0);
sq_setparamscheck (vm, 2, ".n");
sq_newslot (vm, -3, false);
sq_pushstring (vm, "sqrt", -1);
sq_newclosure (vm, _sqrt, 0);
sq_setparamscheck (vm, 2, ".n");
sq_newslot (vm, -3, false);
sq_pushstring (vm, "trunc", -1);
sq_newclosure (vm, _trunc, 0);
sq_setparamscheck (vm, 2, ".n");
sq_newslot (vm, -3, false);
sq_pushstring (vm, "floor", -1);
sq_newclosure (vm, _floor, 0);
sq_setparamscheck (vm, 2, ".n");
sq_newslot (vm, -3, false);
sq_pushstring (vm, "ceil", -1);
sq_newclosure (vm, _ceil, 0);
sq_setparamscheck (vm, 2, ".n");
sq_newslot (vm, -3, false);
sq_pushstring (vm, "rand", -1);
sq_newclosure (vm, _rand, 0);
sq_setparamscheck (vm, 1, ".");
sq_newslot (vm, -3, false);
sq_pushstring (vm, "seed_rand", -1);
sq_newclosure (vm, _seed_rand, 0);
sq_setparamscheck (vm, 2, ".n");
sq_newslot (vm, -3, false);
// pop the root table
sq_pop (vm, 1);
}
//------------------------------------------------------------------------------
static SQInteger _vector__add ( HSQUIRRELVM v )
{
SQFloat ax, ay, az;
SQFloat bx = 0.0, by = 0.0, bz = 0.0;
_getvectorvalues ( v, 1, ax, ay, az );
_getvectorvalues ( v, 2, bx, by, bz );
_pushvector ( v, ax + bx, ay + by, az + bz );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _vector__sub ( HSQUIRRELVM v )
{
SQFloat ax, ay, az;
SQFloat bx = 0.0, by = 0.0, bz = 0.0;
_getvectorvalues ( v, 1, ax, ay, az );
_getvectorvalues ( v, 2, bx, by, bz );
_pushvector ( v, ax - bx, ay - by, az - bz );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _vector__mul ( HSQUIRRELVM v )
{
SQFloat x, y, z, f;
_getvectorvalues ( v, 1, x, y, z );
sq_getfloat ( v, 2, &f );
_pushvector ( v, x*f, y*f, z*f );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _vector__div ( HSQUIRRELVM v )
{
SQFloat x, y, z, f;
_getvectorvalues ( v, 1, x, y, z );
sq_getfloat ( v, 2, &f );
_pushvector ( v, x / f, y / f, y / f );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _vector_length ( HSQUIRRELVM v )
{
SQFloat x, y, z;
_getvectorvalues ( v, 1, x, y, z );
sq_pushfloat ( v, std::sqrt ( x*x + y*y + z*z ) );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _vector_normalize ( HSQUIRRELVM v )
{
SQFloat x, y, z;
_getvectorvalues ( v, 1, x, y, z );
SQFloat l = 1 / std::sqrt ( x * x + y * y + z * z );
_setvectorvalues ( v, 1, x*l, y*l, z*l );
return 0;
}
//------------------------------------------------------------------------------
static SQInteger _vector_constructor ( HSQUIRRELVM v )
{
SQFloat x = 0.0;
SQFloat y = 0.0;
SQFloat z = 0.0;
SQInteger argc = sq_gettop ( v );
if ( argc > 1 )
sq_getfloat ( v, 2, &x );
if ( argc > 2 )
sq_getfloat ( v, 3, &y );
if ( argc > 3 )
sq_getfloat ( v, 4, &z );
_setvectorvalues ( v, 1, x, y, z );
return 0;
}
//------------------------------------------------------------------------------
static void _register_vector_class( HSQUIRRELVM _vm )
{
sq_pushroottable ( _vm );
// push class
sq_pushstring ( _vm, "Vector", -1 );
if ( SQ_SUCCEEDED ( sq_newclass ( _vm, SQFalse ) ) )
{
// register variables
sq_pushstring ( _vm, "x", -1 );
sq_pushfloat ( _vm, 0.0 );
sq_newslot ( _vm, -3, false );
sq_pushstring ( _vm, "y", -1 );
sq_pushfloat ( _vm, 0.0 );
sq_newslot ( _vm, -3, false );
sq_pushstring ( _vm, "z", -1 );
sq_pushfloat ( _vm, 0.0 );
sq_newslot ( _vm, -3, false );
// register constructor
sq_pushstring ( _vm, "constructor", -1 );
sq_newclosure ( _vm, _vector_constructor, 0 );
sq_newslot ( _vm, -3, false );
// register _add
sq_pushstring ( _vm, "_add", -1 );
sq_newclosure ( _vm, _vector__add, 0 );
sq_newslot ( _vm, -3, false );
// register _sub
sq_pushstring ( _vm, "_sub", -1 );
sq_newclosure ( _vm, _vector__sub, 0 );
sq_newslot ( _vm, -3, false );
// register _mul
sq_pushstring ( _vm, "_mul", -1 );
sq_newclosure ( _vm, _vector__mul, 0 );
sq_newslot ( _vm, -3, false );
// register _div
sq_pushstring ( _vm, "_div", -1 );
sq_newclosure ( _vm, _vector__div, 0 );
sq_newslot ( _vm, -3, false );
// register length
sq_pushstring ( _vm, "length", -1 );
sq_newclosure ( _vm, _vector_length, 0 );
sq_newslot ( _vm, -3, false );
// register normalize
sq_pushstring ( _vm, "normalize", -1 );
sq_newclosure ( _vm, _vector_normalize, 0 );
sq_newslot ( _vm, -3, false );
// create_vector class
sq_newslot ( _vm, -3, false );
}
sq_poptop ( _vm );
}
//------------------------------------------------------------------------------
static SQInteger _quaternion_constructor ( HSQUIRRELVM v )
{
SQFloat w = 0.0;
SQFloat x = 0.0;
SQFloat y = 0.0;
SQFloat z = 0.0;
SQInteger argc = sq_gettop ( v );
if ( argc > 1 )
sq_getfloat ( v, 2, &w );
if ( argc > 2 )
sq_getfloat ( v, 3, &x );
if ( argc > 3 )
sq_getfloat ( v, 4, &y );
if ( argc > 4 )
sq_getfloat ( v, 5, &z );
_setquaternionvalues ( v, 1, w, x, y, z );
return 0;
}
//------------------------------------------------------------------------------
static SQInteger _quaternion_apply ( HSQUIRRELVM vm )
{
SQFloat qw, qx, qy, qz;
SQFloat vx, vy, vz;
_getquaternionvalues ( vm, 1, qw, qx, qy, qz );
_getvectorvalues ( vm, 2, vx, vy, vz );
SQFloat xx = qx*qx, xy = qx*qy, xz = qx*qz, xw = qx*qw,
yy = qy*qy, yz = qy*qz, yw = qy*qw,
zz = qz*qz, zw = qz*qw;
SQFloat rx = 2.0 * (vx * (0.5 - yy - zz) + vy * (xy - zw) + vz * (xz + yw));
SQFloat ry = 2.0 * (vx * (xy + zw) + vy * (0.5 - xx - zz) + vz * (yz - xw));
SQFloat rz = 2.0 * (vx * (xz - yw) + vy * (yz + xw) + vz * (0.5 - xx - yy));
_pushvector ( vm, rx, ry, rz );
return 1;
}
//------------------------------------------------------------------------------
static SQInteger _quaternion_applyinversed ( HSQUIRRELVM vm )
{
SQFloat qw, qx, qy, qz;
SQFloat vx, vy, vz;
_getquaternionvalues ( vm, 1, qw, qx, qy, qz );
_getvectorvalues ( vm, 2, vx, vy, vz );
SQFloat xx = qx*qx, xy = qx*qy, xz = qx*qz, xw = -qx*qw,
yy = qy*qy, yz = qy*qz, yw = -qy*qw,
zz = qz*qz, zw = -qz*qw;
SQFloat rx = 2.0 * (vx * (0.5 - yy - zz) + vy * (xy - zw) + vz * (xz + yw));
SQFloat ry = 2.0 * (vx * (xy + zw) + vy * (0.5 - xx - zz) + vz * (yz - xw));
SQFloat rz = 2.0 * (vx * (xz - yw) + vy * (yz + xw) + vz * (0.5 - xx - yy));
_pushvector ( vm, rx, ry, rz );
return 1;
}
//------------------------------------------------------------------------------
static void _register_quaternion_class (HSQUIRRELVM vm)
{
sq_pushroottable ( vm );
// push class
sq_pushstring ( vm, "Quaternion", -1 );
if ( SQ_SUCCEEDED ( sq_newclass ( vm, SQFalse ) ) )
{
// register variables
sq_pushstring ( vm, "w", -1 );
sq_pushfloat ( vm, 0.0 );
sq_newslot ( vm, -3, false );
sq_pushstring ( vm, "x", -1 );
sq_pushfloat ( vm, 0.0 );
sq_newslot ( vm, -3, false );
sq_pushstring ( vm, "y", -1 );
sq_pushfloat ( vm, 0.0 );
sq_newslot ( vm, -3, false );
sq_pushstring ( vm, "z", -1 );
sq_pushfloat ( vm, 0.0 );
sq_newslot ( vm, -3, false );
// register constructor
sq_pushstring ( vm, "constructor", -1 );
sq_newclosure ( vm, _quaternion_constructor, 0 );
sq_newslot ( vm, -3, false );
sq_pushstring ( vm, "apply", -1 );
sq_newclosure ( vm, _quaternion_apply, 0 );
sq_newslot ( vm, -3, false );
sq_pushstring ( vm, "applyInversed", -1 );
sq_newclosure ( vm, _quaternion_applyinversed, 0 );
sq_newslot ( vm, -3, false );
// create_vector class
sq_newslot ( vm, -3, false );
}
sq_poptop ( vm );
}
//------------------------------------------------------------------------------
void setupScriptSystem_Math (ScriptSystem* scriptsystem)
{
if (scriptsystem == 0)
return;
HSQUIRRELVM vm = scriptsystem->getVM();
if (vm)
{
_setup_basic_math (vm);
_register_vector_class(vm);
_register_quaternion_class(vm);
}
}
} // namespace BlueCore