/// Overloaded. Updates the Displable component based on recent changes.
virtual void update(XInfo* xinfo, GameTime* gameTime)
{
// retrieves the state monitor devices for both the keyboard and mouse
KeyboardState* keyboard = xinfo->getKeyboardState();
MouseState* mouse = xinfo->getMouseState();
// series of actions based on the keyboard actions
if(keyboard->isKeyDown(KEY_SPACE))
{
// creates a new text component with the string "SPACEBAR" and specified color
// this is created at a location relative to the current mouse position
Text* spaceText = new Text(mouse->getX() - 50, mouse->getY() - 2, "SPACEBAR", color);
polyLine->add_point(mouse->getX(), mouse->getY());
addComponent(spaceText);
}
// changes the color if the left arrow key is pressed
if(keyboard->isKeyDown(KEY_LEFT))
{
xinfo->setColor(polyLine->getLineContext(), ColorConstants::COLOR_GREEN);
}
// changes the color if the right arrow key is pressed
if(keyboard->isKeyDown(KEY_RIGHT))
{
xinfo->setColor(polyLine->getLineContext(), ColorConstants::COLOR_RED);
}
}
//----------------------------------------------------------------------------------
static void UpdateGame(unsigned int elapsedMS)
{
KeyboardState keyState = Keyboard::GetState();
if (keyState->IsKeyDown(SDL_SCANCODE_ESCAPE))
{
quit = true;
return;
}
oldKeyState = keyState;
}
void Scene::UpdateInput()
{
static KeyboardState state;
if (!m_keyboard->GetState(state))
return;
float factor = 0.01f;
if (state.isKeyDown(DIK_W))
{
m_camera.UpdatePosition(XMVector3Normalize(-m_camera.camTarget));
}
if (state.isKeyDown(DIK_S))
{
m_camera.UpdatePosition(XMVector3Normalize(m_camera.camTarget));
}
if (state.isKeyDown(DIK_A))
{
m_camera.UpdatePosition(XMVector3Normalize(XMVector3Cross(XMVector3Normalize(m_camera.camTarget), m_camera.camUp)));
}
if (state.isKeyDown(DIK_D))
{
m_camera.UpdatePosition(XMVector3Normalize(XMVector3Cross(m_camera.camUp, XMVector3Normalize(m_camera.camTarget))));
}
if (state.isKeyDown(DIK_Z))
{
m_camera.UpdatePosition(XMVector3Normalize(m_camera.camUp));
}
if (state.isKeyDown(DIK_X))
{
m_camera.UpdatePosition(XMVector3Normalize(-m_camera.camUp));
}
}
void Game1::Update(unsigned int time)
{
KeyboardState cState = Keyboard::GetState();
MouseState mState = Mouse::GetState();
world->Step(time * 0.001f, 6, 2);
if (cState.IsKeyDown(SDLK_y) && !oldState.IsKeyDown(SDLK_y))
{
AddCube(mState.X, mState.Y, mState.RelX, mState.RelY);
}
if (cState.IsKeyDown(SDLK_x) && !oldState.IsKeyDown(SDLK_x))
{
AddCircle(mState.X, mState.Y, mState.RelX * 10, mState.RelY * 10);
}
if (cState.IsKeyDown(SDLK_c) && !oldState.IsKeyDown(SDLK_c))
{
AddTriangle(mState.X, mState.Y, mState.RelX * 10, mState.RelY * 10);
}
if (cState.IsKeyDown(SDLK_v) && !oldState.IsKeyDown(SDLK_v))
{
AddRope(mState.X, mState.Y);
}
oldState = cState;
}
void Scene::ReadKeyboard(bool isRotate)
{
static KeyboardState state;
if (!m_keyboard->GetState(state))
return;
float factor = 0.01f;
if (state.isKeyDown(DIK_RIGHT))
{
if (isRotate)
m_camera.Rotate(1, 0);
else
m_camera.Move(0, 0, -1);
}
if (state.isKeyDown(DIK_LEFT))
{
if (isRotate)
m_camera.Rotate(-1, 0);
else
m_camera.Move(0, 0, 1);
}
if (state.isKeyDown(DIK_UP))
{
if (isRotate)
m_camera.Rotate(0, 1);
else
m_camera.Move(1, 0, 0);
}
if (state.isKeyDown(DIK_DOWN))
{
if (isRotate)
m_camera.Rotate(0, -1);
else
m_camera.Move(-1, 0, 0);
}
if (state.isKeyDown(DIK_RSHIFT))
m_camera.Move(0, 1, 0);
if (state.isKeyDown(DIK_RCONTROL))
m_camera.Move(0, -1, 0);
}
void gameInput()
{
// Game state
if (currState.isKeyDown(KEY_ESC))
{
glutLeaveMainLoop();
}
else if (currState.isKeyDown(KEY_SPACE))
{
Random random;
int num = random.getInt(2);
if (num == 0)
{
ball.launch(Vector2(1.0f, random.getFloat(-1.0f, 1.0f)));
}
else if (num == 1)
{
ball.launch(Vector2(-1.0f, random.getFloat(-1.0f, 1.0f)));
}
}
else if (currState.isKeyDown(KEY_B) && prevState.isKeyUp(KEY_B))
{
// Toggle debug drawing
DebugDrawing::getInstance().enabled = !DebugDrawing::getInstance().enabled;
}
else if (currState.isKeyDown(KEY_P) && prevState.isKeyUp(KEY_P))
{
if (paused)
{
timer.start();
paused = false;
}
else
{
keyboard.onPause();
timer.stop();
paused = true;
}
}
else if(currState.isKeyDown(KEY_R) && prevState.isKeyUp(KEY_R))
{
if (won)
{
// reset the string
whoWon = "";
// reset the scores of both players
playerScore = 0;
aiScore = 0;
ball.reset(Point2(static_cast<float>(window.centerX), static_cast<float>(window.centerY)));
won = false;
}
}
// Player movement
if (currState.isKeyDown(KEY_W))
{
player.movePaddle(Vector2(0.0f, -1.0f));
}
else if (currState.isKeyDown(KEY_S))
{
player.movePaddle(Vector2(0.0f, 1.0f));
}
}
void MSAAFilter::Update(const Timer& timer)
{
AppSettings::UpdateUI();
MouseState mouseState = MouseState::GetMouseState(window);
KeyboardState kbState = KeyboardState::GetKeyboardState(window);
if(kbState.IsKeyDown(KeyboardState::Escape))
window.Destroy();
float CamMoveSpeed = 5.0f * timer.DeltaSecondsF();
const float CamRotSpeed = 0.180f * timer.DeltaSecondsF();
const float MeshRotSpeed = 0.180f * timer.DeltaSecondsF();
// Move the camera with keyboard input
if(kbState.IsKeyDown(KeyboardState::LeftShift))
CamMoveSpeed *= 0.25f;
Float3 camPos = camera.Position();
if(kbState.IsKeyDown(KeyboardState::W))
camPos += camera.Forward() * CamMoveSpeed;
else if (kbState.IsKeyDown(KeyboardState::S))
camPos += camera.Back() * CamMoveSpeed;
if(kbState.IsKeyDown(KeyboardState::A))
camPos += camera.Left() * CamMoveSpeed;
else if (kbState.IsKeyDown(KeyboardState::D))
camPos += camera.Right() * CamMoveSpeed;
if(kbState.IsKeyDown(KeyboardState::Q))
camPos += camera.Up() * CamMoveSpeed;
else if (kbState.IsKeyDown(KeyboardState::E))
camPos += camera.Down() * CamMoveSpeed;
camera.SetPosition(camPos);
// Rotate the camera with the mouse
if(mouseState.RButton.Pressed && mouseState.IsOverWindow)
{
float xRot = camera.XRotation();
float yRot = camera.YRotation();
xRot += mouseState.DY * CamRotSpeed;
yRot += mouseState.DX * CamRotSpeed;
camera.SetXRotation(xRot);
camera.SetYRotation(yRot);
}
// Reset the camera projection
camera.SetAspectRatio(camera.AspectRatio());
Float2 jitter = 0.0f;
if(AppSettings::EnableTemporalAA && AppSettings::EnableJitter() && AppSettings::UseStandardResolve == false)
{
if(AppSettings::JitterMode == JitterModes::Uniform2x)
{
jitter = frameCount % 2 == 0 ? -0.5f : 0.5f;
}
else if(AppSettings::JitterMode == JitterModes::Hammersley4x)
{
uint64 idx = frameCount % 4;
jitter = Hammersley2D(idx, 4) * 2.0f - Float2(1.0f);
}
else if(AppSettings::JitterMode == JitterModes::Hammersley8x)
{
uint64 idx = frameCount % 8;
jitter = Hammersley2D(idx, 8) * 2.0f - Float2(1.0f);
}
else if(AppSettings::JitterMode == JitterModes::Hammersley16x)
{
uint64 idx = frameCount % 16;
jitter = Hammersley2D(idx, 16) * 2.0f - Float2(1.0f);
}
jitter *= AppSettings::JitterScale;
const float offsetX = jitter.x * (1.0f / colorTarget.Width);
const float offsetY = jitter.y * (1.0f / colorTarget.Height);
Float4x4 offsetMatrix = Float4x4::TranslationMatrix(Float3(offsetX, -offsetY, 0.0f));
camera.SetProjection(camera.ProjectionMatrix() * offsetMatrix);
}
jitterOffset = (jitter - prevJitter) * 0.5f;
prevJitter = jitter;
// Toggle VSYNC
if(kbState.RisingEdge(KeyboardState::V))
deviceManager.SetVSYNCEnabled(!deviceManager.VSYNCEnabled());
deviceManager.SetNumVSYNCIntervals(AppSettings::DoubleSyncInterval ? 2 : 1);
if(AppSettings::CurrentScene.Changed())
{
meshRenderer.SetModel(&models[AppSettings::CurrentScene]);
AppSettings::ModelOrientation.SetValue(modelOrientations[AppSettings::CurrentScene]);
}
Quaternion orientation = AppSettings::ModelOrientation;
orientation = orientation * Quaternion::FromAxisAngle(Float3(0.0f, 1.0f, 0.0f), AppSettings::ModelRotationSpeed * timer.DeltaSecondsF());
AppSettings::ModelOrientation.SetValue(orientation);
modelTransform = orientation.ToFloat4x4() * Float4x4::ScaleMatrix(ModelScales[AppSettings::CurrentScene]);
modelTransform.SetTranslation(ModelPositions[AppSettings::CurrentScene]);
}
void ShadowsApp::Update(const Timer& timer)
{
MouseState mouseState = MouseState::GetMouseState(window);
KeyboardState kbState = KeyboardState::GetKeyboardState(window);
if (kbState.IsKeyDown(KeyboardState::Escape))
window.Destroy();
float CamMoveSpeed = 5.0f * timer.DeltaSecondsF();
const float CamRotSpeed = 0.180f * timer.DeltaSecondsF();
const float MeshRotSpeed = 0.180f * timer.DeltaSecondsF();
// Move the camera with keyboard input
if (kbState.IsKeyDown(KeyboardState::LeftShift))
CamMoveSpeed *= 0.25f;
Float3 camPos = camera.Position();
if (kbState.IsKeyDown(KeyboardState::W))
camPos += camera.Forward() * CamMoveSpeed;
else if (kbState.IsKeyDown(KeyboardState::S))
camPos += camera.Back() * CamMoveSpeed;
if (kbState.IsKeyDown(KeyboardState::A))
camPos += camera.Left() * CamMoveSpeed;
else if (kbState.IsKeyDown(KeyboardState::D))
camPos += camera.Right() * CamMoveSpeed;
if (kbState.IsKeyDown(KeyboardState::Q))
camPos += camera.Up() * CamMoveSpeed;
else if (kbState.IsKeyDown(KeyboardState::E))
camPos += camera.Down() * CamMoveSpeed;
camera.SetPosition(camPos);
// Rotate the camera with the mouse
if(mouseState.RButton.Pressed && mouseState.IsOverWindow)
{
float xRot = camera.XRotation();
float yRot = camera.YRotation();
xRot += mouseState.DY * CamRotSpeed;
yRot += mouseState.DX * CamRotSpeed;
camera.SetXRotation(xRot);
camera.SetYRotation(yRot);
}
if(AppSettings::AnimateLight)
{
float rotY = XMScalarModAngle(timer.DeltaSecondsF() * 0.25f);
Quaternion rotation = Quaternion::FromAxisAngle(Float3(0.0f, 1.0f, 0.0f), rotY);
Float3 lightDir = AppSettings::LightDirection;
lightDir = Float3::Transform(lightDir, rotation);
AppSettings::LightDirection.SetValue(lightDir);
}
// Toggle VSYNC
if(kbState.RisingEdge(KeyboardState::V))
deviceManager.SetVSYNCEnabled(!deviceManager.VSYNCEnabled());
if(AppSettings::CurrentScene.Changed())
{
float scale = MeshScales[AppSettings::CurrentScene];
meshRenderer.SetSceneMesh(deviceManager.ImmediateContext(), &models[AppSettings::CurrentScene],
XMMatrixScaling(scale, scale, scale));
}
AppSettings::Update();
meshRenderer.Update();
}
