MathToolkit.cpp

Go to the documentation of this file.

#include "Prerequisites.h"
#include "Smoothers.h"
 
int OBJSMOOTHERSCOL;
 
int Random(int mi, int mx)
{
  int d = mx - mi + 1;
  return static_cast<int>(((static_cast<double>(rand()) / (static_cast<double>(RAND_MAX) + 1.0)) * d) + mi);
}
 
const BtQuaternion BtQuaternion::IDENTITY(1.0f, 0.0f, 0.0f, 0.0f);
 
// Smoother destruction callback
int destroySmootherObj(mmachine m, SCOL_PTR_TYPE handsys, int obj)
{
  ISmoother* smoother = MMgetPointer<ISmoother*>(m, MTOP(obj));
  SAFE_DELETE(smoother);
  MMsetPointer<ISmoother*>(m, MTOP(obj), 0);
 
  MMechostr(MSKDEBUG, "ObjSmoother destroyed.\n");
  return 0;
}
 
 
// Push value to a smoother from interface
void pushValue(ISmoother* smoother, float value1, float value2, float value3)
{
  int type = smoother->getSmootherType();
  switch (type)
  {
  case SMOOTHER_TYPE_FLOAT:
    static_cast<TSmoother<float>*>(smoother)->pushValue(value1);
    break;
  case SMOOTHER_TYPE_VEC2:
    static_cast<TSmoother<Vector2>*>(smoother)->pushValue(Vector2(value1, value2));
    break;
  case SMOOTHER_TYPE_VEC3:
    static_cast<TSmoother<Vector3>*>(smoother)->pushValue(Vector3(value1, value2, value3));
    break;
  default:
    break;
  }
}
 
// Get smoothed value from a smoother interface
void getSmoothedValue(ISmoother* smoother, float& value1, float& value2, float& value3)
{
  int type = smoother->getSmootherType();
  switch (type)
  {
  case SMOOTHER_TYPE_FLOAT:
  {
    value1 = static_cast<TSmoother<float>*>(smoother)->getSmoothedValue();
    value2 = 0.0f;
    value3 = 0.0f;
  }
    break;
  case SMOOTHER_TYPE_VEC2:
  {
    Vector2 val = static_cast<TSmoother<Vector2>*>(smoother)->getSmoothedValue();
    value1 = val.x;
    value2 = val.y;
    value3 = 0.0f;
  }
    break;
  case SMOOTHER_TYPE_VEC3:
  {
    Vector3 val = static_cast<TSmoother<Vector3>*>(smoother)->getSmoothedValue();
    value1 = val.x;
    value2 = val.y;
    value3 = val.z;
  }
    break;
  default:
    break;
  }
}
 
// Get extrapolated value from a smoother interface
void getExtrapolatedValue(ISmoother* smoother, float& value1, float& value2, float& value3)
{
  int type = smoother->getSmootherType();
  switch (type)
  {
  case SMOOTHER_TYPE_FLOAT:
  {
    value1 = static_cast<TSmoother<float>*>(smoother)->getExtrapolatedValue();
    value2 = 0.0f;
    value3 = 0.0f;
  }
    break;
  case SMOOTHER_TYPE_VEC2:
  {
    Vector2 val = static_cast<TSmoother<Vector2>*>(smoother)->getExtrapolatedValue();
    value1 = val.x;
    value2 = val.y;
    value3 = 0.0f;
  }
    break;
  case SMOOTHER_TYPE_VEC3:
  {
    Vector3 val = static_cast<TSmoother<Vector3>*>(smoother)->getExtrapolatedValue();
    value1 = val.x;
    value2 = val.y;
    value3 = val.z;
  }
    break;
  default:
    break;
  }
}
 
