Button hudget

src/ui/clicktype.h

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

src/ui/hud/buttonhudget.cpp

@@ -0,0 +1,38 @@
+#include "buttonhudget.h"
+
+#include "hud.h"
+#include "buttonhudgetvoxels.h"
+
+ButtonHudget::ButtonHudget(HUD* hud, glm::vec3 direction, std::function<void(ClickType clickType)> callback, float scale, std::string content, FontSize fontSize, bool bounds) :
+Hudget(hud),
+m_buttonVoxels(new ButtonHudgetVoxels(this, direction, scale, content, fontSize, bounds)),
+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::registerCallback(std::function<void(ClickType clickType)> callback) {
+    m_callback = callback;
+}
+
+void ButtonHudget::setContent(std::string content) {
+    m_buttonVoxels->setContent(content);
+}

src/ui/hud/buttonhudget.h

@@ -0,0 +1,34 @@
+#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, std::function<void(ClickType clickType)> callback, float scale = 0.5f, std::string content = "", FontSize fontSize = FontSize::SIZE5x7, bool bounds = true);
+    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 setContent(std::string content);
+
+    void registerCallback(std::function<void(ClickType clickType)> callback);
+
+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,51 @@
+#include "buttonhudgetvoxels.h"
+
+#include "buttonhudget.h"
+#include "voxel/voxelcluster.h"
+#include "voxel/voxel.h"
+#include "voxel/voxelrenderer.h"
+
+
+ButtonHudgetVoxels::ButtonHudgetVoxels(ButtonHudget* buttonHudget, glm::vec3 direction, float scale, std::string content, FontSize fontSize, bool bounds) :
+TextFieldHudgetVoxels(buttonHudget, direction, scale, content, fontSize),
+m_buttonVoxels(new VoxelCluster(scale)),
+m_bounds(bounds),
+m_hudget(buttonHudget)
+{
+    setContent(content);
+}
+
+ButtonHudgetVoxels::~ButtonHudgetVoxels() = default;
+
+void ButtonHudgetVoxels::updateBounds() {
+    m_buttonVoxels.reset(new VoxelCluster(m_scale));
+    int width = (int)(m_width/m_scale)*m_content.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 {
+                m_buttonVoxels->addVoxel(new Voxel(glm::ivec3(i, j, 1), 0x17012D));
+            }
+        }
+    }
+}
+
+void ButtonHudgetVoxels::draw() {
+    if (m_bounds) {
+        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)));
+        VoxelRenderer::instance()->draw(*m_buttonVoxels);
+    }
+    TextFieldHudgetVoxels::draw();
+}
+
+void ButtonHudgetVoxels::setContent(std::string content) {
+    if (m_content.compare(content) == 0) {
+        return;
+    }
+    TextFieldHudgetVoxels::setContent(content);
+    updateBounds();
+}

src/ui/hud/buttonhudgetvoxels.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "textfieldhudgetvoxels.h"
+
+class VoxelFont;
+class ButtonHudget;
+class VoxelCluster;
+
+class ButtonHudgetVoxels : public TextFieldHudgetVoxels {
+public:
+    ButtonHudgetVoxels(ButtonHudget* textFieldHudget, glm::vec3 direction, float scale = 0.5f, std::string content = "", FontSize fontSize = FontSize::SIZE5x7, bool bounds = true);
+    ~ButtonHudgetVoxels();
+
+    void setContent(std::string content);
+
+    void updateBounds();
+
+    virtual void draw() override;
+
+protected:
+    std::unique_ptr<VoxelCluster> m_buttonVoxels;
+    bool m_bounds;
+    Hudget* m_hudget;
+};
+

src/ui/hud/hud.cpp

@@ -2,6 +2,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <functional>
 
 #include <glm/glm.hpp>
 #include <glm/gtx/quaternion.hpp>
@@ -35,6 +36,7 @@
 #include "display/view.h"
 #include "camera/camerahead.h"
 #include "textfieldhudget.h"
+#include "buttonhudget.h"
 #include "physics/physics.h"
 
 
