Text Wrapping Complete

include/dawn/display/gui/font.h

@@ -27,21 +27,35 @@
 /** Refer to STBTT docs for OpenGL Fill Mode v d3d Fill Modes */
 #define FONT_FILL_MODE 1
 
+// Chars
 #define FONT_NEWLINE '\n'
 #define FONT_SPACE ' '
+
+// Heights
 #define FONT_LINE_HEIGHT FONT_TEXTURE_SIZE*0.75
 #define FONT_INITIAL_LINE FONT_LINE_HEIGHT*0.75
-#define FONT_SPACE_SIZE FONT_TEXTURE_SIZE*0.75
+#define FONT_SPACE_SIZE FONT_TEXTURE_SIZE*0.45
 #define FONT_SCALE_ADJUST 0.03
 
+/** Representation of a font that can be used to render text */
 typedef struct {
   texture_t texture;
   stbtt_bakedchar characterData[FONT_NUM_CHARS];
 } font_t;
 
 typedef struct {
+  /** How many raw chars are in the string */
   int32_t length;
+
+  /** How many rendered chars are in the string */
   int32_t realLength;
+
+  /** How many lines is the string? Trailing newlines will count */
+  int32_t lines;
+
+  /** Dimensions of the string */
   float width, height, scale;
+
+  /** Array of precalculated quads */
   stbtt_aligned_quad *quads;
 } fonttextinfo_t;

src/display/gui/font.c