int _CRsmoother(mmachine m)
{
  MMechostr(MSKDEBUG, "_CRsmoother\n");
 
  int ibeta = MMpull(m);
  int ialpha = MMpull(m);
  int imethod = MMpull(m);
  int itype = MMpull(m);
 
  if ((ibeta == NIL) || (ialpha == NIL) || (imethod == NIL) || (itype == NIL))
  {
    MMechostr(MSKDEBUG, "_CRsmoother: Some arguments are invalid\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  float beta = MTOF(ibeta);
  float alpha = MTOF(ialpha);
  int method = MTOI(imethod);
  int type = MTOI(itype);
 
  ISmoother* smoother = 0;
 
  if (method != SMOOTHER_METHOD_DOUBLEEXP && method != SMOOTHER_METHOD_LINEAR)
  {
    MMechostr(MSKDEBUG, "_CRsmoother: Method is not valid ! Please choose between SMOOTHER_METHOD_DOUBLEEXP and SMOOTHER_METHOD_LINEAR\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  switch (type)
  {
  case SMOOTHER_TYPE_FLOAT:
  {
    if (method == SMOOTHER_METHOD_DOUBLEEXP)
      smoother = new DoubleExponentialSmoother<float>(alpha, beta);
    else if (method == SMOOTHER_METHOD_LINEAR)
      smoother = new LinearSmoother<float>(alpha);
  }
  break;
  case SMOOTHER_TYPE_VEC2:
  {
    if (method == SMOOTHER_METHOD_DOUBLEEXP)
      smoother = new DoubleExponentialSmoother<Vector2>(alpha, beta);
    else if (method == SMOOTHER_METHOD_LINEAR)
      smoother = new LinearSmoother<Vector2>(alpha);
  }
  break;
  case SMOOTHER_TYPE_VEC3:
  {
    if (method == SMOOTHER_METHOD_DOUBLEEXP)
      smoother = new DoubleExponentialSmoother<Vector3>(alpha, beta);
    else if (method == SMOOTHER_METHOD_LINEAR)
      smoother = new LinearSmoother<Vector3>(alpha);
  }
  break;
  default:
    MMechostr(MSKDEBUG, "_CRsmoother: Type is not valid ! Please choose between SMOOTHER_TYPE_FLOAT, SMOOTHER_TYPE_VEC2 and SMOOTHER_TYPE_VEC3\n");
    MMset(m, 0, NIL);
    return 0;
    break;
  }
 
  if (!smoother)
  {
    MMechostr(MSKDEBUG, "_CRsmoother: Couldn't malloc smoother\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if ((MMpushPointer(m, smoother) != 0))
  {
    SAFE_DELETE(smoother);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  return OBJcreate(m, OBJSMOOTHERSCOL, SCOL_PTR smoother, NIL, 0);
}
 
int _CLRsmoother(mmachine m)
{
  MMechostr(MSKDEBUG, "_CLRsmoother");
  int ismoother = MMget(m, 0);
  if (ismoother == NIL)
  {
    MMechostr(MSKDEBUG, "_CLRsmoother: error ! smoother is NIL !\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  ISmoother* smootherOBJ = MMgetPointer<ISmoother*>(m, MTOP(ismoother));
  if (smootherOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  smootherOBJ->clearValues();
 
  return 0;
}
 
int _DSsmoother(mmachine m)
{
  MMechostr(MSKDEBUG, "_DSsmoother\n");
 
  int obj = MMget(m, 0);
  if (obj == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, OBJSMOOTHERSCOL, obj);
 
  MMset(m, 0, ITOM(0));
  return 0;
}
 
int _PUSHsmootherValue1(mmachine m)
{
  int value = MMpull(m);
  int ismoother = MMget(m, 0);
  if (value == NIL || ismoother == NIL)
  {
    MMechostr(MSKDEBUG, "_CLRsmoother: error ! value or smoother is NIL !\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  ISmoother* smootherOBJ = MMgetPointer<ISmoother*>(m, MTOP(ismoother));
  if (smootherOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  pushValue(smootherOBJ, MTOF(value), 0.0f, 0.0f);
  return 0;
}
 
int _PUSHsmootherValue2(mmachine m)
{
  int value2 = MMpull(m);
  int value1 = MMpull(m);
  int ismoother = MMget(m, 0);
  if (value1 == NIL || value2 == NIL || ismoother == NIL)
  {
    MMechostr(MSKDEBUG, "_CLRsmoother: error ! value or smoother is NIL !\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  ISmoother* smootherOBJ = MMgetPointer<ISmoother*>(m, MTOP(ismoother));
  if (smootherOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  pushValue(smootherOBJ, MTOF(value1), MTOF(value2), 0.0f);
  return 0;
}
 
int _PUSHsmootherValue3(mmachine m)
{
  int value3 = MMpull(m);
  int value2 = MMpull(m);
  int value1 = MMpull(m);
  int ismoother = MMget(m, 0);
  if (value1 == NIL || value2 == NIL || value3 == NIL || ismoother == NIL)
  {
    MMechostr(MSKDEBUG, "_CLRsmoother: error ! value or smoother is NIL !\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  ISmoother* smootherOBJ = MMgetPointer<ISmoother*>(m, MTOP(ismoother));
  if (smootherOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  pushValue(smootherOBJ, MTOF(value1), MTOF(value2), MTOF(value3));
  return 0;
}
 
int _GETsmootherSmoothedValue1(mmachine m)
{
  int ismoother = MMget(m, 0);
  if (ismoother == NIL)
  {
    MMechostr(MSKDEBUG, "_CLRsmoother: error ! smoother is NIL !\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  ISmoother* smootherOBJ = MMgetPointer<ISmoother*>(m, MTOP(ismoother));
  if (smootherOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float value1 = 0.0f, value2 = 0.0f, value3 = 0.0f;
  getSmoothedValue(smootherOBJ, value1, value2, value3);
  MMset(m, 0, FTOM(value1));
  return 0;
}
 
int _GETsmootherSmoothedValue2(mmachine m)
{
  int ismoother = MMget(m, 0);
  if (ismoother == NIL)
  {
    MMechostr(MSKDEBUG, "_CLRsmoother: error ! smoother is NIL !\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  ISmoother* smootherOBJ = MMgetPointer<ISmoother*>(m, MTOP(ismoother));
  if (smootherOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float value1 = 0.0f, value2 = 0.0f, value3 = 0.0f;
  getSmoothedValue(smootherOBJ, value1, value2, value3);
  int tupleSize = MMmalloc(m, 2, TYPETAB);
  if (tupleSize == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMstore(m, tupleSize, 0, FTOM(value1));
  MMstore(m, tupleSize, 1, FTOM(value2));
  MMset(m, 0, PTOM(tupleSize));
  return 0;
}
 
int _GETsmootherSmoothedValue3(mmachine m)
{
  int ismoother = MMget(m, 0);
  if (ismoother == NIL)
  {
    MMechostr(MSKDEBUG, "_CLRsmoother: error ! smoother is NIL !\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  ISmoother* smootherOBJ = MMgetPointer<ISmoother*>(m, MTOP(ismoother));
  if (smootherOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float value1 = 0.0f, value2 = 0.0f, value3 = 0.0f;
  getSmoothedValue(smootherOBJ, value1, value2, value3);
 
  int tupleSize = MMmalloc(m, 3, TYPETAB);
  if (tupleSize == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMstore(m, tupleSize, 0, FTOM(value1));
  MMstore(m, tupleSize, 1, FTOM(value2));
  MMstore(m, tupleSize, 2, FTOM(value3));
  MMset(m, 0, PTOM(tupleSize));
  return 0;
}
 
int _GETsmootherExtrapolatedValue1(mmachine m)
{
  int ismoother = MMget(m, 0);
  if (ismoother == NIL)
  {
    MMechostr(MSKDEBUG, "_CLRsmoother: error ! smoother is NIL !\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  ISmoother* smootherOBJ = MMgetPointer<ISmoother*>(m, MTOP(ismoother));
  if (smootherOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float value1 = 0.0f, value2 = 0.0f, value3 = 0.0f;
  getExtrapolatedValue(smootherOBJ, value1, value2, value3);
  MMset(m, 0, FTOM(value1));
  return 0;
}
 
int _GETsmootherExtrapolatedValue2(mmachine m)
{
  int ismoother = MMget(m, 0);
  if (ismoother == NIL)
  {
    MMechostr(MSKDEBUG, "_CLRsmoother: error ! smoother is NIL !\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  ISmoother* smootherOBJ = MMgetPointer<ISmoother*>(m, MTOP(ismoother));
  if (smootherOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float value1 = 0.0f, value2 = 0.0f, value3 = 0.0f;
  getExtrapolatedValue(smootherOBJ, value1, value2, value3);
  int tupleSize = MMmalloc(m, 2, TYPETAB);
  if (tupleSize == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMstore(m, tupleSize, 0, FTOM(value1));
  MMstore(m, tupleSize, 1, FTOM(value2));
  MMset(m, 0, PTOM(tupleSize));
  return 0;
}
 
int _GETsmootherExtrapolatedValue3(mmachine m)
{
  int ismoother = MMget(m, 0);
  if (ismoother == NIL)
  {
    MMechostr(MSKDEBUG, "_CLRsmoother: error ! smoother is NIL !\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  ISmoother* smootherOBJ = MMgetPointer<ISmoother*>(m, MTOP(ismoother));
  if (smootherOBJ == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float value1 = 0.0f, value2 = 0.0f, value3 = 0.0f;
  getExtrapolatedValue(smootherOBJ, value1, value2, value3);
  int tupleSize = MMmalloc(m, 3, TYPETAB);
  if (tupleSize == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMstore(m, tupleSize, 0, FTOM(value1));
  MMstore(m, tupleSize, 1, FTOM(value2));
  MMstore(m, tupleSize, 2, FTOM(value3));
  MMset(m, 0, PTOM(tupleSize));
  return 0;
}
 
NativeDefinition base_math_tk[] = {
  { "ObjSmoother", TYPTYPE, NULL, NULL },
  { "SMOOTHER_TYPE_UNDEFINED", TYPVAR, "I", SCOL_TYPTYPE(SMOOTHER_TYPE_UNDEFINED) },
  { "SMOOTHER_TYPE_FLOAT", TYPVAR, "I", SCOL_TYPTYPE(SMOOTHER_TYPE_FLOAT) },
  { "SMOOTHER_TYPE_VEC2", TYPVAR, "I", SCOL_TYPTYPE(SMOOTHER_TYPE_VEC2) },
  { "SMOOTHER_TYPE_VEC3", TYPVAR, "I", SCOL_TYPTYPE(SMOOTHER_TYPE_VEC3) },
 
  { "SMOOTHER_METHOD_UNDEFINED", TYPVAR, "I", SCOL_TYPTYPE(SMOOTHER_METHOD_UNDEFINED) },
  { "SMOOTHER_METHOD_LINEAR", TYPVAR, "I", SCOL_TYPTYPE(SMOOTHER_METHOD_LINEAR) },
  { "SMOOTHER_METHOD_DOUBLEEXP", TYPVAR, "I", SCOL_TYPTYPE(SMOOTHER_METHOD_DOUBLEEXP) },
 
  { "_CRsmoother", 5, "fun [Chn I I F F] ObjSmoother", _CRsmoother },
  { "_CLRsmoother", 1, "fun [ObjSmoother] ObjSmoother", _CLRsmoother },
  { "_DSsmoother", 1, "fun [ObjSmoother] I", _DSsmoother },
 
  { "_PUSHsmootherValue1", 2, "fun [ObjSmoother F] ObjSmoother", _PUSHsmootherValue1 },
  { "_PUSHsmootherValue2", 3, "fun [ObjSmoother F F] ObjSmoother", _PUSHsmootherValue2 },
  { "_PUSHsmootherValue3", 4, "fun [ObjSmoother F F F] ObjSmoother", _PUSHsmootherValue3 },
 
  { "_GETsmootherSmoothedValue1", 1, "fun [ObjSmoother] F", _GETsmootherSmoothedValue1 },
  { "_GETsmootherSmoothedValue2", 1, "fun [ObjSmoother] [F F]", _GETsmootherSmoothedValue2 },
  { "_GETsmootherSmoothedValue3", 1, "fun [ObjSmoother] [F F F]", _GETsmootherSmoothedValue3 },
 
  { "_GETsmootherExtrapolatedValue1", 1, "fun [ObjSmoother] F", _GETsmootherExtrapolatedValue1 },
  { "_GETsmootherExtrapolatedValue2", 1, "fun [ObjSmoother] [F F]", _GETsmootherExtrapolatedValue2 },
  { "_GETsmootherExtrapolatedValue3", 1, "fun [ObjSmoother] [F F F]", _GETsmootherExtrapolatedValue3 }
};
 
int LoadMathToolkit(mmachine m)
{
  int k;
  MMechostr(MSKDEBUG, " > Loading MathToolkit\n");
  OBJSMOOTHERSCOL = OBJregister(0, 0, destroySmootherObj, "OBJSMOOTHERSCOL");
  k = PKhardpak2(m, "math_toolkit.pkg", sizeof(base_math_tk) / sizeof(base_math_tk[0]), base_math_tk);
  MMechostr(MSKDEBUG, " > Successfully Loaded\n\n");
  return k;
}