TriggersAssignment.cpp

#include "stdafx.h"
#include "TriggersAssignmentScene.h"
#include "CubePosColorNorm.h"
#include "MeshObject.h"
#include "Debug.h"
#include "ContentManager.h"
#include "MeshObject.h"
#include "FreeCamera.h"
#include "PxShape.h"
#include "PxScene.h"
#include "CubePosColorNorm.h"

TriggersAssignmentScene::TriggersAssignmentScene() :
	GameScene(L"TriggersAssignmentScene"),
	m_pSphere(nullptr),
	m_pSphereLeft(nullptr),
	m_pSphereRight(nullptr),
	m_pGateLeft(nullptr), 
	m_pGateRight(nullptr),
	m_pGateLeftJoint(nullptr),
	m_pGateRightJoint(nullptr),
	m_pBoxLeft(nullptr), 
	m_pBoxRight(nullptr),
	m_pBoxTriggerLeft(nullptr), 
	m_pBoxTriggerRight(nullptr),
	m_pLevelMesh(nullptr),
	m_pBoxTriggerLeftMesh(nullptr),
	m_pBoxTriggerRightMesh(nullptr)
{
}

TriggersAssignmentScene::~TriggersAssignmentScene()
{
}

void TriggersAssignmentScene::Initialize(GameContext* pContext)
{
	auto physX = &m_pPhysxScene->getPhysics();

	InputManager* input = pContext->GetInput();
	input->AddInputAction(InputAction(int(InputID::MOVE_LEFT), InputTriggerState::Down, VK_LEFT, -1, XINPUT_GAMEPAD_DPAD_LEFT));
	input->AddInputAction(InputAction(int(InputID::MOVE_RIGHT), InputTriggerState::Down, VK_RIGHT, -1, XINPUT_GAMEPAD_DPAD_RIGHT));
	input->AddInputAction(InputAction(int(InputID::MOVE_FORWARD), InputTriggerState::Down, VK_UP, -1, XINPUT_GAMEPAD_DPAD_UP));
	input->AddInputAction(InputAction(int(InputID::MOVE_BACKWARD), InputTriggerState::Down, VK_DOWN, -1, XINPUT_GAMEPAD_DPAD_DOWN));
	input->AddInputAction(InputAction(int(InputID::JUMP), InputTriggerState::Pressed, VK_SPACE, -1, XINPUT_GAMEPAD_A));
	input->AddInputAction(InputAction(int(InputID::RESET), InputTriggerState::Down, 'R', -1, XINPUT_GAMEPAD_B));

	EnablePhysxDebugRendering(true);

	auto defaultMaterial = physX->createMaterial(0.5f, 0.5f, 0.1f);
	const XMFLOAT4 BLUE = { 0.0f, 0.0f, 1.0f, 1.0f };
	const XMFLOAT4 RED = { 1.0f, 0.0f, 0.0f, 1.0f };

	auto groundPlaneActor = physX->createRigidStatic(PxTransform::createIdentity());
	auto groundShape = groundPlaneActor->createShape(PxPlaneGeometry(), *defaultMaterial, PxTransform(PxQuat(XM_PIDIV2, PxVec3(0, 0, 1))));
	m_pPhysxScene->addActor(*groundPlaneActor);

	// Sphere

	auto sphereMaterial = physX->createMaterial(0.99f, 0.99f, 0.2f);
	m_pSphere = new MeshObject(L"Meshes/Sphere.ovm");
	auto sphereActor = physX->createRigidDynamic(PxTransform::createIdentity());
	sphereActor->createShape(PxSphereGeometry(1.f), *sphereMaterial);
	m_pSphere->AttachRigidActor(sphereActor);
	AddGameObject(m_pSphere);

	PxD6Joint* sphereZAxisConstraintJoint = PxD6JointCreate(*physX,
		nullptr, PxTransform(PxVec3(0, 0, 0)),
		m_pSphere->GetRigidActor(), PxTransform::createIdentity());
	sphereZAxisConstraintJoint->setMotion(PxD6Axis::eX, PxD6Motion::eFREE);
	sphereZAxisConstraintJoint->setMotion(PxD6Axis::eY, PxD6Motion::eFREE);
	sphereZAxisConstraintJoint->setMotion(PxD6Axis::eZ, PxD6Motion::eLOCKED);
	sphereZAxisConstraintJoint->setMotion(PxD6Axis::eTWIST, PxD6Motion::eFREE);
	sphereZAxisConstraintJoint->setMotion(PxD6Axis::eSWING1, PxD6Motion::eFREE);
	sphereZAxisConstraintJoint->setMotion(PxD6Axis::eSWING2, PxD6Motion::eFREE);

	// Triggers

	PxVec3 halfTriggerBoxSize = { 0.6f, 0.2f, 3.0f };

	m_pBoxTriggerLeftMesh = new CubePosColorNorm(halfTriggerBoxSize.x * 2.0f, halfTriggerBoxSize.y * 2.0f, halfTriggerBoxSize.z * 2.0f, BLUE);
	AddGameObject(m_pBoxTriggerLeftMesh);
	m_pBoxTriggerLeftMesh->Translate(-7.2f, 2.25f, 0.0f);
	m_pBoxTriggerLeft = physX->createRigidStatic(PxTransform(PxVec3(-7.2f, 2.25f, 0.0f)));
	auto leftShape = m_pBoxTriggerLeft->createShape(PxBoxGeometry(halfTriggerBoxSize), *defaultMaterial);
	leftShape->setFlag(PxShapeFlag::eSIMULATION_SHAPE, false);
	leftShape->setFlag(PxShapeFlag::eTRIGGER_SHAPE, true);
	m_pPhysxScene->addActor(*m_pBoxTriggerLeft);

	m_pBoxTriggerRightMesh = new CubePosColorNorm(halfTriggerBoxSize.x * 2.0f, halfTriggerBoxSize.y * 2.0f, halfTriggerBoxSize.z * 2.0f, RED);
	AddGameObject(m_pBoxTriggerRightMesh);
	m_pBoxTriggerRightMesh->Translate(6.8f, 2.25f, 0.0f);
	m_pBoxTriggerRight = physX->createRigidStatic(PxTransform(PxVec3(6.8f, 2.25f, 0.0f)));
	auto rightShape = m_pBoxTriggerRight->createShape(PxBoxGeometry(halfTriggerBoxSize ), *defaultMaterial);
	rightShape->setFlag(PxShapeFlag::eSIMULATION_SHAPE, false);
	rightShape->setFlag(PxShapeFlag::eTRIGGER_SHAPE, true);
	m_pPhysxScene->addActor(*m_pBoxTriggerRight);

	// Pushable boxes

	float boxSize = 1.5f;
	m_pBoxLeft = new CubePosColorNorm(boxSize, boxSize, boxSize, BLUE);
	auto boxLeftActor = physX->createRigidDynamic(PxTransform::createIdentity());
	auto boxLeftShape = boxLeftActor->createShape(PxBoxGeometry(boxSize/2.0f, boxSize / 2.0f, boxSize / 2.0f), *defaultMaterial);
	m_pBoxLeft->AttachRigidActor(boxLeftActor);
	AddGameObject(m_pBoxLeft);

	m_pBoxRight = new CubePosColorNorm(boxSize, boxSize, boxSize, RED);
	auto boxRightActor = physX->createRigidDynamic(PxTransform::createIdentity());
	auto boxRightShape = boxRightActor->createShape(PxBoxGeometry(boxSize / 2.0f, boxSize / 2.0f, boxSize / 2.0f), *defaultMaterial);
	m_pBoxRight->AttachRigidActor(boxRightActor);
	AddGameObject(m_pBoxRight);
	
	// Level

	m_pLevelMesh = new MeshObject(L"Meshes/Level.ovm");
	PxTriangleMesh* levelMesh = ContentManager::Load<PxTriangleMesh>(L"Meshes/Level.ovpt");
	auto levelActor = physX->createRigidStatic(PxTransform::createIdentity());
	levelActor->createShape(PxTriangleMeshGeometry(levelMesh), *defaultMaterial);
	m_pLevelMesh->AttachRigidActor(levelActor);
	AddGameObject(m_pLevelMesh);

	// Top spheres

	float sphereSize = 0.8f;
	m_pSphereLeft = new MeshObject(L"Meshes/Sphere.ovm");
	auto sphereLeftActor = physX->createRigidDynamic(PxTransform::createIdentity());
	sphereLeftActor->createShape(PxSphereGeometry(1.0f), *sphereMaterial);
	m_pSphereLeft->AttachRigidActor(sphereLeftActor);
	AddGameObject(m_pSphereLeft);
	m_pSphereLeft->Scale(sphereSize, sphereSize, sphereSize);

	m_pSphereRight = new MeshObject(L"Meshes/Sphere.ovm"); 
	auto sphereRightActor = physX->createRigidDynamic(PxTransform::createIdentity());
	sphereRightActor->createShape(PxSphereGeometry(1.0f), *sphereMaterial);
	m_pSphereRight->AttachRigidActor(sphereRightActor);
	AddGameObject(m_pSphereRight);
	m_pSphereRight->Scale(sphereSize, sphereSize, sphereSize);

	// Gates

	XMFLOAT3 gateSize = { 6.0f, 0.4f, 2.5f };

	m_pGateLeft = new CubePosColorNorm(gateSize.x, gateSize.y, gateSize.z, BLUE);
	auto getLeftActor = physX->createRigidDynamic(PxTransform::createIdentity());
	auto gateLeftShape = getLeftActor->createShape(PxBoxGeometry(gateSize.x / 2.0f, gateSize.y / 2.0f, gateSize.z / 2.0f), *defaultMaterial);
	m_pGateLeft->AttachRigidActor(getLeftActor);
	AddGameObject(m_pGateLeft);

	m_pGateRight = new CubePosColorNorm(gateSize.x, gateSize.y, gateSize.z, RED);
	auto gateRightActor = physX->createRigidDynamic(PxTransform::createIdentity());
	auto gateRightShape = gateRightActor->createShape(PxBoxGeometry(gateSize.x / 2.0f, gateSize.y / 2.0f, gateSize.z / 2.0f), *defaultMaterial);
	m_pGateRight->AttachRigidActor(gateRightActor);
	AddGameObject(m_pGateRight);

	PxQuat gateLeftRot = PxQuat(-PxPiDivTwo, PxVec3(0, 1, 0));
	gateLeftRot *= PxQuat(PxPi, PxVec3(1, 0, 0));
	m_pGateLeftJoint = PxRevoluteJointCreate(*physX,
		m_pGateLeft->GetRigidActor(), PxTransform((PxVec3(0, 0, gateSize.z / 2.0f))),
		m_pLevelMesh->GetRigidActor(), PxTransform(PxVec3(-7.8f, 16.6f, 0), gateLeftRot));

	m_pGateLeftJoint->setRevoluteJointFlag(PxRevoluteJointFlag::eLIMIT_ENABLED, true);
	m_pGateLeftJoint->setRevoluteJointFlag(PxRevoluteJointFlag::eDRIVE_ENABLED, true);
	m_pGateLeftJoint->setRevoluteJointFlag(PxRevoluteJointFlag::eDRIVE_FREESPIN, true);
	m_pGateLeftJoint->setConstraintFlag(PxConstraintFlag::eVISUALIZATION, true);

	PxQuat gateRightRot = PxQuat(PxPiDivTwo, PxVec3(0, 1, 0));
	gateRightRot *= PxQuat(PxPi, PxVec3(1, 0, 0));
	m_pGateRightJoint = PxRevoluteJointCreate(*physX,
		m_pGateRight->GetRigidActor(), PxTransform((PxVec3(0, 0, gateSize.z / 2.0f))),
		m_pLevelMesh->GetRigidActor(), PxTransform(PxVec3(7.8f, 16.6f, 0), gateRightRot));

	m_pGateRightJoint->setRevoluteJointFlag(PxRevoluteJointFlag::eLIMIT_ENABLED, true);
	m_pGateRightJoint->setRevoluteJointFlag(PxRevoluteJointFlag::eDRIVE_ENABLED, true);
	m_pGateRightJoint->setRevoluteJointFlag(PxRevoluteJointFlag::eDRIVE_FREESPIN, true);
	m_pGateRightJoint->setConstraintFlag(PxConstraintFlag::eVISUALIZATION, true);

	Reset();
}

