//------------------------------------------------------------------------------- // @ 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()