void CustomCam1::rotateCamVertical(float degrees)
{
	if (degrees + f_currentPitch > f_pitchLimit && degrees > 0)
	{
		degrees = f_pitchLimit - f_currentPitch;

		if (f_currentPitch >= f_pitchLimit)
		{
			degrees = 0.f;
		}
	}

	else if (degrees + f_currentPitch < -f_pitchLimit && degrees < 0)
	{
		degrees = -f_pitchLimit - f_currentPitch;

		if (f_currentPitch <= -f_pitchLimit)
		{
			degrees = 0.f;
		}
	}

	Vector3 view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(view).Normalized();
	Mtx44 rotation;
	target -= position;
	f_currentPitch += degrees;
	rotation.SetToRotation(static_cast<float>(degrees), right.x, right.y, right.z);
	target = rotation * target;
	target += position;
}
void CTransform::SetRotate( const float angle, const float rx, const float ry, const float rz, bool self)
{
	Mtx44 MtxBackToPosition;
	if (self)
	{
		Mtx44 MtxBackToOrigin;
		MtxBackToOrigin.a[12] = -Mtx.a[12];
		MtxBackToOrigin.a[13] = -Mtx.a[13];
		MtxBackToOrigin.a[14] = -Mtx.a[14];

		MtxBackToPosition.a[12] = Mtx.a[12];
		MtxBackToPosition.a[13] = Mtx.a[13];
		MtxBackToPosition.a[14] = Mtx.a[14];

		Mtx = Mtx + MtxBackToOrigin;
	}
	Mtx44 TempMtx;
	TempMtx.SetToRotation(angle, rx, ry, rz);

	Mtx =  Mtx * TempMtx ;

	if (self)
	{
		Mtx = Mtx + MtxBackToPosition;
	}
}
void AI::movementFB(double &dt, bool forward)
{
	Mtx44 rotation;

	if (forward)
	{
		if (e_State == ATTACK)
		{
			f_movementSpeed = f_move_run;
		}
		else
		{
			f_movementSpeed = f_move_walk;
		}

		vel += (getDirection(true).Normalize() * (f_movementSpeed)) * static_cast<float>(dt);
	}
	else
	{
		Lookat = Lookat - pos;
		rotation.SetToRotation(720 * static_cast<float>(dt), 0, 1, 0);
		Lookat = rotation * Lookat;
		Lookat = Lookat + pos;
		//Velocity += (getDirection(true).Normalize() * f_movementSpeed) * static_cast<float>(dt);
	}
}
Exemple #4
0
void FPcamera::SpinCounterClockwise(const double dt)
{
	float angle = (float)(-TURN_SPEED * (float)dt);
	view = (target - position).Normalized();
	Mtx44 rotation;
	rotation.SetToRotation(angle, 0, 0, 1);
	view = rotation * view;
	target = position + view;
}
void CameraComponent::LookAround(double dt)
{
	auto infoC = this->getParent()->getComponent<InformationComponent>();

	if (infoC)
	{
		Mtx44 rotation;
		rotation.SetToRotation(m_Camera->getCameraYaw(),0, 1, 0);
		Vector3 curDirection = infoC->getDirection().Normalized();
		curDirection = rotation * curDirection;
		infoC->setDirection(curDirection);
	}
}
void CPlayInfo3PV::UpdateDir(float yaw, float pitch)
{
	// Yaw
	Mtx44 rotation;
	rotation.SetToRotation(yaw, 0, 1, 0);
	curDirection = rotation * curDirection;
	Vector3 right = curDirection.Cross(curUp);
	right.y = 0;
	right.Normalize();
	curUp = right.Cross(curDirection).Normalized();

	// Pitch
	//rotation.SetToRotation(pitch, 1, 0, 0);

	right = curDirection.Cross(curUp);
	right.y = 0;
	right.Normalize();
	curUp = right.Cross(curDirection).Normalized();
	rotation.SetToRotation(pitch, right.x, right.y, right.z);

	curDirection = rotation * curDirection;
}
void AI::movementLR(double &dt, bool left, float rotation_speed)
{
	Mtx44 rotation;
	if (left == true)
	{
		Lookat = Lookat - pos;
		rotation.SetToRotation(-rotation_speed * static_cast<float>(dt), 0, 1, 0);
		Lookat = rotation * Lookat;
		Lookat = Lookat + pos;
		//Velocity += (getDirection(true).Normalize() * f_movementSpeed) * static_cast<float>(dt);

	}

	else
	{
		Lookat = Lookat - pos;
		rotation.SetToRotation(rotation_speed * static_cast<float>(dt), 0, 1, 0);
		Lookat = rotation * Lookat;
		Lookat = Lookat + pos;
		//Velocity += (getDirection(true).Normalize() * f_movementSpeed) * static_cast<float>(dt);
	}
}
Exemple #8
0
/********************************************************************************
LookDown
********************************************************************************/
void TPCamera::LookDown(const double dt)
{
	//float pitch = (float)(-CAMERA_SPEED * Application::camera_pitch * (float)dt);
	float pitch = (float)(CAMERA_SPEED * (float)dt);
	Vector3 view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(view).Normalized();
	Mtx44 rotation;
	rotation.SetToRotation(pitch, right.x, right.y, right.z);
	view = rotation * view;
	target = position + view;
}
Exemple #9
0
void FPcamera::lookUp(const double dt)
{
	float pitch = (float)(-TURN_SPEED * Application::camera_pitch * (float)dt);
	rotationX -= pitch;
	view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(view).Normalized();
	Mtx44 rotation;
	rotation.SetToRotation(pitch, right.x, right.y, right.z);
	view = rotation * view;
	target = position + view;
}
Exemple #10
0
void FPcamera::lookRight(const double dt)
{
	view = (target - position).Normalized();
	float yaw = (float)(-TURN_SPEED * Application::camera_yaw * (float)dt);
	rotationY += yaw;
	Mtx44 rotation;
	rotation.SetToRotation(yaw, 0, 1, 0);
	view = rotation * view;
	target = position + view;
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(view).Normalized();
}
Exemple #11
0
/********************************************************************************
Turn right
********************************************************************************/
void TPCamera::TurnRight(const double dt)
{
	Vector3 view = (target - position).Normalized();
	//	float yaw = (float)(-CAMERA_SPEED * Application::camera_yaw * (float)dt);
	float yaw = (float)(-CAMERA_SPEED * (float)dt);
	Mtx44 rotation;
	rotation.SetToRotation(yaw, 0, 1, 0);
	view = rotation * view;
	target = position + view;
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(view).Normalized();
}
Exemple #12
0
/********************************************************************************
LookRight
********************************************************************************/
void Camera3::LookRight(const double dt)
{
	float yaw = yawVelocity;
	Vector3 view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(view).Normalized();
	Mtx44 rotation;
	rotation.SetToRotation(yaw, 0, 1, 0);
	view = rotation * view;
	target = position + view;

	up = rotation * up;
}
Exemple #13
0
void FPcamera::lookDown(const double dt, float downValue)
{
	float pitch = (float)(-WALK_SPEED * Application::camera_pitch * (float)dt - downValue * (float)dt);
	recoil -= 5.f * (float)dt;;
	rotationX -= pitch;
	view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(view).Normalized();
	Mtx44 rotation;
	rotation.SetToRotation(pitch, right.x, right.y, right.z);
	view = rotation * view;
	target = position + view;
}
Exemple #14
0
void FPS_Cam::LookPitch(float pitchValue, double dt)
{
	float mspeed = mouse_speed * pitchValue * dt;

	FaceDirection = (target - position).Normalized();
	Vector3 right = FaceDirection.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(FaceDirection).Normalized();
	rotation22.SetToRotation(mspeed, right.x, right.y, right.z);
	FaceDirection = rotation22 * FaceDirection;
	target = position + FaceDirection;

	up = rotation22 * up;
}
Exemple #15
0
void FPS_Cam::LookYaw(float yawValue, double dt)
{
	float mspeed = mouse_speed * yawValue;

	FaceDirection = (target - position).Normalized();
	Vector3 right = FaceDirection.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(FaceDirection).Normalized();
	rotation22.SetToRotation(mspeed * dt, 0, 1, 0);
	FaceDirection = rotation22 * FaceDirection;
	target = position + FaceDirection;

	up = rotation22 * up;
}
Exemple #16
0
void FPcamera::lookLeft(const double dt)
{
	//Update the camera direction based on mouse move
	// left-right rotate
	view = (target - position).Normalized();
	float yaw = (float)(-TURN_SPEED * Application::camera_yaw * (float)dt);
	rotationY += yaw;
	Mtx44 rotation;
	rotation.SetToRotation(yaw, 0, 1, 0);
	view = rotation * view;
	target = position + view;
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(view).Normalized();
}
Exemple #17
0
/********************************************************************************
LookDown
********************************************************************************/
void Camera3::LookDown(const double dt)
{
	float pitch = pitchVelocity;

	//Controller::incrementPitchAngle(pitch);
	Vector3 view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(view).Normalized();
	Mtx44 rotation;
	rotation.SetToRotation(pitch, right.x, right.y, right.z);
	view = rotation * view;
	target = position + view;

	up = rotation * up;
}
void AI::ai_ScanArea(double &dt)
{
	b_updateAI = false;
	b_aiScanning = true;

	static double rotationSpeed = 50.f;

	if(b_rotateClockwiseFirst == NULL)
	{
		b_rotateClockwiseFirst = static_cast<bool>(Math::RandIntMinMax(0, 1));
	}

	d_totalRotation += rotationSpeed * dt;

	//Scan 
	if(d_totalRotation < 90)
	{
		if(b_rotateClockwiseFirst)
			d_enemyRotation = -rotationSpeed * dt;
		else
			d_enemyRotation = rotationSpeed * dt;
	}
	else if (d_totalRotation >= 90 && d_totalRotation < 270)
	{
		if(b_rotateClockwiseFirst)
			d_enemyRotation = rotationSpeed * dt;
		else
			d_enemyRotation = -rotationSpeed * dt;
	}
	else
	{
		e_State = WALKING;
		d_totalRotation = 0.f;
		b_updateAI = true;
		b_rotateClockwiseFirst = NULL;
		b_aiScanning = false;
	}

	Mtx44 rotation;
	Lookat = Lookat - pos;
	rotation.SetToRotation(static_cast<float>(d_enemyRotation), 0, 1, 0);
	Lookat = rotation * Lookat;
	Lookat = Lookat + pos;
}
/********************************************************************************
 Hero Move Left Right
 ********************************************************************************/