void TriggersAssignmentScene::Update(GameContext* pContext)
{
	InputManager* input = pContext->GetInput();
	float hVel = 0.05f;
	
	if (input->IsActionTriggered(int(InputID::RESET)))
	{
		Reset();
	}
	float moveForce = 30.0f;
	float jumpForce = 1400.0f;
	PxForceMode::Enum moveForceMode = PxForceMode::eACCELERATION;
	PxForceMode::Enum jumpForceMode = PxForceMode::eFORCE;
	PxRigidDynamic* actor = static_cast<PxRigidDynamic*>(m_pSphere->GetRigidActor());
	if (input->IsActionTriggered(int(InputID::MOVE_LEFT)))
	{
		actor->addForce({ -moveForce, 0, 0 }, moveForceMode);
	}
	if (input->IsActionTriggered(int(InputID::MOVE_RIGHT)))
	{
		actor->addForce({ moveForce, 0, 0 }, moveForceMode);
	}
	if (input->IsActionTriggered(int(InputID::MOVE_FORWARD)))
	{
		actor->addForce({ 0, 0, moveForce }, moveForceMode);
	}
	if (input->IsActionTriggered(int(InputID::MOVE_BACKWARD)))
	{
		actor->addForce({ 0, 0, -moveForce }, moveForceMode);
	}
	if (input->IsActionTriggered(int(InputID::JUMP)))
	{
		if (abs(actor->getLinearVelocity().y) < 0.001f)
		{
			actor->addForce({ 0, jumpForce, 0 }, jumpForceMode);
		}
	}
}

