Added UI Scaling support

src/dawn/display/RenderTarget.hpp

@@ -30,6 +30,14 @@ namespace Dawn {
        */
       virtual float_t getHeight() = 0;
 
+      /**
+       * Returns the scale (as in pixel density) of the render target. This is
+       * typically 1.0f, but on high DPI displays this may be 2.0f or higher.
+       * 
+       * @return The scale of the render target.
+       */
+      virtual float_t getScale() = 0;
+
       /**
        * Sets the clear color of the render target when the clear method for
        * the color buffer is requested.

src/dawn/scene/components/ui/UICanvas.cpp

@@ -32,8 +32,8 @@ void UICanvas::rebufferShaderParameters() {
     case UI_DRAW_TYPE_WORLD_CAMERA_RELATIVE:
       data.projection = glm::ortho(
         0.0f,
-        camera->getRenderTarget()->getWidth(),
+        camera->getRenderTarget()->getWidth() / this->getScale(),
-        camera->getRenderTarget()->getHeight(),
+        camera->getRenderTarget()->getHeight() / this->getScale(),
         0.0f
       );
       data.view = glm::mat4(1.0f);
@@ -46,6 +46,10 @@ void UICanvas::rebufferShaderParameters() {
   this->shaderBuffer.buffer(&data);
 }
 
+float_t UICanvas::getScale() {
+  return this->camera->getRenderTarget()->getScale();
+}
+
 float_t UICanvas::getWidth() {
   return w;
 }
@@ -78,13 +82,13 @@ void UICanvas::onStart() {
 
   useEffectWithTeardown([&]{
     if(camera == nullptr) return evtRenderResize = [&] {};
-    this->w = camera->getRenderTarget()->getWidth();
+    this->w = camera->getRenderTarget()->getWidth() / this->getScale();
-    this->h = camera->getRenderTarget()->getHeight();
+    this->h = camera->getRenderTarget()->getHeight() / this->getScale();
     this->rebufferShaderParameters();
 
     return evtRenderResize = useEvent([&](float_t w, float_t h){
-      this->w = w;
+      this->w = w / this->getScale();
-      this->h = h;
+      this->h = h / this->getScale();
       this->rebufferShaderParameters();
       
       auto comps = this->item->findChildren<UIComponent>();

src/dawn/scene/components/ui/UICanvas.hpp

@@ -96,6 +96,13 @@ namespace Dawn {
        */
       UICanvas(SceneItem *item);
 
+      /**
+       * Returns the scale of this canvas.
+       * 
+       * @return The scale of the canvas, where 1 is default scaling.
+       */
+      float_t getScale();
+
       float_t getWidth() override;
       float_t getHeight() override;
       float_t getContentWidth() override;

src/dawn/scene/components/ui/text/UILabel.cpp

@@ -130,8 +130,8 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
   quadCountTotal = 0;
   quadCount = -1;
   std::vector<struct UILabelText> realNewTexts;
-
   float_t maxWidth = this->width;
+  float_t canvasScale = this->getCanvas()->getScale();
 
   // Reset
   lines.clear();
@@ -141,7 +141,7 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
   // Determine font dimensions.
   auto itText = newTexts.begin();
   while(itText != newTexts.end()) {
-    position.y = mathMax<float_t>(position.y, itText->style.size/* this->lineHeight - THIS PART WOULD TAKE THE LINE HEIGHT INTO CONSIDERATION ON THE FIRST/INITIAL LINE */);
+    position.y = mathMax<float_t>(position.y, itText->style.size);
     ++itText;
   }
 
@@ -163,7 +163,7 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
     // Lock the font
     assertNotNull(text.style.font, "UILabel::rebufferQuads: Font cannot be null");
     realText.lockId = text.style.font->lock(TrueTypeFaceTextureStyle{
-      text.style.size,
+      (uint32_t)(text.style.size * canvasScale),// Scale for resolution.
       text.style.style
     });
     assertTrue(realText.lockId != -1, "UILabel::rebufferQuads: Failed to lock font");
@@ -259,13 +259,27 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
 
       // Get font data.
       auto charInfo = realText.texture->getCharacterData(ch);
+      
+      // Now we scale down the char info here. This is because we fetch the 
+      // texture of the font based on the canvas scale, but the sizes that we
+      // render out need to be shrunk to match the original sizes.
+      glm::vec2 charSize = glm::vec2(
+        charInfo.bitmapSize.x / canvasScale, charInfo.bitmapSize.y / canvasScale
+      );
+      glm::vec2 charAdvance = glm::vec2(
+        charInfo.advanceX / canvasScale, charInfo.advanceY / canvasScale
+      );
+      glm::vec2 charPos =  glm::vec2(
+        charInfo.bitmapPosition.x / canvasScale,
+        charInfo.bitmapPosition.y / canvasScale
+      );
 
       // Word wrapping
       if(
         ch != ' ' &&
         lastSpaceCharacter != -1 &&
-        maxWidth > charInfo.bitmapSize.x &&
+        maxWidth > charSize.x &&
-        (position.x + charInfo.advanceX) > maxWidth
+        (position.x + charAdvance.x) > maxWidth
       ) {
         // Basically this rewinds everything we've done to the last space char,
         // changes it to a newline, and then moves the position along.
@@ -284,7 +298,7 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
         continue;
       }
 
-      // Buffer coordinates
+      // Buffer coordinates, use original (non scaled) values.
       glm::vec4 uvs;
       uvs.x = 0.0f;
       uvs.y = charInfo.textureY / wh.y;
@@ -292,10 +306,10 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
       uvs.z = uvs.y + (charInfo.bitmapSize.y / wh.y);
       
       glm::vec4 vert;
-      vert.x = position.x + charInfo.bitmapPosition.x;
+      vert.x = position.x + charPos.x;
-      vert.y = position.y + charInfo.bitmapPosition.y;
+      vert.y = position.y + charPos.y;
-      vert.w = vert.x + charInfo.bitmapSize.x;
+      vert.w = vert.x + charSize.x;
-      vert.z = vert.y + charInfo.bitmapSize.y;
+      vert.z = vert.y + charSize.y;
       vertices.push_back(std::make_pair(vert, uvs));
 
       // Decorations
@@ -318,16 +332,16 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
       }
 
       // Move the current position along.