void CPlayInfo3PV::MoveLeftRight(const bool mode, const float timeDiff)
{
	Mtx44 rotation;
	rotation.SetToRotation(90, 0, 1, 0);
	// Dir without moving y axis
	Vector3 tempTarget = curPosition + curDirection;
	tempTarget.y = curPosition.y;
	Vector3 tempDir = (tempTarget - curPosition).Normalized();

	Vector3 right = rotation * tempDir;
	if (mode)
	{
		curPosition += right * (CAMERA_SPEED * timeDiff);
		//curPosition.x = curPosition.x + (int) (200.0f * timeDiff);
	}
	else
	{
		curPosition -= right * (CAMERA_SPEED * timeDiff);
		//curPosition.x = curPosition.x - (int) (200.0f * timeDiff);
	}
}
Exemple #20
0
void Camera3::Update(double dt)
{
	static const float CAMERA_SPEED = 80.f;
	static const float MOVEMENT_SPEED = 30.f;
	if (Application::IsKeyPressed('W'))
	{
		Vector3 camDir = (target - position).Normalized();
		position += (camDir * MOVEMENT_SPEED * dt);
		target += (camDir * MOVEMENT_SPEED * dt);
	}
	if (Application::IsKeyPressed('S'))
	{
		Vector3 camDir = (target - position).Normalized();
		position -= (camDir * MOVEMENT_SPEED * dt);
		target -= (camDir * MOVEMENT_SPEED * dt);
	}
	if (Application::IsKeyPressed('A'))
	{
		Vector3 camDir = (target - position).Normalized();
		Vector3 leftDir = (up.Cross(camDir)).Normalized();

		position += (leftDir * MOVEMENT_SPEED * dt);
		target += (leftDir * MOVEMENT_SPEED * dt);
	}
	if (Application::IsKeyPressed('D'))
	{
		Vector3 camDir = (target - position).Normalized();
		Vector3 rightDir = (camDir.Cross(up)).Normalized();

		position += (rightDir * MOVEMENT_SPEED * dt);
		target += (rightDir * MOVEMENT_SPEED * dt);
	}
	if (Application::IsKeyPressed(VK_LEFT))
	{
		float yaw = (float)(CAMERA_SPEED * dt);
		Mtx44 rotate;
		rotate.SetToRotation(yaw, 0, 1, 0);
		target.x -= position.x;
		target.y -= position.y;
		target.z -= position.z;
		target = rotate * target;
		target.x += position.x;
		target.y += position.y;
		target.z += position.z;
		up = rotate * up;
	}
	if (Application::IsKeyPressed(VK_RIGHT))
	{
		float yaw = (float)(-CAMERA_SPEED * dt);
		Mtx44 rotate;
		rotate.SetToRotation(yaw, 0, 1, 0);
		target.x -= position.x;
		target.y -= position.y;
		target.z -= position.z;
		target = rotate * target;
		target.x += position.x;
		target.y += position.y;
		target.z += position.z;
		up = rotate * up;
	}
	if (Application::IsKeyPressed(VK_UP))
	{
		float pitch = (float)(CAMERA_SPEED * dt);
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
		up = right.Cross(view).Normalized();
		Mtx44 rotate;
		rotate.SetToRotation(pitch, right.x, right.y, right.z);
		target.x -= position.x;
		target.y -= position.y;
		target.z -= position.z;
		target = rotate * target;
		target.x += position.x;
		target.y += position.y;
		target.z += position.z;
	}
	if (Application::IsKeyPressed(VK_DOWN))
	{
		float pitch = (float)(-CAMERA_SPEED * dt);
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
		up = right.Cross(view).Normalized();
		Mtx44 rotate;
		rotate.SetToRotation(pitch, right.x, right.y, right.z);
		target.x -= position.x;
		target.y -= position.y;
		target.z -= position.z;
		target = rotate * target;
		target.x += position.x;
		target.y += position.y;
		target.z += position.z;
	}
	if (Application::IsKeyPressed('R'))
	{
		Reset();
	}
}
void AI::AiLookatRotation(double &dt)
{
	if(currentLookat != 0)
	{
		static float rotationSpeed = 4;

		if(e_State == ATTACK)
		{
			rotationSpeed = 10;
		}
		else
		{
			rotationSpeed = 5;
		}

		if (b_aiRotating == false)
		{
			float rotationdiff = (CalAnglefromPosition(currentLookat, pos, true) - CalAnglefromPosition(Lookat, pos, true));
			
			if (rotationdiff >= 180)
			{
				Mtx44 rotation;
				Lookat = Lookat - pos;
				rotation.SetToRotation(-360, 0, 1, 0);
				Lookat = rotation * Lookat;
				Lookat = Lookat + pos;
				rotationdiff -= 360;
			}
			else if (rotationdiff <= -180)
			{
				Mtx44 rotation;
				Lookat = Lookat - pos;
				rotation.SetToRotation(360, 0, 1, 0);
				Lookat = rotation * Lookat;
				Lookat = Lookat + pos;
				rotationdiff += 360;
			}

			Mtx44 rotation;
			Lookat = Lookat - pos;
			rotation.SetToRotation(rotationdiff * rotationSpeed * static_cast<float>(dt), 0, 1, 0);
			Lookat = rotation * Lookat;
			Lookat = Lookat + pos;

			if(rotationdiff < 0.1 && rotationdiff > -0.1)
			{
				b_aiRotating = true;
			}
		}
		else
		{
			if (e_State == ATTACK)
			{
				prevPosition = pos;
			}
			else if (e_State == ALERT)
			{
				destination = currentLookat;
				prevPosition = pos;
			}

			currentLookat = 0;
			b_aiRotating = false;
		}
	}
}
void AI::aiStateHandling(double &dt, Vector3 &playerPos, std::vector<GameObject*> &m_GOList)
{
	Mtx44 rotation;
	rotation.SetToRotation(CalAnglefromPosition(Lookat, pos, true), 0.f, 1.f, 0.f);
	Vector3 L, R, C;
	C = rotation * Vector3(0.f, ModelPos.y, 50.f);
	L = rotation * Vector3(-15.f, ModelPos.y, 15.f);
	R = rotation * Vector3(15.f, ModelPos.y, 15.f);

	switch (e_State)
	{
	case WALKING:
		{
			//Have the AI partol a certain area
			//Need Pathfinding i think
			destination = playerPos;
			if (b_isDestinationWithinFOV && b_isDestinationVisible)
			{
				//If player is infront and near player, then ai will switch to attack state
				if ((playerPos - pos).LengthSquared() < d_detectionRange)
				{
					currentLookat.x = playerPos.x;
					currentLookat.z = playerPos.z;
					destination = playerPos;
					prevPosition = pos;
					e_State = ATTACK;
					break;
				}
				//if ai saw player but is too far way, the ai will investigate
				else if ((playerPos - pos).LengthSquared() >= d_detectionRange && (playerPos - pos).LengthSquared() <= d_detectionRangeMax)
				{
					destination.x = playerPos.x;
					destination.z = playerPos.z;
					destination = playerPos;
					prevPosition = pos;
					e_State = ALERT;
					break;
				}
			}

			SensorUpdate(dt, collisionChecking(pos + L, m_GOList), collisionChecking(pos + C, m_GOList), collisionChecking(pos + R, m_GOList));
		}
		break;

	case ALERT:
		{					
			//If destination is not visible
			if (!b_isDestinationVisible)
			{
				//use sensor update 2 to get to the destination
				SensorUpdate2(dt, collisionChecking(pos + L, m_GOList), collisionChecking(pos + C, m_GOList), collisionChecking(pos + R, m_GOList));
			}
			//If player is infront and near player, then ai will switch to attack state
			if (isVisible(pos, Lookat, getDetectionAngle(), playerPos) && (playerPos - pos).LengthSquared() < d_detectionRange)
			{
				currentLookat.x = playerPos.x;
				currentLookat.z = playerPos.z;
				destination = playerPos;
			}

			if (b_isDestinationVisible && b_isDestinationWithinFOV && destination == playerPos)
			{
				e_State = ATTACK;
			}
				
			if(b_isDestinationVisible && b_isDestinationWithinFOV)
			{
				moveToDestination(dt);
			}

			if((pos - destination).LengthSquared() < 300)
			{
				e_State = WALKING;
			}
		}
		break;

	case ATTACK:
	{
		destination = playerPos;
		//if enemy is holding a weapon
		if (holding != NULL)
		{
			if (holding->isWeapon)
			{
				WeaponsObject *WO = dynamic_cast<WeaponsObject*>(holding);

				//Enemy is holding a gun
				if (WO->isGun)
				{
					//Make enemy stay at the same pos 
					if (b_isDestinationVisible && b_isDestinationWithinFOV && (playerPos - pos).LengthSquared() < d_detectionRange)
					{
						currentLookat.x = playerPos.x;
						currentLookat.z = playerPos.z;
						b_SHOOTLA = true;
					}
					else
					{
						b_SHOOTLA = false;
						if (!b_isDestinationVisible)
						{
							SensorUpdate2(dt, collisionChecking(pos + L, m_GOList), collisionChecking(pos + C, m_GOList), collisionChecking(pos + R, m_GOList));
						}
						else
						{
							moveToDestination(dt);
						}
					}
				}
				else
				{
					if (!b_isDestinationVisible)
					{
						SensorUpdate2(dt, collisionChecking(pos + L, m_GOList), collisionChecking(pos + C, m_GOList), collisionChecking(pos + R, m_GOList));
					}
					else
					{
						moveToDestination(dt);
					}
				}
			}
			else
			{
				if (!b_isDestinationVisible)
				{
					SensorUpdate2(dt, collisionChecking(pos + L, m_GOList), collisionChecking(pos + C, m_GOList), collisionChecking(pos + R, m_GOList));
				}
				else
				{
					moveToDestination(dt);
				}
			}
		}
		//Enemy is not holding a weapon
		else
		{
			if (!b_isDestinationVisible)
			{
				SensorUpdate2(dt, collisionChecking(pos + L, m_GOList), collisionChecking(pos + C, m_GOList), collisionChecking(pos + R, m_GOList));
			}
			else
			{
				moveToDestination(dt);
			}
		}
		break;
	}
	default:
		break;
	}
}
Exemple #23
0
void FPCamera::Update(double dt){
	tempPos = position;
	static const float MOVE_SPEED = 100.0f;
	static const float CAMERA_SPEED = MOVE_SPEED * 2;
	if (Application::IsKeyPressed('A'))
	{
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		view = target - position;
		view.Normalize();
		position -= right * dt * MOVE_SPEED;
		target -= right * dt * MOVE_SPEED;
	}
	if (Application::IsKeyPressed('D'))
	{
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		view = target - position;
		view.Normalize();
		position += right * dt * MOVE_SPEED;
		target += right * dt * MOVE_SPEED;
	}
	if (Application::IsKeyPressed('W'))
	{
		Vector3 view = (target - position).Normalized();
		/*position.x += view.x * dt * MOVE_SPEED;
		position.z += view.z * dt * MOVE_SPEED;

		target.x += view.x * dt * MOVE_SPEED;
		target.z += view.z * dt * MOVE_SPEED;*/

		//for free y move
		position += view * dt * MOVE_SPEED;
		target += view * dt * MOVE_SPEED;
	}
	if (Application::IsKeyPressed('S'))
	{
		Vector3 view = (target - position).Normalized();
		/*position.x -= view.x * dt * MOVE_SPEED;
		position.z -= view.z * dt * MOVE_SPEED;

		target.x -= view.x * dt * MOVE_SPEED;
		target.z -= view.z * dt * MOVE_SPEED;*/

		//for free y move
		position -= view * dt * MOVE_SPEED;
		target -= view * dt * MOVE_SPEED;
	}

	if (Application::IsKeyPressed(VK_UP))
	{
		float pitch = (float)(-CAMERA_SPEED * dt);
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		Mtx44 rotation;
		rotation.SetToRotation(-pitch, right.x, right.y, right.z);
		up = rotation * up;
		view = rotation * view;
		target = position + view;
	}

	if (Application::IsKeyPressed(VK_DOWN))
	{
		float pitch = (float)(-CAMERA_SPEED * dt);
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		Mtx44 rotation;
		rotation.SetToRotation(pitch, right.x, right.y, right.z);
		up = rotation * up;
		view = rotation * view;
		target = position + view;
	}

	if (Application::IsKeyPressed(VK_LEFT))
	{
		float yaw = (float)(-CAMERA_SPEED * dt);
		Mtx44 rotation;
		rotation.SetToRotation(-yaw, 0, 1, 0);
		Vector3 view = position - target;
		//view.Normalize();
		view = rotation * view;
		position = target + view;
		up = rotation * up;
	}

	if (Application::IsKeyPressed(VK_RIGHT))
	{
		float yaw = (float)(-CAMERA_SPEED * dt);
		Mtx44 rotation;
		rotation.SetToRotation(yaw, 0, 1, 0);
		Vector3 view = position - target;
		//view.Normalize();
		view = rotation * view;
		position = target + view;
		up = rotation * up;
	}

	if (Application::IsKeyPressed('N'))
	{
		Vector3 direction = target - position;
		if (direction.Length() > 5)
		{
			Vector3 view = (target - position).Normalized();
			position += view * (float)(100.f * dt);
		}
	}

	if (Application::IsKeyPressed('M'))
	{
		Vector3 view = (target - position).Normalized();
		position -= view * (float)(100.f * dt);
	}
	if (Application::IsKeyPressed('R'))
	{
		Reset();
	}

	if (position.x > 499 || position.z > 499 || position.x < -499 || position.z < -499 || position.y > 499 || position.y < -499){
		Reset();
	}
	
}
Exemple #24
0
void Camera2::Update(double dt)
{
    static const float CAMERA_SPEED = 50.f;

    TestPosition = position;
    PlayerPosition = position;

    if (Application::IsKeyPressed('W'))
    {
        Vector3 view = (target - position).Normalized();
        // Normalize view vector

        TestPosition.x += view.x * dt * 100;
        TestPosition.z += view.z * dt * 100;

        if (BoundaryCheck(TestPosition) == true) {
            position.x += view.x * dt * 100;
            position.z += view.z * dt * 100;
            target.x += view.x * dt * 100;
            target.z += view.z * dt * 100;
        }
    }
    if (Application::IsKeyPressed('A'))
    {
        Vector3 view = (target - position).Normalized();
        // Normalize view vector
        Vector3 right = view.Cross(up);

        TestPosition.x -= right.x * dt * 100;
        TestPosition.z -= right.z * dt * 100;

        if ((BoundaryCheck(TestPosition) == true)) {
            position.x -= right.x * dt * 100;
            position.z -= right.z * dt * 100;
            target.x -= right.x * dt * 100;
            target.z -= right.z * dt * 100;
        }
    }
    if (Application::IsKeyPressed('S'))
    {
        Vector3 view = (target - position).Normalized();
        // Normalize view vector

        TestPosition.x -= view.x * dt * 100;
        TestPosition.z -= view.z * dt * 100;

        if ((BoundaryCheck(TestPosition) == true)) {
            position.x -= view.x * dt * 100;
            position.z -= view.z * dt * 100;
            target.x -= view.x * dt * 100;
            target.z -= view.z * dt * 100;
        }
    }
    if (Application::IsKeyPressed('D'))
    {
        Vector3 view = (target - position).Normalized();
        // Normalize view vector
        Vector3 right = view.Cross(up);

        TestPosition.x += right.x * dt * 100;
        TestPosition.z += right.z * dt * 100;

        if ((BoundaryCheck(TestPosition) == true)) {
            position.x += right.x * dt * 100;
            position.z += right.z * dt * 100;
            target.x += right.x * dt * 100;
            target.z += right.z * dt * 100;
        }
    }

    Application::MouseMovement(mouseXPos, mouseYPos);

    float horizontalMouseMovement = 10 * dt * static_cast<float>((800 / 2) - mouseXPos);
    float verticalMouseMovement = 10 * dt * static_cast<float>((600 / 2) - mouseYPos);

    if (verticalMouseMovement)
    {
        Vector3 TESTview = ((target - position).Normalized()) * 10;
        Vector3 view = ((target - position).Normalized()) * 10;
        // normalize view vector
        Vector3 right = view.Cross(up);
        Mtx44 rotation;
        rotation.SetToRotation(verticalMouseMovement, right.x, right.y, right.z);
        TESTview = rotation * view;
        if (TESTview.y < 8.f && TESTview.y > -9.f) {
            view = rotation * view;
            up = rotation * up;
            target = position + view;
        }
    }

    if (horizontalMouseMovement)
    {
        Vector3 view = ((target - position).Normalized()) * 10;
        // normalize view vector
        float yaw = (float)(CAMERA_SPEED * dt);
        Mtx44 rotation;
        rotation.SetToRotation(horizontalMouseMovement, 0, 1, 0);
        view = rotation * view;
        target = position + view;
        up = rotation * up;
    }

    if (Application::IsKeyPressed('R'))
    {
        Reset();
    }
}
Exemple #25
0
void Camera2::Update(double dt)
{
	//Mouse shit
	POINT currentposition_;
	GetCursorPos(&currentposition_);
	static const float CAMERA_SPEED = 40.f;
	//Move front
	if (Application::IsKeyPressed('W'))
	{
		Vector3 view = (target - position).Normalized();
		view.y = 0;
		position += (view * dt * 10.f);
		target += (view * dt * 10.f);
	}

	//Move Back
	if (Application::IsKeyPressed('S'))
	{
		Vector3 view = (target - position).Normalized();
		view.y = 0;
		position -= (view * dt * 10.f);
		target -= (view * dt * 10.f);
	}

	//Move Right
	if (Application::IsKeyPressed('D'))
	{
		Vector3 view = (target - position).Normalized();
		Vector3 right=view.Cross(up);
		right.y = 0;
		position += (right * dt * 10.f);
		target += (right * dt * 10.f);
	}
	//Move Left
	if (Application::IsKeyPressed('A'))
	{
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		right.y = 0;
		position -= (right * dt * 10.f);
		target -= (right * dt * 10.f);
	}
	//Rotate up
	if (Application::IsKeyPressed(VK_UP)) //Pitch
	{
		//Original
		float pitch = (float)(CAMERA_SPEED * dt);
		/*Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
		up = right.Cross(view).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(pitch, right.x, right.y, right.z);
		position = rotation * position;*/
		// FOr FP view
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		up = right.Cross(view).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(pitch, right.x, right.y, right.z);
		view = rotation * view;
		target = position + view;

	}
	//Rotate Down
	if (Application::IsKeyPressed(VK_DOWN)) //Pitch, down
	{
		float pitch = (float)(-CAMERA_SPEED * dt);
		//Original
		/*Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
		up = right.Cross(view).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(pitch, right.x, right.y, right.z);
		position = rotation * position;*/
		//Fp Camera
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		up = right.Cross(view).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(pitch, right.x, right.y, right.z);
		view = rotation * view;
		target = position + view;
	}
	//Rotate Right
	if (Application::IsKeyPressed(VK_RIGHT))
	{
		float yaw = (float)(-CAMERA_SPEED * dt);
		//Original
		/*	Mtx44 rotation;
		rotation.SetToRotation(yaw, 0, 1, 0);
		position = rotation * position;
		up = rotation * up;*/
		//FP camera
		Vector3 view = (target - position).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(yaw, 0, 1, 0);
		view = rotation * view;
		target = position + view;
		up = rotation*up;

	}
	//Rotate Left
	if (Application::IsKeyPressed(VK_LEFT))
	{
		float yaw = (float)(CAMERA_SPEED * dt);
		//Original
		/*Mtx44 rotation;
		rotation.SetToRotation(yaw, 0, 1, 0);
		position = rotation * position;
		up = rotation * up;*/
		//FP camera
		Vector3 view = (target - position).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(yaw, 0, 1, 0);
		
		view = rotation * view;
		target = position + view;
		up = rotation*up;
	}
	if (currentposition_.x > (1600/2))
	{
		float yaw = (float)(-CAMERA_SPEED * dt);
		Vector3 view = (target - position).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(yaw, 0, 1, 0);
		view = rotation * view;
		target = position + view;
		up = rotation*up;
	}
	if (currentposition_.x < (1600 / 2))
	{
		float yaw = (float)(CAMERA_SPEED * dt);
		Vector3 view = (target - position).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(yaw, 0, 1, 0);

		view = rotation * view;
		target = position + view;
		up = rotation*up;
	}
	if (currentposition_.y > (900 / 2))
	{
		float pitch = (float)(-CAMERA_SPEED * dt);
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		up = right.Cross(view).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(pitch, right.x, right.y, right.z);
		view = rotation * view;
		target = position + view;
	}
	if (currentposition_.y < (900 / 2))
	{
		float pitch = (float)(CAMERA_SPEED * dt);
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		up = right.Cross(view).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(pitch, right.x, right.y, right.z);
		view = rotation * view;
		target = position + view;
	}
	if (Application::IsKeyPressed('R'))
	{
		Reset();
	}
	SetCursorPos(1600 / 2, 900 / 2);


}
Exemple #26
0
void Camera2::Update(double dt)
{
	static const float CAMERA_SPEED = 50.f;
	if(Application::IsKeyPressed(VK_LEFT) || Application::IsKeyPressed('A'))
	{
		float yaw = (float)(-CAMERA_SPEED * dt);
		Mtx44 rotation;
		rotation.SetToRotation(yaw, 0, 1, 0);
		position = rotation * position;
		up = rotation * up;
	}
	if(Application::IsKeyPressed(VK_RIGHT) || Application::IsKeyPressed('D'))
	{
		float yaw = (float)(CAMERA_SPEED * dt);
		Mtx44 rotation;
		rotation.SetToRotation(yaw, 0, 1, 0);
		position = rotation * position;
		up = rotation * up;
	}
	if(Application::IsKeyPressed(VK_UP) || Application::IsKeyPressed('W'))
	{
		float pitch = (float)(-CAMERA_SPEED * dt);
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
		up = right.Cross(view).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(pitch, right.x, right.y, right.z);
		position = rotation * position;
	}
	if(Application::IsKeyPressed(VK_DOWN) || Application::IsKeyPressed('S'))
	{
		float pitch = (float)(CAMERA_SPEED * dt);
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
		up = right.Cross(view).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(pitch, right.x, right.y, right.z);
		position = rotation * position;
	}
	if(Application::IsKeyPressed('N'))
	{
		Vector3 direction = target - position;
		if(direction.Length() > 5)
		{
			Vector3 view = (target - position).Normalized();
			position += view * (float)(100.f * dt);
		}
	}
	if(Application::IsKeyPressed('M'))
	{
		Vector3 view = (target - position).Normalized();
		position -= view * (float)(100.f * dt);
	}
	if(Application::IsKeyPressed('R'))
	{
		Reset();
	}
}
Exemple #27
0
void MS::Rotate(float degrees, float axisX, float axisY, float axisZ) {
	Mtx44 mat;
	mat.SetToRotation(degrees, axisX, axisY, axisZ);
	ms.top() = ms.top() * mat;
}
Exemple #28
0
void Helicopter::Update(double dt, bool controlling)
{
    static const float THRUST_SPEED = 10.f;
    static const float THRUST_LIMIT = 5.f;
    static const float TURN_SPEED = 100.f;

    bool piloting = false;

    if (controlling) {
        if (Application::IsKeyPressed('W'))
        {
            if (thrustSpeed < THRUST_LIMIT)
                thrustSpeed += (float)(THRUST_SPEED * dt);

            piloting = true;
        }
        if (Application::IsKeyPressed('S'))
        {
            if (thrustSpeed > -THRUST_LIMIT)
                thrustSpeed -= (float)(THRUST_SPEED * dt);

            piloting = true;
        }

        if (Application::IsKeyPressed('A'))
        {
            float yaw = (float)(TURN_SPEED * dt);

            rotateYaw += yaw;
            camera.Rotate(yaw, 0, 1, 0);

            Mtx44 rotate;
            rotate.SetToRotation(yaw, 0, 1, 0);
            thrustDir = rotate * thrustDir;
            frontDir = rotate * frontDir;
            right = rotate * right;
        }
        if (Application::IsKeyPressed('D'))
        {
            float yaw = (float)(-TURN_SPEED * dt);

            rotateYaw += yaw;
            camera.Rotate(yaw, 0, 1, 0);

            Mtx44 rotate;
            rotate.SetToRotation(yaw, 0, 1, 0);
            thrustDir = rotate * thrustDir;
            frontDir = rotate * frontDir;
            right = rotate * right;
        }
        if (Application::IsKeyPressed(VK_NUMPAD8))
        {
            float pitch = (float)(-TURN_SPEED * dt);

            rotatePitch += pitch;
            //camera.Rotate(pitch, right.x, right.y, right.z);

            Mtx44 rotate;
            rotate.SetToRotation(pitch, right.x, right.y, right.z);
            thrustDir = rotate * thrustDir;
            frontDir = rotate * frontDir;
            std::cout << frontDir << std::endl;
        }
        if (Application::IsKeyPressed(VK_NUMPAD5))
        {
            float pitch = (float)(TURN_SPEED * dt);

            rotatePitch += pitch;
            //camera.Rotate(pitch, right.x, right.y, right.z);

            Mtx44 rotate;
            rotate.SetToRotation(pitch, right.x, right.y, right.z);
            thrustDir = rotate * thrustDir;
            frontDir = rotate * frontDir;
        }
        if (Application::IsKeyPressed(VK_NUMPAD4))
        {
            float roll = (float)(-TURN_SPEED * dt);

            rotateRoll += roll;

            Mtx44 rotate;
            rotate.SetToRotation(roll, frontDir.x, frontDir.y, frontDir.z);
            thrustDir = rotate * thrustDir;
            right = rotate * right;
        }
        if (Application::IsKeyPressed(VK_NUMPAD6))
        {
            float roll = (float)(TURN_SPEED * dt);

            rotateRoll += roll;

            Mtx44 rotate;
            rotate.SetToRotation(roll, frontDir.x, frontDir.y, frontDir.z);
            thrustDir = rotate * thrustDir;
            right = rotate * right;
        }
    }
    if (!piloting) {
        if (thrustSpeed > 0.f) {
            thrustSpeed -= (float)(THRUST_SPEED * dt);
        }
        else if (thrustSpeed < 0.f) {
            thrustSpeed += (float)(THRUST_SPEED * dt);
        }
    }

    frontDir.Normalize();
    right.Normalize();
    thrustDir.Normalize();

    Vector3 oldPos = position;

    vSpeed += ((thrustDir.y * thrustSpeed) - WV_GRAVITY) * dt;
    xSpeed += ((thrustDir.x * thrustSpeed)) * dt;
    zSpeed += ((thrustDir.z * thrustSpeed)) * dt;
    position.x += xSpeed * dt;
    position.z += zSpeed * dt;
    position.y += vSpeed * dt;
    hitbox.SetPosition(position);

    if (Hitbox::CheckHitBox(hitbox, position, oldPos, &hitbox)) {
        vSpeed = 0.f;
        xSpeed = 0.f;
        zSpeed = 0.f;
    }


    camera.target = position;
    camera.Update(dt);
}
Exemple #29
0
void Camera3::Update(double dt)
{
	static const float CAMERA_LOOK_SPEED = 200.f;
    static const float CAMERA_MOVE_SPEED = 100.f;
	if(Application::IsKeyPressed('A'))
	{
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
		position -= right * CAMERA_MOVE_SPEED * (float)dt;
        target -= right * CAMERA_MOVE_SPEED * (float)dt;
	}
	if(Application::IsKeyPressed('D'))
	{
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
        position += right * CAMERA_MOVE_SPEED * (float)dt;
        target += right * CAMERA_MOVE_SPEED * (float)dt;
	}
	if(Application::IsKeyPressed('W'))
	{
		Vector3 view = (target - position).Normalized();
        position += view * CAMERA_MOVE_SPEED * (float)dt;
        target += view * CAMERA_MOVE_SPEED * (float)dt;
	}
	if(Application::IsKeyPressed('S'))
	{
		Vector3 view = (target - position).Normalized();
        position -= view * CAMERA_MOVE_SPEED * (float)dt;
        target -= view * CAMERA_MOVE_SPEED * (float)dt;
	}
	if(Application::IsKeyPressed(VK_LEFT))
	{
		Vector3 view = (target - position).Normalized();
        float yaw = (float)(CAMERA_MOVE_SPEED * (float)dt);
		Mtx44 rotation;
		rotation.SetToRotation(yaw, 0, 1, 0);
		view = rotation * view;
		target = position + view;
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
		up = right.Cross(view).Normalized();
	}
	if(Application::IsKeyPressed(VK_RIGHT))
	{
		Vector3 view = (target - position).Normalized();
        float yaw = (float)(-CAMERA_MOVE_SPEED * (float)dt);
		Mtx44 rotation;
		rotation.SetToRotation(yaw, 0, 1, 0);
		view = rotation * view;
		target = position + view;
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
		up = right.Cross(view).Normalized();
	}
	if(Application::IsKeyPressed(VK_UP))
	{
        float pitch = (float)(CAMERA_MOVE_SPEED * (float)dt);
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
		up = right.Cross(view).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(pitch, right.x, right.y, right.z);
		view = rotation * view;
		target = position + view;
	}
	if(Application::IsKeyPressed(VK_DOWN))
	{
        float pitch = (float)(-CAMERA_MOVE_SPEED * (float)dt);
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
		up = right.Cross(view).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(pitch, right.x, right.y, right.z);
		view = rotation * view;
		target = position + view;
	}
	//Update the camera direction based on mouse move
	// left-right rotate
	{
		Vector3 view = (target - position).Normalized();
        float yaw = (float)(-CAMERA_LOOK_SPEED * Application::camera_yaw * (float)dt);
		Mtx44 rotation;
		rotation.SetToRotation(yaw, 0, 1, 0);
		view = rotation * view;
		target = position + view;
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
		up = right.Cross(view).Normalized();
	}
	{
        float pitch = (float)(-CAMERA_LOOK_SPEED * Application::camera_pitch * (float)dt);
		Vector3 view = (target - position).Normalized();
		Vector3 right = view.Cross(up);
		right.y = 0;
		right.Normalize();
		up = right.Cross(view).Normalized();
		Mtx44 rotation;
		rotation.SetToRotation(pitch, right.x, right.y, right.z);
		view = rotation * view;
		target = position + view;
	}
	if(Application::IsKeyPressed('R'))
	{
		Reset();
	}
}
void SecurityCam::update(const double &dt, Vector3 &playerPos, std::vector<GameObject*> m_goList)
{

	Vector3 SCPos = pos;
	Vector3 SCLookat = Lookat;

	SCPos.y = SCLookat.y = 0;

	switch(c_State)
	{
	case SPOTTED:
		{
			float rotationdiff = (CalAnglefromPosition(playerPos, pos, true) - CalAnglefromPosition(Lookat, pos, true)) * 2.f;

			Mtx44 rotation;
			Lookat = Lookat - pos;
			f_rotationLimiter += rotationdiff * static_cast<float>(dt);
			rotation.SetToRotation(rotationdiff * static_cast<float>(dt), 0, 1, 0);
			Lookat = rotation * Lookat;
			Lookat = Lookat + pos;

			//Check whether player is still in the fov of security camera
			if (((isVisible(SCPos, SCLookat, static_cast<float>(f_cameraFOV), playerPos)) && (SCPos - playerPos).LengthSquared() < f_cameraRange))
			{
				//Give player 1 sec to prevent detection by the security camera
				if (alerttimer < 1)
				{
					alerttimer += static_cast<float>(dt);
				}
				else
				{
					c_State = FOUND;
					alerttimer = 0;
				}
			}
			else
			{
				//if player is no longer in the fov of the security camera
				c_State = NOTFOUND;
				alerttimer = 0;
			}
		}
		break;

	case FOUND:
		{
			float rotationdiff = (CalAnglefromPosition(playerPos, pos, true) - CalAnglefromPosition(Lookat, pos, true));

			if (rotationdiff >= 180)
			{
				Mtx44 rotation;
				Lookat = Lookat - pos;
				rotation.SetToRotation(-360, 0, 1, 0);
				Lookat = rotation * Lookat;
				Lookat = Lookat + pos;
				rotationdiff -= 360;
			}
			else if (rotationdiff <= -180)
			{
				Mtx44 rotation;
				Lookat = Lookat - pos;
				rotation.SetToRotation(360, 0, 1, 0);
				Lookat = rotation * Lookat;
				Lookat = Lookat + pos;
				rotationdiff += 360;
			}

			Mtx44 rotation;
			Lookat = Lookat - pos;
			f_rotationLimiter += rotationdiff * static_cast<float>(dt);
			rotation.SetToRotation(rotationdiff * 2 * static_cast<float>(dt), 0, 1, 0);
			Lookat = rotation * Lookat;
			Lookat = Lookat + pos;

			//Alert all the ai to the camera's position
			if (b_alertAI)
			{
				for (std::vector<GameObject*>::iterator it = m_goList.begin(); it != m_goList.end(); it++)
				{
					GameObject *go = (GameObject *)*it;
					AI *ai = dynamic_cast<AI*>(go);
					if (ai != NULL)
					{
						if (ai->getState() == AI::WALKING)
						{
							ai->setState(AI::ALERT);
							ai->setcurrentLookat(pos);
							ai->setDestination(pos);
						}
					}
				}
				b_alertAI = false;
			}
			else
			{
				if (!isVisible(pos, Lookat, f_cameraFOV, playerPos) || (playerPos - pos).LengthSquared() > f_cameraRange)
				{
					c_State = NOTFOUND;
				}
			}
		}
		break;

	case NOTFOUND:
		{
			//Check whether enemy is within security camera's FOV
			b_alertAI = true;
			if (((isVisible(SCPos, SCLookat, static_cast<float>(f_cameraFOV), playerPos)) && (SCPos - playerPos).LengthSquared() < f_cameraRange))
			{
				c_State = SPOTTED;
			}
		}
		break;
	}
	
	if (c_State == NOTFOUND)
	{
		float f_currentRotation = 0;

		if (rotationState)
		{
			f_currentRotation = 20;

			if (f_rotationLimiter > f_rotationAngle)
			{
				rotationState = false;
			}
		}
		else
		{
			f_currentRotation = -20;

			if (f_rotationLimiter < -f_rotationAngle)
			{
				rotationState = true;
			}
		}

		if (f_currentRotation != 0)
		{
			Mtx44 rotation;
			Lookat = Lookat - pos;
			f_rotationLimiter += f_currentRotation * static_cast<float>(dt);
			rotation.SetToRotation(f_currentRotation * static_cast<float>(dt), 0, 1, 0);
			Lookat = rotation * Lookat;
			Lookat = Lookat + pos;
		}
	}
	//CollisionChecking(m_goList);
}