@@ -61,8 +61,7 @@ fonttextinfo_t * fontGetTextInfo(font_t *font, char *text, float scale) {
   i = 0;
   while(c = text[i++]) {
     info->length++;
-    if(c == FONT_SPACE) continue;
+    if(c == FONT_SPACE || c == FONT_NEWLINE) continue;
-    if(c == FONT_NEWLINE) continue;
     info->realLength++;
   }
 
@@ -70,6 +69,7 @@ fonttextinfo_t * fontGetTextInfo(font_t *font, char *text, float scale) {
   info->quads = malloc(sizeof(stbtt_aligned_quad) * info->realLength);
   info->scale = scale * FONT_SCALE_ADJUST;
   info->width = 0, info->height = 0;
+  info->lines = 1;
 
   // Begin buffering quads.
   x = 0;
@@ -85,6 +85,7 @@ fonttextinfo_t * fontGetTextInfo(font_t *font, char *text, float scale) {
 
     // Newlines reset X
     if(c == FONT_NEWLINE) {
+      info->lines++;
       y += FONT_LINE_HEIGHT;
       x = 0;
       continue;
@@ -131,4 +132,99 @@ void fontTextInit(font_t *font, primitive_t *primitive, fonttextinfo_t *info) {
     QUAD_VERTICE_COUNT * info->realLength, QUAD_INDICE_COUNT * info->realLength
   );
   fontTextBuffer(font, primitive, info);
+}
+
+
+fonttextinfo_t * fontTextClamp(font_t *font, char *text, float scale,
+  float maxWidth
+) {
+  // This method is similar to fontGetTextInfo, but will modify the text.
+  int32_t i, j, wordIndex;
+  char c;
+  float x, y, wordX;
+  stbtt_aligned_quad *quad;
+  fonttextinfo_t *info = malloc(sizeof(fonttextinfo_t));
+
+  /** Which index in the original text var is the current word from */
+  int32_t wordStart = 0;
+
+  /** Buffer of the quads for the word (currently) */
+  int32_t bufferTextSize = 64;
+  info->quads = malloc(sizeof(stbtt_aligned_quad) * bufferTextSize);
+
+  // Setup Scales
+  info->length = 0;
+  info->realLength = 0;
+  info->scale = scale * FONT_SCALE_ADJUST;
+  info->lines = 1;
+  
+  // Unlike GetTextInfo we can actually calculate the quads at the same time
+  // that we determine the string length.
+  i = 0;
+  x = 0;
+  y = FONT_INITIAL_LINE;
+  wordX = 0;
+  while(c = text[i++]) {
+    info->length++;
+
+    // When space, start of new word about to begin
+    if(c == FONT_SPACE) {
+      x += FONT_SPACE_SIZE;
+      // Did this space cause a newline?
+      if(x > maxWidth) {
+        info->lines++;
+        wordStart = i+1;
+        y += FONT_LINE_HEIGHT;
+        x = 0;
+      }
+      wordX = x;
+      wordStart = i+1;
+      continue;
+    }
+
+    // New line.
+    if(c == FONT_NEWLINE) {
+      info->lines++;
+      wordStart = i+1;
+      y += FONT_LINE_HEIGHT;
+      x = 0;
+      continue;
+    }
+
+    // Actual letter. We need to start by resizing the buffer
+    if(info->realLength+1 >= bufferTextSize) {
+      info->quads = memBufferResize(info->quads,
+        bufferTextSize, bufferTextSize * 2, sizeof(stbtt_aligned_quad)
+      );
+      bufferTextSize *= 2;
+    }
+
+    // Generate the quad.
+    quad = info->quads + info->realLength;
+    stbtt_GetBakedQuad(font->characterData,
+      FONT_TEXTURE_WIDTH, FONT_TEXTURE_HEIGHT,
+      ((int32_t)c)-FONT_FIRST_CHAR, &x, &y, quad, FONT_FILL_MODE
+    );
+    quad->x0 *= info->scale, quad->x1 *= info->scale;
+    quad->y0 *= info->scale, quad->y1 *= info->scale;
+
+    // Now measure the width of the line (take the right side of that quad)
+    if(quad->x1 > maxWidth) {
+      // We've exceeded the edge, go back to the start of the word and newline.
+      info->lines++;
+      for(j = wordStart; j <= i; j++) {
+        quad = info->quads + j;
+        quad->x0 -= wordX, quad->x1 -= wordX;
+        quad->y0 += FONT_LINE_HEIGHT, quad->y1 += FONT_LINE_HEIGHT;
+        x = 0;
+        y += FONT_LINE_HEIGHT;
+      }
+    }
+
+    info->width = mathMax(info->width, quad->x1);
+    info->height = mathMax(info->height, quad->y1);
+    info->realLength++;
+  }
+
+  return info;
 }

src/display/gui/font.h

@@ -11,6 +11,7 @@
 #include "../texture.h"
 #include "../primitive.h"
 #include "../primitives/quad.h"
+#include "../../util/mem.h"
 
 /**
  * Initializes Font from raw TTF data.
@@ -60,4 +61,20 @@ void fontTextBuffer(font_t *font, primitive_t *primitive, fonttextinfo_t *info);
  * @param primitive Primitive to render into.
  * @param info Text Info to use while rendering.
  */
-void fontTextInit(font_t *font, primitive_t *primitive, fonttextinfo_t *info);
+void fontTextInit(font_t *font, primitive_t *primitive, fonttextinfo_t *info);
+
+
+
+
+/**
+ * Clamps text to a max width, inserting newlines where possible.
+ * 
+ * @param font Font to use
+ * @param text Text to clamp
+ * @param scale Scale of the text to render.
+ * @param maxWidth Max width (in pixels) to clamp the text to.
+ * @returns The calculated text information.
+ */
+fonttextinfo_t * fontTextClamp(font_t *font,char *text,float scale,
+  float maxWidth
+);

src/poker/render/frame.c

@@ -14,8 +14,8 @@ void pokerFrameInit(poker_t *poker, render_t *render) {
   frameBufferInit(&poker->frameGui, render->width, render->height);
 
   fonttextinfo_t *info;
-  char *text = "Hello\n World";
+  char *text = "Hello world how are you today? I'm doing fine myself.";
-  info = fontGetTextInfo(&poker->font, text, 16);
+  info = fontTextClamp(&poker->font, text, 16, 500);
   fontTextInit(&poker->font, &bruh, info);
 }
 

src/util/mem.c

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "mem.h"
+
+void * memBufferResize(void *oldBuffer, int32_t oldSize, int32_t newSize, 
+  size_t size
+) {
+  // Malloc a new buffer
+  void *newBuffer = malloc(size * newSize);
+
+  // Copy old data
+  memcpy(newBuffer, oldBuffer, size * oldSize);
+
+  // Clear old buffer
+  free(oldBuffer);
+
+  return newBuffer;
+}

src/util/mem.h

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+
+/**
+ * Resizes a buffer to hold new amounts of data. Essentially a 3 step process of
+ * - Malloc (new buffer)
+ * - Memcpy (from old buffer)
+ * - Free (old buffer)
+ * - Return (new buffer)
+ * 
+ * @param oldBuffer The old buffer.
+ * @param oldSize The current size of the old buffer.
+ * @param newSize Size of the new buffer.
+ * @param size Size of the elements within the buffer.
+ * @return The new buffer.
+ */
+void * memBufferResize(void *oldBuffer, int32_t oldSize, int32_t newSize,
+  size_t size
+);