//-------------------------------------------------------------------------------
// @ IvQuat::GetAxisAngle()
//-------------------------------------------------------------------------------
// Get axis-angle based on quaternion
//-------------------------------------------------------------------------------
void
IvQuat::GetAxisAngle( IvVector3& axis, float& angle )
{
angle = 2.0f*acosf( w );
float length = ::IvSqrt( 1.0f - w*w );
if ( ::IsZero(length) )
axis.Zero();
else
{
length = 1.0f/length;
axis.Set( x*length, y*length, z*length );
}
} // End of IvQuat::GetAxisAngle()
//-------------------------------------------------------------------------------
// @ IvQuat::Set()
//-------------------------------------------------------------------------------
// Set quaternion based on axis-angle
//-------------------------------------------------------------------------------
void
IvQuat::Set( const IvVector3& axis, float angle )
{
// if axis of rotation is zero vector, just set to identity quat
float length = axis.LengthSquared();
if ( ::IsZero( length ) )
{
Identity();
return;
}
// take half-angle
angle *= 0.5f;
float sintheta, costheta;
IvSinCos(angle, sintheta, costheta);
float scaleFactor = sintheta/IvSqrt( length );
w = costheta;
x = scaleFactor * axis.x;
y = scaleFactor * axis.y;
z = scaleFactor * axis.z;
} // End of IvQuat::Set()
void LetterDisplayAnimation::Animate()
{
unsigned int elapsed = GetTicks() - mStartTime;
float t = elapsed/(float)mDuration;
if(t > 1.0f)
{
GameMessage msg;
msg.mEventName = "FINISHED";
msg.mSender = mID;
SendOutMessage(msg);
return;
}
IvVector3 pos = Lerp(t, mStartPos, mEndPos);
//Add noise to movement
IvVector3 normDir = mEndPos - mStartPos;
normDir.z = 0;
normDir.Normalize();
float x = normDir.x;
float y = normDir.y;
normDir.x = -y;
normDir.y = x;
float noise = Perlin::Noise(pos.x*0.01f,pos.y*0.01f);
//ramp noise based on proximity to endpoints
float s = 1.0f;
if(t <= 0.1f)
s = Perlin::lerp(t*10.0f,0.0f,1.0f);
else if( t >= 0.9f)
s = Perlin::lerp((t-0.9f)*10.0f,1.0f,0.0f);
normDir *= noise*5.0f * s;
pos += normDir;
IvVector3 intPos;
intPos.x = (int)pos.x;
intPos.y = (int)pos.y;
intPos.z = mStartPos.z;
SetPosition(intPos);
IvVector3 vel(0,201,0);
mMetaballGrid->ObjectMoved(mID, intPos,vel);
}
//-------------------------------------------------------------------------------
// @ ::TestLineOverlap()
//-------------------------------------------------------------------------------
// Helper for TriangleIntersect()
//
// This tests whether the rearranged triangles overlap, by checking the intervals
// where their edges cross the common line between the two planes. If the
// interval for P is [i,j] and Q is [k,l], then there is intersection if the
// intervals overlap. Previous algorithms computed these intervals directly,
// this tests implictly by using two "plane tests."
//-------------------------------------------------------------------------------
inline bool
TestLineOverlap( const IvVector3& P0, const IvVector3& P1,
const IvVector3& P2, const IvVector3& Q0,
const IvVector3& Q1, const IvVector3& Q2 )
{
// get "plane normal"
IvVector3 normal = (P1-P0).Cross(Q0-P0);
// fails test, no intersection
if ( normal.Dot( Q1 - P0 ) > kEpsilon )
return false;
// get "plane normal"
normal = (P2-P0).Cross(Q2-P0);
// fails test, no intersection
if ( normal.Dot( Q0 - P0 ) > kEpsilon )
return false;
// intersection!
return true;
}
//-------------------------------------------------------------------------------
// @ ::TriangleIntersect()
//-------------------------------------------------------------------------------
// Returns true if ray intersects triangle
//-------------------------------------------------------------------------------
bool
TriangleIntersect( float& t, const IvVector3& P0, const IvVector3& P1,
const IvVector3& P2, const IvRay3& ray )
{
// test ray direction against triangle
IvVector3 e1 = P1 - P0;
IvVector3 e2 = P2 - P0;
IvVector3 p = ray.GetDirection().Cross(e2);
float a = e1.Dot(p);
// if result zero, no intersection or infinite intersections
// (ray parallel to triangle plane)
if ( IvIsZero(a) )
return false;
// compute denominator
float f = 1.0f/a;
// compute barycentric coordinates
IvVector3 s = ray.GetOrigin() - P0;
float u = f*s.Dot(p);
// ray falls outside triangle
if (u < 0.0f || u > 1.0f)
return false;
IvVector3 q = s.Cross(e1);
float v = f*ray.GetDirection().Dot(q);
// ray falls outside triangle
if (v < 0.0f || u+v > 1.0f)
return false;
// compute line parameter
t = f*e2.Dot(q);
return (t >= 0.0f);
}
//-------------------------------------------------------------------------------
// @ SimObject::Colliding()
//-------------------------------------------------------------------------------
// Check to see if colliding with another SimObject
//-------------------------------------------------------------------------------
bool
SimObject::Colliding( const SimObject* other, IvVector3& collisionNormal,
IvVector3& collisionPoint, float& penetration ) const
{
// first check sphere collision (cheaper)
float radiusSum = mBoundingRadius + other->mBoundingRadius;
collisionNormal = other->mTranslate - mTranslate;
float distancesq = collisionNormal.LengthSquared();
// if distance squared > sum of radii squared, no collision!
if ( distancesq > radiusSum*radiusSum )
{
return false;
}
// now do capsule collision
return mWorldCapsule.ComputeCollision( other->mWorldCapsule, collisionNormal,
collisionPoint, penetration );
}
//-------------------------------------------------------------------------------
// @ IvQuat::Set()
//-------------------------------------------------------------------------------
// Set quaternion based on start and end vectors
//-------------------------------------------------------------------------------
void
IvQuat::Set( const IvVector3& from, const IvVector3& to )
{
// Ensure that our vectors are unit
ASSERT( from.IsUnit() && to.IsUnit() );
// get axis of rotation
IvVector3 axis = from.Cross( to );
// get cos of angle between vectors
float costheta = from.Dot( to );
// if vectors are 180 degrees apart
if ( costheta <= -1.0f )
{
// find orthogonal vector
IvVector3 orthoVector;
orthoVector.Normalize();
w = 0.0f;
x = orthoVector.x;
y = orthoVector.y;
z = orthoVector.z;
return;
}
// use trig identities to get the values we want
float factor = IvSqrt( 2.0f*(1.0f + costheta) );
float scaleFactor = 1.0f/factor;
// set values
w = 0.5f*factor;
x = scaleFactor*axis.x;
y = scaleFactor*axis.y;
z = scaleFactor*axis.z;
} // End of IvQuat::Set()
//-------------------------------------------------------------------------------
// @ Player::Update()
//-------------------------------------------------------------------------------
// Main update loop
//-------------------------------------------------------------------------------
void
Player::Update( float dt )
{
// get scale, rotate, translate for this frame
float s = 1.0f;
float r = 0.0f;
// set up scaling
if (IvGame::mGame->mEventHandler->IsKeyDown(';'))
{
s -= 0.25f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('p'))
{
s += 0.25f*dt;
}
mScale *= s;
// set up rotate
if (IvGame::mGame->mEventHandler->IsKeyDown('o'))
{
r -= kPI*0.25f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('u'))
{
r += kPI*0.25f*dt;
}
IvMatrix33 rotate;
rotate.RotationZ(r);
mRotate = rotate*mRotate;
// set up translation
IvVector3 xlate;
xlate.Zero();
if (IvGame::mGame->mEventHandler->IsKeyDown('k'))
{
xlate.x -= 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('i'))
{
xlate.x += 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('l'))
{
xlate.y -= 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('j'))
{
xlate.y += 3.0f*dt;
}
mTranslate += xlate;
// clear transform
if (IvGame::mGame->mEventHandler->IsKeyPressed(' '))
{
mRotate.Identity();
mScale = 1.0f;
mTranslate.Zero();
}
// change texture
if (IvGame::mGame->mEventHandler->IsKeyPressed('t'))
{
mCurrentBlendTexIndex = (mCurrentBlendTexIndex + 1) % NUM_BLEND_TEX;
}
// change blending mode
if (IvGame::mGame->mEventHandler->IsKeyPressed('b'))
{
mBlendMode = (BlendMode)((mBlendMode + 1) % kBlendModeCount);
}
} // End of Player::Update()
//-------------------------------------------------------------------------------
// @ Player::Update()
//-------------------------------------------------------------------------------
// Main update loop
//-------------------------------------------------------------------------------
void
Player::Update( float dt )
{
// update based on input
if (IvGame::mGame->mEventHandler->IsKeyPressed(' '))
{
if (mRun)
{
mTime = 0.0f;
mRun = false;
}
else
{
mRun = true;
}
}
if (IvGame::mGame->mEventHandler->IsKeyPressed('m'))
{
mMode = (mMode + 1)%4;
}
if (mRun)
{
mTime += dt;
// stop just before end so we don't end up with zero vector
// when we look ahead
if ( mTime > 11.5f )
mTime = 11.5f;
}
// now we set up the camera
// get eye position
IvVector3 eye = mCurve.Evaluate( mTime );
IvVector3 viewDir;
IvVector3 viewSide;
IvVector3 viewUp;
// set parameters depending on what mode we're in
// Frenet frame
if ( mMode == 3 )
{
IvVector3 T = mCurve.Velocity( mTime );
IvVector3 a = mCurve.Acceleration( mTime );
IvVector3 B = T.Cross( a );
B.Normalize();
T.Normalize();
IvVector3 N = B.Cross( T );
viewDir = T;
viewSide = -N; // have to negate to get from RH frame to LH frame
viewUp = B;
}
else
{
IvVector3 lookAt;
// look same direction all the time
if ( mMode == 2 )
{
viewDir = IvVector3::xAxis;
}
// look along tangent
else if ( mMode == 1 )
{
viewDir = mCurve.Velocity( mTime );
}
// look ahead .5 in parameter
else if ( mMode == 0 )
{
viewDir = mCurve.Evaluate( mTime+0.5f ) - eye;
}
// compute view vectors
viewDir.Normalize();
viewUp = IvVector3::zAxis - IvVector3::zAxis.Dot(viewDir)*viewDir;
viewUp.Normalize();
viewSide = viewDir.Cross(viewUp);
}
// now set up matrices
// build transposed rotation matrix
IvMatrix33 rotate;
if ( IvRenderer::mRenderer->GetAPI() == kOpenGL )
{
rotate.SetRows( viewSide, viewUp, -viewDir );
}
else
{
rotate.SetRows( viewSide, viewUp, viewDir );
}
// transform translation
IvVector3 eyeInv = -(rotate*eye);
// build 4x4 matrix
IvMatrix44 matrix(rotate);
matrix(0,3) = eyeInv.x;
matrix(1,3) = eyeInv.y;
matrix(2,3) = eyeInv.z;
::IvSetViewMatrix( matrix );
} // End of Player::Update()
//-------------------------------------------------------------------------------
// @ Player::Update()
//-------------------------------------------------------------------------------
// Main update loop
//-------------------------------------------------------------------------------
void
Player::Update( float dt )
{
// get scale, rotate, translate for this frame
float s = 1.0f;
float r = 0.0f;
// set up scaling
if (IvGame::mGame->mEventHandler->IsKeyDown(';'))
{
s -= 0.25f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('p'))
{
s += 0.25f*dt;
}
mScale *= s;
// set up rotate
if (IvGame::mGame->mEventHandler->IsKeyDown('o'))
{
r -= kPI*0.25f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('u'))
{
r += kPI*0.25f*dt;
}
IvMatrix33 rotate;
rotate.RotationY(r);
mRotate = rotate*mRotate;
// set up translation
IvVector3 xlate;
xlate.Zero();
if (IvGame::mGame->mEventHandler->IsKeyDown('k'))
{
xlate.x -= 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('i'))
{
xlate.x += 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('l'))
{
xlate.y -= 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('j'))
{
xlate.y += 3.0f*dt;
}
mTranslate += xlate;
// clear transform
if (IvGame::mGame->mEventHandler->IsKeyDown(' '))
{
mRotate.Identity();
mTranslate.Set(0.0f, 0.0f, 0.0f);
mScale = 3.0f;
}
} // End of Player::Update()
//-------------------------------------------------------------------------------
// @ Player::Update()
//-------------------------------------------------------------------------------
// Main update loop
//-------------------------------------------------------------------------------
void
Player::Update( float dt )
{
// get scale, rotate, translate for this frame
float s = 1.0f;
float r = 0.0f;
// set up scaling
if (IvGame::mGame->mEventHandler->IsKeyDown(';'))
{
s -= 0.25f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('p'))
{
s += 0.25f*dt;
}
mScale *= s;
// set up rotate
if (IvGame::mGame->mEventHandler->IsKeyDown('o'))
{
r -= kPI*0.25f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('u'))
{
r += kPI*0.25f*dt;
}
IvMatrix33 rotate;
rotate.RotationZ(r);
mRotate = rotate*mRotate;
// set up translation
IvVector3 xlate;
xlate.Zero();
if (IvGame::mGame->mEventHandler->IsKeyDown('k'))
{
xlate.x -= 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('i'))
{
xlate.x += 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('l'))
{
xlate.y -= 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('j'))
{
xlate.y += 3.0f*dt;
}
mTranslate += xlate;
// clear transform
if (IvGame::mGame->mEventHandler->IsKeyDown(' '))
{
mRotate.Identity();
mScale = 1.0f;
mTranslate.Zero();
}
r = 0.0f;
static bool lightDirChanged = true;
// set up rotate
if (IvGame::mGame->mEventHandler->IsKeyDown('a'))
{
r -= kPI*0.0625f*dt;
lightDirChanged = true;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('d'))
{
r += kPI*0.0625f*dt;
lightDirChanged = true;
}
if (lightDirChanged)
{
IvMatrix33 rotate;
rotate.RotationY(r);
mLightPos = rotate * mLightPos;
mLightPos.Normalize();
lightDirChanged = false;
}
} // End of Player::Update()
//-------------------------------------------------------------------------------
// @ ::BarycentricCoordinates()
//-------------------------------------------------------------------------------
// Returns barycentric coordinates for point inside triangle (3D version)
// Assumes triangle is not degenerate
//-------------------------------------------------------------------------------
void BarycentricCoordinates( float &r, float &s, float& t,
const IvVector3& point, const IvVector3& P0,
const IvVector3& P1, const IvVector3& P2 )
{
// get difference vectors
IvVector3 u = P1 - P0;
IvVector3 v = P2 - P0;
IvVector3 w = point - P0;
// compute cross product to get area of parallelograms
IvVector3 a = u.Cross(w);
IvVector3 b = v.Cross(w);
IvVector3 c = u.Cross(v);
// compute barycentric coordinates as ratios of areas
float denom = 1.0f/c.Length();
s = b.Length()*denom;
t = a.Length()*denom;
r = 1.0f - s - t;
}
//-------------------------------------------------------------------------------
// @ ::TriangleIntersect()
//-------------------------------------------------------------------------------
// Returns true if triangles P0P1P2 and Q0Q1Q2 intersect
// Assumes triangle is not degenerate
//
// This is not the algorithm presented in the text. Instead, it is based on a
// recent article by Guigue and Devillers in the July 2003 issue Journal of
// Graphics Tools. As it is faster than the ERIT algorithm, under ordinary
// circumstances it would have been discussed in the text, but it arrived too late.
//
// More information and the original source code can be found at
// http://www.acm.org/jgt/papers/GuigueDevillers03/
//
// A nearly identical algorithm was in the same issue of JGT, by Shen Heng and
// Tang. See http://www.acm.org/jgt/papers/ShenHengTang03/ for source code.
//
// Yes, this is complicated. Did you think testing triangles would be easy?
//-------------------------------------------------------------------------------
bool TriangleIntersect( const IvVector3& P0, const IvVector3& P1,
const IvVector3& P2, const IvVector3& Q0,
const IvVector3& Q1, const IvVector3& Q2 )
{
// test P against Q's plane
IvVector3 normalQ = (Q1-Q0).Cross(Q2-Q0);
float testP0 = normalQ.Dot( P0 - Q0 );
float testP1 = normalQ.Dot( P1 - Q0 );
float testP2 = normalQ.Dot( P2 - Q0 );
// P doesn't intersect Q's plane
if (testP0*testP1 > kEpsilon && testP0*testP2 > kEpsilon )
return false;
// test Q against P's plane
IvVector3 normalP = (P1-P0).Cross(P2-P0);
float testQ0 = normalP.Dot( Q0 - P0 );
float testQ1 = normalP.Dot( Q1 - P0 );
float testQ2 = normalP.Dot( Q2 - P0 );
// Q doesn't intersect P's plane
if (testQ0*testQ1 > kEpsilon && testQ0*testQ2 > kEpsilon )
return false;
// now we rearrange P's vertices such that the lone vertex (the one that lies
// in its own half-space of Q) is first. We also permute the other
// triangle's vertices so that P0 will "see" them in counterclockwise order
// Once reordered, we pass the vertices down to a helper function which will
// reorder Q's vertices, and then test
// P0 in Q's positive half-space
if (testP0 > kEpsilon)
{
// P1 in Q's positive half-space (so P2 is lone vertex)
if (testP1 > kEpsilon)
return AdjustQ(P2, P0, P1, Q0, Q2, Q1, testQ0, testQ2, testQ1, normalP);
// P2 in Q's positive half-space (so P1 is lone vertex)
else if (testP2 > kEpsilon)
return AdjustQ(P1, P2, P0, Q0, Q2, Q1, testQ0, testQ2, testQ1, normalP);
// P0 is lone vertex
else
return AdjustQ(P0, P1, P2, Q0, Q1, Q2, testQ0, testQ1, testQ2, normalP);
}
// P0 in Q's negative half-space
else if (testP0 < -kEpsilon)
{
// P1 in Q's negative half-space (so P2 is lone vertex)
if (testP1 < -kEpsilon)
return AdjustQ(P2, P0, P1, Q0, Q1, Q2, testQ0, testQ1, testQ2, normalP);
// P2 in Q's negative half-space (so P1 is lone vertex)
else if (testP2 < -kEpsilon)
return AdjustQ(P1, P2, P0, Q0, Q1, Q2, testQ0, testQ1, testQ2, normalP);
// P0 is lone vertex
else
return AdjustQ(P0, P1, P2, Q0, Q2, Q1, testQ0, testQ2, testQ1, normalP);
}
// P0 on Q's plane
else
{
// P1 in Q's negative half-space
if (testP1 < -kEpsilon)
{
// P2 in Q's negative half-space (P0 is lone vertex)
if (testP2 < -kEpsilon)
return AdjustQ(P0, P1, P2, Q0, Q1, Q2, testQ0, testQ1, testQ2, normalP);
// P2 in positive half-space or on plane (P1 is lone vertex)
else
return AdjustQ(P1, P2, P0, Q0, Q2, Q1, testQ0, testQ2, testQ1, normalP);
}
// P1 in Q's positive half-space
else if (testP1 > kEpsilon)
{
// P2 in Q's positive half-space (P0 is lone vertex)
if (testP2 > kEpsilon)
return AdjustQ(P0, P1, P2, Q0, Q2, Q1, testQ0, testQ2, testQ1, normalP);
// P2 in negative half-space or on plane (P1 is lone vertex)
else
return AdjustQ(P1, P2, P0, Q0, Q1, Q2, testQ0, testQ1, testQ2, normalP);
}
// P1 lies on Q's plane too
else
{
// P2 in Q's positive half-space (P2 is lone vertex)
if (testP2 > kEpsilon)
return AdjustQ(P2, P0, P1, Q0, Q1, Q2, testQ0, testQ1, testQ2, normalP);
// P2 in Q's negative half-space (P2 is lone vertex)
// note different ordering for Q vertices
else if (testP2 < -kEpsilon)
return AdjustQ(P2, P0, P1, Q0, Q2, Q1, testQ0, testQ2, testQ1, normalP);
// all three points lie on Q's plane, default to 2D test
else
return CoplanarTriangleIntersect(P0, P1, P2, Q0, Q1, Q2, normalP);
}
}
}
//-------------------------------------------------------------------------------
// @ Player::Update()
//-------------------------------------------------------------------------------
// Main update loop
//-------------------------------------------------------------------------------
void
Player::Update( float dt )
{
float s = 1.0f;
float r = 0.0f;
float x = 0.0f, y = 0.0f, z = 0.0f;
IvQuat rotate;
IvVector3 xlate;
IvMatrix44 transform;
// set up scaling
if (IvGame::mGame->mEventHandler->IsKeyDown(';'))
{
s -= 0.25f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('p'))
{
s += 0.25f*dt;
}
mScale *= s;
// set up rotate
if (IvGame::mGame->mEventHandler->IsKeyDown('o'))
{
r -= kPI*0.25f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('u'))
{
r += kPI*0.25f*dt;
}
rotate.Set(IvVector3::zAxis, r);
mRotate = rotate*mRotate;
mRotate.Normalize();
// set up translation
if (IvGame::mGame->mEventHandler->IsKeyDown('k'))
{
x -= 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('i'))
{
x += 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('l'))
{
y -= 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('j'))
{
y += 3.0f*dt;
}
xlate.Set( x, y, z );
mTranslate += xlate;
if (IvGame::mGame->mEventHandler->IsKeyPressed('s'))
{
mUseSkyShader = !mUseSkyShader;
}
// clear transform
if (IvGame::mGame->mEventHandler->IsKeyPressed(' '))
{
mRotate.Identity();
mScale = 1.0f;
mTranslate.Zero();
}
} // End of Player::Update()
void LetterChooser::RandomLayout()
{
std::vector<IvAABB> blockedAreas;
mGameLogic->GetBlockedDropletAreas(blockedAreas);
mPositionList.clear();
float x,y;
x = mDisplayMin.x;
y = 480.0f - mDisplayMin.y;
IvVector2 dim = mDisplayMax - mDisplayMin;
int increment = 2.0f*TOUCH_RADIUS + mJitterStrength;
IvVector3 origin;
GetWorldPosition(origin);
srand(1972);
for(int i = 0; i < mSourceLetters.size(); ++i)
{
LetterButton* l = mSourceLetters[i];
IvVector3 pos;
float xNoise = rand() % (int)mJitterStrength;
float yNoise = rand() % (int)mJitterStrength;
pos.Set(x+xNoise,480.0f - (y+yNoise),origin.z);
for(unsigned int j = 0; j < blockedAreas.size(); j++)
{
float yradius = l->mRadius*480.0f*0.5f;
float xradius = l->mRadius*320.0f*0.5f;
IvAABB blocker = blockedAreas[j];
IvVector3 min, max;
min.x = pos.x - xradius;
min.y = pos.y - yradius;
min.z = -5.0f;
max.x = pos.x + xradius;
max.y = pos.y + yradius;
max.z = +5.0f;
IvAABB test(min,max);
if(test.Intersect(blocker))
{
float newX = blocker.GetMaxima().x + xradius;
if(newX > x)
{
x = newX;
if(x >= mDisplayMax.x)
{
y += increment;
pos.y -= increment;
x = mDisplayMin.x;
}
pos.x = x;
}
}
}
mPositionList.push_back(pos);
mPositionDB[l->mChar] = pos;
x += increment;
if(x >= mDisplayMax.x)
{
y += increment;
x = mDisplayMin.x;
}
}
}
//-------------------------------------------------------------------------------
// @ Player::Update()
//-------------------------------------------------------------------------------
// Main update loop
//-------------------------------------------------------------------------------
void
Player::Update( float dt )
{
float s = 1.0f;
float r = 0.0f;
float x = 0.0f, y = 0.0f, z = 0.0f;
IvMatrix33 rotate;
IvVector3 xlate;
IvMatrix44 transform;
mTurret->Update( dt );
// set up scaling
if (IvGame::mGame->mEventHandler->IsKeyDown(';'))
{
s -= 0.25f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('p'))
{
s += 0.25f*dt;
}
mScale *= s;
// set up rotate
if (IvGame::mGame->mEventHandler->IsKeyDown('o'))
{
r -= kPI*0.25f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('u'))
{
r += kPI*0.25f*dt;
}
rotate.RotationZ(r);
mRotate = rotate*mRotate;
// set up translation
if (IvGame::mGame->mEventHandler->IsKeyDown('k'))
{
x -= 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('i'))
{
x += 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('l'))
{
y -= 3.0f*dt;
}
if (IvGame::mGame->mEventHandler->IsKeyDown('j'))
{
y += 3.0f*dt;
}
xlate.Set( x, y, z );
mTranslate += xlate;
// clear transform
if (IvGame::mGame->mEventHandler->IsKeyDown(' '))
{
mRotate.Identity();
mScale = 0.25f;
mTranslate.Zero();
}
} // End of Player::Update()