@@ -48,6 +50,7 @@ HUD::HUD(Player* player):
     m_scanner(new WorldTreeScanner()),
     m_targetName(new TextFieldHudget(this, glm::normalize(glm::vec3(0, -1.1f, -2)), 0.025f, "")),
     m_speedLabel(new TextFieldHudget(this, glm::normalize(glm::vec3(1.5f, -1.1f, -2)), 0.020f, "")),
+    m_menuButton(new ButtonHudget(this, glm::normalize(glm::vec3(-1.5f, 1.1f, -2)), (std::function<void(ClickType clickType)>)std::bind(&HUD::openMenu, this, std::placeholders::_1), 0.01f, "MENU")),
     m_target(nullptr),
     m_drawHud("vfx.drawhud")
 {
@@ -56,6 +59,7 @@ HUD::HUD(Player* player):
     m_hudgets.push_back(m_aimHelper.get());
     m_hudgets.push_back(m_targetName.get());
     m_hudgets.push_back(m_speedLabel.get());
+    m_hudgets.push_back(m_menuButton.get());
 }
 
 HUD::~HUD() = default;
@@ -241,6 +245,10 @@ float HUD::fovx() const {
     return m_fovx;
 }
 
+void HUD::openMenu(ClickType clicktype) {
+    glow::debug("Not yet implemented");
+}
+
 void HUD::setViewer(Viewer& viewer) {
     m_viewer = &viewer;
 }

src/ui/hud/hud.h

@@ -10,13 +10,9 @@
 
 #include "property/property.h"
 
-#include "utils/handle/handle.h"
-
-enum class ClickType {
-    None,
-    Selection
-};
+#include "ui/clicktype.h"
 
+#include "utils/handle/handle.h"
 
 class Player;
 class Hudget;
@@ -27,6 +23,7 @@ class Viewer;
 class WorldTreeScanner;
 class CrossHair;
 class TextFieldHudget;
+class ButtonHudget;
 
 class HUD {
 public:
@@ -84,11 +81,13 @@ class HUD {
     std::unique_ptr<WorldTreeScanner> m_scanner;
     std::unique_ptr<TextFieldHudget> m_speedLabel;
     std::unique_ptr<TextFieldHudget> m_targetName;
+    std::unique_ptr<ButtonHudget> m_menuButton;
 
     std::list<Hudget*> m_hudgets;
 
     std::map<WorldObject*, HUDObjectDelegate*> m_objectDelegates;
     void updateScanner(float deltaSec);
     void updateFov();
-};
 
+    void openMenu(ClickType clicktype);
+};

src/ui/hud/hudget.h

@@ -4,8 +4,8 @@
 #include <glm/gtx/quaternion.hpp>
 
 #include "geometry/ray.h"
+#include "ui/clicktype.h"
 
-enum class ClickType;
 class HUD;
 
 

src/ui/hud/textfieldhudgetvoxels.cpp

@@ -12,26 +12,28 @@
 
 #include "utils/geometryhelper.h"
 
-TextFieldHudgetVoxels::TextFieldHudgetVoxels(TextFieldHudget* textFieldHudget, glm::vec3 direction, float scale, std::string content, FontSize fontSize) :
-m_textFieldHudget(textFieldHudget),
+TextFieldHudgetVoxels::TextFieldHudgetVoxels(Hudget* textFieldHudget, glm::vec3 direction, float scale, std::string content, FontSize fontSize) :
+m_hudget(textFieldHudget),
 m_voxelFont(VoxelFont::instance()),
 m_content(content),
 m_direction(direction),
 m_scale(scale),
 m_fontSize(fontSize)
 {
     m_width = m_voxelFont->letterWidth(fontSize) * m_scale;
-    m_height = m_voxelFont->letterWidth(fontSize) * m_scale;
+    m_height = m_voxelFont->letterHeight(fontSize) * m_scale;
     m_offset = -1.f * ((m_content.length() - 1) / 2.0f) * m_width;
 }
 
