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); } } }