void Jacobian(const gsl_vector *X, gsl_matrix *J) const
{
std::vector<real_t> vX(m_arity);
std::vector<real_t> vR(m_arity), vJ(m_arity*m_arity);
m_f.roots_and_jacobian(&vX[0], &vR[0], &vJ[0]);
ToGSL(J, vJ);
}
void Roots(const gsl_vector *X, gsl_vector *R) const
{
std::vector<real_t> vX(FromGSL<real_t>(X));
std::vector<real_t> vR(m_arity);
m_f.roots(&vX[0], &vR[0]);
ToGSL(R, vR);
}
void House::CreateStep(std::vector<Vertex*>& vect, double base, double height)
{
assert(base != height);
std::vector<Vertex*> ceiling;
for (int i = 0; i < 4; i++)
{
int u = (i == 2) ? 3 : ((i == 3) ? 2 : i);
ceiling.push_back(new Vertex((vect[u])->X(), (vect[u])->Y(), height));
}
faces->push_back(new Face(new std::vector<Vertex*>(ceiling)));
unsigned int n = vect.size();
for (unsigned int i = 0; i < n; ++i)
{
Vertex vL(*(vect[i]));
Vertex vR(*(vect[(i+1)%n]));
double wins = Distance(vL,vR) / (height-base);
if (wins == 1)
{
Vertex *v = PointOnALine(vL, vR, 0.5f);
CreateWindow(vL, *v, base, height);
CreateWindow(*v, vR, base, height);
delete v;
}
else
{
double step = 1.f / wins;
double currentS = step;
Vertex *v = PointOnALine(vL, vR, currentS);
Vertex *v2;
CreateWindow(vL, *v, base, height);
for (int i = 0; i < wins-2; i++)
{
currentS += step;
v2 = PointOnALine(vL, vR , currentS);
CreateWindow(*v, *v2, base, height);
delete v;
v = v2;
}
CreateWindow(*v, vR, base, height);
delete v;
}
}
}
void CLightningFX::PreRender( float tmFrameTime )
{
LTVector vPulse;
LTVector vF(0.0f, 0.0f, 1.0f);
LTVector vU(0.0f, 1.0f, 0.0f);
LTVector vR(1.0f, 0.0f, 0.0f);
// Transform the bolt
LTMatrix mCam;
if( m_bReallyClose )
{
mCam.Identity();
}
else
{
mCam = GetCamTransform(m_pLTClient, m_hCamera);
}
CLightningBolt *pBolt = LTNULL;
LightningBolts::iterator iter;
for( iter = m_lstBolts.begin(); iter != m_lstBolts.end(); ++iter )
{
pBolt = *iter;
// Skip this bolt if there are not enough segments...
if( pBolt->m_collPathPts.GetSize() < 2 || !pBolt->m_bActive )
continue;
CLinkListNode<PT_TRAIL_SECTION> *pNode = pBolt->m_collPathPts.GetHead();
//as long as some amount of time has passed, apply a pulse onto the bolt to make
//it jitter
if(tmFrameTime > 0.001f)
{
while (pNode)
{
vPulse = pNode->m_Data.m_vPos;
vPulse += (vF * GetRandom( -GetProps()->m_fPulse, GetProps()->m_fPulse ));
vPulse += (vU * GetRandom( -GetProps()->m_fPulse, GetProps()->m_fPulse ));
vPulse += (vR * GetRandom( -GetProps()->m_fPulse, GetProps()->m_fPulse ));
if( pNode == pBolt->m_collPathPts.GetHead() || !pNode->m_pNext )
{
MatVMul(&pNode->m_Data.m_vTran, &mCam, &pNode->m_Data.m_vPos);
}
else
{
MatVMul(&pNode->m_Data.m_vTran, &mCam, &vPulse);
}
pNode = pNode->m_pNext;
}
}
// Do some precalculations
float fScale;
CalcScale( pBolt->m_tmElapsed, pBolt->m_fLifetime, &fScale );
float fWidth = pBolt->m_fWidth * fScale;
// Setup the colour
float r, g, b, a;
CalcColour( pBolt->m_tmElapsed, pBolt->m_fLifetime, &r, &g, &b, &a );
int ir = Clamp( (int)(r * 255.0f), 0, 255 );
int ig = Clamp( (int)(g * 255.0f), 0, 255 );
int ib = Clamp( (int)(b * 255.0f), 0, 255 );
int ia = Clamp( (int)(a * 255.0f), 0, 255 );
LTVector vStart, vEnd, vPrev, vBisector;
vBisector.z = 0.0f;
pNode = pBolt->m_collPathPts.GetHead();
while( pNode )
{
if( GetProps()->m_eAllignment == ePTA_Camera )
{
// Compute the midpoint vectors
if( pNode == pBolt->m_collPathPts.GetHead() )
{
vStart = pNode->m_Data.m_vTran;
vEnd = pNode->m_pNext->m_Data.m_vTran;
vBisector.x = vEnd.y - vStart.y;
vBisector.y = -(vEnd.x - vStart.x);
}
else if( pNode == pBolt->m_collPathPts.GetTail() )
{
vEnd = pNode->m_Data.m_vTran;
vStart = pNode->m_pPrev->m_Data.m_vTran;
vBisector.x = vEnd.y - vStart.y;
vBisector.y = -(vEnd.x - vStart.x);
}
else
{
vPrev = pNode->m_pPrev->m_Data.m_vTran;
vStart = pNode->m_Data.m_vTran;
vEnd = pNode->m_pNext->m_Data.m_vTran;
float x1 = vEnd.y - vStart.y;
float y1 = -(vEnd.x - vStart.x);
float z1 = vStart.z - vEnd.z;
float x2 = vStart.y - vPrev.y;
float y2 = -(vStart.x - vPrev.x);
float z2 = vPrev.z - vEnd.z;
vBisector.x = (x1 + x2) / 2.0f;
vBisector.y = (y1 + y2) / 2.0f;
}
pNode->m_Data.m_vBisector = vBisector;
}
// Set the width for this section...
pNode->m_Data.m_vBisector.Norm( fWidth );
// Set the color for this section...
pNode->m_Data.m_red = ir;
pNode->m_Data.m_green = ig;
pNode->m_Data.m_blue = ib;
pNode->m_Data.m_alpha = ia;
pNode = pNode->m_pNext;
}
}
}
bool CLTBModelFX::Update(float tmFrameTime)
{
//Ok, what we are going to do is see if we are supposed to be sync'd to the
//animation. If so, we are going to flat out ignore tmCur, and instead generate
//our own. This way we can match the model exactly.
if(GetProps()->m_bSyncToModelAnim)
{
//we need to find out where in the animation the model currently is
ILTModel *pLTModel = m_pLTClient->GetModelLT();
ANIMTRACKERID nTracker;
if(pLTModel->GetMainTracker( m_hObject, nTracker ) == LT_OK)
{
//we have the main tracker, see where in its timeline it is
uint32 nCurrTime;
uint32 nAnimTime;
pLTModel->GetCurAnimTime(m_hObject, nTracker, nCurrTime);
pLTModel->GetCurAnimLength(m_hObject, nTracker, nAnimTime);
if(nAnimTime)
{
//handle wrapping
nCurrTime %= nAnimTime;
//ok, now convert cur time to a valid time
m_tmElapsed = (nCurrTime * GetProps()->m_tmLifespan) / (float)nAnimTime;
}
else
{
//zero length animation?
m_tmElapsed = 0.0f;
}
}
}
else if(GetProps()->m_bSyncToKey)
{
//we need to find out where in the key we currently are
ILTModel *pLTModel = m_pLTClient->GetModelLT();
ANIMTRACKERID nTracker;
if(pLTModel->GetMainTracker( m_hObject, nTracker ) == LT_OK)
{
//we have the main tracker, see where in its timeline it is
uint32 nAnimLength;
m_pLTClient->GetModelLT()->ResetAnim( m_hObject, nTracker );
pLTModel->GetCurAnimLength(m_hObject, nTracker, nAnimLength);
if(nAnimLength > 0)
nAnimLength--;
float tmWrappedTime = fmodf(m_tmElapsed / GetProps()->m_tmLifespan, 1.0f);
uint32 nAnimTime = (uint32)(tmWrappedTime * nAnimLength);
pLTModel->SetCurAnimTime(m_hObject, nTracker, nAnimTime);
}
}
// Base class update first
if (!CBaseFX::Update(tmFrameTime))
return false;
//see if we should reset our model animation
if(!GetProps()->m_bSyncToKey && IsFinishedShuttingDown())
{
//Reset the animation
ANIMTRACKERID nTracker;
m_pLTClient->GetModelLT()->GetMainTracker( m_hObject, nTracker );
m_pLTClient->GetModelLT()->ResetAnim( m_hObject, nTracker );
if(GetProps()->m_bOverrideAniLength)
m_pLTClient->GetModelLT()->SetAnimRate( m_hObject, nTracker, m_fAniRate);
}
// Align if neccessary, to the rotation of our parent
if ((m_hParent) && (GetProps()->m_nFacing == FACE_PARENTALIGN))
{
LTRotation rParentRot;
m_pLTClient->GetObjectRotation(m_hParent, &rParentRot);
rParentRot = (GetProps()->m_bRotate ? rParentRot : rParentRot * m_rNormalRot);
m_pLTClient->SetObjectRotation(m_hObject, &rParentRot);
}
// If we want to add a rotation, make sure we are facing the correct way...
if( GetProps()->m_bRotate )
{
LTFLOAT tmFrame = tmFrameTime;
LTVector vR( m_rRot.Right() );
LTVector vU( m_rRot.Up() );
LTVector vF( m_rRot.Forward() );
LTRotation rRotation;
if( m_hCamera && (GetProps()->m_nFacing == FACE_CAMERAFACING))
{
m_pLTClient->GetObjectRotation( m_hCamera, &rRotation );
}
else
{
m_pLTClient->GetObjectRotation( m_hObject, &rRotation );
}
m_rRot.Rotate( vR, MATH_DEGREES_TO_RADIANS( GetProps()->m_vRotAdd.x * tmFrame ));
m_rRot.Rotate( vU, MATH_DEGREES_TO_RADIANS( GetProps()->m_vRotAdd.y * tmFrame ));
m_rRot.Rotate( vF, MATH_DEGREES_TO_RADIANS( GetProps()->m_vRotAdd.z * tmFrame ));
rRotation = rRotation * m_rRot;
m_pLTClient->SetObjectRotation( m_hObject, &(rRotation * m_rNormalRot));
}
else if( GetProps()->m_nFacing == FACE_CAMERAFACING )
{
LTRotation rCamRot;
m_pLTClient->GetObjectRotation( m_hCamera, &rCamRot );
m_pLTClient->SetObjectRotation( m_hObject, &(rCamRot * m_rNormalRot) );
}
// Success !!
return true;
}
//////////////////////////////////////////////////////////////////////
/// Draw
void COGLWin::Draw()
{
if (!m_Parse.IsCodeOK())
{
m_ToolBox.ResetToolInUseFlags();
// Keep fixed tools but do not redraw here
m_ToolBox.PruneToolMap(true, false);
// Redraw tools here explicitly
// m_ToolBox.Update();
if (m_pOutput)
m_pOutput->SetText(" ");
// Standard reason for re-evaluation of script.
SetExecModeVar(EXEC_MODE_NONE);
return;
}
// Set standard color
if (m_bUseLighting)
{
m_Filter.SetColor(MGray);
m_StdMaterial.Apply();
}
else
{
m_Filter.SetColor(MGray);
}
m_ToolBox.ResetToolInUseFlags();
m_Parse.ToggleTempImageList();
m_Parse.ResetTempImageList();
// Reset Filter Modes
m_Filter.ResetModes();
m_bFrameTransChanged = false;
MultiV<float> vR(m_vRMain);
m_mTransform[0].ResetTransChanged();
ClearOutput();
ClearError();
//m_Parse.ResetTempVexList();
if (!m_Parse.RunCode())
{
int iErrLine, iErrPos, iErrInPos;
cStr csErrFile, csText;
CCLUCodeBase::SOutputObject OutObj;
/*
m_sError = "<b>Runtime Errors:</b><p>";
m_sError += m_Parse.PrintCodeErrors().Str();
m_sError += "</p> <p>";
//csText << "Vars:\n" << m_Parse.PrintVars() << "\n";
m_sError += "<b>Stack:</b><br> <br>";
m_sError += m_Parse.PrintStack().Str();
m_sError += "</p>";
*/
OutObj.sName = "Output up to Error";
OutObj.bCanChangeSize = false;
OutObj.bCanHideValue = false;
OutObj.bBRAfterValue = true;
OutObj.bBRBeforeValue = true;
OutObj.bShowInfo = false;
OutObj.bShowValue = true;
OutObj.sRelSym = ":";
OutObj.sType = " ";
OutObj.iSize = 0;
OutObj.sValue = " ";
m_Parse.InsertOutputObject(OutObj);
OutObj.sName = "Stack";
OutObj.bCanChangeSize = true;
OutObj.bCanHideValue = true;
OutObj.bBRAfterValue = true;
OutObj.bBRBeforeValue = true;
OutObj.bShowInfo = false;
OutObj.bShowValue = false;
OutObj.sRelSym = ":";
OutObj.sType = "stack";
OutObj.iSize = 0;
OutObj.sValue = m_Parse.PrintStack().Str();
m_Parse.InsertOutputObject(OutObj);
OutObj.sName = "Runtime Error";
OutObj.bCanChangeSize = false;
OutObj.bCanHideValue = true;
OutObj.bBRAfterValue = true;
OutObj.bBRBeforeValue = true;
OutObj.bShowInfo = true;
OutObj.bShowValue = true;
OutObj.sRelSym = " ";
OutObj.sType = "error message";
OutObj.iSize = 0;
m_Parse.GetCodeErrorPos(iErrLine, iErrPos, iErrInPos, csErrFile);
csText = "";
csText << "Line " << iErrLine << ", Pos " << iErrPos;
OutObj.sInfo = csText;
csText = "<font size=\"10\">File: <i>";
csText << csErrFile << "</i></font><p>";
csText << m_Parse.PrintCodeErrors().Str();
OutObj.sValue = csText;
m_Parse.InsertOutputObject(OutObj);
m_bHasError = true;
m_bHasOutput = true;
/*
cStr &rText = m_Parse.GetTextOutput();
if (rText.Len())
{
m_sError += "<br><b>Script Output:</b><br> <br>";
m_sError += rText.Str();
}
*/
/*
if (m_pOutput && !m_bVizOnlyMode)
{
m_pOutput->SetText(m_sError.c_str());
m_pOutput->show();
}
*/ //ClearError();
if (m_pEditor && !m_bVizOnlyMode)
{
cStr csFilename;
int iLine, iPos, iInputPos;
if (m_Parse.GetCodeErrorPos(iLine, iPos, iInputPos, csFilename))
m_pEditor->HighlightLinePos(csFilename.Str(), iInputPos);
m_pEditor->show();
}
m_Parse.ResetErrors();
m_bExecCode = false;
SetAnimCode(false);
StopAnimation();
m_Parse.OverrideSetRenderLatex(false);
}
else
{
//m_vecOutObj = m_Parse.GetOutputObjectList();
//cStr &rText = m_Parse.GetTextOutput();
m_bHasOutput = true;
if (m_mTransform[0].HasTransChanged(0) ||
m_mTransform[0].HasTransChanged(1) ||
m_mTransform[0].HasTransChanged(2))
{
m_mTransform[0].iFlags = 0;
m_bFrameTransChanged = true;
}
if (vR != m_vRMain)
{
m_bFrameTransChanged = true;
}
m_Parse.OverrideSetRenderLatex(false);
}
// Keep fixed tools but do not redraw here
m_ToolBox.PruneToolMap(true, false);
// Redraw tools here explicitly
// m_ToolBox.Update();
// Reset Tool Name Variable
if (m_iExecMode &
(EXEC_MODE_TOOL | EXEC_MODE_LINK | EXEC_MODE_KEYUP | EXEC_MODE_KEYDOWN | EXEC_MODE_ANIM))
{
SetToolNameVar("None");
SetLinkDataVar("None");
}
// Standard reason for re-evaluation of script.
SetExecModeVar(EXEC_MODE_NONE);
}