void TriggersAssignmentScene::SceneActivated()
{
	Debug::LogInfo(L".::PhysXTriggersAssignmentScene::");
	Debug::LogInfo(L"Press \'R\' to reset.");

	//Reset Camera
	auto cam = GetContext()->GetCamera();
	auto pos = XMFLOAT3(-8.13f, 19.83f, -53.12f);
	auto tar = XMFLOAT3(-6.58f, 18.50f, -43.33f);
	static_cast<FreeCamera*>(cam)->SetPositionAndTarget(pos, tar);
}

void TriggersAssignmentScene::SceneDeactivated()
{
}

void TriggersAssignmentScene::Reset()
{
	m_pSphere->SetPosition(0, 5.0f, 0);
	m_pSphere->Rotate(0, 0, 0);
	m_pSphere->GetRigidActor()->isRigidDynamic()->setLinearVelocity({ 0, 0, 0 });
	m_pSphereLeft->SetPosition(-6.0f, 23.0f, 0.0f);
	m_pSphereRight->SetPosition(6.0f, 23.0f, 0.0f);
	m_pBoxLeft->SetPosition(-4.2f, 6.0f, 0.0f);
	m_pBoxLeft->Rotate(0, 0, 0);
	m_pBoxRight->SetPosition(3.8f, 6.0f, 0.0f);
	m_pBoxRight->Rotate(0, 0, 0);
	m_pGateLeft->SetPosition(-9.0f, 16.6f, 0.0f);
	m_pGateLeftJoint->setLimit(PxJointAngularLimitPair(0, 0.05f));
	m_pGateRightJoint->setLimit(PxJointAngularLimitPair(0, 0.05f));

	static_cast<PxRigidDynamic*>(m_pGateLeft->GetRigidActor())->setGlobalPose(PxTransform::createIdentity());
	static_cast<PxRigidDynamic*>(m_pGateRight->GetRigidActor())->setGlobalPose(PxTransform::createIdentity());
}