+TextFieldHudgetVoxels::~TextFieldHudgetVoxels() = default;
+
 void TextFieldHudgetVoxels::setContent(std::string content) {
     m_content = content;
     m_offset = -1.f * ((m_content.length() - 1) / 2.0f) * m_width;
 }
 
 void TextFieldHudgetVoxels::draw() {
-    m_voxelFont->drawString(m_content, m_textFieldHudget->worldPosition(m_direction), m_textFieldHudget->worldOrientation(m_direction), m_fontSize, m_scale, FontAlign::CENTER);
+    m_voxelFont->drawString(m_content, worldPosition(), worldOrientation(), m_fontSize, m_scale, FontAlign::CENTER);
 }
 
 const glm::vec3 TextFieldHudgetVoxels::upperLeft() const {
@@ -67,9 +69,9 @@ float TextFieldHudgetVoxels::scale() {
 const glm::vec3 TextFieldHudgetVoxels::offsetToCenter(bool upper, bool left) const {
     float horizontalOffset, verticalOffset;
     if (left) {
-        horizontalOffset = (float)m_content.length();
-    } else {
         horizontalOffset = 0;
+    } else {
+        horizontalOffset = (float)m_content.length();
     }
     if (upper) {
         verticalOffset = m_height;
@@ -81,9 +83,9 @@ const glm::vec3 TextFieldHudgetVoxels::offsetToCenter(bool upper, bool left) con
 }
 
 glm::vec3 TextFieldHudgetVoxels::worldPosition() const {
-    return m_textFieldHudget->worldPosition(m_direction);
+    return m_hudget->worldPosition(m_direction);
 }
 
 glm::quat TextFieldHudgetVoxels::worldOrientation() const {
-    return m_textFieldHudget->worldOrientation(m_direction);
+    return m_hudget->worldOrientation(m_direction);
 }

src/ui/hud/textfieldhudgetvoxels.h

@@ -11,12 +11,13 @@ class VoxelFont;
 
 class TextFieldHudgetVoxels{
 public:
-    TextFieldHudgetVoxels(TextFieldHudget* textFieldHudget, glm::vec3 direction, float scale = 0.5f, std::string content = "", FontSize fontSize = FontSize::SIZE5x7);
+    TextFieldHudgetVoxels(Hudget* textFieldHudget, glm::vec3 direction, float scale = 0.5f, std::string content = "", FontSize fontSize = FontSize::SIZE5x7);
+    ~TextFieldHudgetVoxels();
 
-    void setContent(std::string content);
+    virtual void setContent(std::string content);
 
-    void update(float deltaSec);
-    void draw();
+
+    virtual void draw();
 
     virtual bool isAt(const Ray& ray) const;
 
@@ -25,16 +26,16 @@ class TextFieldHudgetVoxels{
     float scale();
 
 protected:
-    const glm::vec3 upperLeft() const;
-    const glm::vec3 lowerLeft() const;
-    const glm::vec3 upperRight() const;
-    const glm::vec3 lowerRight() const;
+    virtual const glm::vec3 upperLeft() const;
+    virtual const glm::vec3 lowerLeft() const;
+    virtual const glm::vec3 upperRight() const;
+    virtual const glm::vec3 lowerRight() const;
 
+    Hudget* m_hudget;
     glm::vec3 worldPosition()  const;
     glm::quat worldOrientation() const;
 
     FontSize m_fontSize;
-    TextFieldHudget* m_textFieldHudget;
     std::string m_content;
     VoxelFont* m_voxelFont;
     glm::vec3 m_direction;

src/ui/voxelfont.cpp

@@ -91,9 +91,9 @@ void VoxelFont::drawString(std::string text, glm::vec3 position, glm::quat orien
 int VoxelFont::letterWidth(FontSize size) {
     switch (size) {
         case FontSize::SIZE3x5:
-            return 3;
-        case FontSize::SIZE5x7:
             return 5;
+        case FontSize::SIZE5x7:
+            return 7;
         default:
             assert(false);
     }