void RaceScene::Enter()
{
mFollowCamera = mSceneManager->addFpsCameraNode(2, nullptr, XMFLOAT3(0, 100.0f, -100.0f), XMFLOAT3(0, 1.0f, 0.0f), XMFLOAT3(0, 1.0f, 0), true);
mFollowCamera->setNearZ(1.0f);
mFollowCamera->setFarZ(1000.0f);
mFollowCamera->setShadowRange(300.0f);
mSideCamera = mSceneManager->addFpsCameraNode(3, nullptr);
mSideCamera->setNearZ(1.0f);
mSideCamera->setFarZ(1000.0f);
mSideCamera->setShadowRange(300.0f);
mPlayerVehicle = new Vehicle(mSceneManager, mTerrainNode, "carA");
mSceneManager->setActiveCamera(2);
XMFLOAT3 camPos = mFreeCamera->getPosition();
mPlayerVehicle->setPosition(camPos);
mFreeCamera->update(0);
XMFLOAT3 look = mFreeCamera->getLookVector();
XMVECTOR look_v = XMVector3Normalize(XMVectorSet(look.x, 0, look.z, 0));
XMVECTOR neg_x_v = XMVectorSet(-1.0f, 0, 0, 0);
XMVECTOR axis = XMVector3Normalize(XMVector3Cross(neg_x_v, look_v));
XMVECTOR angle = XMVector3AngleBetweenNormals(neg_x_v, look_v);
XMVECTOR quat_v = XMQuaternionRotationAxis(axis, XMVectorGetX(angle));
XMFLOAT4 quat;
XMStoreFloat4(&quat, quat_v);
mPlayerVehicle->setRotation(quat);
mVideoDriver->setDeferredAntiAliasing(true);
IMeshNode* skyNode = mSceneManager->getSkyNode();
if (skyNode)
skyNode->setMaterialName("skydome_material");
u32 textureWidth = mVideoDriver->getBackBufferWidth() / 2;
u32 textureHeight = mVideoDriver->getBackBufferHeight() / 2;
ITextureManager* textureManager = ITextureManager::getInstance();
mTireTrailTexture = textureManager->createTexture2D("tire_trail",
textureWidth,
textureHeight,
ETBT_SHADER_RESOURCE | ETBT_RENDER_TARGET,
nullptr, 1, EGF_R16_FLOAT);
mTireTrailDepthSurface = textureManager->createDepthStencilSurface("tire_trail_depth",
textureWidth,
textureHeight,
16, 0, false, 1, 0, false, false);
}
void GCamera::Target(XMFLOAT3 new_target)
{
if (XMVector3Equal(GMathFV(new_target), GMathFV(mPosition)) ||
XMVector3Equal(GMathFV(new_target), GMathFV(mTarget)))
return;
XMFLOAT3 old_look_at_target = GMathVF(GMathFV(mTarget) - GMathFV(mPosition));
XMFLOAT3 new_look_at_target = GMathVF(GMathFV(new_target) - GMathFV(mPosition));
float angle = XMConvertToDegrees(XMVectorGetX(
XMVector3AngleBetweenNormals(XMVector3Normalize(GMathFV(old_look_at_target)),
XMVector3Normalize(GMathFV(new_look_at_target)))));
if (angle != 0.0f && angle != 360.0f && angle != 180.0f)
{
XMVECTOR axis = XMVector3Cross(GMathFV(old_look_at_target), GMathFV(new_look_at_target));
Rotate(GMathVF(axis), angle);
}
mTarget = new_target;
this->lookatViewMatrix();
}
void Enemy::move(FLOAT dt)
{
bool dontUpdate = false;
XMMATRIX startingworldMatrix = XMLoadFloat4x4(&mEnemyStartingWorld);
XMVECTOR S;
XMVECTOR P;
XMVECTOR Q;
XMMatrixDecompose(&S, &Q, &P, startingworldMatrix);
XMVECTOR enemyPosition = XMLoadFloat3(&mEnemyPosition);
FLOAT newPos = XMVectorGetZ(enemyPosition);
FLOAT oldPos = XMVectorGetZ(P);
direction = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
FLOAT diffX;
FLOAT diffY;
FLOAT diffZ;
diffX = 0;
diffY = 0;
diffZ = 0;
if (travelToPoint == 2)
{
diffX = mEnemyPosition.x - mEnemyPositionTwo.x;
diffY = mEnemyPosition.y - mEnemyPositionTwo.y;
diffZ = mEnemyPosition.z - mEnemyPositionTwo.z;
mEnemyPositionThree.x;
int nothing = 0;
if (diffX < 0.0f)
{
diffX *= -1;
}
if (diffY < 0.0f)
{
diffY *= -1;
}
if (diffZ < 0.0f)
{
diffZ *= -1;
}
//////////////////////////////////
if (diffX < 0.01)
{
mEnemyPosition.x = mEnemyPositionTwo.x;
}
if (diffY < 0.01)
{
mEnemyPosition.y = mEnemyPositionTwo.y;
}
if (diffZ < 0.01)
{
mEnemyPosition.z = mEnemyPositionTwo.z;
}
////////////////////////////////
if (mEnemyPosition.x > mEnemyPositionTwo.x)
{
direction += XMVectorSet(-1.0f, 0.0f, 0, 0.0f);
}
else if (mEnemyPosition.x < mEnemyPositionTwo.x)
{
direction += XMVectorSet(1.0f, 0.0f, 0, 0.0f);
}
if (mEnemyPosition.z > mEnemyPositionTwo.z)
{
direction += XMVectorSet(0.0f, 0.0f, -1.0f, 0.0f);
}
else if (mEnemyPosition.z < mEnemyPositionTwo.z)
{
direction += XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f);
}
if (mEnemyPosition.y > mEnemyPositionTwo.y)
{
direction += XMVectorSet(0.0f, -1.0f, 0.0f, 0.0f);
}
else if (mEnemyPosition.y < mEnemyPositionTwo.y)
{
direction += XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
}
if (diffX < 0.05f && diffY < 0.05f && diffZ < 0.05f)
{
if (timesThrough == 0)
{
if (mEnemyPositionThree.x == 0)
{
dontUpdate = true;
travelToPoint = 1;
lastPoint = mEnemyPositionTwo;
}
else if (mEnemyPositionThree.x != 0)
{
dontUpdate = true;
travelToPoint = 3;
lastPoint = mEnemyPositionTwo;
}
}
else
{
dontUpdate = true;
travelToPoint = 1;
lastPoint = mEnemyPositionTwo;
}
int something = 1;
}
}
/////////////////////////////////////////
else if (travelToPoint == 1)
{
timesThrough = 0;
diffX = mEnemyPosition.x - mEnemyPositionOne.x;
diffY = mEnemyPosition.y - mEnemyPositionOne.y;
diffZ = mEnemyPosition.z - mEnemyPositionOne.z;
if (diffX < 0.0f)
{
diffX *= -1;
}
if (diffY < 0.0f)
{
diffY *= -1;
}
if (diffZ < 0.0f)
{
diffZ *= -1;
}
//////////////////////////////////
if (diffX < 0.01)
{
mEnemyPosition.x = mEnemyPositionOne.x;
}
if (diffY < 0.01)
{
mEnemyPosition.y = mEnemyPositionOne.y;
}
if (diffZ < 0.01)
{
mEnemyPosition.z = mEnemyPositionOne.z;
}
////////////////////////////////
if (mEnemyPosition.x > mEnemyPositionOne.x)
{
direction += XMVectorSet(-1.0f, 0.0f, 0, 0.0f);
}
if (mEnemyPosition.x < mEnemyPositionOne.x)
{
direction += XMVectorSet(1.0f, 0.0f,0, 0.0f);
}
if (mEnemyPosition.z > mEnemyPositionOne.z && diffZ > 0.01)
{
direction += XMVectorSet(0.0f, 0.0f, -1.0f, 0.0f);
}
if (mEnemyPosition.z < mEnemyPositionOne.z && diffZ > 0.01)
{
direction += XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f);
}
if (mEnemyPosition.y > mEnemyPositionOne.y)
{
direction += XMVectorSet(0.0f, -1.0f, 0.0f, 0.0f);
}
if (mEnemyPosition.y < mEnemyPositionOne.y)
{
direction += XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
}
if (diffX < 0.05f && diffY < 0.05f && diffZ < 0.05f)
{
travelToPoint = 2;
lastPoint = mEnemyPositionOne;
}
}
////////////////////////////////////////////////////////////////////////////////
else if (travelToPoint == 3 && timesThrough == 0)
{
diffX = mEnemyPosition.x - mEnemyPositionThree.x;
diffY = mEnemyPosition.y - mEnemyPositionThree.y;
diffZ = mEnemyPosition.z - mEnemyPositionThree.z;
int nothing;
if (diffX < 0.0f)
{
diffX *= -1;
}
if (diffY < 0.0f)
{
diffY *= -1;
}
if (diffZ < 0.0f)
{
diffZ *= -1;
}
//////////////////////////////////
if (diffX < 0.01)
{
mEnemyPosition.x = mEnemyPositionThree.x;
}
if (diffY < 0.01)
{
mEnemyPosition.y = mEnemyPositionThree.y;
}
if (diffZ < 0.01)
{
mEnemyPosition.z = mEnemyPositionThree.z;
}
////////////////////////////////
if (mEnemyPosition.x > mEnemyPositionThree.x)
{
direction += XMVectorSet(-1.0f, 0.0f, 0, 0.0f);
}
if (mEnemyPosition.x < mEnemyPositionThree.x)
{
direction += XMVectorSet(1.0f, 0.0f, 0, 0.0f);
}
if (mEnemyPosition.z > mEnemyPositionThree.z)
{
direction += XMVectorSet(0.0f, 0.0f, -1.0f, 0.0f);
}
if (mEnemyPosition.z < mEnemyPositionThree.z)
{
direction += XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f);
}
if (mEnemyPosition.y > mEnemyPositionThree.y)
{
direction += XMVectorSet(0.0f, -1.0f, 0.0f, 0.0f);
}
if (mEnemyPosition.y < mEnemyPositionThree.y)
{
direction += XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
}
if (diffX < 0.05f && diffY < 0.05f && diffZ < 0.05f)
{
if (mEnemyPositionFour.x == NULL)
{
travelToPoint = 2;
timesThrough = 1;
}
else
{
travelToPoint = 4;
}
}
}
else if (travelToPoint == 4)
{
diffX = mEnemyPosition.x - mEnemyPositionFour.x;
diffY = mEnemyPosition.y - mEnemyPositionFour.y;
diffZ = mEnemyPosition.z - mEnemyPositionFour.z;
if (diffX < 0.0f)
{
diffX *= -1;
}
if (diffY < 0.0f)
{
diffY *= -1;
}
if (diffZ < 0.0f)
{
diffZ *= -1;
}
//////////////////////////////////
if (diffX < 0.001)
{
mEnemyPosition.x = mEnemyPositionFour.x;
}
if (diffY < 0.001)
{
mEnemyPosition.y = mEnemyPositionFour.y;
}
if (diffZ < 0.001)
{
mEnemyPosition.z = mEnemyPositionFour.z;
}
////////////////////////////////
if (mEnemyPosition.x > mEnemyPositionFour.x)
{
direction += XMVectorSet(-1.0f, 0.0f, 0, 0.0f);
}
if (mEnemyPosition.x < mEnemyPositionFour.x)
{
direction += XMVectorSet(1.0f, 0.0f,0, 0.0f);
}
if (mEnemyPosition.z > mEnemyPositionFour.z && diffZ > 0.01)
{
direction += XMVectorSet(0.0f, 0.0f, -1.0f, 0.0f);
}
if (mEnemyPosition.z < mEnemyPositionFour.z && diffZ > 0.01)
{
direction += XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f);
}
if (mEnemyPosition.y > mEnemyPositionFour.y)
{
direction += XMVectorSet(0.0f, -1.0f, 0.0f, 0.0f);
}
if (mEnemyPosition.y < mEnemyPositionFour.y)
{
direction += XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
}
if (diffX < 0.05f && diffY < 0.05f && diffZ < 0.05f)
{
travelToPoint = 1;
lastPoint = mEnemyPositionFour;
}
}
XMMATRIX worldMatrix = XMLoadFloat4x4(&mEnemyWorld);
XMVECTOR r = XMLoadFloat3(&mEnemyPosition);
// Normalize our destinated direction vector
direction = XMVector3Normalize(direction);
/////character spinning make it more smooth
if (XMVectorGetX(XMVector3Dot(direction, oldCharDirection)) == -1)
{
oldCharDirection += XMVectorSet(1.11f, 1.0f, 0.0f, 0.0f);
}
///////get characters position in world space
charPosition = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
charPosition = XMVector3TransformCoord(charPosition, worldMatrix);
///// rotate the character
float destDirLength = 10.0f * dt;
currCharDirection = (oldCharDirection)+(direction * destDirLength);
currCharDirection = XMVector3Normalize(currCharDirection);
// get the angle
float charDirAngle = XMVectorGetX(XMVector3AngleBetweenNormals(XMVector3Normalize(currCharDirection), XMVector3Normalize(EnemyForward)));
if (XMVectorGetY(XMVector3Cross(currCharDirection, EnemyForward)) > 0.0f)
{
charDirAngle = -charDirAngle;
}
float Speed = speed * dt;
direction = direction * Speed;
charPosition = charPosition + direction;
XMMATRIX rotationMatrix;
XMMATRIX Translation = XMMatrixTranslation(XMVectorGetX(charPosition), XMVectorGetY(charPosition), XMVectorGetZ(charPosition));
rotationMatrix = XMMatrixRotationY(charDirAngle - 3.14159265f); // Subtract PI from angle so the character doesn't run backwards
worldMatrix = rotationMatrix * Translation;
XMMatrixDecompose(&S, &Q, &P, worldMatrix);
XMStoreFloat3(&mEnemyPosition, P);
XMStoreFloat4(&mEnemyRotationQuad, Q);
XMStoreFloat4x4(&mEnemyWorld, worldMatrix);
oldCharDirection = currCharDirection;
}
void Entity::Update(const Camera& camera, float dt)
{
if (mSpinning) {Yaw(dt*movementMult);}
if (mUpDown) {GoUpDown(dt);}
if (mFlipping) {Pitch(dt*movementMult);}
if (mRolling) {Roll(dt*movementMult);}
if (mSideToSide) {GoSideToSide(dt);}
if (mBackAndForth) {GoBackAndForth(dt);}
if (mOrbit) { Yaw(dt*movementMult); Walk(dt*movementMult*100); }
XMVECTOR R = XMLoadFloat3(&mRight);
XMVECTOR U = XMLoadFloat3(&mUp);
XMVECTOR L = XMLoadFloat3(&mLook);
XMVECTOR P = XMLoadFloat3(&mPosition);
// Keep axes orthogonal to each other and of unit length.
L = XMVector3Normalize(L);
U = XMVector3Normalize(XMVector3Cross(L, R));
// U, L already ortho-normal, so no need to normalize cross product.
R = XMVector3Cross(U, L);
// Fill in the world matrix entries.
// float x = XMVectorGetX(XMVector3Dot(P, R));
// float y = XMVectorGetX(XMVector3Dot(P, U));
// float z = XMVectorGetX(XMVector3Dot(P, L));
float x = XMVectorGetX(P);
float y = XMVectorGetY(P);
float z = XMVectorGetZ(P);
XMStoreFloat3(&mRight, R);
XMStoreFloat3(&mUp, U);
XMStoreFloat3(&mLook, L);
mWorld(0, 0) = mRight.x;
mWorld(1, 0) = mRight.y;
mWorld(2, 0) = mRight.z;
mWorld(3, 0) = x;
mWorld(0, 1) = mUp.x;
mWorld(1, 1) = mUp.y;
mWorld(2, 1) = mUp.z;
mWorld(3, 1) = y;
if (reverseLook){
mWorld(0, 2) = -mLook.x;
mWorld(1, 2) = -mLook.y;
mWorld(2, 2) = -mLook.z;
mWorld(3, 2) = z;}
else
{ mWorld(0, 2) = mLook.x;
mWorld(1, 2) = mLook.y;
mWorld(2, 2) = mLook.z;
mWorld(3, 2) = z;}
mWorld(0, 3) = 0.0f;
mWorld(1, 3) = 0.0f;
mWorld(2, 3) = 0.0f;
mWorld(3, 3) = 1.0f;
if (hovering)
{
XMMATRIX M = XMLoadFloat4x4(&mWorld);
XMMATRIX scaling = XMMatrixScaling(1.3f, 1.3f, 1.3f);
XMStoreFloat4x4(&mWorld, scaling * M);
}
//GROWING MOVEMENTS
if (mPulse) { Pulse(dt); }
if (mGrowIn){ GrowIn(dt); }
if (mGrowOut){ GrowOut(dt); }
if (mSquishX || mSquishY || mSquishZ){ Squish(dt);
if (mSquishX){ ScaleX(currProgress); }
if (mSquishY){ ScaleY(currProgress); }
if (mSquishZ){ ScaleZ(currProgress); }}
if (progressBar)
{
ScaleX(currProgress);
}
if (billboard)
{
XMMATRIX M = XMLoadFloat4x4(&mWorld);
XMVECTOR L = XMVector3Normalize(XMVectorSubtract(camera.GetPositionXM(), GetPositionXM()));
XMVECTOR Look = XMLoadFloat3(&mLook);
XMVECTOR angle = XMVector3AngleBetweenNormals(L, Look);
float theAngle = XMVectorGetY(angle);
XMMATRIX rotY;
camera.GetPosition().x < mPosition.x ? rotY = XMMatrixRotationY(-theAngle) : rotY = XMMatrixRotationY(theAngle);
XMStoreFloat4x4(&mWorld, rotY * M);
}
if (goToPos)
{
if (mDistanceLeft <= 0){ goToPos = false; }
}
if (mUseAnimation){ mAnim->Update(dt);}
//update sphere collider
mSphereCollider.Center = mPosition;
if (mUseAAB){ UpdateAAB(); }
if (mUseAABOnce){ UpdateAAB(); mUseAABOnce = false; }
}
