void update(float elapsed)
{
if(isKeyDown(WK_1))
{
outlineDraw = outlineDraw == True ? False : True;
resetKey(WK_1);
}
if(isKeyDown(WK_2))
{
outlineSmooth = outlineSmooth == True ? False : True;
resetKey(WK_2);
}
if(isKeyDown(WK_UP))
{
outlineWidth++;
resetKey(WK_UP);
}
if(isKeyDown(WK_DOWN))
{
outlineWidth--;
resetKey(WK_DOWN);
}
if(isKeyDown(WK_SPACE))
{
modelRotate = modelRotate == True ? False : True;
resetKey(WK_SPACE);
}
if(True == modelRotate)
modelAngle += (elapsed * 25.0f);
}
void InputManager::updateCamera(Ogre::Real _timeElapsed){
if(mCameraNode){
mCameraNode->translate(mCamTrans * _timeElapsed, Ogre::Node::TS_LOCAL);
if(isKeyDown(OIS::KC_Q))
mCameraNode->roll(Ogre::Degree(ROTATE), Ogre::Node::TS_LOCAL);
if(isKeyDown(OIS::KC_E))
mCameraNode->roll(Ogre::Degree(-ROTATE), Ogre::Node::TS_LOCAL);
}
}
void HdrApp::keyIncControlDec(int key, float &val, float offset, float min, float max)
{
if (isKeyDown(key))
{
if (isKeyDown(SDLK_RCTRL) || isKeyDown(SDLK_LCTRL))
val = Math::clamp(val-offset, min, max);
else
val = Math::clamp(val+offset, min, max);
}
}
//Input
void Paddle::handleInput()
{
auto inputMgr = Lore::InputManager::instance();
m_speed = Lore::Vector2::Zero();
if(inputMgr->isKeyDown(SDL_SCANCODE_LEFT))
m_speed.x += -800;
if(inputMgr->isKeyDown(SDL_SCANCODE_RIGHT))
m_speed.x += +800;
}
CWVOID TessellationDemoScene::update(CWFLOAT dt)
{
if (isKeyDown(KeyCode::A)) {
cwRepertory::getInstance().getEngine()->getDefaultCamera()->strafe(-10 * dt);
}
else if (isKeyDown(KeyCode::D)) {
cwRepertory::getInstance().getEngine()->getDefaultCamera()->strafe(10 * dt);
}
if (isKeyDown(KeyCode::W)) {
cwRepertory::getInstance().getEngine()->getDefaultCamera()->walk(10 * dt);
}
else if (isKeyDown(KeyCode::S)) {
cwRepertory::getInstance().getEngine()->getDefaultCamera()->walk(-10 * dt);
}
}
void InputSystem::waitForKeyPress()
{
while(1)
{
for(int i = 0; i < 256; ++i)
{
if(isKeyDown((KeyboardKey)i))
{
return;
}
}
for(int i = 0; i < 4; ++i)
{
if(isMouseButtonDown((MouseButton)i))
{
return;
}
}
eagle.sleep(10);
eagle.updateEngine();
}
}
KeyModifierMask
CMSWindowsKeyState::pollActiveModifiers() const
{
KeyModifierMask state = 0;
// get non-toggle modifiers from our own shadow key state
for (size_t i = 0; i < sizeof(s_modifiers) / sizeof(s_modifiers[0]); ++i) {
KeyButton button = virtualKeyToButton(s_modifiers[i].m_vk);
if (button != 0 && isKeyDown(button)) {
state |= s_modifiers[i].m_mask;
}
}
// we can get toggle modifiers from the system
if ((GetKeyState(VK_CAPITAL) & 0x01) != 0) {
state |= KeyModifierCapsLock;
}
if ((GetKeyState(VK_NUMLOCK) & 0x01) != 0) {
state |= KeyModifierNumLock;
}
if ((GetKeyState(VK_SCROLL) & 0x01) != 0) {
state |= KeyModifierScrollLock;
}
return state;
}
bool InputManager::isKeyPressed(unsigned int keyID)
{
if (isKeyDown(keyID) && !wasKeyDown(keyID)){
return true;
}
return false;
}
bool Keyboard::isKeyDown(Key k) const
{
auto ptr = lock();
if(ptr)
return ptr->isKeyDown(k);
return false;
}
void Display::update()
{
m_hasResized = false;
SDL_GL_SwapWindow(m_window);
SDL_Event e;
while (SDL_PollEvent(&e)) {
switch (e.type){
case SDL_QUIT:
m_isClosing = true;
break;
case SDL_KEYDOWN: {
unsigned int keycode = SDL_GetScancodeFromKey(e.key.keysym.sym);
if (keycode >= 256)
std::cerr << "ERROR: Keycode '" << keycode << "' to high. Max is 256." << std::endl;
else{
m_keystate[keycode] = true;
if (keycode == SDL_GetScancodeFromKey(SDLK_p)){
SDL_SetWindowFullscreen(m_window, SDL_TRUE);
}
}
break; }
case SDL_KEYUP: {
unsigned int keycode = SDL_GetScancodeFromKey(e.key.keysym.sym);
if (keycode >= 256)
std::cerr << "ERROR: Keycode '" << keycode << "' to high. Max is 256." << std::endl;
else
m_keystate[keycode] = false;
break; }
case SDL_MOUSEMOTION:
m_mouse_x = e.motion.x;
m_mouse_y = e.motion.y;
break;
}
}
if (grabbed)
SDL_WarpMouseInWindow(m_window, m_width / 2, m_height / 2);
int oldw = m_width, oldh = m_height;
SDL_GetWindowSize(m_window, &m_width, &m_height);
if (isKeyDown(SDLK_F2))
{
grabbed = !grabbed;
if (grabbed)
{
SDL_ShowCursor(SDL_DISABLE);
}
else
{
SDL_ShowCursor(SDL_ENABLE);
}
}
if (oldw != m_width || oldh != m_height){
m_mouse_x = m_width / 2;
m_mouse_y = m_height / 2;
m_mouse_old_x = m_width / 2;
m_mouse_old_y = m_height / 2;
m_hasResized = true;
}
}
bool InputManager::isKeyPressed(unsigned int keyID) {
//Check if it was pressed current frame and not last frame
if ((isKeyDown(keyID)) && (wasKeyDown(keyID) == false)) {
return true;
}
return false;
}
bool InputManager::isKeyPressed(unsigned int keyID) {
// Check if it is pressed this frame, and wasn't pressed last frame
if (isKeyDown(keyID) == true && wasKeyDown(keyID) == false) {
return true;
}
return false;
}
bool KEYS::getKey(uint8_t *key) {
uint8_t tmpkey;
tmpkey = readKeypad();
*key = *key & 0x7F;
return(isKeyDown(tmpkey));
}
//-------------------------------------------------------------------------
bool DefaultInputSystem::isKeyDown(const KeyList& _keyList) const
{
for(size_t i = 0; i != _keyList.size(); ++i)
{
if(isKeyDown(_keyList[i]))
return true;
}
return false;
}
bool HdrApp::keyIncControlDecLoop(int key, int &val, int max)
{
bool change = false;
if (isKeyJustDown(key))
{
change = true;
if (isKeyDown(SDLK_RCTRL) || isKeyDown(SDLK_LCTRL))
{
if (--val < 0)
val = max-1;
}
else
{
if (++val >= max)
val = 0;
}
}
return change;
}
void MenuScreen::update(float dt, World* world)
{
if (isKeyDown(VK_DOWN) && m_KeyPressCooldown <= 0)
{
if (m_selected < m_menuItems - 1)
{
m_selected++;
}
else
{
m_selected = 0;
}
m_KeyPressCooldown = KEY_PRESS_COOLDOWN;
}
if (isKeyDown(VK_UP) && m_KeyPressCooldown <= 0)
{
if (m_selected > 0)
{
m_selected--;
}
else
{
m_selected = m_menuItems - 1;
}
m_KeyPressCooldown = KEY_PRESS_COOLDOWN;
}
if (isKeyDown(VK_RETURN) && m_KeyPressCooldown <= 0)
{
if(m_selected < 2)
{
m_nextScreen = ScreenType_Game;
WarriorWorld* ww = (WarriorWorld*)world;
ww->setPlayers(m_selected + 1);
}
m_KeyPressCooldown = KEY_PRESS_COOLDOWN;
}
if (m_KeyPressCooldown > 0)
{
m_KeyPressCooldown -= dt;
}
}
void update()
{
if(isKeyDown(WK_UP)) /* Is the UP ARROW key Being Pressed? */
{
scaleValue += 0.001f; /* Increase the scale value to zoom in */
resetKey(WK_UP);
}
if(isKeyDown(WK_DOWN)) /* Is the DOWN ARROW key Being Pressed? */
{
scaleValue -= 0.001f; /* Decrease the scale value to zoom out */
resetKey(WK_DOWN);
}
if(isKeyDown(WK_SPACE)) /* Is SPACE kes being pressed? */
{
bRender = !bRender; /* toggle wireframe/fill mode*/
resetKey(WK_SPACE);
}
}
int PlayerObject::update(long elapsedTime)
{
if (isKeyDown(IM_W)) walkForward();
if (isKeyDown(IM_S)) walkBackward();
if (isKeyDown(IM_A)) walkLeft();
if (isKeyDown(IM_D)) walkRight();
//if (isKeyPressed(IM_SPACE)) jump();
if (isKeyDown(IM_SPACE)) jump();
if (isKeyPressed(IM_M1)) primaryClick();
if (isKeyReleased(IM_M1)) primaryRelease();
if (isKeyDown(IM_M1)) primaryDown();
if (isKeyUp(IM_M1)) primaryUp();
if (isKeyPressed(IM_M2)) secondaryClick();
if (isKeyReleased(IM_M2)) secondaryRelease();
if (isKeyDown(IM_M2)) secondaryDown();
if (isKeyUp(IM_M2)) secondaryUp();
if (isKeyPressed(IM_1)) changeSpell(0);
if (isKeyPressed(IM_2)) changeSpell(1);
if (isKeyPressed(IM_3)) changeSpell(2);
if (isKeyPressed(IM_4)) changeSpell(3);
if (isKeyPressed(IM_5)) changeSpell(4);
if (getNetworkState() == NETWORK_STATE_OFFLINE) {
if (isMouseScrollUp())
{
PropObject * temp = new PropObject("sword.obj", "error.tga", "default.glsl",
camera->getPos() + camera->getLookAtVector(), camera->getLookAtVector(), camera->getUpVector(), "sword.prop");
//RagdollObject * temp = new RagdollObject(box, t, s, camera->getPos(), camera->getLookAtVector(), camera->getUpVector());
temp->setVelocity(camera->getLookAtVector()*10.0f);
temp->setRotation(camera->getLookAtVector(), camera->getUpVector());
}
if (isMouseScrollDown())
{
PropObject * temp = new PropObject("box.obj", "error.tga", "default.glsl",
camera->getPos() + camera->getLookAtVector(), camera->getLookAtVector(), camera->getUpVector(), "box1x1.prop");
//RagdollObject * temp = new RagdollObject(box, t, s, camera->getPos(), camera->getLookAtVector(), camera->getUpVector());
temp->setVelocity(camera->getLookAtVector()*10.0f);
temp->setRotation(camera->getLookAtVector(), camera->getUpVector());
}
}
POINT p = inputManager->getMouseMovement();
turn(p.x*0.05f, p.y*0.05f);
int ret = CharacterObject::update(elapsedTime);
//setDirection(camera->getLookAtVector());
camera->setPosition(btToGLM3(&getBTPosition()) + glm::vec3(0,1,0));
camera->setLookAtVector(getDirection());
//camera->update(elapsedTime);
return ret;
}
void Level::updateInput( float dt )
{
m_localPlayer->resetDirection();
m_localPlayer->setSpeed(0.0f);
if (isKeyDown(OIS::KC_SPACE))
m_localPlayer->jump();
OIS::KeyCode codes_for_dbg_ai[] =
{
OIS::KC_DOWN,
OIS::KC_UP,
OIS::KC_LEFT,
OIS::KC_RIGHT,
OIS::KC_SPACE,
OIS::KC_LSHIFT,
OIS::KC_RSHIFT,
OIS::KC_TAB,
OIS::KC_LCONTROL,
OIS::KC_RCONTROL
};
if (isKeyDown(OIS::KC_S) && isKeyDown(OIS::KC_LCONTROL))
serializeGameObjects("data/levels/serialized.json");
// temp plz
for (int i = 0; i < _countof(codes_for_dbg_ai); ++i)
{
if (isKeyDown(codes_for_dbg_ai[i]))
{
TGameObjectVec objects;
findObjectsOfType(objects, &ActorAI::Type);
for (size_t ai_idx = 0; ai_idx < objects.size(); ++ai_idx)
{
static_cast<ActorAI*>(objects[ai_idx])->onDbgKeyDown(codes_for_dbg_ai[i]);
}
}
}
}
void OBEngine::onMousePressed(int button)
{
if ( m_uiMode == UI_ADDINGPOINT ) return;
if ( isKeyDown(17) ) // ctrl
{
m_uiMode = UI_ADJUSTINGMARS;
}
else
{
m_uiMode = UI_ADJUSTINGPOINT;
}
}
//-------------------------------------------------------------------------
bool DefaultInputSystem::isKeyDown(const KeyComb& _keyComb) const
{
for(size_t m = 0; m != _keyComb.getNumMouseButtons(); ++m)
{
if(!isMouseDown(_keyComb.getMouseButton(m)))
return false;
}
for(size_t k = 0; k != _keyComb.getNumKeyCodes(); ++k)
{
if(!isKeyDown(_keyComb.getKeyCode(k)))
return false;
}
return true;
}
bool IntroState::frameStarted(const Ogre::FrameEvent& evt)
{
mInput->capture();
auto key = mInput->getKeyboard();
auto mouse = mInput->getMouse()->getMouseState();
if (key->isKeyDown(OIS::KC_SPACE))
{
mGuiRoot->destroy();
changeState(TestState::getState());
}
//if (key->isKeyDown(OIS::KC_ESCAPE))
// mExit = true;
return true;
}
void Renderer::mouseDragHandler(int x, int y, int button)
{
if(Gui->isFreeView()){
cameraManager.notifyMouseDragged(x,y, button);
}else{
for (Shape * selected : selectedShapes)
{
if (button != 2)
selected->AddTranslation(x, y, *(mouseWatcher->CurretVector()));
else
{
bool rotated = false;
if (isKeyDown('1'))
{
selected->AddRotation(*(mouseWatcher->CurretVector()), 0);
rotated = true;
}
if (isKeyDown('2'))
{
selected->AddRotation(*(mouseWatcher->CurretVector()), 1);
rotated = true;
}
if (isKeyDown('3'))
{
selected->AddRotation(*(mouseWatcher->CurretVector()), 2);
rotated = true;
}
if (!rotated)
{
selected->AddRotation(*(mouseWatcher->CurretVector()), 0);
}
}
}
}
}
void Renderer::mouseClickHandler(int x, int y, int button)
{
if (!isKeyDown(261))
clearSelectedShapes();
for (Shape* visible : *(this->sceneStructure->GetElements()) /*visibleShapes*/)
{
if (visible->IsPointWithinBounds(x, y))
{
addSelectedShape(visible);
visible->SetSelected(true);
break;
}
}
}
bool InputSystem::isKeyPressed(KeyboardKey key)
{
bool a = 0;
if(!m_oldKeys[key] && isKeyDown(key))
{
a = 1;
}
else
{
a = 0;
}
//m_oldKeys[k] = getKeyState(k);
return a;
}
void View::update() {
if(isKeyDown('G')) {
if(m_is_visible) {
if(m_cell_size == 3)
m_cell_size = 6;
else if(m_cell_size == 6)
m_cell_size = 9;
else {
m_cell_size = 1;
m_is_visible = false;
}
}
else {
m_cell_size = 3;
m_is_visible = true;
}
}
int height_change = getMouseWheelMove() +
(isKeyDownAuto(InputKey::pagedown)? -1 : 0) +
(isKeyDownAuto(InputKey::pageup)? 1 : 0);
if(height_change)
m_height = clamp(m_height + height_change, 0, (int)Grid::max_height);
{
int actions[TileGroup::Group::side_count] = {
InputKey::kp_1,
InputKey::kp_2,
InputKey::kp_3,
InputKey::kp_6,
InputKey::kp_9,
InputKey::kp_8,
InputKey::kp_7,
InputKey::kp_4
};
for(int n = 0; n < arraySize(actions); n++)
if(isKeyDownAuto(actions[n]))
m_view_pos += worldToScreen(TileGroup::Group::s_side_offsets[n] * m_cell_size);
}
if((isKeyPressed(InputKey::lctrl) && isMouseKeyPressed(0)) || isMouseKeyPressed(2))
m_view_pos -= getMouseMove();
IRect rect = worldToScreen(IBox(int3(0, 0, 0), asXZY(m_tile_map.dimensions(), 256)));
m_view_pos = clamp(m_view_pos, rect.min, rect.max - m_view_size);
}
void SSAODemo::update(float timeSinceLastUpdate)
{
auto input = engine->getInput();
if(input.isKeyPressed(KEY_R))
{
ssaoOn = !ssaoOn;
updateShaderParameters();
}
else if(input.isKeyPressed(KEY_T))
{
showSSAOTex = !showSSAOTex;
updateShaderParameters();
}
float moveDistance = timeSinceLastUpdate * 20.0f;
float moveRotation = timeSinceLastUpdate * 60.0f;
if(input.isKeyDown(KEY_LEFT))
camera->rotate(Quaternion(moveRotation, Vector3::UNIT_Y), FrameOfReference::World);
if(input.isKeyDown(KEY_RIGHT))
camera->rotate(Quaternion(-moveRotation, Vector3::UNIT_Y), FrameOfReference::World);
if(input.isKeyDown(KEY_UP))
camera->rotate(Quaternion(moveRotation, Vector3::UNIT_X), FrameOfReference::Local);
if(input.isKeyDown(KEY_DOWN))
camera->rotate(Quaternion(-moveRotation, Vector3::UNIT_X), FrameOfReference::Local);
if(input.isKeyDown(KEY_W))
camera->translate((Vector3(0.0f, 0.0f, -moveDistance)), FrameOfReference::Local);
if(input.isKeyDown(KEY_S))
camera->translate(Vector3(0.0f, 0.0f, moveDistance), FrameOfReference::Local);
if(input.isKeyDown(KEY_A))
camera->translate(Vector3(-moveDistance, 0.0f, 0.0f), FrameOfReference::Local);
if(input.isKeyDown(KEY_D))
camera->translate(Vector3(moveDistance, 0.0f, 0.0f), FrameOfReference::Local);
}
void Game::movePlayer( float forward, float right, float dt )
{
static float s_FreeCamSpeed = 12.f;
const mkVec3 forward_vec = m_playerCam->getForwardVec() * forward ;
const mkVec3 right_vec = m_playerCam->getRightVec() * right;
mkVec3 move_dir = (forward_vec + right_vec).normalisedCopy();
if (!m_freelook && m_level)
{
Player* player = m_level->getPlayer();
player->addDirection(move_dir);
player->setSpeed(isKeyDown(OIS::KC_LSHIFT) ? 1.f : 0.5f);
}
else
{
m_playerCam->move(move_dir * s_FreeCamSpeed * getRealTimeDelta() * 5.f);
}
}
void Renderer::mouseDownHandler(int x, int y, int button)
{
if(Gui->isFreeView()){
if (button == OF_MOUSE_BUTTON_4)
{
cameraManager.zoomIn();
}
else if (button == OF_MOUSE_BUTTON_5)
{
cameraManager.zoomOut();
}
else
{
cameraManager.notifyMousePressed(x, y, button);
}
}else{
bool clickedOnSelectedShape = false;
for (Shape* selected : selectedShapes)
{
if (selected->IsPointWithinBounds(x, y))
{
clickedOnSelectedShape = true;
break;
}
}
if (!clickedOnSelectedShape)
{
for (Shape* visible : visibleShapes)
{
if (visible->IsPointWithinBounds(x, y))
{
if (!isKeyDown(261))
clearSelectedShapes();
selectedShapes.push_back(visible);
visible->SetSelected(true);
break;
}
}
}
}
}
void SceneManager::act(float deltaTimeMs)
{
fps=1.0f/(deltaTimeMs/1000.0f);
//if(isKeyPressed(GLFW_KEY_F9))reload();
//if(isKeyPressed(GLFW_KEY_F10))script.compileAndReload(this);
if(isKeyPressed(GLFW_KEY_F1))useDebugCamera(!isUsingDebugCamera);
if(isUsingDebugCamera) {
if(isMouseButtonDown(MouseState::LEFT_BUTTON)) {
vec2 delta=getMousePositionDelta();
if(delta.x)debugCamera.setRotX(debugCamera.getRotX()-delta.x);
if(delta.y)debugCamera.setRotY(debugCamera.getRotY()+delta.y);
}
float speed=1;
if(isKeyDown(GLFW_KEY_LEFT_SHIFT))speed*=1.5;
debugCamera.Pos+=(getPositionMovementRotated(debugCamera.getRotX())*(deltaTimeMs/100.0f))*speed;
}
actorManager->update(deltaTimeMs);
systemManager->update(deltaTimeMs);
}