void TriggersAssignmentScene::onTrigger(PxTriggerPair* pairs, PxU32 count)
{
	for (size_t i = 0; i < count; i++)
	{
		if (pairs[i].flags & (PxTriggerPairFlag::eDELETED_SHAPE_TRIGGER | PxTriggerPairFlag::eDELETED_SHAPE_OTHER))
		{
			continue;
		}

		float gateSpeed = -0.9f;
		if (pairs[i].status & PxPairFlag::eNOTIFY_TOUCH_FOUND)
		{
			if (pairs[i].triggerActor == m_pBoxTriggerLeft &&
				pairs[i].otherActor == m_pBoxLeft->GetRigidActor())
			{
				cout << "Blue box entered blue trigger!" << endl;
				m_pGateLeftJoint->setLimit(PxJointAngularLimitPair(-PxPiDivTwo, 0));
				m_pGateLeftJoint->setDriveVelocity(gateSpeed);
			}
			else if (pairs[i].triggerActor == m_pBoxTriggerRight &&
					pairs[i].otherActor == m_pBoxRight->GetRigidActor())
			{
				cout << "Red box entered red trigger!" << endl;
				m_pGateRightJoint->setLimit(PxJointAngularLimitPair(-PxPiDivTwo, 0));
				m_pGateRightJoint->setDriveVelocity(gateSpeed);
			}
		}
		else if (pairs[i].status & PxPairFlag::eNOTIFY_TOUCH_LOST)
		{
			if (pairs[i].triggerActor == m_pBoxTriggerLeft)
			{
				cout << "Left left trigger" << endl;
			}
			else if (pairs[i].triggerActor == m_pBoxTriggerRight)
			{
				cout << "Left right trigger" << endl;
			}
		}
	}
}