First pass UI Alignment

src/dawn/component/ui/UICanvas.cpp

@@ -60,17 +60,13 @@ struct RenderPassContext &ctx
   nextBinding = 0;
 
   // Define the root alignment
-  struct UIAlign rootAlignment = {
-    glm::vec2(0, 0),
-    glm::vec2(1280, 720)
-  };
 
   // Get the quads for each component
   auto itComponents = components.begin();
   auto self = std::ref(*this);
   while(itComponents != components.end()) {
     auto component = *itComponents;
-    component->getQuads(rootAlignment, self);
+    component->getQuads(self);
     ++itComponents;
   }
 
@@ -136,4 +132,13 @@ void UICanvas::flushPass() {
   nextBinding = 0;
   textures.clear();
   textureBindings.clear();
+}
+
+void UICanvas::addComponent(std::shared_ptr<UIComponent> component) {
+  components.push_back(component);
+  component->updateAlignment(
+    glm::vec2(0, 0),
+    glm::vec2(1280, 720),
+    1.0f
+  );
 }

src/dawn/component/ui/UICanvas.hpp

@@ -18,6 +18,7 @@ namespace Dawn {
     private:
       std::shared_ptr<Mesh> mesh;
       UIShaderData data;
+      std::vector<std::shared_ptr<UIComponent>> components;
 
       size_t quadCount = 0;
       shadertexturebinding_t nextBinding = 0;
@@ -41,8 +42,6 @@ namespace Dawn {
       void flushPass();
 
     public:
-      std::vector<std::shared_ptr<UIComponent>> components;
-
       std::vector<std::shared_ptr<IRenderPass>> getPasses(
         struct RenderPassContext &ctx
       ) override;
@@ -63,5 +62,12 @@ namespace Dawn {
         const enum UIShaderQuadStyle style,
         const std::shared_ptr<Texture> texture = nullptr
       );
+
+      /**
+       * Adds a component to the canvas.
+       * 
+       * @param component The component to add.
+       */
+      void addComponent(std::shared_ptr<UIComponent> component);
   };
 }

src/dawn/display/font/TrueTypeTexture.hpp

