void Slice::drawPolygon(Polygons &pgs, int layer){
glColor4f(0.0f, 1.0f, 0.0f, 0.25f);
GLUtesselator* tess = gluNewTess();
gluTessCallback(tess, GLU_TESS_BEGIN, (GLvoid (__stdcall *) ())&BeginCallback);
gluTessCallback(tess, GLU_TESS_VERTEX, (GLvoid (__stdcall *) ())&VertexCallback);
gluTessCallback(tess, GLU_TESS_END, (GLvoid (__stdcall *) ())&EndCallback);
gluTessCallback(tess, GLU_TESS_COMBINE, (GLvoid (__stdcall *) ())&CombineCallback);
gluTessCallback(tess, GLU_TESS_ERROR, (GLvoid (__stdcall *) ())&ErrorCallback);
gluTessNormal(tess, 0.0, 0.0, 1.0);
gluTessProperty(tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
gluTessProperty(tess, GLU_TESS_BOUNDARY_ONLY, GL_FALSE); //GL_FALSE
gluTessBeginPolygon(tess, NULL);
glPushMatrix();
glTranslated(0.0,0.0,this->layerHeight*layer);
for (Polygons::size_type i = 0; i < pgs.size(); ++i)
{
gluTessBeginContour(tess);
for (ClipperLib::Polygon::size_type j = 0; j < pgs[i].size(); ++j)
{
GLdouble *vert =
NewVector((GLdouble)pgs[i][j].X/1000, (GLdouble)pgs[i][j].Y/1000);
gluTessVertex(tess, vert, vert);
}
gluTessEndContour(tess);
}
gluTessEndPolygon(tess);
ClearVectors();
glColor4f(0.0f, 0.6f, 1.0f, 0.5f);
glLineWidth(1.8f);
gluTessProperty(tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
gluTessProperty(tess, GLU_TESS_BOUNDARY_ONLY, GL_TRUE);
for (Polygons::size_type i = 0; i < pgs.size(); ++i)
{
gluTessBeginPolygon(tess, NULL);
gluTessBeginContour(tess);
for (ClipperLib::Polygon::size_type j = 0; j < pgs[i].size(); ++j)
{
GLdouble *vert =
NewVector((GLdouble)pgs[i][j].X/1000, (GLdouble)pgs[i][j].Y/1000);
gluTessVertex(tess, vert, vert);
}
glColor4f(0.0f, 0.0f, 0.8f, 0.5f);
gluTessEndContour(tess);
gluTessEndPolygon(tess);
}
//final cleanup ...
gluDeleteTess(tess);
ClearVectors();
glPopMatrix();
}
// 向量乘以矩阵,该乘法也可是使用矩阵转置和MtxVecMultiple函数实现，
// 但是考虑到系统矩阵太大，矩阵转置消耗内存，因此不使用
int SprsMtxOperator::VecMtxMultiple(Vector& InVec, const SparseMtx& Mtx, Vector& ResultVec)
{
int i;
int iRowNum;
int iColNum;
int iTotElemNum;
int iVecNum;
iRowNum = Mtx.n_rows;
iColNum = Mtx.n_cols;
iTotElemNum = Mtx.n_actual_ELEM;
iVecNum = InVec.iNum;
if ( iRowNum != iVecNum || iColNum != ResultVec.iNum )
{
printf("Dimensions of matrix and vector mismatch\n");
return (-1);
}
Vector NewVector(iColNum);
NewVector. Initilize();
for ( i = 0; i < iTotElemNum; i++ )
{
NewVector.pdData[Mtx.items[i].col] += Mtx.items[i].val * InVec.pdData[Mtx.items[i].row];
}
for ( i = 0; i < ResultVec.iNum; i++ )
{
ResultVec.pdData[i] = NewVector.pdData[i];
}
return 0;
}
double *CreateVector(SMatrix M)
{
long i, j;
double *b;
b = NewVector(M.n);
for (j=0; j<M.n; j++)
b[j] = 0.0;
if (M.nz) {
for (j=0; j<M.n; j++)
for (i=M.col[j]; i<M.col[j+1]; i++) {
b[M.row[i]] += M.nz[i];
}
}
else {
for (j=0; j<M.n; j++)
for (i=M.col[j]; i<M.col[j+1]; i++) {
b[M.row[i]] += Value(M.row[i], j);
}
}
return(b);
}
VAR * AddUnitVar(VTYPE Type, char * Name, UNIT * Owner)
{
VAR * pNewVar = malloc(sizeof(VAR));
pNewVar->Name = myStrCpy(Name);
pNewVar->Type = Float;
if (Type == Int)
{
int *x = malloc(sizeof(int));
*x = 0;
pNewVar->Data = x;
}
else if (Type == Float)
{
float *x = malloc(sizeof(float));
*x = 0.0;
pNewVar->Data = x;
}
else if (Type == Vector)
{
VECTOR *x = malloc(sizeof(VECTOR));
*x = NewVector(0, 0);
pNewVar->Data = x;
}
else if (Type == String)
{
char **x = malloc(sizeof(char*));
*x = NULL;
pNewVar->Data = x;
}
else if (Type == Color)
{
COLOR newCol = { 1, 1, 1, 1 };
COLOR *x = malloc(sizeof(COLOR));
*x = newCol;
pNewVar->Data = x;
}
else if (Type == Bool)
{
BOOL *x = malloc(sizeof(BOOL));
*x = False;
pNewVar->Data = x;
}
else if (Type == Char)
{
char *x = malloc(sizeof(char));
*x = '\0';
pNewVar->Data = x;
}
else if (Type == Matrix)
{
MATRIX *temp = (MATRIX*)malloc(sizeof(MATRIX));
SecureZeroMemory(temp->m, sizeof(float) * 9);
pNewVar->Data = temp;
}
pNewVar->nextVar = Owner->nextVar;
Owner->nextVar = pNewVar;
return pNewVar;
return NULL;
}
void BloombergVector::RepackVector(){
Q_D(BloombergVector);
if (d->m_VectVal.isEmpty()) {
d->m_Vector = "";
return;
}
QString NewVector("");
int StepSize = 1;
int RampSize = 0;
double PrevVal;
double predictedRamp;
boost::math::tools::eps_tolerance<double> ToleranceMonitor(std::numeric_limits<double>::digits / 2);
PrevVal = d->m_VectVal.at(0);
NewVector += QString("%1").arg(PrevVal*d->m_Divisor);
for (int i = 1; i<d->m_VectVal.size(); i++) {
if (ToleranceMonitor(d->m_VectVal.at(i), PrevVal) && RampSize == 0) {
StepSize++;
}
else {
if (StepSize == 1) {
if (RampSize == 0) {
RampSize++;
predictedRamp = d->m_VectVal.at(i) - PrevVal;
}
else {
if (ToleranceMonitor(d->m_VectVal.at(i) - d->m_VectVal.at(i - 1), predictedRamp)) {
RampSize++;
}
else { //The Ramp is Over
PrevVal = d->m_VectVal.at(--i);
NewVector += QString(" %1%2 %3").arg(RampSize).arg(RampSize>1 ? 'R' : 'S').arg(PrevVal*d->m_Divisor);
RampSize = 0;
}
}
}
else {
PrevVal = d->m_VectVal.at(i);
NewVector += QString(" %1S %2").arg(StepSize).arg(PrevVal*d->m_Divisor);
StepSize = 1;
}
}
}
if (RampSize>0)
NewVector += QString(" %1%2 %3").arg(RampSize).arg(RampSize>1 ? 'R' : 'S').arg(d->m_VectVal.last()*d->m_Divisor);
d->m_Vector = NewVector;
}
//Creates an empty Level.
LEVEL * AddLevel(GAME * pGame, char *Name, int Order)
{
LEVEL * pNewLevel = malloc(sizeof(LEVEL));
CAMERA * pCam = malloc(sizeof(CAMERA));
pCam->Position = NewVector(0, 0);
pCam->Zoom = 48;
pNewLevel->Name = myStrCpy(Name);
pNewLevel->Order = Order;
pNewLevel->pCamera = pCam;
pNewLevel->nextUnit = NULL;
pNewLevel->pGame = pGame;
pNewLevel->nextLevel = pGame->nextLevel;
pGame->nextLevel = pNewLevel;
return pNewLevel;
}
// 矩阵乘以向量
int SprsMtxOperator::MtxVecMultiple(const SparseMtx& Mtx, Vector& InVec, Vector& ResultVec)
{
int i;
int iRowNum;
int iColNum;
int iTotElemNum;
int iVecNum;
iRowNum = Mtx.n_rows;
iColNum = Mtx.n_cols;
iTotElemNum = Mtx.n_actual_ELEM;
iVecNum = InVec.iNum;
if ( iColNum != iVecNum || iRowNum != ResultVec.iNum )
{
printf("Dimensions of matrix and vector mismatch\n");
return (-1);
}
Vector NewVector(iRowNum);
NewVector.Initilize();
for ( i = 0; i < iTotElemNum; i++ ) //iTotElemNum是2506949 iRowNum是16384 row的最大是为16384 col的最大是为16384 pdData最大值为16384
{ // cout<<NewVector.pdData[Mtx.items[i].row-1]<<"+";
NewVector.pdData[Mtx.items[i].row] += Mtx.items[i].val*InVec.pdData[Mtx.items[i].col];
//cout<<Mtx.items[i].val<<"*"<<InVec.pdData[Mtx.items[i].col-1]<<"="<<NewVector.pdData[Mtx.items[i].row-1]<<endl;
}
//cout<<Mtx.items[i].val<<"*"<<InVec.pdData[Mtx.items[i].col-1]<<"="<<NewVector.pdData[Mtx.items[i].row-1]<<endl;
for ( i = 0; i < ResultVec.iNum; i++ )
{
ResultVec.pdData[i] = NewVector.pdData[i];
}
return 0;
}
void InterpretArchetype(FILE * fpArch)
{
char buffer[MAX_LENGTH];
ARCHETYPE * pNewArchetype = malloc(sizeof(ARCHETYPE));
COMPONENT * pCurrComp = NULL;
pNewArchetype->Name = "Untitled";
pNewArchetype->nextArchetype = NULL;
pNewArchetype->nextComponent = NULL;
pNewArchetype->pGame = pTheGame;
pNewArchetype->pUnit = NULL;
pNewArchetype->nextArchetype = pTheGame->nextArchetype;
pTheGame->nextArchetype = pNewArchetype;
while (!feof(fpArch))
{
if (fgets(buffer, MAX_LENGTH, fpArch))
{
char question[MAX_LENGTH];
int inputInt = 0;
float inputFloat = 0.0f;
VECTOR inputVector = NewVector(0, 0);
AddNull(buffer);
if (buffer[0] != '#' && strlen(buffer) > 2)
{
sscanf(buffer, "%s", &question);
if (myStrCmp(question, "Name") <= 0)
{
char nameInput[MAX_LENGTH];
sscanf(buffer, "Name = %s", nameInput);
pNewArchetype->Name = myStrCpy(nameInput);
continue;
}
if (myStrCmp(question, "Tag") <= 0)
{
char tagInput[MAX_LENGTH];
sscanf(buffer, "Tag = %s", tagInput);
pNewArchetype->Tag = GetTagFromString(tagInput);
continue;
}
if (myStrCmp(question, "COMPONENT") <= 0)
{
COMPONENTTYPE theType;
char typeInput[MAX_LENGTH];
sscanf(buffer, "COMPONENT |%s|", &typeInput);
if (myStrCmp(typeInput, "Sprite") <= 0) theType = Sprite;
if (myStrCmp(typeInput, "Mesh") <= 0) theType = Mesh;
if (myStrCmp(typeInput, "Behavior") <= 0) theType = Behavior;
if (myStrCmp(typeInput, "Physics") <= 0) theType = Physics;
if (myStrCmp(typeInput, "Collider") <= 0) theType = Collider;
if (myStrCmp(typeInput, "KSound") <= 0) theType = KSound;
pCurrComp = AddComponent(pNewArchetype, theType);
continue;
}
if (pCurrComp)
{
if (pCurrComp->Type == Mesh)
{
MESH * pMesh = (MESH*)pCurrComp->pStruct;
if (myStrCmp(question, "Size") <= 0)
{
sscanf(buffer, "\tSize = (%f, %f)", &inputVector.x, &inputVector.y);
pMesh->Size = inputVector;
continue;
}
if (myStrCmp(question, "Color") <= 0)
{
COLOR inputColor;
sscanf(buffer, "\tColor = (%f, %f, %f, %f)", &inputColor.r, &inputColor.g, &inputColor.b, &inputColor.a);
pMesh->Color = inputColor;
continue;
}
if (myStrCmp(question, "Opacity") <= 0)
{
sscanf(buffer, "\tOpacity = %f", &inputFloat);
pMesh->Opacity = inputFloat;
continue;
}
}
if (pCurrComp->Type == Behavior)
{
BEHAVIOR * pBehavior = (BEHAVIOR*)pCurrComp->pStruct;
if (myStrCmp(question, "BehaviorScript") <= 0)
{
char scriptInput[MAX_LENGTH];
sscanf(buffer, "\tBehaviorScript = %s", &scriptInput);
pBehavior->BehaviorScript = GetBehaviorFromString(scriptInput);
continue;
}
}
if (pCurrComp->Type == Physics)
{
PHYSICS * pPhysics = (PHYSICS*)pCurrComp->pStruct;
if (myStrCmp(question, "Gravity") <= 0)
{
sscanf(buffer, "\tGravity = %f", &inputFloat);
pPhysics->Gravity = inputFloat;
continue;
}
if (myStrCmp(question, "MaxSpeed") <= 0)
{
sscanf(buffer, "\tMaxSpeed = %f", &inputFloat);
pPhysics->MaxSpeed = inputFloat;
continue;
}
if (myStrCmp(question, "Friction") <= 0)
{
sscanf(buffer, "\tFriction = %f", &inputFloat);
pPhysics->Friction = inputFloat;
continue;
}
if (myStrCmp(question, "Velocity") <= 0)
{
sscanf(buffer, "\tVelocity = (%f, %f)", &inputVector.x, &inputVector.y);
pPhysics->Velocity = inputVector;
continue;
}
if (myStrCmp(question, "Acceleration") <= 0)
{
sscanf(buffer, "\tAcceleration = (%f, %f)", &inputVector.x, &inputVector.y);
pPhysics->Acceleration = inputVector;
continue;
}
}
if (pCurrComp->Type == Collider)
{
COLLIDER * pCollider = (COLLIDER*)pCurrComp->pStruct;
if (myStrCmp(question, "Offset") <= 0)
{
sscanf(buffer, "\tOffset = (%f, %f)", &inputVector.x, &inputVector.y);
pCollider->Offset = inputVector;
continue;
}
if (myStrCmp(question, "Height") <= 0)
{
sscanf(buffer, "\tHeight = %f", &inputFloat);
pCollider->Height = inputFloat;
continue;
}
if (myStrCmp(question, "Width") <= 0)
{
sscanf(buffer, "\tWidth = %f", &inputFloat);
pCollider->Width = inputFloat;
continue;
}
if (myStrCmp(question, "IsGhosted") <= 0)
{
sscanf(buffer, "\tIsGhosted = %i", &inputInt);
pCollider->IsGhosted = inputInt;
continue;
}
}
if (pCurrComp->Type == KSound)
{
KSOUND * pSound = (KSOUND*)pCurrComp->pStruct;
if (myStrCmp(question, "Volume") <= 0)
{
sscanf(buffer, "\tVolume = %f", &inputFloat);
pSound->Volume = inputFloat;
continue;
}
if (myStrCmp(question, "Positional") <= 0)
{
sscanf(buffer, "\tPositional = %i", &inputInt);
pSound->Positional = inputInt;
continue;
}
if (myStrCmp(question, "MaxReach") <= 0)
{
sscanf(buffer, "\tMaxReach = %f", &inputFloat);
pSound->MaxReach = inputFloat;
continue;
}
if (myStrCmp(question, "SoundFile") <= 0)
{
char scriptInput[MAX_LENGTH];
sscanf(buffer, "\tSoundFile = %s", &scriptInput);
pSound->SoundFile = scriptInput;
continue;
}
if (myStrCmp(question, "PlayOnStart") <= 0)
{
sscanf(buffer, "\tPlayOnStart = %i", &inputInt);
pSound->PlayOnStart = inputInt;
continue;
}
// TODO : Add the rest of the params.
}
if (pCurrComp->Type == Sprite)
{
SPRITE * pSprite = (SPRITE*)pCurrComp->pStruct;
if (myStrCmp(question, "TextureFile") <= 0)
{
int temp;
char textureInput[MAX_LENGTH];
sscanf(buffer, "\tTextureFile = %i , ", &temp);
MultipleAnimations(buffer, temp, pSprite);
continue;
}
if (myStrCmp(question, "Animated") <= 0)
{
sscanf(buffer, "\tAnimated = %i", &inputInt);
pSprite->Animated = inputInt;
continue;
}
if (myStrCmp(question, "RowCol") <= 0)
{
sscanf(buffer, "\tRowCol = (%f, %f)", &inputVector.x, &inputVector.y);
pSprite->RowCol = inputVector;
continue;
}
if (myStrCmp(question, "Offset") <= 0)
{
sscanf(buffer, "\tOffset = (%f, %f)", &inputVector.x, &inputVector.y);
pSprite->Offset = inputVector;
continue;
}
if (myStrCmp(question, "AnimationSpeed") <= 0)
{
sscanf(buffer, "\tAnimationSpeed = %f", &inputFloat);
pSprite->AnimationSpeed = inputFloat;
continue;
}
}
if (myStrCmp(question, "EndComponent") <= 0)
{
pCurrComp = NULL;
continue;
}
}
}
}
}
}
void InterpretLevel(FILE * fpLevel)
{
char buffer[MAX_LENGTH];
LEVEL * pNewLevel = malloc(sizeof(LEVEL));
CAMERA * pCam = malloc(sizeof(CAMERA));
UNIT * pCurrUnit = NULL;
pCam->Position = NewVector(0, 0);
pCam->Zoom = 48;
pNewLevel->Name = "Untitled";
pNewLevel->Order = 0;
pNewLevel->pCamera = pCam;
pNewLevel->nextUnit = NULL;
pNewLevel->pGame = pTheGame;
pNewLevel->nextLevel = pTheGame->nextLevel;
pTheGame->nextLevel = pNewLevel;
while (!feof(fpLevel))
{
if (fgets(buffer, MAX_LENGTH, fpLevel))
{
char question[MAX_LENGTH];
int inputInt = 0;
float inputFloat = 0.0f;
VECTOR inputVector = NewVector(0, 0);
AddNull(buffer);
if (buffer[0] != '#' && strlen(buffer) > 2)
{
sscanf(buffer, "%s", &question);
if ((myStrCmp(question, "Name") <= 0) && pCurrUnit == NULL)
{
char nameInput[MAX_LENGTH];
sscanf(buffer, "Name = %s", nameInput);
pNewLevel->Name = myStrCpy(nameInput);
continue;
}
if (myStrCmp(question, "Order") <= 0)
{
char nameInput[MAX_LENGTH];
sscanf(buffer, "Order = %i", &inputInt);
pNewLevel->Order = inputInt;
continue;
}
if (myStrCmp(question, "UNIT") <= 0)
{
char archInput[MAX_LENGTH];
char nameInput[MAX_LENGTH];
ARCHETYPE * pArchetype = NULL;
sscanf(buffer, "UNIT < %s > %s", &archInput, &nameInput);
pArchetype = FindArchetypeByName(pTheGame, archInput);
pCurrUnit = AddUnit(pNewLevel, pArchetype, myStrCpy(nameInput));
continue;
}
if (pCurrUnit)
{
if (myStrCmp(question, "Tag") <= 0)
{
char tagInput[MAX_LENGTH];
sscanf(buffer, "\tTag = %s", tagInput);
pCurrUnit->Tag = GetTagFromString(tagInput);
continue;
}
if (myStrCmp(question, "InitialPosition") <= 0)
{
sscanf(buffer, "\tInitialPosition = (%f, %f)", &inputVector.x, &inputVector.y);
pCurrUnit->pInitTransform->Position = inputVector;
continue;
}
if (myStrCmp(question, "InitialRotation") <= 0)
{
sscanf(buffer, "\tInitialRotation = %f", &inputFloat);
pCurrUnit->pInitTransform->Rotation = inputFloat;
continue;
}
if (myStrCmp(question, "InitialScale") <= 0)
{
sscanf(buffer, "\tInitialScale = (%f, %f)", &inputVector.x, &inputVector.y);
pCurrUnit->pInitTransform->Scale = inputVector;
continue;
}
if (myStrCmp(question, "VAR") <= 0)
{
VTYPE theType;
VAR * newVar;
char varInput[MAX_LENGTH];
char typeInput[MAX_LENGTH];
char dataInput[MAX_LENGTH];
void * data;
sscanf(buffer, "\tVAR %s : %s = %s", &varInput, &typeInput, &dataInput);
theType = GetVTypeFromString(typeInput);
newVar = AddUnitVar(theType, varInput, pCurrUnit);
if (theType == Float)
{
float x;
sscanf(dataInput, "%f", &x);
data = malloc(sizeof(x));
*((float*)newVar->Data) = x;
}
else if (theType == Int)
{
int x;
sscanf(dataInput, "%i", &x);
data = malloc(sizeof(x));
*(int*)newVar->Data = x;
}
else if (theType == Vector)
{
VECTOR x;
sscanf(dataInput, "(%f, %f)", &x.x, &x.y);
data = malloc(sizeof(x));
*(VECTOR*)newVar->Data = x;
}
else if (theType == String)
{
char * x;
x = myStrCpy(dataInput);
data = malloc(sizeof(x));
*(char**)newVar->Data = x;
}
else if (theType == Bool)
{
BOOL x;
sscanf(dataInput, "%i", &x);
data = malloc(sizeof(x));
*(BOOL*)newVar->Data = x;
}
else if (theType == Color)
{
COLOR x;
sscanf(dataInput, "(%f, %f, %f, %f)", &x.r, &x.g, &x.b, &x.a);
data = malloc(sizeof(x));
*(COLOR*)newVar->Data = x;
}
else if (theType == Char)
{
char x;
sscanf(dataInput, "%c", &x);
data = malloc(sizeof(x));
*(char*)newVar->Data = x;
}
else if (theType == Matrix)
{
MATRIX x;
sscanf(dataInput, "{ {%f, %f, %f} {%f, %f, %f} {%f, %f, %f} }",
&x.m[0][0], &x.m[0][1], &x.m[0][2],
&x.m[1][0], &x.m[1][1], &x.m[1][2],
&x.m[2][0], &x.m[2][1], &x.m[2][2]);
data = malloc(sizeof(x));
*(MATRIX*)newVar->Data = x;
}
}
}
if (myStrCmp(question, "EndUnit") <= 0)
{
pCurrUnit = NULL;
continue;
}
}
}
}
}
void __stdcall CombineCallback(GLdouble coords[3],
GLdouble *data[4], GLfloat weight[4], GLdouble **dataOut )
{
GLdouble *vert = NewVector(coords[0], coords[1]);
*dataOut = vert;
}
static void KIM_Malloc(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
int status;
mxArray *mx_in[3], *mx_out[2];
int mxiter, msbset, msbsetsub, etachoice, mxnbcf;
double eta, egamma, ealpha, mxnewtstep, relfunc, fnormtol, scsteptol;
booleantype verbose, noInitSetup, noMinEps;
double *constraints;
N_Vector NVconstraints;
int ptype;
int mudq, mldq, mupper, mlower;
int maxl, maxrs;
double dqrely;
/*
* -----------------------------
* Find out the vector type and
* then pass it to the vector
* library.
* -----------------------------
*/
/* Send vec_type and mx_comm */
InitVectors();
/*
* -----------------------------
* Extract stuff from arguments:
* - SYS function
* - problem dimension
* - solver options
* - user data
* -----------------------------
*/
/* Matlab user-provided function */
mxDestroyArray(mx_SYSfct);
mx_SYSfct = mxDuplicateArray(prhs[0]);
/* problem dimension */
N = (int) mxGetScalar(prhs[1]);
/* Solver Options -- optional argument */
status = get_SolverOptions(prhs[2],
&verbose,
&mxiter, &msbset, &msbsetsub, &etachoice, &mxnbcf,
&eta, &egamma, &ealpha, &mxnewtstep,
&relfunc, &fnormtol, &scsteptol,
&constraints,
&noInitSetup, &noMinEps);
/* User data -- optional argument */
mxDestroyArray(mx_data);
mx_data = mxDuplicateArray(prhs[3]);
/*
* -----------------------------------------------------
* Set solution vector (used as a template to KINMAlloc)
* -----------------------------------------------------
*/
y = NewVector(N);
/*
* ----------------------------------------
* Create kinsol object and allocate memory
* ----------------------------------------
*/
kin_mem = KINCreate();
/* attach error handler function */
status = KINSetErrHandlerFn(kin_mem, mtlb_KINErrHandler, NULL);
if (verbose) {
status = KINSetPrintLevel(kin_mem,3);
/* attach info handler function */
status = KINSetInfoHandlerFn(kin_mem, mtlb_KINInfoHandler, NULL);
/* initialize the output window */
mx_in[0] = mxCreateScalarDouble(0);
mx_in[1] = mxCreateScalarDouble(0); /* ignored */
mx_in[2] = mxCreateScalarDouble(0); /* ignored */
mexCallMATLAB(1,mx_out,3,mx_in,"kim_info");
fig_handle = (int)*mxGetPr(mx_out[0]);
}
/* Call KINMalloc */
status = KINMalloc(kin_mem, mtlb_KINSys, y);
/* Redirect output */
status = KINSetErrFile(kin_mem, stdout);
/* Optional inputs */
status = KINSetNumMaxIters(kin_mem,mxiter);
status = KINSetNoInitSetup(kin_mem,noInitSetup);
status = KINSetNoMinEps(kin_mem,noMinEps);
status = KINSetMaxSetupCalls(kin_mem,msbset);
status = KINSetMaxSubSetupCalls(kin_mem,msbsetsub);
status = KINSetMaxBetaFails(kin_mem,mxnbcf);
status = KINSetEtaForm(kin_mem,etachoice);
status = KINSetEtaConstValue(kin_mem,eta);
status = KINSetEtaParams(kin_mem,egamma,ealpha);
status = KINSetMaxNewtonStep(kin_mem,mxnewtstep);
status = KINSetRelErrFunc(kin_mem,relfunc);
status = KINSetFuncNormTol(kin_mem,fnormtol);
status = KINSetScaledStepTol(kin_mem,scsteptol);
if (constraints != NULL) {
NVconstraints = N_VCloneEmpty(y);
N_VSetArrayPointer(constraints, NVconstraints);
status = KINSetConstraints(kin_mem,NVconstraints);
N_VDestroy(NVconstraints);
}
status = get_LinSolvOptions(prhs[2],
&mupper, &mlower,
&mudq, &mldq, &dqrely,
&ptype, &maxrs, &maxl);
switch (ls) {
case LS_NONE:
mexErrMsgTxt("KINMalloc:: no linear solver specified.");
break;
case LS_DENSE:
status = KINDense(kin_mem, N);
if (!mxIsEmpty(mx_JACfct))
status = KINDenseSetJacFn(kin_mem, mtlb_KINDenseJac, NULL);
break;
case LS_BAND:
status = KINBand(kin_mem, N, mupper, mlower);
if (!mxIsEmpty(mx_JACfct))
status = KINBandSetJacFn(kin_mem, mtlb_KINBandJac, NULL);
break;
case LS_SPGMR:
switch(pm) {
case PM_NONE:
status = KINSpgmr(kin_mem, maxl);
if (!mxIsEmpty(mx_PSOLfct)) {
if (!mxIsEmpty(mx_PSETfct))
status = KINSpilsSetPreconditioner(kin_mem, mtlb_KINSpilsPset, mtlb_KINSpilsPsol, NULL);
else
status = KINSpilsSetPreconditioner(kin_mem, NULL, mtlb_KINSpilsPsol, NULL);
}
break;
case PM_BBDPRE:
if (!mxIsEmpty(mx_GCOMfct))
bbd_data = KINBBDPrecAlloc(kin_mem, N, mudq, mldq, mupper, mlower, dqrely, mtlb_KINGloc, mtlb_KINGcom);
else
bbd_data = KINBBDPrecAlloc(kin_mem, N, mudq, mldq, mupper, mlower, dqrely, mtlb_KINGloc, NULL);
status = KINBBDSpgmr(kin_mem, maxl, bbd_data);
break;
}
status = KINSpilsSetMaxRestarts(kin_mem, maxrs);
if (!mxIsEmpty(mx_JACfct))
status = KINSpilsSetJacTimesVecFn(kin_mem, mtlb_KINSpilsJac, NULL);
break;
case LS_SPBCG:
switch(pm) {
case PM_NONE:
status = KINSpbcg(kin_mem, maxl);
if (!mxIsEmpty(mx_PSOLfct)) {
if (!mxIsEmpty(mx_PSETfct))
status = KINSpilsSetPreconditioner(kin_mem, mtlb_KINSpilsPset, mtlb_KINSpilsPsol, NULL);
else
status = KINSpilsSetPreconditioner(kin_mem, NULL, mtlb_KINSpilsPsol, NULL);
}
break;
case PM_BBDPRE:
if (!mxIsEmpty(mx_GCOMfct))
bbd_data = KINBBDPrecAlloc(kin_mem, N, mudq, mldq, mupper, mlower, dqrely, mtlb_KINGloc, mtlb_KINGcom);
else
bbd_data = KINBBDPrecAlloc(kin_mem, N, mudq, mldq, mupper, mlower, dqrely, mtlb_KINGloc, NULL);
status = KINBBDSpbcg(kin_mem, maxl, bbd_data);
break;
}
if (!mxIsEmpty(mx_JACfct))
status = KINSpilsSetJacTimesVecFn(kin_mem, mtlb_KINSpilsJac, NULL);
break;
case LS_SPTFQMR:
switch(pm) {
case PM_NONE:
status = KINSptfqmr(kin_mem, maxl);
if (!mxIsEmpty(mx_PSOLfct)) {
if (!mxIsEmpty(mx_PSETfct))
status = KINSpilsSetPreconditioner(kin_mem, mtlb_KINSpilsPset, mtlb_KINSpilsPsol, NULL);
else
status = KINSpilsSetPreconditioner(kin_mem, NULL, mtlb_KINSpilsPsol, NULL);
}
break;
case PM_BBDPRE:
if (!mxIsEmpty(mx_GCOMfct))
bbd_data = KINBBDPrecAlloc(kin_mem, N, mudq, mldq, mupper, mlower, dqrely, mtlb_KINGloc, mtlb_KINGcom);
else
bbd_data = KINBBDPrecAlloc(kin_mem, N, mudq, mldq, mupper, mlower, dqrely, mtlb_KINGloc, NULL);
status = KINBBDSptfqmr(kin_mem, maxl, bbd_data);
break;
}
if (!mxIsEmpty(mx_JACfct))
status = KINSpilsSetJacTimesVecFn(kin_mem, mtlb_KINSpilsJac, NULL);
break;
}
return;
}
void * AddVar(VTYPE Type, char * Name, BEHAVIOR * Owner)
{
VAR * pNewVar = malloc(sizeof(VAR));
pNewVar->Name = myStrCpy(Name);
pNewVar->Type = Float;
pNewVar->nextVar = NULL;
// NOTE: SHOULD MAKE A SWITCH CASE. MUCH CLEANER (AND SOMETIMES FASTER!)
if (Type == Int)
{
int *x = malloc(sizeof(int));
*x = 0;
pNewVar->Data = x;
}
else if (Type == Float)
{
float *x = malloc(sizeof(float));
*x = 0.0;
pNewVar->Data = x;
}
else if (Type == Vector)
{
VECTOR *x = malloc(sizeof(VECTOR));
*x = NewVector(0,0);
pNewVar->Data = x;
}
else if (Type == String)
{
char **x = malloc(sizeof(char*));
*x = NULL;
pNewVar->Data = x;
}
else if (Type == Color)
{
COLOR newCol = { 1, 1, 1, 1 };
COLOR *x = malloc(sizeof(COLOR));
*x = newCol;
pNewVar->Data = x;
}
else if (Type == Bool)
{
BOOL *x = malloc(sizeof(BOOL));
*x = False;
pNewVar->Data = x;
}
else if (Type == Char)
{
char *x = malloc(sizeof(char));
*x = '\0';
pNewVar->Data = x;
}
else if (Type == Matrix)
{
MATRIX *temp = (MATRIX*)malloc(sizeof(MATRIX));
SecureZeroMemory(temp->m, sizeof(float)* 9);
pNewVar->Data = temp;
}
pNewVar->nextVar = Owner->nextVar;
Owner->nextVar = pNewVar;
return pNewVar->Data;
}
COMPONENT * AddComponent(ARCHETYPE *pArchetype, COMPONENTTYPE DesiredType)
{
COMPONENT * pNewComponent = calloc(1, sizeof(COMPONENT));
pNewComponent->pArchetype = pArchetype;
pNewComponent->nextComponent = pArchetype->nextComponent;
pArchetype->nextComponent = pNewComponent;
if (DesiredType == Sprite) {
SPRITE * pNewSprite = calloc(1, sizeof(SPRITE));
IMAGE * pImage = calloc(1, sizeof(IMAGE));
pNewSprite->Visible = True;
pImage->pNextImage = NULL;
pNewComponent->Type = Sprite;
*pNewSprite = *(pArchetype->pGame->pGameStats->pDefaultSprite);
pNewSprite->pImage = pImage;
pNewSprite->CurrentAnimation = "Blank.png";
pNewComponent->pStruct = pNewSprite;
pNewSprite->pImage->TextureFile = NULL;
pNewSprite->pComponent = pNewComponent;
pNewSprite->pArchetype = pArchetype;
}
if (DesiredType == Mesh)
{
MESH * pNewMesh = calloc(1, sizeof(MESH));
pNewComponent->Type = Mesh;
*pNewMesh = *(pArchetype->pGame->pGameStats->pDefaultMesh);
pNewMesh->Color = NewColor(1, 1, 1, 1);
pNewMesh->Opacity = 1.0;
pNewComponent->pStruct = pNewMesh;
pNewMesh->pComponent = pNewComponent;
pNewMesh->pArchetype = pArchetype;
}
if (DesiredType == Behavior)
{
BEHAVIOR * pNewBehavior = calloc(1, sizeof(BEHAVIOR));
pNewComponent->Type = Behavior;
pNewComponent->pStruct = pNewBehavior;
pNewBehavior->BehaviorScript = DefaultBehavior;
pNewBehavior->pComponent = pNewComponent;
pNewBehavior->pArchetype = pArchetype;
}
if (DesiredType == Physics)
{
PHYSICS * pNewPhysics = calloc(1, sizeof(PHYSICS));
pNewComponent->Type = Physics;
pNewComponent->pStruct = pNewPhysics;
pNewPhysics->Velocity = NewVector(0, 0);
pNewPhysics->Acceleration = NewVector(0, 0);
pNewPhysics->Gravity = 0.5;
pNewPhysics->Friction = 0.1f;
pNewPhysics->MaxSpeed = 0.5;
pNewPhysics->pComponent = pNewComponent;
pNewPhysics->pArchetype = pArchetype;
}
if (DesiredType == Collider)
{
COLLIDER * pNewCollider = calloc(1, sizeof(COLLIDER));
pNewComponent->Type = Collider;
pNewComponent->pStruct = pNewCollider;
pNewCollider->Enabled = True;
pNewCollider->Offset = NewVector(0, 0);
pNewCollider->Height = 1;
pNewCollider->Width = 1;
pNewCollider->pComponent = pNewComponent;
pNewCollider->pArchetype = pArchetype;
}
if (DesiredType == KSound)
{
KSOUND * pNewSound = calloc(1, sizeof(KSOUND));
KSOUND_Init(pNewSound);
pNewComponent->Type = KSound;
pNewComponent->pStruct = pNewSound;
// Generic component stuff.
pNewSound->pComponent = pNewComponent;
pNewSound->pArchetype = pArchetype;
}
return pNewComponent;
}
