Tribes2/engine
1
0
Fork 0
mirror of https://github.com/tribes2/engine.git synced 2026-01-20 03:34:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
engine/math/mathTypes.cc
loop ff569bd2ae t2 engine svn checkout
2024-01-07 04:36:33 +00:00

547 lines
18 KiB
C++
Raw Blame History

//-----------------------------------------------------------------------------
// V12 Engine
//
// Copyright (c) 2001 GarageGames.Com
// Portions Copyright (c) 2001 by Sierra Online, Inc.
//-----------------------------------------------------------------------------
#include "console/consoleTypes.h"
#include "console/console.h"
#include "Math/mPoint.h"
#include "Math/mMatrix.h"
#include "Math/mRect.h"
#include "Math/mBox.h"
#include "Math/mathTypes.h"
#include "Math/mRandom.h"
//------------------------------------------------------------------------------
static const char* getDataTypePoint2I(void *dptr, EnumTable *, BitSet32 /*flag*/)
{
Point2I *pt = (Point2I *) dptr;
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer, 256, "%d %d", pt->x, pt->y);
return returnBuffer;
}
static void setDataTypePoint2I(void *dptr, S32 argc, const char **argv, EnumTable *, BitSet32 /*flag*/)
{
if(argc == 1)
dSscanf(argv[0], "%d %d", &((Point2I *) dptr)->x, &((Point2I *) dptr)->y);
else if(argc == 2)
*((Point2I *) dptr) = Point2I(dAtoi(argv[0]), dAtoi(argv[1]));
else
Con::printf("Point2I must be set as { x, y } or \"x y\"");
}
static const char* getDataTypePoint2F(void *dptr, EnumTable *, BitSet32 /*flag*/)
{
Point2F *pt = (Point2F *) dptr;
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer, 256, "%f %f", pt->x, pt->y);
return returnBuffer;
}
static void setDataTypePoint2F(void *dptr, S32 argc, const char **argv, EnumTable *, BitSet32 /*flag*/)
{
if(argc == 1)
dSscanf(argv[0], "%f %f", &((Point2F *) dptr)->x, &((Point2F *) dptr)->y);
else if(argc == 2)
*((Point2F *) dptr) = Point2F(dAtof(argv[0]), dAtof(argv[1]));
else
Con::printf("Point2F must be set as { x, y } or \"x y\"");
}
static const char *getDataTypePoint3F(void *dptr, EnumTable *, BitSet32 /*flag*/)
{
Point3F *pt = (Point3F *) dptr;
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer, 256, "%g %g %g", pt->x, pt->y, pt->z);
return returnBuffer;
}
static void setDataTypePoint3F(void *dptr, S32 argc, const char **argv, EnumTable *, BitSet32 /*flag*/)
{
if(argc == 1)
dSscanf(argv[0], "%f %f %f", &((Point3F *) dptr)->x, &((Point3F *) dptr)->y, &((Point3F *) dptr)->z);
else if(argc == 3)
*((Point3F *) dptr) = Point3F(dAtof(argv[0]), dAtof(argv[1]), dAtof(argv[2]));
else
Con::printf("Point3F must be set as { x, y, z } or \"x y z\"");
}
static const char *getDataTypePoint4F(void *dptr, EnumTable *, BitSet32 /*flag*/)
{
Point4F *pt = (Point4F *) dptr;
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer, 256, "%g %g %g %g", pt->x, pt->y, pt->z, pt->w);
return returnBuffer;
}
static void setDataTypePoint4F(void *dptr, S32 argc, const char **argv, EnumTable *, BitSet32 /*flag*/)
{
if(argc == 1)
dSscanf(argv[0], "%f %f %f %f", &((Point4F *) dptr)->x, &((Point4F *) dptr)->y, &((Point4F *) dptr)->z, &((Point4F *) dptr)->w);
else if(argc == 4)
*((Point4F *) dptr) = Point4F(dAtof(argv[0]), dAtof(argv[1]), dAtof(argv[2]), dAtof(argv[3]));
else
Con::printf("Point3F must be set as { x, y, z, w } or \"x y z w\"");
}
static const char *getDataTypeRectI(void *dptr, EnumTable *, BitSet32 /*flag*/)
{
RectI *rect = (RectI *) dptr;
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer, 256, "%d %d %d %d", rect->point.x, rect->point.y,
rect->extent.x, rect->extent.y);
return returnBuffer;
}
static void setDataTypeRectI(void *dptr, S32 argc, const char **argv, EnumTable *, BitSet32 /*flag*/)
{
if(argc == 1)
dSscanf(argv[0], "%d %d %d %d", &((RectI *) dptr)->point.x, &((RectI *) dptr)->point.y,
&((RectI *) dptr)->extent.x, &((RectI *) dptr)->extent.y);
else if(argc == 4)
*((RectI *) dptr) = RectI(dAtoi(argv[0]), dAtoi(argv[1]), dAtoi(argv[2]), dAtoi(argv[3]));
else
Con::printf("RectI must be set as { x, y, w, h } or \"x y w h\"");
}
static const char *getDataTypeRectF(void *dptr, EnumTable *, BitSet32 /*flag*/)
{
RectF *rect = (RectF *) dptr;
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer, 256, "%f %f %f %f", rect->point.x, rect->point.y,
rect->extent.x, rect->extent.y);
return returnBuffer;
}
static void setDataTypeRectF(void *dptr, S32 argc, const char **argv, EnumTable *, BitSet32 /*flag*/)
{
if(argc == 1)
dSscanf(argv[0], "%f %f %f %f", &((RectF *) dptr)->point.x, &((RectF *) dptr)->point.y,
&((RectF *) dptr)->extent.x, &((RectF *) dptr)->extent.y);
else if(argc == 4)
*((RectF *) dptr) = RectF(dAtof(argv[0]), dAtof(argv[1]), dAtof(argv[2]), dAtof(argv[3]));
else
Con::printf("RectF must be set as { x, y, w, h } or \"x y w h\"");
}
static const char *getDataTypeMatrixPosition(void *dptr, EnumTable *, BitSet32 /*flag*/)
{
F32 *col = (F32 *) dptr + 3;
char* returnBuffer = Con::getReturnBuffer(256);
if(col[12] == 1.f)
dSprintf(returnBuffer, 256, "%g %g %g", col[0], col[4], col[8]);
else
dSprintf(returnBuffer, 256, "%g %g %g %g", col[0], col[4], col[8], col[12]);
return returnBuffer;
}
static void setDataTypeMatrixPosition(void *dptr, S32 argc, const char **argv, EnumTable *, BitSet32 /*flag*/)
{
F32 *col = ((F32 *) dptr) + 3;
if (argc == 1)
{
col[0] = col[4] = col[8] = 0.f;
col[12] = 1.f;
dSscanf(argv[0], "%g %g %g %g", &col[0], &col[4], &col[8], &col[12]);
}
else
if (argc <= 4) {
for (S32 i = 0; i < argc; i++)
col[i << 2] = dAtoi(argv[i]);
}
else
Con::printf("Matrix position must be set as { x, y, z, w } or \"x y z w\"");
}
static const char *getDataTypeMatrixRotation(void * dptr, EnumTable *, BitSet32 /*flag*/)
{
AngAxisF aa(*(MatrixF *) dptr);
aa.axis.normalize();
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer,256,"%g %g %g %g",aa.axis.x,aa.axis.y,aa.axis.z,mRadToDeg(aa.angle));
return returnBuffer;
}
static void setDataTypeMatrixRotation(void *dptr, S32 argc, const char **argv, EnumTable *, BitSet32 /*flag*/)
{
// DMM: Note that this will ONLY SET the ULeft 3x3 submatrix.
//
AngAxisF aa(Point3F(0,0,0),0);
if (argc == 1)
{
dSscanf(argv[0], "%g %g %g %g", &aa.axis.x, &aa.axis.y, &aa.axis.z, &aa.angle);
aa.angle = mDegToRad(aa.angle);
}
else
if (argc == 4) {
for (S32 i = 0; i < argc; i++)
((F32*)&aa)[i] = dAtof(argv[i]);
aa.angle = mDegToRad(aa.angle);
}
else
Con::printf("Matrix rotation must be set as { x, y, z, angle } or \"x y z angle\"");
//
MatrixF temp;
aa.setMatrix(&temp);
F32* pDst = *(MatrixF *)dptr;
const F32* pSrc = temp;
for (U32 i = 0; i < 3; i++)
for (U32 j = 0; j < 3; j++)
pDst[i*4 + j] = pSrc[i*4 + j];
}
static const char *getDataTypeBox3F(void * dptr, EnumTable *, BitSet32 /*flag*/)
{
const Box3F* pBox = (const Box3F*)dptr;
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer, 256, "%g %g %g %g %g %g",
pBox->min.x, pBox->min.y, pBox->min.z,
pBox->max.x, pBox->max.y, pBox->max.z);
return returnBuffer;
}
static void setDataTypeBox3F(void *dptr, S32 argc, const char **argv, EnumTable *, BitSet32 /*flag*/)
{
Box3F* pDst = (Box3F*)dptr;
if (argc == 1) {
U32 args = dSscanf(argv[0], "%f %f %f %f %f %f",
&pDst->min.x, &pDst->min.y, &pDst->min.z,
&pDst->max.x, &pDst->max.y, &pDst->max.z);
AssertWarn(args == 6, "Warning, box probably not read properly");
} else {
Con::printf("Box3F must be set as \"xMin yMin zMin xMax yMax zMax\"");
}
}
//----------------------------------------------------------------------------
static const char* cVectorAdd(SimObject *, S32, const char ** argv)
{
VectorF v1(0,0,0),v2(0,0,0);
dSscanf(argv[1],"%f %f %f",&v1.x,&v1.y,&v1.z);
dSscanf(argv[2],"%f %f %f",&v2.x,&v2.y,&v2.z);
VectorF v;
v = v1 + v2;
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer,256,"%g %g %g",v.x,v.y,v.z);
return returnBuffer;
}
static const char* cVectorSub(SimObject *, S32, const char ** argv)
{
VectorF v1(0,0,0),v2(0,0,0);
dSscanf(argv[1],"%f %f %f",&v1.x,&v1.y,&v1.z);
dSscanf(argv[2],"%f %f %f",&v2.x,&v2.y,&v2.z);
VectorF v;
v = v1 - v2;
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer,256,"%g %g %g",v.x,v.y,v.z);
return returnBuffer;
}
static const char* cVectorScale(SimObject *, S32, const char ** argv)
{
VectorF v(0,0,0);
dSscanf(argv[1],"%f %f %f",&v.x,&v.y,&v.z);
v *= dAtof(argv[2]);
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer,256,"%g %g %g",v.x,v.y,v.z);
return returnBuffer;
}
static const char* cVectorNormalize(SimObject *, S32, const char ** argv)
{
VectorF v(0,0,0);
dSscanf(argv[1],"%f %f %f",&v.x,&v.y,&v.z);
if (v.len() != 0)
v.normalize();
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer,256,"%g %g %g",v.x,v.y,v.z);
return returnBuffer;
}
static F32 cVectorDot(SimObject *, S32, const char ** argv)
{
VectorF v1(0,0,0),v2(0,0,0);
dSscanf(argv[1],"%f %f %f",&v1.x,&v1.y,&v1.z);
dSscanf(argv[2],"%f %f %f",&v2.x,&v2.y,&v2.z);
return mDot(v1,v2);
}
static const char* cVectorCross(SimObject *, S32, const char ** argv)
{
VectorF v1(0,0,0),v2(0,0,0);
dSscanf(argv[1],"%f %f %f",&v1.x,&v1.y,&v1.z);
dSscanf(argv[2],"%f %f %f",&v2.x,&v2.y,&v2.z);
VectorF v;
mCross(v1,v2,&v);
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer,256,"%g %g %g",v.x,v.y,v.z);
return returnBuffer;
}
static const char* cVectorDist(SimObject *, S32, const char ** argv)
{
VectorF v1(0,0,0),v2(0,0,0);
dSscanf(argv[1],"%f %f %f",&v1.x,&v1.y,&v1.z);
dSscanf(argv[2],"%f %f %f",&v2.x,&v2.y,&v2.z);
VectorF v = v2 - v1;
float dist = mSqrt((v.x * v.x) + (v.y * v.y) + (v.z * v.z));
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer,256,"%g",dist);
return returnBuffer;
}
static const char* cVectorLen(SimObject *, S32, const char ** argv)
{
VectorF v(0,0,0);
dSscanf(argv[1],"%f %f %f",&v.x,&v.y,&v.z);
float dist = mSqrt((v.x * v.x) + (v.y * v.y) + (v.z * v.z));
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer,256,"%g",dist);
return returnBuffer;
}
static const char* cVectorOrthoBasis(SimObject *, S32, const char ** argv)
{
AngAxisF aa;
dSscanf(argv[1],"%f %f %f %f", &aa.axis.x,&aa.axis.y,&aa.axis.z,&aa.angle);
MatrixF mat;
aa.setMatrix(&mat);
Point3F col0, col1, col2;
mat.getColumn(0, &col0);
mat.getColumn(1, &col1);
mat.getColumn(2, &col2);
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer,256,"%g %g %g %g %g %g %g %g %g",
col0.x, col0.y, col0.z, col1.x, col1.y, col1.z, col2.x, col2.y, col2.z);
return returnBuffer;
}
static const char* cMatrixCreate(SimObject *, S32, const char ** argv)
{
Point3F pos;
dSscanf(argv[1], "%g %g %g", &pos.x, &pos.y, &pos.z);
AngAxisF aa(Point3F(0,0,0),0);
dSscanf(argv[2], "%g %g %g %g", &aa.axis.x, &aa.axis.y, &aa.axis.z, &aa.angle);
aa.angle = mDegToRad(aa.angle);
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer, 255, "%g %g %g %g %g %g %g",
pos.x, pos.y, pos.z,
aa.axis.x, aa.axis.y, aa.axis.z,
aa.angle);
return returnBuffer;
}
static const char* cMatrixCreateFromEuler(SimObject *, S32, const char ** argv)
{
EulerF rot;
dSscanf(argv[1], "%g %g %g", &rot.x, &rot.y, &rot.z);
QuatF rotQ(rot);
AngAxisF aa;
aa.set(rotQ);
char* ret = Con::getReturnBuffer(256);
dSprintf(ret, 255, "0 0 0 %g %g %g %g",aa.axis.x,aa.axis.y,aa.axis.z,aa.angle);
return ret;
}
static const char* cMatrixMultiply(SimObject *, S32, const char ** argv)
{
Point3F pos1;
AngAxisF aa1(Point3F(0,0,0),0);
dSscanf(argv[1], "%g %g %g %g %g %g %g", &pos1.x, &pos1.y, &pos1.z, &aa1.axis.x, &aa1.axis.y, &aa1.axis.z, &aa1.angle);
MatrixF temp1(true);
aa1.setMatrix(&temp1);
temp1.setColumn(3, pos1);
Point3F pos2;
AngAxisF aa2(Point3F(0,0,0),0);
dSscanf(argv[2], "%g %g %g %g %g %g %g", &pos2.x, &pos2.y, &pos2.z, &aa2.axis.x, &aa2.axis.y, &aa2.axis.z, &aa2.angle);
MatrixF temp2(true);
aa2.setMatrix(&temp2);
temp2.setColumn(3, pos2);
temp1.mul(temp2);
Point3F pos;
AngAxisF aa(temp1);
aa.axis.normalize();
temp1.getColumn(3, &pos);
char* ret = Con::getReturnBuffer(256);
dSprintf(ret, 255, "%g %g %g %g %g %g %g",
pos.x, pos.y, pos.z,
aa.axis.x, aa.axis.y, aa.axis.z,
aa.angle);
return ret;
}
static const char* cMatrixMulVector(SimObject *, S32, const char ** argv)
{
Point3F pos1;
AngAxisF aa1(Point3F(0,0,0),0);
dSscanf(argv[1], "%g %g %g %g %g %g %g", &pos1.x, &pos1.y, &pos1.z, &aa1.axis.x, &aa1.axis.y, &aa1.axis.z, &aa1.angle);
MatrixF temp1(true);
aa1.setMatrix(&temp1);
temp1.setColumn(3, pos1);
Point3F vec1;
dSscanf(argv[2], "%g %g %g", &vec1.x, &vec1.y, &vec1.z);
Point3F result;
temp1.mulV(vec1, &result);
char* ret = Con::getReturnBuffer(256);
dSprintf(ret, 255, "%g %g %g", result.x, result.y, result.z);
return ret;
}
static const char* cMatrixMulPoint(SimObject *, S32, const char ** argv)
{
Point3F pos1;
AngAxisF aa1(Point3F(0,0,0),0);
dSscanf(argv[1], "%g %g %g %g %g %g %g", &pos1.x, &pos1.y, &pos1.z, &aa1.axis.x, &aa1.axis.y, &aa1.axis.z, &aa1.angle);
MatrixF temp1(true);
aa1.setMatrix(&temp1);
temp1.setColumn(3, pos1);
Point3F vec1;
dSscanf(argv[2], "%g %g %g", &vec1.x, &vec1.y, &vec1.z);
Point3F result;
temp1.mulP(vec1, &result);
char* ret = Con::getReturnBuffer(256);
dSprintf(ret, 255, "%g %g %g", result.x, result.y, result.z);
return ret;
}
//----------------------------------------------------------------------------
static const char* cGetBoxCenter(SimObject *, S32, const char ** argv)
{
Box3F box;
box.min.set(0,0,0);
box.max.set(0,0,0);
dSscanf(argv[1],"%f %f %f %f %f %f",
&box.min.x,&box.min.y,&box.min.z,
&box.max.x,&box.max.y,&box.max.z);
Point3F p;
box.getCenter(&p);
char* returnBuffer = Con::getReturnBuffer(256);
dSprintf(returnBuffer,256,"%g %g %g",p.x,p.y,p.z);
return returnBuffer;
}
//------------------------------------------------------------------------------
static void cSetRandomSeed(SimObject *, S32 argc, const char ** argv)
{
U32 seed = Platform::getRealMilliseconds();
if (argc == 2)
seed = dAtoi(argv[1]);
MRandomLCG::setGlobalRandSeed(seed);
}
static S32 cGetRandomSeed(SimObject *, S32, const char **)
{
return gRandGen.getSeed();
}
S32 mRandI(S32 i1, S32 i2)
{
return gRandGen.randI(i1, i2);
}
F32 mRandF(F32 f1, F32 f2)
{
return gRandGen.randF(f1, f2);
}
static F32 cGetRandom(SimObject *, S32 argc, const char **argv)
{
if (argc == 2)
return F32(gRandGen.randI(0,dAtoi(argv[1])));
else
{
if (argc == 3) {
S32 min = dAtoi(argv[1]);
S32 max = dAtoi(argv[2]);
if (min > max) {
S32 t = min;
min = max;
max = t;
}
return F32(gRandGen.randI(min,max));
}
}
return gRandGen.randF();
}
//------------------------------------------------------------------------------
void RegisterMathTypes(void)
{
//register persistent types
Con::registerType(TypePoint2I, sizeof(Point2I), getDataTypePoint2I, setDataTypePoint2I);
Con::registerType(TypePoint2F, sizeof(Point2F), getDataTypePoint2F, setDataTypePoint2F);
Con::registerType(TypePoint3F, sizeof(Point3F), getDataTypePoint3F, setDataTypePoint3F);
Con::registerType(TypePoint4F, sizeof(Point4F), getDataTypePoint4F, setDataTypePoint4F);
Con::registerType(TypeRectI, sizeof(RectI), getDataTypeRectI, setDataTypeRectI);
Con::registerType(TypeRectF, sizeof(RectF), getDataTypeRectF, setDataTypeRectF);
Con::registerType(TypeMatrixPosition, sizeof(4*sizeof(F32)), getDataTypeMatrixPosition, setDataTypeMatrixPosition);
Con::registerType(TypeMatrixRotation, sizeof(MatrixF), getDataTypeMatrixRotation, setDataTypeMatrixRotation);
Con::registerType(TypeBox3F, sizeof(Box3F), getDataTypeBox3F, setDataTypeBox3F);
}
void RegisterMathFunctions(void)
{
Con::addCommand("VectorAdd", cVectorAdd, "VectorAdd(vec1,vec2)", 3, 3);
Con::addCommand("VectorSub", cVectorSub, "VectorSub(vec1,vec2)", 3, 3);
Con::addCommand("VectorScale", cVectorScale, "VectorScale(vec,scaler)", 3, 3);
Con::addCommand("VectorNormalize", cVectorNormalize, "VectorNormalize(vec)", 2, 2);
Con::addCommand("VectorDot", cVectorDot, "VectorDot(vec1,vec2)", 3, 3);
Con::addCommand("VectorCross", cVectorCross, "VectorCross(vec1,vec2)", 3, 3);
Con::addCommand("VectorDist", cVectorDist, "VectorDist(vec1,vec2)", 3, 3);
Con::addCommand("VectorLen", cVectorLen, "VectorLen(vec)", 2, 2);
Con::addCommand("VectorOrthoBasis", cVectorOrthoBasis, "VectorOrthoBasis(AngAxisF)", 2, 2);
Con::addCommand("MatrixCreate", cMatrixCreate, "MatrixCreate(Pos, Rot)", 3, 3);
Con::addCommand("MatrixMultiply", cMatrixMultiply, "MatrixMultiply(Left, Right)", 3, 3);
Con::addCommand("MatrixMulVector", cMatrixMulVector, "MatrixMulVector(transform, vector)", 3, 3);
Con::addCommand("MatrixMulPoint", cMatrixMulPoint, "MatrixMulPoint(transform, point)", 3, 3);
Con::addCommand("getBoxCenter", cGetBoxCenter, "getBoxCenter(Box)", 2, 2);
Con::addCommand("setRandomSeed", cSetRandomSeed, "setRandomSeed([seed])", 1, 2);
Con::addCommand("getRandomSeed", cGetRandomSeed, "getRandomSeed()", 1, 1);
Con::addCommand("getRandom", cGetRandom, "getRandom([[max]||[min,max]])", 1, 3);
Con::addCommand("MatrixCreateFromEuler", cMatrixCreateFromEuler, "MatrixCreateFromEuler(\"x y z\")", 2, 2);
}
Reference in a new issue View git blame Copy permalink