@@ -14,9 +14,9 @@ namespace Dawn {
   class TrueTypeTexture final {
     private:
       FT_Face face;
-      uint32_t fontSize;
 
     public:
+      uint32_t fontSize;
       std::shared_ptr<Texture> texture;
       std::unordered_map<wchar_t, struct TrueTypeCharacter> characterData;
 

src/dawn/ui/UIComponent.cpp

@@ -4,29 +4,194 @@
 // https://opensource.org/licenses/MIT
 
 #include "UIComponent.hpp"
+#include "assert/assert.hpp"
 
 using namespace Dawn;
 
+UIComponent::UIComponent() {
+  alignUnit[0] = UIAlignmentUnit::SCALE;
+  alignUnit[1] = UIAlignmentUnit::SCALE;
+  alignUnit[2] = UIAlignmentUnit::SCALE;
+  alignUnit[3] = UIAlignmentUnit::SCALE;
+
+  eventAlignmentUpdated = [&](const glm::vec2 p, const glm::vec2 s) {
+  };
+}
+
+void UIComponent::updateAlignment(
+  const glm::vec2 pPos,
+  const glm::vec2 pSize,
+  const float_t canvasScale
+) {
+  auto valueAxis = [&](
+    const enum UIAlignmentUnit unit,
+    const float_t alignment,
+    const float_t parentSize,
+    const float_t ratioSize
+  ) {
+    switch(unit) {
+      case UIAlignmentUnit::PIXEL:
+        return alignment;
+
+      case UIAlignmentUnit::SCALE:
+        return canvasScale * alignment;
+
+      case UIAlignmentUnit::PERCENT:
+        return parentSize * (alignment / 100.0f);
+
+      case UIAlignmentUnit::RATIO:
+        return (alignment / 100.0f) * ratioSize;
+      
+      default:
+        assertUnreachable("Invalid UIAlignmentType");
+        return 0.0f;
+    }
+  };
+
+  auto alignAxis = [&](
+    const enum UIAlignmentType type,
+    const enum UIAlignmentUnit unit0,
+    const enum UIAlignmentUnit unit1,
+    const float_t alignment0,
+    const float_t alignment1,
+    const float_t parentSize,
+    const float_t ratioSize,
+    float_t &selfPosition,
+    float_t &selfSize
+  ) {
+    switch(type) {
+      case UIAlignmentType::START:
+        selfPosition = valueAxis(
+          unit0,
+          alignment0,
+          parentSize,
+          ratioSize
+        );
+        selfSize = valueAxis(
+          unit1,
+          alignment1,
+          parentSize,
+          ratioSize
+        );
+        break;
+
+      case UIAlignmentType::MIDDLE:
+        selfSize = valueAxis(
+          unit1,
+          alignment1,
+          parentSize,
+          ratioSize
+        );
+        selfPosition = (parentSize / 2.0f) - (selfSize / 2.0f) + valueAxis(
+          unit0,
+          alignment0,
+          parentSize,
+          ratioSize
+        );
+        break;
+
+      case UIAlignmentType::END:
+        selfSize = valueAxis(
+          unit0,
+          alignment0,
+          parentSize,
+          ratioSize
+        );
+        selfPosition = parentSize - selfSize - valueAxis(
+          unit1,
+          alignment1,
+          parentSize,
+          ratioSize
+        );
+        break;
+
+      case UIAlignmentType::STRETCH:
+        selfPosition = valueAxis(
+          unit0,
+          alignment0,
+          parentSize,
+          ratioSize
+        );
+        selfSize = parentSize - (selfPosition + valueAxis(
+          unit1,
+          alignment1,
+          parentSize,
+          ratioSize
+        ));
+        break;
+
+      default:
+        assertUnreachable("Invalid UIAlignmentType");
+    }
+  };
+
+  bool_t heightFirst = (
+    alignUnit[0] == UIAlignmentUnit::RATIO ||
+    alignUnit[2] == UIAlignmentUnit::RATIO
+  );
+
+  if(heightFirst) {
+    // Align height first, this will define size.y which we can use as the ratio
+    // for the width/X axis alignment.
+    alignAxis(
+      alignY,
+      alignUnit[1],
+      alignUnit[3],
+      align[1],
+      align[3],
+      pSize.y,
+      0,
+      position.y,
+      size.y
+    );
+    alignAxis(
+      alignX,
+      alignUnit[0],
+      alignUnit[2],
+      align[0],
+      align[2],
+      pSize.x,
+      size.y,
+      position.x,
+      size.x
+    );
+  } else {
+    alignAxis(
+      alignX,
+      alignUnit[0],
+      alignUnit[2],
+      align[0],
+      align[2],
+      pSize.x,
+      0,
+      position.x,
+      size.x
+    );
+    alignAxis(
+      alignY,
+      alignUnit[1],
+      alignUnit[3],
+      align[1],
+      align[3],
+      pSize.y,
+      size.x,
+      position.y,
+      size.y
+    );
+  }
+
+  this->eventAlignmentUpdated(position, size);
+}
+
 std::vector<std::shared_ptr<UIComponent>> UIComponent::getChildren() {
   return {};
 }
 
-void UIComponent::getQuads(
+void UIComponent::getQuads(UICanvas &ctx) {
-  const struct UIAlign alignment,
+  this->getSelfQuads(ctx);
-  UICanvas &ctx
-) {
-  auto selfAlignment = getSelfAlignment(alignment);
-  this->getSelfQuads(selfAlignment, ctx);
 
   auto children = getChildren();
   for(auto &c : children) {
-    c->getQuads(selfAlignment, ctx);
+    c->getQuads(ctx);
   }
-}
-
-struct UIAlign UIComponent::getSelfAlignment(const struct UIAlign alignment) {
-  return (struct UIAlign){
-    alignment.position + position,
-    alignment.size
-  };
 }

src/dawn/ui/UIComponent.hpp

@@ -8,13 +8,25 @@
 #include "component/ui/UICanvas.hpp"
 
 namespace Dawn {
-  struct UIAlign {
+  enum class UIAlignmentType {
-    glm::vec2 position;
+    START,
-    glm::vec2 size;
+    MIDDLE,
+    END,
+    STRETCH
+  };
+
+  enum class UIAlignmentUnit {
+    PIXEL,
+    SCALE,
+    PERCENT,
+    RATIO
   };
 
   class UIComponent {
     protected:
+      glm::vec2 position;
+      glm::vec2 size;
+
       /**
        * Virtual method overridden by the UIComponent to get the quads for the
        * component.
@@ -22,21 +34,34 @@ namespace Dawn {
        * @param alignment The alignment of this component.
        * @param ctx The canvas to add the quads to.
        */
-      virtual void getSelfQuads(
+      virtual void getSelfQuads(UICanvas &ctx) = 0;
-        const struct UIAlign alignment,
-        UICanvas &ctx
-      ) = 0;
 
       /**
-       * Allows a component to modify its self alignment.
+       * Updates the alignment of this component based on the parent.
        * 
-       * @param alignment Aliugnment to modify.
+       * @param parentPosition The position of the parent.
-       * @return New alignment for this component.
+       * @param parentSize The size of the parent.
        */
-      virtual struct UIAlign getSelfAlignment(const struct UIAlign alignment);
+      void updateAlignment(
+        const glm::vec2 parentPosition,
+        const glm::vec2 parentSize,
+        const float_t canvasScale
+      );
 
     public:
-      glm::vec2 position;
+      glm::vec4 align = glm::vec4(0, 0, 32, 32);
+      enum UIAlignmentType alignX = UIAlignmentType::START;
+      enum UIAlignmentType alignY = UIAlignmentType::START;
+      enum UIAlignmentUnit alignUnit[4];
+
+      std::function<
+        void(const glm::vec2, const glm::vec2)
+      > eventAlignmentUpdated;
+
+      /**
+       * Instantiates a new UIComponent.
+       */
+      UIComponent();
 
       /**
        * Virtual method overridden by the UIComponent to get the children of
@@ -47,12 +72,10 @@ namespace Dawn {
       /**
        * Method called by the UICanvas to get the quads for this component.
        * 
-       * @param alignment The alignment of this component.
        * @param ctx The canvas to add the quads to.
        */
-      void getQuads(
+      void getQuads(UICanvas &ctx);
-        const struct UIAlign alignment,
+
-        UICanvas &ctx
+      friend class UICanvas;
-      );
   };
 }

src/dawn/ui/UILabel.cpp

@@ -7,24 +7,67 @@
 
 using namespace Dawn;
 
-void UILabel::getSelfQuads(
+void UILabel::getSelfQuads(UICanvas &ctx) {
-  const struct UIAlign alignment,
-  UICanvas &ctx
-) {
   std::vector<struct UIShaderQuad> quads;
   if(this->texture == nullptr || this->text.empty()) return;
 
   glm::vec4 quad;
-  glm::vec2 pos = alignment.position;
+  glm::vec2 pos = glm::vec2(0, this->texture->fontSize);
+  bool_t lastCharWasSpace = false;
 
-  for(wchar_t c : text) {
+  for(size_t i = 0; i < text.size(); i++) {
+    wchar_t c = text[i];
     auto info = texture->getCharacterData(c);
+
+    // Newline(s)
+    if(c == L'\n') {
+      pos.x = 0;
+      pos.y += this->texture->fontSize;
+      continue;
+    }
+
+    // Spaces
+    if(c == L' ') {
+      pos.x += info.advance.x;
+      lastCharWasSpace = true;
+      continue;
+    }
+
+    // Word Wrap
+    if(wordWrap) {
+      if(lastCharWasSpace) {
+        // Scan ahead to next space
+        float_t wordWidth = pos.x;// Start at current position and scan ahead.
+        for(size_t j = i; j < text.size(); j++) {
+          wchar_t c2 = text[j];
+          if(c2 == L' ' || c2 == L'\n') {
+            break;// If we hit another space, we are OK.
+          }
+
+          // Will this character fit on the row? If not the whole word will wrap.
+          auto info2 = texture->getCharacterData(c);
+          wordWidth += info.advance.x;
+          if(wordWidth > size.x) {
+            pos.x = 0;
+            pos.y += this->texture->fontSize;
+            break;
+          }
+        }
+
+        lastCharWasSpace = false;
+      }
+    } else if(pos.x + info.size.x > position.x + size.x) {
+      // Not word wrap, but instead just overflow characters.
+      pos.x = 0;
+      pos.y += this->texture->fontSize;
+    }
+
     ctx.addQuad(
       {
-        pos.x + info.offset.x,
+        position.x + pos.x + info.offset.x,
-        pos.y + info.offset.y,
+        position.y + pos.y + info.offset.y,
-        pos.x + info.size.x + info.offset.x,
+        position.x + pos.x + info.size.x + info.offset.x,
-        pos.y + info.size.y + info.offset.y
+        position.y + pos.y + info.size.y + info.offset.y
       },
       {
         info.quad.x,

src/dawn/ui/UILabel.hpp

@@ -14,12 +14,11 @@ namespace Dawn {
       std::wstring text = L"Hello World";
 
     protected:
-      void getSelfQuads(
+      void getSelfQuads(UICanvas &ctx) override;
-        const struct UIAlign alignment,
-        UICanvas &ctx
-      ) override;
 
     public:
+      bool_t wordWrap = true;
+
       /**
        * Returns the font used for this label.
        * 

src/dawn/ui/UIRectangle.cpp

@@ -7,13 +7,10 @@
 
 using namespace Dawn;
 
-void UIRectangle::getSelfQuads(
+void UIRectangle::getSelfQuads(UICanvas &ctx) {
-  const struct UIAlign alignment,
-  UICanvas &ctx
-) {
   std::vector<struct UIShaderQuad> quads;
   ctx.addQuad(
-    glm::vec4(alignment.position, alignment.position + size),
+    glm::vec4(position, position + size),
     uv,
     color,
     UIShaderQuadStyle::TEXTURED,

src/dawn/ui/UIRectangle.hpp

@@ -9,15 +9,11 @@
 namespace Dawn {
   class UIRectangle final : public UIComponent {
     protected:
-      void getSelfQuads(
+      void getSelfQuads(UICanvas &ctx) override;
-        const struct UIAlign alignment,
-        UICanvas &ctx
-      ) override;
 
     public:
       struct Color color = COLOR_WHITE;
       std::shared_ptr<Texture> texture = nullptr;
-      glm::vec2 size = glm::vec2(32, 32);
       glm::vec4 uv = glm::vec4(0,0,1,1);
   };
 }

src/dawnglfw/display/RenderHost.cpp

@@ -98,7 +98,7 @@ void RenderHost::update(const std::shared_ptr<Game> game) {
   assertNoGLError();
   glDepthFunc(GL_LESS);
   assertNoGLError();
-  glEnable(GL_DEPTH_TEST);
+  // glEnable(GL_DEPTH_TEST);
   assertNoGLError();
   glEnable(GL_BLEND);
   assertNoGLError();

src/dawnhelloworld/scene/HelloWorldScene.cpp

@@ -56,14 +56,17 @@ void Dawn::helloWorldScene(Scene &s) {
   auto uiCanvas = uiCanvasItem->addComponent<UICanvas>();
 
   auto rect = std::make_shared<UIRectangle>();
-  rect->position = { 32, 32 };
-  rect->size = { texture->texture->getWidth(), texture->texture->getHeight() };
   rect->color = COLOR_MAGENTA;
-  rect->texture = texture->texture;
+  rect->align = { 32, 32, 300, 250 };
-  uiCanvas->components.push_back(rect);
+  rect->alignX = UIAlignmentType::START;
+  rect->alignY = UIAlignmentType::START;
+  uiCanvas->addComponent(rect);
 
   auto label = std::make_shared<UILabel>();
+  label->setText(L"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.");
   label->setFont(texture);
-  label->position = { 32, 650 };
+  label->align = { 32, 32, 300, 250 };
-  uiCanvas->components.push_back(label);
+  label->alignX = UIAlignmentType::START;
+  label->alignY = UIAlignmentType::START;
+  uiCanvas->addComponent(label);
 }