Button hudget

src/display/rendering/starfield.h

@@ -19,7 +19,6 @@ namespace glow {
     class Buffer;
 };
 
-
 /**
  * Renders a starfield around the camera.
  * Old camera positions/orientations are stored in order to stretch the

src/gamestate/gameplay/gameplay.cpp

@@ -29,6 +29,7 @@
 #include "camera/camerahead.h"
 #include "camera/cameradolly.h"
 #include "ui/hud/hud.h"
+#include "ui/hud/buttonhudget.h"
 #include "display/viewer.h"
 
 #include "display/rendering/texturerenderer.h"
@@ -43,8 +44,10 @@ GamePlay::GamePlay(Game* game) :
     m_freecamInput(new GamePlayFreecamInput(*this)),
     m_freecamActive(false),
     m_scene(new GamePlayScene(*this)),
+    m_scenario(new ScriptedScenario(this, "")),
     m_soundManager(new SoundManager())
 {
+	World::instance()->player().hud().resetButton()->setCallback((std::function<void(ClickType clickType)>)std::bind(&GamePlay::resetButtonCallback, this, std::placeholders::_1));
     updateView();
     setInitialSubState(m_runningState);
 
@@ -140,6 +143,8 @@ void GamePlay::loadScenario(int i) {
     }
 
     m_scenario->load();
+    setResetCallback();
+
 }
 
 void GamePlay::update(float deltaSec) {
@@ -170,3 +175,17 @@ void GamePlay::updateView() {
     World::instance()->player().hud().setView(&m_game->viewer().view());
 }
 
+void GamePlay::resetButtonCallback(ClickType clickType){
+    TextureRenderer loadRenderer("data/textures/loading.dds");
+    loadRenderer.display("Loading Scenario...");
+
+    m_soundManager->stopAll();
+    m_scenario->clear();
+    updateView();
+    m_scenario->load();
+    setResetCallback();
+}
+
+void GamePlay::setResetCallback() {
+    World::instance()->player().hud().resetButton()->setCallback((std::function<void(ClickType clickType)>)std::bind(&GamePlay::resetButtonCallback, this, std::placeholders::_1));
+}

src/gamestate/gameplay/gameplay.h

@@ -3,6 +3,7 @@
 #include <memory>
 
 #include "gamestate/gamestate.h"
+#include "ui/clicktype.h"
 
 
 class BaseScenario;
@@ -64,5 +65,9 @@ class GamePlay: public GameState {
     std::unique_ptr<GamePlayFreecamInput> m_freecamInput;
 
     bool m_freecamActive;
+
+	void resetButtonCallback(ClickType clickType);
+
+    void setResetCallback();
 };
 

src/gamestate/gameplay/input/gameplaynormalinput.cpp

@@ -1,8 +1,5 @@
 #include "gameplaynormalinput.h"
 
-#ifdef WIN32
-#include <windows.h>
-#endif
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 
@@ -103,7 +100,8 @@ GamePlayNormalInput::GamePlayNormalInput(GamePlay& gamePlay) :
     m_lastfocus = glfwGetWindowAttrib(glfwGetCurrentContext(), GLFW_FOCUSED);
 
     retrieveInputValues();
-    m_currentTimePressed = 0;
+    m_currentTimePressedRight = 0;
+    m_currentTimePressedLeft = 0;
 }
 
 void GamePlayNormalInput::onResizeEvent(const unsigned int width, const unsigned int height) {
@@ -143,11 +141,16 @@ void GamePlayNormalInput::onKeyEvent(int key, int scancode, int action, int mods
 
 void GamePlayNormalInput::onMouseButtonEvent(int button, int action, int mods) {
     if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_RELEASE) {
-        if (m_currentTimePressed > 0 && m_currentTimePressed < m_maxClickTime) {
+        if (m_currentTimePressedRight > 0 && m_currentTimePressedRight < m_maxClickTime) {
             World::instance()->player().hud().onClick(ClickType::Selection);
-        } else {
         }
-        m_currentTimePressed = 0;
+        m_currentTimePressedRight = 0;
+    }
+    if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_RELEASE) {
+        if (m_currentTimePressedLeft > 0 && m_currentTimePressedLeft < m_maxClickTime) {
+            World::instance()->player().hud().onClick(ClickType::Selection);
+        }
+        m_currentTimePressedLeft = 0;
     }
 }
 
@@ -239,11 +242,14 @@ void GamePlayNormalInput::processMouseUpdate(float deltaSec) {
         m_fireUpdate = true;
     }
 
-    if (glfwGetMouseButton(glfwGetCurrentContext(), GLFW_MOUSE_BUTTON_RIGHT) == GLFW_PRESS){
-        m_currentTimePressed += deltaSec;
+    if (glfwGetMouseButton(glfwGetCurrentContext(), GLFW_MOUSE_BUTTON_RIGHT) == GLFW_PRESS) {
+        m_currentTimePressedRight += deltaSec;
+    }
+    if (glfwGetMouseButton(glfwGetCurrentContext(), GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS) {
+        m_currentTimePressedLeft += deltaSec;
     }
 
-    if (m_mouseControl || glfwGetMouseButton(glfwGetCurrentContext(), GLFW_MOUSE_BUTTON_RIGHT) == GLFW_PRESS &&  m_maxClickTime < m_currentTimePressed) {
+    if (m_mouseControl || glfwGetMouseButton(glfwGetCurrentContext(), GLFW_MOUSE_BUTTON_RIGHT) == GLFW_PRESS &&  m_maxClickTime < m_currentTimePressedRight) {
         glm::vec3 rot;
         x = ContextProvider::instance()->resolution().width() / 2 - (int)floor(x);
         y = ContextProvider::instance()->resolution().height() / 2 - (int)floor(y);

src/gamestate/gameplay/input/gameplaynormalinput.h

@@ -57,7 +57,8 @@ class GamePlayNormalInput : public GamePlayInput {
     void addActionsToVector();
     void retrieveInputValues();
 
-    float m_currentTimePressed;
+    float m_currentTimePressedLeft;
+    float m_currentTimePressedRight;
 
     Property<float> m_deadzoneMouse;
     Property<float> m_deadzoneGamepad;

src/input/inputconfigurator.cpp

@@ -88,8 +88,10 @@ bool InputConfigurator::isConfiguring() {
 
 void InputConfigurator::startConfiguration(InputClass inputClass) {
     if (inputClass == InputClass::Primary) {
+        World::instance()->player().hud().showMissionInfo("", "Starting configuration for primary input device (keyboard), Please follow the instructions");
         glow::info("Starting configuration for primary input device (keyboard), Please follow the instructions");
     } else {
+        World::instance()->player().hud().showMissionInfo("", "Starting configuration for secondary input device (gamepad/Joystick), Please follow the instructions");
         glow::info("Starting configuration for secondary input device (gamepad/Joystick), Please follow the instructions");
         m_idleValues.resize(m_secondaryInputValues->axisCnt);
         for(int a = 0; a < m_secondaryInputValues->axisCnt; a++) {

src/player.cpp

@@ -7,9 +7,6 @@
 
 #include "factions/factionmatrix.h"
 
-#include "gamestate/game.h"
-#include "gamestate/gameplay/gameplay.h"
-
 #include "ui/hud/hud.h"
 #include "ui/hud/hudget.h"
 #include "ui/hud/aimhelperhudget.h"

src/scenarios/basescenario.h

@@ -7,8 +7,8 @@ class BaseScenario {
 public:
     BaseScenario(GamePlay* gamePlay);
 
-    void load();
-    void clear();
+    virtual void load();
+    virtual void clear();
     void reset();
 
 

src/scenarios/scriptedscenario.cpp

@@ -35,9 +35,9 @@
 
 ScriptedScenario::ScriptedScenario(GamePlay* gamePlay, const std::string& path):
     BaseScenario(gamePlay),
-    m_script(new GamePlayScript(World::instance()->scriptEngine()))
+    m_script(new GamePlayScript(World::instance()->scriptEngine())),
+    m_path(path)
 {
-    m_script->load(path);
 }
 
 ScriptedScenario::~ScriptedScenario() = default;
@@ -54,3 +54,13 @@ void ScriptedScenario::populateWorld() {
     m_world->scriptEngine().addScript(m_script);
 }
 
+void ScriptedScenario::load() {
+    m_script.reset(new GamePlayScript(World::instance()->scriptEngine()));
+    m_script->load(m_path);
+    BaseScenario::load();
+}
+
+void ScriptedScenario::clear() {
+    m_script.reset();
+    BaseScenario::clear();
+}

src/scenarios/scriptedscenario.h

@@ -17,10 +17,14 @@ class ScriptedScenario: public BaseScenario {
     ScriptedScenario(GamePlay* gamePlay, const std::string& path);
     virtual ~ScriptedScenario();
 
+    virtual void load() override;
+    virtual void clear() override;
 
 protected:
     std::shared_ptr<GamePlayScript> m_script;
 
     virtual void populateWorld() override;
+
+    std::string m_path;
 };
 

src/ui/clicktype.h

@@ -0,0 +1,7 @@
+#pragma once
+
+enum class ClickType {
+    None,
+    Selection,
+    Fire
+};

src/ui/hud/buttonhudget.cpp

@@ -0,0 +1,50 @@
+#include "buttonhudget.h"
+
+#include "hud.h"
+#include "buttonhudgetvoxels.h"
+
+ButtonHudget::ButtonHudget(HUD* hud, glm::vec3 direction, const std::function<void(ClickType clickType)>& callback, TextOrientation textOrientation, float scale, std::string content, FontSize fontSize, ButtonStyle buttonStyle) :
+    Hudget(hud),
+    m_buttonVoxels(new ButtonHudgetVoxels(this, direction, textOrientation, scale, content, fontSize, buttonStyle)),
+    m_callback(callback)
+{
+    m_buttonVoxels->updateBounds();
+}
+
+ButtonHudget::~ButtonHudget() = default;
+
+void ButtonHudget::update(float deltaSec) {
+}
+
+void ButtonHudget::draw() {
+    m_buttonVoxels->draw();
+}
+
+bool ButtonHudget::isAt(const Ray& ray) const {
+    return m_buttonVoxels->isAt(ray);
+}
+
+void ButtonHudget::onClick(ClickType clickType) {
+    assert(m_callback);
+    m_callback(clickType);
+}
+
+void ButtonHudget::setCallback(const std::function<void(ClickType clickType)>& callback) {
+    m_callback = callback;
+}
+
+void ButtonHudget::setText(const std::string& content) {
+    m_buttonVoxels->setText(content);
+}
+
+void ButtonHudget::setTextOrientation(TextOrientation textOrientation) {
+    m_buttonVoxels->setTextOrientation(textOrientation);
+}
+
+ButtonStyle ButtonHudget::buttonStyle() {
+    return m_buttonVoxels->buttonStyle();
+}
+
+void ButtonHudget::setButtonStyle(ButtonStyle buttonStyle) {
+    m_buttonVoxels->setButtonStyle(buttonStyle);
+}

src/ui/hud/buttonhudget.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <functional>
+
+#include "hudget.h"
+#include "ui/voxelfontconstants.h"
+
+
+class ButtonHudgetVoxels;
+class TextFieldHudgetVoxels;
+
+class ButtonHudget : public Hudget {
+public:
+    ButtonHudget(HUD* hud, glm::vec3 direction, const std::function<void(ClickType clickType)>& callback, TextOrientation textOrientation = TextOrientation::BACKWARDS, float scale = 0.5f, std::string content = "", FontSize fontSize = FontSize::SIZE5x7, ButtonStyle borderStyle = ButtonStyle::BORDERED);
+    virtual ~ButtonHudget();
+
+    virtual void update(float deltaSec) override;
+    virtual void draw() override;
+
+    virtual bool isAt(const Ray& ray) const override;
+
+    virtual void onClick(ClickType clicktype) override;
+
+    virtual void setText(const std::string& content);
+
+    void setCallback(const std::function<void(ClickType clickType)>& callback);
+
+    void setTextOrientation(TextOrientation textOrientation);
+
+    ButtonStyle buttonStyle();
+    void setButtonStyle(ButtonStyle buttonStyle);
+
+protected:
+    std::function<void(ClickType clickType)> m_callback;
+    std::string m_content;
+    std::unique_ptr<ButtonHudgetVoxels> m_buttonVoxels;
+};
+

src/ui/hud/buttonhudgetvoxels.cpp

@@ -0,0 +1,72 @@
+#include "buttonhudgetvoxels.h"
+
+#include "buttonhudget.h"
+#include "voxel/voxelcluster.h"
+#include "voxel/voxel.h"
+#include "voxel/voxelrenderer.h"
+#include "hud.h"
+
+
+ButtonHudgetVoxels::ButtonHudgetVoxels(ButtonHudget* buttonHudget, glm::vec3 direction, TextOrientation textOrientation, float scale, std::string content, FontSize fontSize, ButtonStyle buttonStyle) :
+TextFieldHudgetVoxels(buttonHudget, direction, textOrientation, scale, content, fontSize),
+    m_buttonVoxels(new VoxelCluster(scale)),
+    m_buttonStyle(buttonStyle),
+    m_hudget(buttonHudget)
+{
+    setText(content);
+}
+
+ButtonHudgetVoxels::~ButtonHudgetVoxels() = default;
+
+void ButtonHudgetVoxels::updateBounds() {
+    if (m_buttonStyle == ButtonStyle::PLAIN) {
+        return;
+    }
+    m_buttonVoxels.reset(new VoxelCluster(m_scale));
+    int width = (int)(m_width/m_scale)*m_text.size()+1;
+    int height = (int)(m_height/m_scale)*2;
+    for (int i = 0; i < width; i++) {
+        for (int j = 0; j < height; j++) {
+            if (i == 0 || j == 0 || i == width - 1 || j == height - 1) {
+                m_buttonVoxels->addVoxel(new Voxel(glm::ivec3(i, j, 0), 0x0FF00F));
+            } else if (m_buttonStyle == ButtonStyle::BORDERED_FILLED) {
+                m_buttonVoxels->addVoxel(new Voxel(glm::ivec3(i, j, 1), 0x17012D));
+            }
+        }
+    }
+}
+
+void ButtonHudgetVoxels::draw() {
+    if (m_buttonStyle == ButtonStyle::BORDERED || m_buttonStyle == ButtonStyle::BORDERED_FILLED) {
+        switch (textOrientation()) {
+        case TextOrientation::BACKWARDS:
+            m_buttonVoxels->transform().setPosition(lowerRight());
+            m_buttonVoxels->transform().setOrientation(m_hudget->hud()->orientation());
+            m_buttonVoxels->transform().rotate(glm::angleAxis(glm::pi<float>(), glm::vec3(0, 1, 0)));
+            break;
+        case TextOrientation::SPHERE_STRAIGHT:
+            m_buttonVoxels->transform().setPosition(lowerRight());
+            m_buttonVoxels->transform().setOrientation(m_hudget->worldOrientation(TextFieldHudgetVoxels::m_direction));
+            m_buttonVoxels->transform().rotate(glm::angleAxis(glm::pi<float>(), glm::vec3(0, 1, 0)));
+            break;
+        }
+        VoxelRenderer::instance()->draw(*m_buttonVoxels);
+    }
+    TextFieldHudgetVoxels::draw();
+}
+
+void ButtonHudgetVoxels::setText(const std::string& text) {
+    if (m_text.compare(text) == 0) {
+        return;
+    }
+    TextFieldHudgetVoxels::setText(text);
+    updateBounds();
+}
+
+ButtonStyle ButtonHudgetVoxels::buttonStyle() {
+    return m_buttonStyle;
+}
+
+void ButtonHudgetVoxels::setButtonStyle(ButtonStyle buttonStyle) {
+    m_buttonStyle = buttonStyle;
+}