void SignedDistanceFieldText::MoveCamera(float timeStep)
{
// Do not move if the UI has a focused element (the console)
if (GetContext()->m_UISystem.get()->GetFocusElement())
return;
Input* input = GetContext()->m_InputSystem.get();
// Movement speed as world units per second
const float MOVE_SPEED = 20.0f;
// Mouse sensitivity as degrees per pixel
const float MOUSE_SENSITIVITY = 0.1f;
// Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
IntVector2 mouseMove = input->GetMouseMove();
yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
pitch_ = Clamp(pitch_, -90.0f, 90.0f);
// Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
// Use the Translate() function (default local space) to move relative to the node's orientation.
if (input->GetKeyDown(KEY_W))
cameraNode_->Translate(Vector3::FORWARD * MOVE_SPEED * timeStep);
if (input->GetKeyDown(KEY_S))
cameraNode_->Translate(Vector3::BACK * MOVE_SPEED * timeStep);
if (input->GetKeyDown(KEY_A))
cameraNode_->Translate(Vector3::LEFT * MOVE_SPEED * timeStep);
if (input->GetKeyDown(KEY_D))
cameraNode_->Translate(Vector3::RIGHT * MOVE_SPEED * timeStep);
}
void UI::HandleMouseButtonUp(StringHash eventType, VariantMap& eventData)
{
if (inputDisabled_ || consoleVisible_)
return;
using namespace MouseButtonUp;
unsigned button = eventData[P_BUTTON].GetUInt();
IntVector2 pos;
Input* input = GetSubsystem<Input>();
pos = input->GetMousePosition();
int qualifiers = input->GetQualifiers();
#ifdef ATOMIC_PLATFORM_WINDOWS
bool superdown = input->GetKeyDown(KEY_LCTRL) || input->GetKeyDown(KEY_RCTRL);
#else
bool superdown = input->GetKeyDown(KEY_LGUI) || input->GetKeyDown(KEY_RGUI);
#endif
MODIFIER_KEYS mod = GetModifierKeys(qualifiers, superdown);
if (button == MOUSEB_RIGHT)
rootWidget_->InvokeRightPointerUp(pos.x_, pos.y_, mod);
else
rootWidget_->InvokePointerUp(pos.x_, pos.y_, mod, false);
}
void DynamicGeometry::MoveCamera(float timeStep)
{
Input* input = GetSubsystem<Input>();
// Movement speed as world units per second
const float MOVE_SPEED = 20.0f;
// Mouse sensitivity as degrees per pixel
const float MOUSE_SENSITIVITY = 0.1f;
// Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
IntVector2 mouseMove = input->GetMouseMove();
yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
pitch_ = Clamp(pitch_, -90.0f, 90.0f);
// Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
if (input->GetKeyDown(KEY_W))
cameraNode_->Translate(Vector3::FORWARD * MOVE_SPEED * timeStep);
if (input->GetKeyDown(KEY_S))
cameraNode_->Translate(Vector3::BACK * MOVE_SPEED * timeStep);
if (input->GetKeyDown(KEY_A))
cameraNode_->Translate(Vector3::LEFT * MOVE_SPEED * timeStep);
if (input->GetKeyDown(KEY_D))
cameraNode_->Translate(Vector3::RIGHT * MOVE_SPEED * timeStep);
}
void RenderToTexture::MoveCamera(float timeStep)
{
// Do not move if the UI has a focused element (the console)
if (GetSubsystem<UI>()->GetFocusElement())
return;
Input* input = GetSubsystem<Input>();
// Movement speed as world units per second
const float MOVE_SPEED = 20.0f;
// Mouse sensitivity as degrees per pixel
const float MOUSE_SENSITIVITY = 0.1f;
// Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
IntVector2 mouseMove = input->GetMouseMove();
yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
pitch_ = Clamp(pitch_, -90.0f, 90.0f);
// Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
if (input->GetKeyDown('W'))
cameraNode_->Translate(Vector3::FORWARD * MOVE_SPEED * timeStep);
if (input->GetKeyDown('S'))
cameraNode_->Translate(Vector3::BACK * MOVE_SPEED * timeStep);
if (input->GetKeyDown('A'))
cameraNode_->Translate(Vector3::LEFT * MOVE_SPEED * timeStep);
if (input->GetKeyDown('D'))
cameraNode_->Translate(Vector3::RIGHT * MOVE_SPEED * timeStep);
}
void CharacterDemo::HandleUpdate(StringHash eventType, VariantMap& eventData)
{
using namespace Update;
float timeStep = eventData[P_TIMESTEP].GetFloat();
Input* input = GetSubsystem<Input>();
if (character_)
{
UI* ui = GetSubsystem<UI>();
// Get movement controls and assign them to the character logic component. If UI has a focused element, clear controls
if (!ui->GetFocusElement())
{
character_->controls_.Set(CTRL_FORWARD, input->GetKeyDown('W'));
character_->controls_.Set(CTRL_BACK, input->GetKeyDown('S'));
character_->controls_.Set(CTRL_LEFT, input->GetKeyDown('A'));
character_->controls_.Set(CTRL_RIGHT, input->GetKeyDown('D'));
character_->controls_.Set(CTRL_JUMP, input->GetKeyDown(KEY_SPACE));
// Add character yaw & pitch from the mouse motion
character_->controls_.yaw_ += (float)input->GetMouseMoveX() * YAW_SENSITIVITY;
character_->controls_.pitch_ += (float)input->GetMouseMoveY() * YAW_SENSITIVITY;
// Limit pitch
character_->controls_.pitch_ = Clamp(character_->controls_.pitch_, -80.0f, 80.0f);
// Switch between 1st and 3rd person
if (input->GetKeyPress('F'))
firstPerson_ = !firstPerson_;
// Check for loading / saving the scene
if (input->GetKeyPress(KEY_F5))
{
File saveFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/CharacterDemo.xml",
FILE_WRITE);
scene_->SaveXML(saveFile);
}
if (input->GetKeyPress(KEY_F7))
{
File loadFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/CharacterDemo.xml", FILE_READ);
scene_->LoadXML(loadFile);
// After loading we have to reacquire the weak pointer to the Character component, as it has been recreated
// Simply find the character's scene node by name as there's only one of them
Node* characterNode = scene_->GetChild("Jack", true);
if (characterNode)
character_ = characterNode->GetComponent<Character>();
}
}
else
character_->controls_.Set(CTRL_FORWARD | CTRL_BACK | CTRL_LEFT | CTRL_RIGHT | CTRL_JUMP, false);
// Set rotation already here so that it's updated every rendering frame instead of every physics frame
character_->GetNode()->SetRotation(Quaternion(character_->controls_.yaw_, Vector3::UP));
}
}
void Physics::MoveCamera(float timeStep)
{
// Do not move if the UI has a focused element (the console)
if (GetSubsystem<UI>()->GetFocusElement())
return;
Input* input = GetSubsystem<Input>();
// Movement speed as world units per second
const float MOVE_SPEED = 20.0f;
// Mouse sensitivity as degrees per pixel
const float MOUSE_SENSITIVITY = 0.1f;
// Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
IntVector2 mouseMove = input->GetMouseMove();
yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
pitch_ = Clamp(pitch_, -90.0f, 90.0f);
// Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
if (input->GetKeyDown(KEY_W))
cameraNode_->Translate(Vector3::FORWARD * MOVE_SPEED * timeStep);
if (input->GetKeyDown(KEY_S))
cameraNode_->Translate(Vector3::BACK * MOVE_SPEED * timeStep);
if (input->GetKeyDown(KEY_A))
cameraNode_->Translate(Vector3::LEFT * MOVE_SPEED * timeStep);
if (input->GetKeyDown(KEY_D))
cameraNode_->Translate(Vector3::RIGHT * MOVE_SPEED * timeStep);
// "Shoot" a physics object with left mousebutton
if (input->GetMouseButtonPress(MOUSEB_LEFT))
SpawnObject();
// Check for loading/saving the scene. Save the scene to the file Data/Scenes/Physics.xml relative to the executable
// directory
if (input->GetKeyPress(KEY_F5))
{
File saveFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/Physics.xml", FILE_WRITE);
scene_->SaveXML(saveFile);
}
if (input->GetKeyPress(KEY_F7))
{
File loadFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/Physics.xml", FILE_READ);
scene_->LoadXML(loadFile);
}
// Toggle physics debug geometry with space
if (input->GetKeyPress(KEY_SPACE))
drawDebug_ = !drawDebug_;
}
void Navigation::MoveCamera(float timeStep)
{
// Right mouse button controls mouse cursor visibility: hide when pressed
UI* ui = GetSubsystem<UI>();
Input* input = GetSubsystem<Input>();
ui->GetCursor()->SetVisible(!input->GetMouseButtonDown(MOUSEB_RIGHT));
// Do not move if the UI has a focused element (the console)
if (ui->GetFocusElement())
return;
// Movement speed as world units per second
const float MOVE_SPEED = 20.0f;
// Mouse sensitivity as degrees per pixel
const float MOUSE_SENSITIVITY = 0.1f;
// Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
// Only move the camera when the cursor is hidden
if (!ui->GetCursor()->IsVisible())
{
IntVector2 mouseMove = input->GetMouseMove();
yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
pitch_ = Clamp(pitch_, -90.0f, 90.0f);
// Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
}
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
if (input->GetKeyDown('W'))
cameraNode_->TranslateRelative(Vector3::FORWARD * MOVE_SPEED * timeStep);
if (input->GetKeyDown('S'))
cameraNode_->TranslateRelative(Vector3::BACK * MOVE_SPEED * timeStep);
if (input->GetKeyDown('A'))
cameraNode_->TranslateRelative(Vector3::LEFT * MOVE_SPEED * timeStep);
if (input->GetKeyDown('D'))
cameraNode_->TranslateRelative(Vector3::RIGHT * MOVE_SPEED * timeStep);
// Set route start/endpoint with left mouse button, recalculate route if applicable
if (input->GetMouseButtonPress(MOUSEB_LEFT))
SetPathPoint();
// Add or remove objects with middle mouse button, then rebuild navigation mesh partially
if (input->GetMouseButtonPress(MOUSEB_MIDDLE))
AddOrRemoveObject();
// Toggle debug geometry with space
if (input->GetKeyPress(KEY_SPACE))
drawDebug_ = !drawDebug_;
}
void DebugCameraController::Update(float timeStep)
{
// Do not move if the UI has a focused element
if (GetUI()->GetFocusElement())
return;
// Do not move if interacting with UI controls
if (GetSystemUI()->IsAnyItemActive())
return;
Input* input = GetInput();
// Movement speed as world units per second
float moveSpeed_ = speed_;
if (input->GetKeyDown(KEY_SHIFT))
{
moveSpeed_ *= 2;
if (input->GetKeyPress(KEY_KP_PLUS))
speed_ += 1.f;
else if (input->GetKeyPress(KEY_KP_MINUS))
speed_ -= 1.f;
}
if (input->GetMouseButtonDown(MOUSEB_RIGHT))
{
IntVector2 delta = input->GetMouseMove();
if (input->IsMouseVisible() && delta != IntVector2::ZERO)
input->SetMouseVisible(false);
auto yaw = GetNode()->GetRotation().EulerAngles().x_;
if ((yaw > -90.f && yaw < 90.f) || (yaw <= -90.f && delta.y_ > 0) || (yaw >= 90.f && delta.y_ < 0))
GetNode()->RotateAround(Vector3::ZERO, Quaternion(mouseSensitivity_ * delta.y_, Vector3::RIGHT), TS_LOCAL);
GetNode()->RotateAround(GetNode()->GetPosition(), Quaternion(mouseSensitivity_ * delta.x_, Vector3::UP), TS_WORLD);
}
else if (!input->IsMouseVisible())
input->SetMouseVisible(true);
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
if (input->GetKeyDown(KEY_W))
GetNode()->Translate(Vector3::FORWARD * moveSpeed_ * timeStep);
if (input->GetKeyDown(KEY_S))
GetNode()->Translate(Vector3::BACK * moveSpeed_ * timeStep);
if (input->GetKeyDown(KEY_A))
GetNode()->Translate(Vector3::LEFT * moveSpeed_ * timeStep);
if (input->GetKeyDown(KEY_D))
GetNode()->Translate(Vector3::RIGHT * moveSpeed_ * timeStep);
}
void Level00::HandleInput(Input& input)
{
// Player Mouse
if (input.GetKeyDown(KEYCODE_1))
{
Application::SharedInstance().LoadScene<MainMenuScene>();
}
if (input.GetMouseButtonDown(MOUSEBUTTON_LEFT))
{
float x = (2.0f * input.mousePosition.x) / mRenderer->GetWindowWidth() - 1.0f;
float y = 1.0f - (2.0f * input.mousePosition.y) / mRenderer->GetWindowHeight();
mat4f toWorld = (mQuadShaderData.Projection * mQuadShaderData.View).inverse();
vec3f worldPos = vec4f(x, y, 0.0f, 1.0f) * toWorld;
vec3f worldDir = vec3f(0.0f, 0.0f, 1.0f);
worldPos.z = -30.0f;
Ray<vec3f> ray = { worldPos, worldDir };
RayCastHit<vec3f> hit;
if (RayCast(&hit, ray, mLightColliders, mCircleCount))
{
mCircleColorWeights[hit.index] = mCircleColorWeights[hit.index] > 0 ? 0.0f : 1.0f;
}
}
}
void VehicleDemo::HandleUpdate(StringHash eventType, VariantMap& eventData)
{
using namespace Update;
float timeStep = eventData[P_TIMESTEP].GetFloat();
Input* input = GetSubsystem<Input>();
if (vehicle_)
{
UI* ui = GetSubsystem<UI>();
// Get movement controls and assign them to the vehicle component. If UI has a focused element, clear controls
if (!ui->GetFocusElement())
{
vehicle_->controls_.Set(CTRL_FORWARD, input->GetKeyDown('W'));
vehicle_->controls_.Set(CTRL_BACK, input->GetKeyDown('S'));
vehicle_->controls_.Set(CTRL_LEFT, input->GetKeyDown('A'));
vehicle_->controls_.Set(CTRL_RIGHT, input->GetKeyDown('D'));
// Add yaw & pitch from the mouse motion. Used only for the camera, does not affect motion
vehicle_->controls_.yaw_ += (float)input->GetMouseMoveX() * YAW_SENSITIVITY;
vehicle_->controls_.pitch_ += (float)input->GetMouseMoveY() * YAW_SENSITIVITY;
// Limit pitch
vehicle_->controls_.pitch_ = Clamp(vehicle_->controls_.pitch_, 0.0f, 80.0f);
// Check for loading / saving the scene
if (input->GetKeyPress(KEY_F5))
{
File saveFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/VehicleDemo.xml",
FILE_WRITE);
scene_->SaveXML(saveFile);
}
if (input->GetKeyPress(KEY_F7))
{
File loadFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/VehicleDemo.xml", FILE_READ);
scene_->LoadXML(loadFile);
// After loading we have to reacquire the weak pointer to the Vehicle component, as it has been recreated
// Simply find the vehicle's scene node by name as there's only one of them
Node* vehicleNode = scene_->GetChild("Vehicle", true);
if (vehicleNode)
vehicle_ = vehicleNode->GetComponent<Vehicle>();
}
}
else
vehicle_->controls_.Set(CTRL_FORWARD | CTRL_BACK | CTRL_LEFT | CTRL_RIGHT, false);
}
}
void LoadScriptState::Update(float timestep)
{
Input* input = GetSubsystem<Input>();
if (input->GetKeyDown('Q'))
{
RaiseEvent("Exit");
}
}
void DebugCameraController2D::Update(float timeStep)
{
// Do not move if the UI has a focused element
if (GetUI()->GetFocusElement())
return;
// Do not move if interacting with UI controls
if (GetSystemUI()->IsAnyItemActive())
return;
Input* input = GetInput();
// Movement speed as world units per second
float moveSpeed_ = speed_;
if (input->GetKeyDown(KEY_SHIFT))
{
moveSpeed_ *= 2;
if (input->GetKeyPress(KEY_KP_PLUS))
speed_ += 1.f;
else if (input->GetKeyPress(KEY_KP_MINUS))
speed_ -= 1.f;
}
if (input->GetMouseButtonDown(MOUSEB_RIGHT))
{
IntVector2 delta = input->GetMouseMove();
if (input->IsMouseVisible() && delta != IntVector2::ZERO)
input->SetMouseVisible(false);
GetNode()->Translate2D(Vector2{(float)delta.x_ * -1.f, (float)delta.y_} * moveSpeed_ * timeStep);
}
else if (!input->IsMouseVisible())
input->SetMouseVisible(true);
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
if (input->GetKeyDown(KEY_W))
GetNode()->Translate(Vector3::UP * moveSpeed_ * timeStep);
if (input->GetKeyDown(KEY_S))
GetNode()->Translate(Vector3::DOWN * moveSpeed_ * timeStep);
if (input->GetKeyDown(KEY_A))
GetNode()->Translate(Vector3::LEFT * moveSpeed_ * timeStep);
if (input->GetKeyDown(KEY_D))
GetNode()->Translate(Vector3::RIGHT * moveSpeed_ * timeStep);
}
void CameraMaster::HandleSceneUpdate(StringHash /* eventType */, VariantMap &eventData)
{
using namespace Update;
//Take the frame time step, which is stored as a double
double timeStep = eventData[P_TIMESTEP].GetFloat();
//Movement speed as world units per second
const double MOVE_SPEED = 2000.0;
//Mouse sensitivity as degrees per pixel
const double MOUSE_SENSITIVITY = 0.1;
//Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees. Only move the camera when the cursor is hidden.
Input* input = GetSubsystem<Input>();
IntVector2 mouseMove = input->GetMouseMove();
yawDelta_ = 0.5*(yawDelta_ + MOUSE_SENSITIVITY * mouseMove.x_);
pitchDelta_ = 0.5*(pitchDelta_ + MOUSE_SENSITIVITY * mouseMove.y_);
yaw_ += yawDelta_;
pitch_ += pitchDelta_;
pitch_ = Clamp(pitch_, -89.0, 89.0);
//Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
translationNode_->SetRotation(Quaternion(0.0f, 0.0f, 0.0f));
rotationNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
//Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
Vector3 camForce = Vector3::ZERO;
if (input->GetKeyDown('W')) camForce += Scale(rotationNode_->GetDirection(), Vector3(1.0f,0.0f,1.0f) ).Normalized();
if (input->GetKeyDown('S')) camForce += Scale(rotationNode_->GetDirection(), Vector3(-1.0f,0.0f,-1.0f) ).Normalized();
if (input->GetKeyDown('D')) camForce += Scale(rotationNode_->GetRight(), Vector3(1.0f,0.0f,1.0f) ).Normalized();
if (input->GetKeyDown('A')) camForce += Scale(rotationNode_->GetRight(), Vector3(-1.0f,0.0f,-1.0f) ).Normalized();
if (input->GetKeyDown('E')) camForce += Vector3::UP;
if (input->GetKeyDown('Q') && translationNode_->GetPosition().y_ > 1.0f) camForce += Vector3::DOWN;
camForce = camForce.Normalized() * MOVE_SPEED * timeStep;
if ( forceMultiplier < 8.0 && (input->GetKeyDown(KEY_LSHIFT)||input->GetKeyDown(KEY_RSHIFT)) ) {
forceMultiplier += 0.23;
} else forceMultiplier = pow(forceMultiplier, 0.75);
rigidBody_->ApplyForce( (forceMultiplier * camForce) - (2.3f * rigidBody_->GetLinearVelocity()) );
if (translationNode_->GetPosition().y_ < 1.0f)
{
translationNode_->SetPosition(Vector3(translationNode_->GetPosition().x_, 1.0f, translationNode_->GetPosition().z_));
rigidBody_->SetLinearVelocity(Vector3(rigidBody_->GetLinearVelocity().x_, 0.0f, rigidBody_->GetLinearVelocity().z_));
}
}
void MultipleViewports::MoveCamera(float timeStep)
{
// Do not move if the UI has a focused element (the console)
if (GetSubsystem<UI>()->GetFocusElement())
return;
Input* input = GetSubsystem<Input>();
// Movement speed as world units per second
const float MOVE_SPEED = 20.0f;
// Mouse sensitivity as degrees per pixel
const float MOUSE_SENSITIVITY = 0.1f;
// Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
IntVector2 mouseMove = input->GetMouseMove();
yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
pitch_ = Clamp(pitch_, -90.0f, 90.0f);
// Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
if (input->GetKeyDown('W'))
cameraNode_->Translate(Vector3::FORWARD * MOVE_SPEED * timeStep);
if (input->GetKeyDown('S'))
cameraNode_->Translate(Vector3::BACK * MOVE_SPEED * timeStep);
if (input->GetKeyDown('A'))
cameraNode_->Translate(Vector3::LEFT * MOVE_SPEED * timeStep);
if (input->GetKeyDown('D'))
cameraNode_->Translate(Vector3::RIGHT * MOVE_SPEED * timeStep);
// Toggle post processing effects on the front viewport. Note that the rear viewport is unaffected
RenderPath* effectRenderPath = GetSubsystem<Renderer>()->GetViewport(0)->GetRenderPath();
if (input->GetKeyPress('B'))
effectRenderPath->ToggleEnabled("Bloom");
if (input->GetKeyPress('F'))
effectRenderPath->ToggleEnabled("FXAA2");
// Toggle debug geometry with space
if (input->GetKeyPress(KEY_SPACE))
drawDebug_ = !drawDebug_;
}
void Urho3DTemplate::MoveCamera(float timeStep)
{
//Right mouse button controls mouse cursor visibility: hide when pressed
UI* ui = GetSubsystem<UI>();
Input* input = GetSubsystem<Input>();
ui->GetCursor()->SetVisible(!input->GetMouseButtonDown(MOUSEB_RIGHT));
//Do not move if the UI has a focused element (the console)
if (ui->GetFocusElement())
return;
//Movement speed as world units per second
const float MOVE_SPEED = 20.0f;
//Mouse sensitivity as degrees per pixel
const float MOUSE_SENSITIVITY = 0.1f;
//Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees. Only move the camera when the cursor is hidden.
if (!ui->GetCursor()->IsVisible())
{
IntVector2 mouseMove = input->GetMouseMove();
cameraYaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
cameraPitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
cameraPitch_ = Clamp(cameraPitch_, -90.0f, 90.0f);
//Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
cameraNode_->SetRotation(Quaternion(cameraPitch_, cameraYaw_, 0.0f));
}
//Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
if (input->GetKeyDown('W'))
cameraNode_->Translate(Vector3::FORWARD * MOVE_SPEED * timeStep);
if (input->GetKeyDown('S'))
cameraNode_->Translate(Vector3::BACK * MOVE_SPEED * timeStep);
if (input->GetKeyDown('A'))
cameraNode_->Translate(Vector3::LEFT * MOVE_SPEED * timeStep);
if (input->GetKeyDown('D'))
cameraNode_->Translate(Vector3::RIGHT * MOVE_SPEED * timeStep);
//Add or remove objects with left mouse button
if (input->GetMouseButtonPress(MOUSEB_LEFT))
AddOrRemoveObject();
}
void UI::HandleMouseButtonDown(StringHash eventType, VariantMap& eventData)
{
if (inputDisabled_ || consoleVisible_)
return;
using namespace MouseButtonDown;
unsigned button = eventData[P_BUTTON].GetUInt();
IntVector2 pos;
pos = GetSubsystem<Input>()->GetMousePosition();
Input* input = GetSubsystem<Input>();
int qualifiers = input->GetQualifiers();
#ifdef ATOMIC_PLATFORM_WINDOWS
bool superdown = input->GetKeyDown(KEY_LCTRL) || input->GetKeyDown(KEY_RCTRL);
#else
bool superdown = input->GetKeyDown(KEY_LGUI) || input->GetKeyDown(KEY_RGUI);
#endif
MODIFIER_KEYS mod = GetModifierKeys(qualifiers, superdown);
static double last_time = 0;
static int counter = 1;
Time* t = GetSubsystem<Time>();
double time = t->GetElapsedTime() * 1000;
if (time < last_time + 600)
counter++;
else
counter = 1;
last_time = time;
if (button == MOUSEB_RIGHT)
rootWidget_->InvokeRightPointerDown(pos.x_, pos.y_, counter, mod);
else
rootWidget_->InvokePointerDown(pos.x_, pos.y_, counter, mod, false);
}
void SoundSynthesis::HandleUpdate(StringHash eventType, VariantMap& eventData)
{
using namespace Update;
// Take the frame time step, which is stored as a float
float timeStep = eventData[P_TIMESTEP].GetFloat();
// Use keys to control the filter constant
Input* input = GetSubsystem<Input>();
if (input->GetKeyDown(KEY_UP))
filter_ += timeStep * 0.5f;
if (input->GetKeyDown(KEY_DOWN))
filter_ -= timeStep * 0.5f;
filter_ = Clamp(filter_, 0.01f, 1.0f);
instructionText_->SetText("Use cursor up and down to control sound filtering\n"
"Coefficient: " + String(filter_));
UpdateSound();
}
void TowerApp::MoveCamera(float timeStep) {
// Do not move if the UI has a focused element (the console)
if (GetSubsystem<UI>()->GetFocusElement())
return;
Input *input = GetSubsystem<Input>();
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
const SharedPtr<Node> &cameraNode = scene->GetCamera();
cameraNode->GetComponent<Camera>();
if (input->GetKeyDown(KEY_PAGEUP)) {
Camera *camera = cameraNode->GetComponent<Camera>();
camera->SetZoom(camera->GetZoom() * 1.01f);
}
if (input->GetKeyDown(KEY_PAGEDOWN)) {
Camera *camera = cameraNode->GetComponent<Camera>();
camera->SetZoom(camera->GetZoom() * 0.99f);
}
}
void Urho2DTileMap::MoveCamera(float timeStep)
{
// Do not move if the UI has a focused element (the console)
if (GetSubsystem<UI>()->GetFocusElement())
return;
Input* input = GetSubsystem<Input>();
// Movement speed as world units per second
const float MOVE_SPEED = 4.0f;
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
if (input->GetKeyDown('W'))
cameraNode_->Translate(Vector3::UP * MOVE_SPEED * timeStep);
if (input->GetKeyDown('S'))
cameraNode_->Translate(Vector3::DOWN * MOVE_SPEED * timeStep);
if (input->GetKeyDown('A'))
cameraNode_->Translate(Vector3::LEFT * MOVE_SPEED * timeStep);
if (input->GetKeyDown('D'))
cameraNode_->Translate(Vector3::RIGHT * MOVE_SPEED * timeStep);
if (input->GetKeyDown(KEY_PAGEUP))
{
Camera* camera = cameraNode_->GetComponent<Camera>();
camera->SetZoom(camera->GetZoom() * 1.01f);
}
if (input->GetKeyDown(KEY_PAGEDOWN))
{
Camera* camera = cameraNode_->GetComponent<Camera>();
camera->SetZoom(camera->GetZoom() * 0.99f);
}
}
void Water::MoveCamera(float timeStep)
{
// Do not move if the UI has a focused element (the console)
if (GetContext()->m_UISystem.get()->GetFocusElement())
return;
Input* input = GetContext()->m_InputSystem.get();
// Movement speed as world units per second
const float MOVE_SPEED = 20.0f;
// Mouse sensitivity as degrees per pixel
const float MOUSE_SENSITIVITY = 0.1f;
// Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
IntVector2 mouseMove = input->GetMouseMove();
yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
pitch_ = Clamp(pitch_, -90.0f, 90.0f);
// Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
if (input->GetKeyDown(KEY_W))
cameraNode_->Translate(Vector3::FORWARD * MOVE_SPEED * timeStep);
if (input->GetKeyDown(KEY_S))
cameraNode_->Translate(Vector3::BACK * MOVE_SPEED * timeStep);
if (input->GetKeyDown(KEY_A))
cameraNode_->Translate(Vector3::LEFT * MOVE_SPEED * timeStep);
if (input->GetKeyDown(KEY_D))
cameraNode_->Translate(Vector3::RIGHT * MOVE_SPEED * timeStep);
// In case resolution has changed, adjust the reflection camera aspect ratio
Graphics* graphics = GetContext()->m_Graphics.get();
Camera* reflectionCamera = reflectionCameraNode_->GetComponent<Camera>();
reflectionCamera->SetAspectRatio((float)graphics->GetWidth() / (float)graphics->GetHeight());
}
void World::MoveCamera(float timeStep)
{
static float yaw_ = 0.0f;
static float pitch_ = 0.0f;
Input* input = context->GetSubsystem<Input>();
const float MOVE_SPEED = 20.0f;
const float MOUSE_SENSITIVITY = 0.1f;
IntVector2 mouseMove = input->GetMouseMove();
yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
pitch_ = Clamp(pitch_, -90.0f, 90.0f);
camera.node->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
Quaternion camRotation = camera.node->GetWorldRotation();
camRotation.z_ = 0.0f;
Vector3 dir = Vector3::ZERO;
if (input->GetKeyDown('W'))
dir += Vector3::FORWARD;
if (input->GetKeyDown('S'))
dir += Vector3::BACK;
if (input->GetKeyDown('A'))
dir += Vector3::LEFT;
if (input->GetKeyDown('D'))
dir += Vector3::RIGHT;
if (input->GetKeyDown(KEY_SPACE))
{
dir += Vector3::UP;
}
if (dir.Length() > 0)
{
Vector3 curVel = player.body->GetLinearVelocity();
if (curVel.Length() < 5.0f)
{
float multipler = 1.0f;
//if (input->GetQualifierDown(KEY_SHIFT))
if (input->GetKeyDown(KEY_LSHIFT))
{
multipler = 2.0f;
}
player.body->SetLinearVelocity(multipler * 200.0f * (camRotation * dir) * timeStep);
}
}
}
void UI::HandleKeyDown(StringHash eventType, VariantMap& eventData)
{
if (inputDisabled_ || keyboardDisabled_ || consoleVisible_)
return;
using namespace KeyDown;
int keycode = eventData[P_KEY].GetInt();
int scancode = eventData[P_SCANCODE].GetInt();
HandleKey(true, keycode, scancode);
// Send Global Shortcut
Input* input = GetSubsystem<Input>();
#ifdef ATOMIC_PLATFORM_WINDOWS
bool superdown = input->GetKeyDown(KEY_LCTRL) || input->GetKeyDown(KEY_RCTRL);
if (keycode == KEY_LCTRL || keycode == KEY_RCTRL)
superdown = false;
#else
bool superdown = input->GetKeyDown(KEY_LGUI) || input->GetKeyDown(KEY_RGUI);
if (keycode == KEY_LGUI || keycode == KEY_RGUI)
superdown = false;
#endif
if (!superdown)
return;
VariantMap shortcutData;
shortcutData[UIShortcut::P_KEY] = keycode;
shortcutData[UIShortcut::P_QUALIFIERS] = eventData[P_QUALIFIERS].GetInt();
SendEvent(E_UISHORTCUT, shortcutData);
}
void SceneView3D::MoveCamera(float timeStep)
{
if (!enabled_)
return;
Input* input = GetSubsystem<Input>();
// Movement speed as world units per second
float MOVE_SPEED = 20.0f;
// Mouse sensitivity as degrees per pixel
const float MOUSE_SENSITIVITY = 0.2f;
if (input->GetKeyDown(KEY_LSHIFT) || input->GetKeyDown(KEY_RSHIFT))
MOVE_SPEED *= 3.0f;
// Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
if (input->GetMouseButtonDown(MOUSEB_RIGHT))
{
IntVector2 mouseMove = input->GetMouseMove();
yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
pitch_ = Clamp(pitch_, -90.0f, 90.0f);
// Not working on OSX
//input->SetMouseMode(MM_RELATIVE);
}
else
{
// Not working on OSX
/*
if (input->GetMouseMode() != MM_ABSOLUTE)
input->SetMouseMode(MM_ABSOLUTE);
*/
}
// Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
//Vector3 pos = cameraNode_->GetWorldPosition();
//Quaternion q = cameraNode_->GetWorldRotation();
//LOGINFOF("%f %f %f : %f %f %f %f", pos.x_, pos.y_, pos.z_, q.x_, q.y_, q.z_, q.w_ );
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
// Use the Translate() function (default local space) to move relative to the node's orientation.
if (input->GetKeyDown('W'))
cameraNode_->Translate(Vector3::FORWARD * MOVE_SPEED * timeStep);
if (input->GetKeyDown('S'))
cameraNode_->Translate(Vector3::BACK * MOVE_SPEED * timeStep);
if (input->GetKeyDown('A'))
cameraNode_->Translate(Vector3::LEFT * MOVE_SPEED * timeStep);
if (input->GetKeyDown('D'))
cameraNode_->Translate(Vector3::RIGHT * MOVE_SPEED * timeStep);
}
void Labyrinth::HandlePostUpdate(StringHash eventType, VariantMap& eventData)
{
Input* input = GetSubsystem<Input>();
if (input->GetKeyDown(KEY_PAUSE))
Pause();
// DELETE ???
/*using namespace Update;
if (playerCtrl_)
{
// Clear previous controls
playerCtrl_->controls_.Set(CTRL_FORWARD | CTRL_BACK | CTRL_LEFT | CTRL_RIGHT | CTRL_JUMP, false);
playerCtrl_->controls_.Set(CTRL_FORWARD, input->GetKeyDown('W'));
playerCtrl_->controls_.Set(CTRL_BACK, input->GetKeyDown('S'));
playerCtrl_->controls_.Set(CTRL_LEFT, input->GetKeyDown('A'));
playerCtrl_->controls_.Set(CTRL_RIGHT, input->GetKeyDown('D'));
}*/
}
void VehicleDemo::HandleUpdate(StringHash eventType, VariantMap& eventData)
{
using namespace Update;
Input* input = GetSubsystem<Input>();
if (vehicle_)
{
UI* ui = GetSubsystem<UI>();
// Get movement controls and assign them to the vehicle component. If UI has a focused element, clear controls
if (!ui->GetFocusElement())
{
vehicle_->controls_.Set(CTRL_FORWARD, input->GetKeyDown(KEY_W));
vehicle_->controls_.Set(CTRL_BACK, input->GetKeyDown(KEY_S));
vehicle_->controls_.Set(CTRL_LEFT, input->GetKeyDown(KEY_A));
vehicle_->controls_.Set(CTRL_RIGHT, input->GetKeyDown(KEY_D));
// Add yaw & pitch from the mouse motion or touch input. Used only for the camera, does not affect motion
if (touchEnabled_)
{
for (unsigned i = 0; i < input->GetNumTouches(); ++i)
{
TouchState* state = input->GetTouch(i);
if (!state->touchedElement_) // Touch on empty space
{
Camera* camera = cameraNode_->GetComponent<Camera>();
if (!camera)
return;
Graphics* graphics = GetSubsystem<Graphics>();
vehicle_->controls_.yaw_ += TOUCH_SENSITIVITY * camera->GetFov() / graphics->GetHeight() * state->delta_.x_;
vehicle_->controls_.pitch_ += TOUCH_SENSITIVITY * camera->GetFov() / graphics->GetHeight() * state->delta_.y_;
}
}
}
else
{
vehicle_->controls_.yaw_ += (float)input->GetMouseMoveX() * YAW_SENSITIVITY;
vehicle_->controls_.pitch_ += (float)input->GetMouseMoveY() * YAW_SENSITIVITY;
}
// Limit pitch
vehicle_->controls_.pitch_ = Clamp(vehicle_->controls_.pitch_, 0.0f, 80.0f);
// Check for loading / saving the scene
if (input->GetKeyPress(KEY_F5))
{
File saveFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/VehicleDemo.xml",
FILE_WRITE);
scene_->SaveXML(saveFile);
}
if (input->GetKeyPress(KEY_F7))
{
File loadFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/VehicleDemo.xml", FILE_READ);
scene_->LoadXML(loadFile);
// After loading we have to reacquire the weak pointer to the Vehicle component, as it has been recreated
// Simply find the vehicle's scene node by name as there's only one of them
Node* vehicleNode = scene_->GetChild("Vehicle", true);
if (vehicleNode)
vehicle_ = vehicleNode->GetComponent<Vehicle>();
}
}
else
vehicle_->controls_.Set(CTRL_FORWARD | CTRL_BACK | CTRL_LEFT | CTRL_RIGHT, false);
}
}
void CharacterDemo::HandleUpdate(StringHash eventType, VariantMap& eventData)
{
using namespace Update;
Input* input = GetSubsystem<Input>();
if (character_)
{
// Clear previous controls
character_->controls_.Set(CTRL_FORWARD | CTRL_BACK | CTRL_LEFT | CTRL_RIGHT | CTRL_JUMP, false);
// Update controls using touch utility class
if (touch_)
touch_->UpdateTouches(character_->controls_);
// Update controls using keys
UI* ui = GetSubsystem<UI>();
if (!ui->GetFocusElement())
{
if (!touch_ || !touch_->useGyroscope_)
{
character_->controls_.Set(CTRL_FORWARD, input->GetKeyDown(KEY_W));
character_->controls_.Set(CTRL_BACK, input->GetKeyDown(KEY_S));
character_->controls_.Set(CTRL_LEFT, input->GetKeyDown(KEY_A));
character_->controls_.Set(CTRL_RIGHT, input->GetKeyDown(KEY_D));
}
character_->controls_.Set(CTRL_JUMP, input->GetKeyDown(KEY_SPACE));
// Add character yaw & pitch from the mouse motion or touch input
if (touchEnabled_)
{
for (unsigned i = 0; i < input->GetNumTouches(); ++i)
{
TouchState* state = input->GetTouch(i);
if (!state->touchedElement_) // Touch on empty space
{
Camera* camera = cameraNode_->GetComponent<Camera>();
if (!camera)
return;
Graphics* graphics = GetSubsystem<Graphics>();
character_->controls_.yaw_ += TOUCH_SENSITIVITY * camera->GetFov() / graphics->GetHeight() * state->delta_.x_;
character_->controls_.pitch_ += TOUCH_SENSITIVITY * camera->GetFov() / graphics->GetHeight() * state->delta_.y_;
}
}
}
else
{
character_->controls_.yaw_ += (float)input->GetMouseMoveX() * YAW_SENSITIVITY;
character_->controls_.pitch_ += (float)input->GetMouseMoveY() * YAW_SENSITIVITY;
}
// Limit pitch
character_->controls_.pitch_ = Clamp(character_->controls_.pitch_, -80.0f, 80.0f);
// Set rotation already here so that it's updated every rendering frame instead of every physics frame
character_->GetNode()->SetRotation(Quaternion(character_->controls_.yaw_, Vector3::UP));
// Switch between 1st and 3rd person
if (input->GetKeyPress(KEY_F))
firstPerson_ = !firstPerson_;
// Turn on/off gyroscope on mobile platform
if (touch_ && input->GetKeyPress(KEY_G))
touch_->useGyroscope_ = !touch_->useGyroscope_;
// Check for loading / saving the scene
if (input->GetKeyPress(KEY_F5))
{
File saveFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/CharacterDemo.xml", FILE_WRITE);
scene_->SaveXML(saveFile);
}
if (input->GetKeyPress(KEY_F7))
{
File loadFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/CharacterDemo.xml", FILE_READ);
scene_->LoadXML(loadFile);
// After loading we have to reacquire the weak pointer to the Character component, as it has been recreated
// Simply find the character's scene node by name as there's only one of them
Node* characterNode = scene_->GetChild("Jack", true);
if (characterNode)
character_ = characterNode->GetComponent<Character>();
}
}
}
}
void UI::HandleKey(bool keydown, int keycode, int scancode)
{
if (keydown && (keycode == KEY_ESCAPE || keycode == KEY_RETURN || keycode == KEY_RETURN2 || keycode == KEY_KP_ENTER)
&& TBWidget::focused_widget)
{
SendEvent(E_UIWIDGETFOCUSESCAPED);
}
#ifdef ATOMIC_PLATFORM_WINDOWS
if (keycode == KEY_LCTRL || keycode == KEY_RCTRL)
return;
#else
if (keycode == KEY_LGUI || keycode == KEY_RGUI)
return;
#endif
Input* input = GetSubsystem<Input>();
int qualifiers = input->GetQualifiers();
#ifdef ATOMIC_PLATFORM_WINDOWS
bool superdown = input->GetKeyDown(KEY_LCTRL) || input->GetKeyDown(KEY_RCTRL);
#else
bool superdown = input->GetKeyDown(KEY_LGUI) || input->GetKeyDown(KEY_RGUI);
#endif
MODIFIER_KEYS mod = GetModifierKeys(qualifiers, superdown);
SPECIAL_KEY specialKey = TB_KEY_UNDEFINED;
switch (keycode)
{
case KEY_RETURN:
case KEY_RETURN2:
case KEY_KP_ENTER:
specialKey = TB_KEY_ENTER;
break;
case KEY_F1:
specialKey = TB_KEY_F1;
break;
case KEY_F2:
specialKey = TB_KEY_F2;
break;
case KEY_F3:
specialKey = TB_KEY_F3;
break;
case KEY_F4:
specialKey = TB_KEY_F4;
break;
case KEY_F5:
specialKey = TB_KEY_F5;
break;
case KEY_F6:
specialKey = TB_KEY_F6;
break;
case KEY_F7:
specialKey = TB_KEY_F7;
break;
case KEY_F8:
specialKey = TB_KEY_F8;
break;
case KEY_F9:
specialKey = TB_KEY_F9;
break;
case KEY_F10:
specialKey = TB_KEY_F10;
break;
case KEY_F11:
specialKey = TB_KEY_F11;
break;
case KEY_F12:
specialKey = TB_KEY_F12;
break;
case KEY_LEFT:
specialKey = TB_KEY_LEFT;
break;
case KEY_UP:
specialKey = TB_KEY_UP;
break;
case KEY_RIGHT:
specialKey = TB_KEY_RIGHT;
break;
case KEY_DOWN:
specialKey = TB_KEY_DOWN;
break;
case KEY_PAGEUP:
specialKey = TB_KEY_PAGE_UP;
break;
case KEY_PAGEDOWN:
specialKey = TB_KEY_PAGE_DOWN;
break;
case KEY_HOME:
specialKey = TB_KEY_HOME;
break;
case KEY_END:
specialKey = TB_KEY_END;
break;
case KEY_INSERT:
specialKey = TB_KEY_INSERT;
break;
case KEY_TAB:
specialKey = TB_KEY_TAB;
break;
case KEY_DELETE:
specialKey = TB_KEY_DELETE;
break;
case KEY_BACKSPACE:
specialKey = TB_KEY_BACKSPACE;
break;
case KEY_ESCAPE:
specialKey = TB_KEY_ESC;
break;
}
if (specialKey == TB_KEY_UNDEFINED)
{
if (mod & TB_SUPER)
{
InvokeKey(this, rootWidget_, keycode, TB_KEY_UNDEFINED, mod, keydown);
}
}
else
{
InvokeKey(this, rootWidget_, 0, specialKey, mod, keydown);
}
}
void SceneReplication::HandlePhysicsPreStep(StringHash eventType, VariantMap& eventData)
{
// This function is different on the client and server. The client collects controls (WASD controls + yaw angle)
// and sets them to its server connection object, so that they will be sent to the server automatically at a
// fixed rate, by default 30 FPS. The server will actually apply the controls (authoritative simulation.)
Network* network = GetSubsystem<Network>();
Connection* serverConnection = network->GetServerConnection();
// Client: collect controls
if (serverConnection)
{
UI* ui = GetSubsystem<UI>();
Input* input = GetSubsystem<Input>();
Controls controls;
// Copy mouse yaw
controls.yaw_ = yaw_;
// Only apply WASD controls if there is no focused UI element
if (!ui->GetFocusElement())
{
controls.Set(CTRL_FORWARD, input->GetKeyDown('W'));
controls.Set(CTRL_BACK, input->GetKeyDown('S'));
controls.Set(CTRL_LEFT, input->GetKeyDown('A'));
controls.Set(CTRL_RIGHT, input->GetKeyDown('D'));
}
serverConnection->SetControls(controls);
// In case the server wants to do position-based interest management using the NetworkPriority components, we should also
// tell it our observer (camera) position. In this sample it is not in use, but eg. the NinjaSnowWar game uses it
serverConnection->SetPosition(cameraNode_->GetPosition());
}
// Server: apply controls to client objects
else if (network->IsServerRunning())
{
const Vector<SharedPtr<Connection> >& connections = network->GetClientConnections();
for (unsigned i = 0; i < connections.Size(); ++i)
{
Connection* connection = connections[i];
// Get the object this connection is controlling
Node* ballNode = serverObjects_[connection];
if (!ballNode)
continue;
RigidBody* body = ballNode->GetComponent<RigidBody>();
// Get the last controls sent by the client
const Controls& controls = connection->GetControls();
// Torque is relative to the forward vector
Quaternion rotation(0.0f, controls.yaw_, 0.0f);
const float MOVE_TORQUE = 3.0f;
// Movement torque is applied before each simulation step, which happen at 60 FPS. This makes the simulation
// independent from rendering framerate. We could also apply forces (which would enable in-air control),
// but want to emphasize that it's a ball which should only control its motion by rolling along the ground
if (controls.buttons_ & CTRL_FORWARD)
body->ApplyTorque(rotation * Vector3::RIGHT * MOVE_TORQUE);
if (controls.buttons_ & CTRL_BACK)
body->ApplyTorque(rotation * Vector3::LEFT * MOVE_TORQUE);
if (controls.buttons_ & CTRL_LEFT)
body->ApplyTorque(rotation * Vector3::FORWARD * MOVE_TORQUE);
if (controls.buttons_ & CTRL_RIGHT)
body->ApplyTorque(rotation * Vector3::BACK * MOVE_TORQUE);
}
}
}
void Player::HandleSceneUpdate(StringHash eventType, VariantMap &eventData)
{
//Take the frame time step, which is stored as a double
float timeStep = eventData[Update::P_TIMESTEP].GetFloat();
//Pulse and spin the counters' apples and hearts
UpdateGUI(timeStep);
//Only handle input when player is active
if (!rootNode_->IsEnabled()) return;
Input* input = GetSubsystem<Input>();
//Movement values
Vector3 move = Vector3::ZERO;
Vector3 moveJoy = Vector3::ZERO;
Vector3 moveKey = Vector3::ZERO;
float thrust = pilotMode_ ? 256.0f : 2323.0f;
float maxSpeed = pilotMode_? 1.8f : 23.0f; //Firing values
Vector3 fire = Vector3::ZERO;
Vector3 fireJoy = Vector3::ZERO;
Vector3 fireKey = Vector3::ZERO;
//Read input
if (input->GetJoystickByIndex(0)){
moveJoy = Vector3::RIGHT * input->GetJoystickByIndex(0)->GetAxisPosition(0) +
Vector3::BACK * input->GetJoystickByIndex(0)->GetAxisPosition(1);
fireJoy = Vector3::RIGHT * input->GetJoystickByIndex(0)->GetAxisPosition(2) +
Vector3::BACK * input->GetJoystickByIndex(0)->GetAxisPosition(3);
}
moveKey = Vector3::LEFT * input->GetKeyDown(KEY_A) +
Vector3::RIGHT * input->GetKeyDown(KEY_D) +
Vector3::FORWARD * input->GetKeyDown(KEY_W) +
Vector3::BACK * input->GetKeyDown(KEY_S);
fireKey = Vector3::LEFT * (input->GetKeyDown(KEY_J) || input->GetKeyDown(KEY_KP_4)) +
Vector3::RIGHT * (input->GetKeyDown(KEY_L) || input->GetKeyDown(KEY_KP_6)) +
Vector3::FORWARD * (input->GetKeyDown(KEY_I) || input->GetKeyDown(KEY_KP_8)) +
Vector3::BACK * (input->GetKeyDown(KEY_K) || input->GetKeyDown(KEY_KP_2) || input->GetKeyDown(KEY_KP_5)) +
Quaternion(45.0f, Vector3::UP)*Vector3::LEFT * input->GetKeyDown(KEY_KP_7) +
Quaternion(45.0f, Vector3::UP)*Vector3::RIGHT * input->GetKeyDown(KEY_KP_3) +
Quaternion(45.0f, Vector3::UP)*Vector3::FORWARD * input->GetKeyDown(KEY_KP_9) +
Quaternion(45.0f, Vector3::UP)*Vector3::BACK * input->GetKeyDown(KEY_KP_1);
//Pick most significant input
moveJoy.Length() > moveKey.Length() ? move = moveJoy : move = moveKey;
fireJoy.Length() > fireKey.Length() ? fire = fireJoy : fire = fireKey;
//Restrict move vector length
if (move.Length() > 1.0f) move /= move.Length();
//Deadzone
else if (move.Length() < 0.1f) move *= 0.0f;
if (fire.Length() < 0.1f) fire *= 0.0f;
else fire.Normalize();
//When in pilot mode
if (pilotMode_){
//Apply movement
Vector3 force = move * thrust * timeStep;
if (rigidBody_->GetLinearVelocity().Length() < maxSpeed ||
(rigidBody_->GetLinearVelocity().Normalized() + force.Normalized()).Length() < 1.0f) {
rigidBody_->ApplyForce(force);
}
//Update rotation according to direction of the player's movement.
Vector3 velocity = rigidBody_->GetLinearVelocity();
Vector3 lookDirection = velocity + 2.0f*fire;
Quaternion rotation = rootNode_->GetWorldRotation();
Quaternion aimRotation = rotation;
aimRotation.FromLookRotation(lookDirection);
rootNode_->SetRotation(rotation.Slerp(aimRotation, 7.0f * timeStep * velocity.Length()));
//Update animation
if (velocity.Length() > 0.05f){
animCtrl_->PlayExclusive("Resources/Models/WalkRelax.ani", 0, true, 0.15f);
animCtrl_->SetSpeed("Resources/Models/WalkRelax.ani", velocity.Length()*2.3f);
animCtrl_->SetStartBone("Resources/Models/WalkRelax.ani", "MasterBone");
}
else {
animCtrl_->PlayExclusive("Resources/Models/IdleRelax.ani", 0, true, 0.15f);
animCtrl_->SetStartBone("Resources/Models/IdleRelax.ani", "MasterBone");
}
// When in ship mode
} else {
//Update shield
Quaternion randomRotation = Quaternion(Random(360.0f),Random(360.0f),Random(360.0f));
shieldNode_->SetRotation(shieldNode_->GetRotation().Slerp(randomRotation, Random(1.0f)));
Color shieldColor = shieldMaterial_->GetShaderParameter("MatDiffColor").GetColor();
Color newColor = Color(shieldColor.r_ * Random(0.6f, 0.9f),
shieldColor.g_ * Random(0.7f, 0.95f),
shieldColor.b_ * Random(0.8f, 0.9f));
shieldMaterial_->SetShaderParameter("MatDiffColor", shieldColor.Lerp(newColor, Min(timeStep * 23.5f, 1.0f)));
//Float
ship_.node_->SetPosition(Vector3::UP *masterControl_->Sine(2.3f, -0.1f, 0.1f));
//Apply movement
Vector3 force = move * thrust * timeStep;
if (rigidBody_->GetLinearVelocity().Length() < maxSpeed ||
(rigidBody_->GetLinearVelocity().Normalized() + force.Normalized()).Length() < 1.0f) {
rigidBody_->ApplyForce(force);
}
//Update rotation according to direction of the ship's movement.
if (rigidBody_->GetLinearVelocity().Length() > 0.1f)
rootNode_->LookAt(rootNode_->GetPosition()+rigidBody_->GetLinearVelocity());
//Shooting
sinceLastShot_ += timeStep;
if (fire.Length()) {
if (sinceLastShot_ > shotInterval_)
{
Shoot(fire);
}
}
}
}
void UI::HandleKey(bool keydown, int keycode, int scancode)
{
#ifdef ATOMIC_PLATFORM_WINDOWS
if (keycode == KEY_LCTRL || keycode == KEY_RCTRL)
return;
#else
if (keycode == KEY_LGUI || keycode == KEY_RGUI)
return;
#endif
Input* input = GetSubsystem<Input>();
int qualifiers = input->GetQualifiers();
#ifdef ATOMIC_PLATFORM_WINDOWS
bool superdown = input->GetKeyDown(KEY_LCTRL) || input->GetKeyDown(KEY_RCTRL);
#else
bool superdown = input->GetKeyDown(KEY_LGUI) || input->GetKeyDown(KEY_RGUI);
#endif
MODIFIER_KEYS mod = GetModifierKeys(qualifiers, superdown);
switch (keycode)
{
case KEY_RETURN:
case KEY_RETURN2:
case KEY_KP_ENTER:
InvokeKey(rootWidget_, 0, TB_KEY_ENTER, mod, keydown);
break;
case KEY_F1:
InvokeKey(rootWidget_, 0, TB_KEY_F1, mod, keydown);
break;
case KEY_F2:
InvokeKey(rootWidget_, 0, TB_KEY_F2, mod, keydown);
break;
case KEY_F3:
InvokeKey(rootWidget_, 0, TB_KEY_F3, mod, keydown);
break;
case KEY_F4:
InvokeKey(rootWidget_, 0, TB_KEY_F4, mod, keydown);
break;
case KEY_F5:
InvokeKey(rootWidget_, 0, TB_KEY_F5, mod, keydown);
break;
case KEY_F6:
InvokeKey(rootWidget_, 0, TB_KEY_F6, mod, keydown);
break;
case KEY_F7:
InvokeKey(rootWidget_, 0, TB_KEY_F7, mod, keydown);
break;
case KEY_F8:
InvokeKey(rootWidget_, 0, TB_KEY_F8, mod, keydown);
break;
case KEY_F9:
InvokeKey(rootWidget_, 0, TB_KEY_F9, mod, keydown);
break;
case KEY_F10:
InvokeKey(rootWidget_, 0, TB_KEY_F10, mod, keydown);
break;
case KEY_F11:
InvokeKey(rootWidget_, 0, TB_KEY_F11, mod, keydown);
break;
case KEY_F12:
InvokeKey(rootWidget_, 0, TB_KEY_F12, mod, keydown);
break;
case KEY_LEFT:
InvokeKey(rootWidget_, 0, TB_KEY_LEFT, mod, keydown);
break;
case KEY_UP:
InvokeKey(rootWidget_, 0, TB_KEY_UP, mod, keydown);
break;
case KEY_RIGHT:
InvokeKey(rootWidget_, 0, TB_KEY_RIGHT, mod, keydown);
break;
case KEY_DOWN:
InvokeKey(rootWidget_, 0, TB_KEY_DOWN, mod, keydown);
break;
case KEY_PAGEUP:
InvokeKey(rootWidget_, 0, TB_KEY_PAGE_UP, mod, keydown);
break;
case KEY_PAGEDOWN:
InvokeKey(rootWidget_, 0, TB_KEY_PAGE_DOWN, mod, keydown);
break;
case KEY_HOME:
InvokeKey(rootWidget_, 0, TB_KEY_HOME, mod, keydown);
break;
case KEY_END:
InvokeKey(rootWidget_, 0, TB_KEY_END, mod, keydown);
break;
case KEY_INSERT:
InvokeKey(rootWidget_, 0, TB_KEY_INSERT, mod, keydown);
break;
case KEY_TAB:
InvokeKey(rootWidget_, 0, TB_KEY_TAB, mod, keydown);
break;
case KEY_DELETE:
InvokeKey(rootWidget_, 0, TB_KEY_DELETE, mod, keydown);
break;
case KEY_BACKSPACE:
InvokeKey(rootWidget_, 0, TB_KEY_BACKSPACE, mod, keydown);
break;
case KEY_ESC:
InvokeKey(rootWidget_, 0, TB_KEY_ESC, mod, keydown);
break;
default:
if (mod & TB_SUPER)
{
InvokeKey(rootWidget_, keycode, TB_KEY_UNDEFINED, mod, keydown);
}
}
}