-      position.x += charInfo.advanceX;
+      position.x += charAdvance.x;
-      position.y += charInfo.advanceY;
+      position.y += charAdvance.y;
 
       // Update the continuous dimensions
       if(ch == ' ') {
         lineWidth += wordWidth;
-        lineWidth += charInfo.advanceX;
+        lineWidth += charAdvance.x;
         wordWidth = 0.0f;
       } else {
-        wordWidth += charInfo.advanceX;
+        wordWidth += charAdvance.x;
       }
 
       // Set the part index to the quad mappings

src/dawndefs/CMakeLists.txt

@@ -8,4 +8,5 @@ if(DAWN_TARGET_WIN32 AND DAWN_TARGET_GLFW)
 endif()
 
 if(DAWN_TARGET_OSX AND DAWN_TARGET_GLFW)
+  add_subdirectory(opengl-osx)
 endif()

src/dawnglfw/host/DawnGLFWHost.cpp

@@ -57,10 +57,17 @@ int32_t DawnHost::init(DawnGame *game) {
 
   // Override the defaults
   int32_t fbWidth, fbHeight;
+  int32_t windowWidth, windowHeight;
   glfwGetFramebufferSize(this->data->window, &fbWidth, &fbHeight);
+  glfwGetWindowSize(this->data->window, &windowWidth, &windowHeight);
+  
   assertTrue(fbWidth > 0, "Detected framebuffer width is too small?");
   assertTrue(fbWidth > 0, "Detected framebuffer height is too small?");
+  assertTrue(windowWidth > 0, "Detected window width is too small?");
+  assertTrue(windowHeight > 0, "Detected window height is too small?");
   game->renderManager.backBuffer.setSize(fbWidth, fbHeight);
+  game->renderManager.backBuffer.scale = ((float_t)fbWidth) / ((float_t)windowWidth);
+  assertTrue(game->renderManager.backBuffer.scale > 0, "Back buffer scale is invalid");
   assertNoGLError();
 
   // Default keybinds
@@ -166,9 +173,18 @@ void glfwOnError(int error, const char* description) {
 
 void glfwOnResize(GLFWwindow *window, int32_t w, int32_t h) {
   if(DAWN_HOST == nullptr) return;
+  assertTrue(window == DAWN_HOST->data->window, "glfwOnResize: Window mismatch");
+
+  auto backBuffer = ((BackBufferRenderTarget*)&DAWN_HOST->game->renderManager.backBuffer);
+  assertNotNull(backBuffer, "glfwOnResize: Back buffer is not valid");
+
+  int32_t windowWidth, windowHeight;
+  glfwGetWindowSize(window, &windowWidth, &windowHeight);
 
   // TODO: I may throttle this, it calls for every frame the window's resized.
-  DAWN_HOST->game->renderManager.backBuffer.setSize((float_t)w, (float_t)h);
+  backBuffer->setSize((float_t)w, (float_t)h);
+  backBuffer->scale = ((float_t)w) / ((float_t)windowWidth);
+  assertTrue(backBuffer->scale > 0, "glfwOnResize: Back buffer scale is invalid");
 }
 
 void glfwOnKey(

src/dawnopengl/display/BackBufferRenderTarget.cpp

@@ -12,6 +12,10 @@ BackBufferRenderTarget::BackBufferRenderTarget(RenderManager &renderManager) :
 {
 }
 
+float_t BackBufferRenderTarget::getScale() {
+  return this->scale;
+}
+
 float_t BackBufferRenderTarget::getWidth() {
   return this->width;
 }

src/dawnopengl/display/BackBufferRenderTarget.hpp

@@ -19,6 +19,8 @@ namespace Dawn {
       struct Color clearColor = COLOR_CORNFLOWER_BLUE;
 
     public:
+      float_t scale = 1.0f;
+
       /**
        * Construct the back buffer render target.
        * 
@@ -38,6 +40,7 @@ namespace Dawn {
        */
       void setSize(float_t width, float_t height);
 
+      float_t getScale() override;
       float_t getWidth() override;
       float_t getHeight() override;
       void setClearColor(struct Color color) override;

src/dawnopengl/display/TextureRenderTarget.cpp

@@ -64,6 +64,10 @@ void TextureRenderTarget::setSize(float_t width, float_t height) {
   }
 }
 
+float_t TextureRenderTarget::getScale() {
+  return 1.0f;
+}
+
 float_t TextureRenderTarget::getWidth() {
   return (float_t)this->texture.getWidth();
 }

src/dawnopengl/display/TextureRenderTarget.hpp

@@ -26,6 +26,7 @@ namespace Dawn {
       
       void setSize(float_t width, float_t height);
 
+      float_t getScale() override;
       float_t getWidth() override;
       float_t getHeight() override;
       void setClearColor(struct Color color) override;