Still working on my scrolling text and bug fixing.

IDEA.md

@@ -1,2 +1,2 @@
-- Make font measure take in a pointer to a primitive to offer auto buffering of verts
+- Adjust timeline script to have the timeline and the timeline actions disconnected
-- Make a clone of the string into font measure pointing only to real chars?
+- Make the method take in the array of actions and length so that the funtion can be provided any actions needed

include/dawn/dawn.h

@@ -55,4 +55,9 @@
 #include "util/array.h"
 #include "util/list.h"
 #include "util/math.h"
-#include "util/rand.h"
+#include "util/rand.h"
+
+// Visual Novel Objects
+#include "vn/conversation.h"
+
+#include "vn/gui/vntextbox.h"

include/dawn/display/animation/timeline.h

@@ -8,15 +8,24 @@
 #pragma once
 #include "../../libs.h"
 
-#define TIMELINE_ACTION_COUNT_MAX 128
+/** Maximum number of actions a timeline can support, smaller than 0xFF */
+#define TIMELINE_ACTION_COUNT_MAX 32
 
-/** Type forwarder for timeline_t */
+/** Type forwarders */
 typedef struct _timeline_t timeline_t;
+typedef struct _timelineaction_t timelineaction_t;
 
-/** Callback for when a timeline event occurs */
+/**
-typedef void timelinecallback_t(timeline_t*);
+ * Callback for when a timeline event occurs
+ * @param timeline The timeline that fired this callback.
+ * @param action The action that this callback is attached to.
+ * @param i The index that this action is within the timeline.
+ */
+typedef void timelinecallback_t(timeline_t *timeline, timelineaction_t *action,
+  uint8_t i
+);
 
-typedef struct test_t {
+typedef struct _timelineaction_t {
   /**
    * The time that this action should occur within the timeline
    * set to 0 or less to start immediately.
@@ -33,6 +42,13 @@ typedef struct test_t {
    */
   float duration;
 
+  /**
+   * Enables animation looping. This works by forcing start to be equal to the
+   * current time at the point in time that onEnd is called. This will also stop
+   * onStart being called so ensure that your onStart and onEnd logic works.
+   */
+  bool loop;
+
   timelinecallback_t *onStart;
   timelinecallback_t *onDuration;
   timelinecallback_t *onEnd;

include/dawn/display/gui/font.h

@@ -25,7 +25,7 @@
 #define FONT_FILL_MODE 1
 
 /** Passed to STBTT for scaling the font nicely, essentially the font size. */
-#define FONT_TEXTURE_SIZE 112
+#define FONT_TEXTURE_SIZE 32
 
 // Chars
 #define FONT_NEWLINE '\n'
@@ -36,25 +36,41 @@
 #define FONT_INITIAL_LINE FONT_LINE_HEIGHT*0.75
 #define FONT_SPACE_SIZE FONT_TEXTURE_SIZE*0.45
 
+/** Maximum number of characters a font text info can hold. */
+#define FONT_TEXT_INFO_CHARS_MAX 1024
+
+/** Maximum number of newlines that a font text info can hold. */
+#define FONT_TEXT_INFO_LINES_MAX FONT_TEXT_INFO_CHARS_MAX/50
+
 /** 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 {
+  /** What (real character) index the line starts at */
+  int32_t start;
+  /** How many (real) characters the line is in length */
+  int32_t length;
+} fonttextinfoline_t;
+
 typedef struct {
   /** How many raw chars are in the string */
   int32_t length;
 
-  /** How many rendered chars are in the string */
+  /** How many real characters (non whitespace) are in the string */
   int32_t realLength;
 
   /** How many lines is the string? Trailing newlines will count */
-  int32_t lines;
+  int32_t lineCount;
+
+  /** The real character info for each line */
+  fonttextinfoline_t lines[FONT_TEXT_INFO_LINES_MAX];
 
   /** Dimensions of the string */
   float width, height;
 
   /** Array of precalculated quads */
-  stbtt_aligned_quad *quads;
+  stbtt_aligned_quad quads[FONT_TEXT_INFO_CHARS_MAX];
 } fonttextinfo_t;

include/dawn/poker/poker.h

@@ -84,9 +84,6 @@ typedef struct {
   /** Frames to hold the world and GUI render outputs */
   framebuffer_t frameWorld, frameGui;
 
-  /** Game's Font */
-  font_t font;
-
   /** Game's Shader */
   shader_t shader;
   
@@ -96,16 +93,6 @@ typedef struct {
   /** Refer to POKER_GUI_HEIGHT */
   float guiWidth;
 
-  /** Last frame's GUI width, used to track font wrapping */
-  float textLastWidth;
-  /** Primitive to hold talking text */
-  primitive_t talkPrimitive;
-  /** Current spoken text, tracked in-case of re-render */
-  char *talkText;
-  /** Information about the current rendered text */
-  fonttextinfo_t *talkTextInfo;
-
-
   texture_t chipTexture;
   primitive_t chipPrimitive;
   

include/dawn/vn/conversation.h

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../libs.h"
+
+#define CONVERSATION_TEXT_COUNT_MAX 32
+
+typedef struct {
+  char *text;
+  uint8_t speaker;
+} conversationtext_t;
+
+typedef struct {
+  conversationtext_t texts[CONVERSATION_TEXT_COUNT_MAX];
+  uint8_t textCount;
+  uint8_t textCurrent;
+} conversation_t;

include/dawn/vn/gui/vntextbox.h

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../../libs.h"
+#include "../../display/animation/timeline.h"
+#include "../../display/gui/font.h"
+
+/** Amount of characters scrolled, per second */
+#define VN_TEXTBOX_SCROLL_SPEED 60
+
+typedef struct {
+  /** Stores the maximum width that this textbox can take up */
+  float widthMax;
+
+  /** Font that the text box uses */
+  font_t *font;
+
+  /** How many rows of text at most can be displayed in a single text box */
+  int32_t linesMax;
+  int32_t lineCurrent;
+
+  /** X, Y Position of the textbox */
+  float x, y;
+
+  /** Animation of the textbox */
+  timeline_t animTimeline;
+  // timelineaction_t animActions;
+
+  /** Information about the current rendered text */
+  fonttextinfo_t textInfo;
+
+  /** Primitive to hold talking text */
+  primitive_t primitive;
+
+  // Testing assets
+  primitive_t testPrimitive;
+  texture_t testTexture;
+
+  /** Current spoken text, tracked in-case of re-render */
+  char *text;
+} vntextbox_t;

src/display/animation/timeline.c

@@ -7,17 +7,12 @@
 
 #include "timeline.h"
 
-void onDone(timeline_t *test) {
-}
-
 void timelineInit(timeline_t *timeline) {
   timeline->current = 0;
   timeline->diff = 0;
   timeline->previous = 0;
   timeline->user = 0;
   timeline->actionCount = 0;
-  
-  timeline->actions[0].onStart = &onDone;
 }
 
 void timelineUpdate(timeline_t *timeline, float delta) {
@@ -38,7 +33,7 @@ void timelineUpdate(timeline_t *timeline, float delta) {
 
     // Did we start this frame?
     if(action->start > timeline->previous && action->onStart != NULL) {
-      action->onStart(timeline);
+      action->onStart(timeline, action, i);
     }
 
     // Durations of 0 only fire starts, never ends or durations.
@@ -47,9 +42,10 @@ void timelineUpdate(timeline_t *timeline, float delta) {
     // Is the end still in the future? Durations in negatives go forever
     full = action->start+action->duration;
     if(action->duration < 0 || full > timeline->current) {
-      if(action->onDuration != NULL) action->onDuration(timeline);
+      if(action->onDuration != NULL) action->onDuration(timeline, action, i);
     } else if(full > timeline->previous) {// Did we end this frame?
-      if(action->onEnd != NULL) action->onEnd(timeline);
+      if(action->onEnd != NULL) action->onEnd(timeline, action, i);
+      if(action->loop) action->start = timeline->current;
     }
   }
 }
@@ -74,6 +70,7 @@ timelineaction_t * timelineAddAction(timeline_t *timeline, float start,
 ) {
   if(timeline->actionCount == TIMELINE_ACTION_COUNT_MAX) return NULL;
   timelineaction_t *action = timeline->actions + (timeline->actionCount++);
+  action->loop = false;
   action->start = start, action->duration = duration;
   action->onStart = action->onEnd = action->onDuration = NULL;
   return action;

src/display/gui/font.c

@@ -44,17 +44,6 @@ void fontDispose(font_t *font) {
   textureDispose(&font->texture);
 }
 
-
-fonttextinfo_t * fontGetTextInfo(font_t *font, char *text) {
-  return fontTextClamp(font, text, 999999);
-}
-
-void fontTextInfoDispose(fonttextinfo_t *info) {
-  free(info->quads);
-  free(info);
-}
-
-
 void fontTextBuffer(font_t *font,primitive_t *primitive,fonttextinfo_t *info) {
   stbtt_aligned_quad *quad;
   int32_t i;
@@ -76,29 +65,27 @@ void fontTextInit(font_t *font, primitive_t *primitive, fonttextinfo_t *info) {
   fontTextBuffer(font, primitive, info);
 }
 
-
+void fontTextClamp(font_t *font, fonttextinfo_t *info, char *text,
-fonttextinfo_t * fontTextClamp(font_t *font, char *text, float maxWidth) {
+  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->lines = 1;
+  info->lineCount = 0;
+
+  // Prepare the line counters
+  info->lines[0].start = 0;
+  info->lines[0].length = 0;
   
-  // Unlike GetTextInfo we can actually calculate the quads at the same time
+  // Setup the initial loop state, and X/Y coords for the quad.
-  // that we determine the string length.
   i = 0;
   x = 0;
   y = FONT_INITIAL_LINE;
@@ -112,12 +99,13 @@ fonttextinfo_t * fontTextClamp(font_t *font, char *text, float maxWidth) {
 
       // Did this space cause a newline?
       if(x > maxWidth) {
-        info->lines++;
+        info->lineCount++;
+        info->lines[info->lineCount].start = info->realLength;
+        info->lines[info->lineCount].length = 0;
+
         y += FONT_LINE_HEIGHT;
         x = 0;
       }
-      // info->width = mathMax(info->width, x);
-      // info->height = mathMax(info->height, y);
       wordX = x;
       wordStart = info->realLength;
       continue;
@@ -125,21 +113,16 @@ fonttextinfo_t * fontTextClamp(font_t *font, char *text, float maxWidth) {
 
     // New line.
     if(c == FONT_NEWLINE) {
-      info->lines++;
+      info->lineCount++;
+      info->lines[info->lineCount].start = info->realLength;
+      info->lines[info->lineCount].length = 0;
+
       wordStart = info->realLength;
       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,
@@ -156,20 +139,28 @@ fonttextinfo_t * fontTextClamp(font_t *font, char *text, float maxWidth) {
         quad->x0 -= wordX, quad->x1 -= wordX;
         quad->y0 += FONT_LINE_HEIGHT, quad->y1 += FONT_LINE_HEIGHT;
       }
+
+      // Go back to the previous (still current) line and remove the chars
+      info->lines[info->lineCount].length -= info->realLength - wordStart;
+
+      // Next line begins with this word
+      info->lineCount++;
+      info->lines[info->lineCount].start = wordStart;
+      info->lines[info->lineCount].length = info->realLength - wordStart;
+
       y += FONT_LINE_HEIGHT;
-      info->lines++;
       wordX = 0;
     }
 
+    info->lines[info->lineCount].length++;
     info->realLength++;
   }
   
+  info->lineCount++;
+  
   for(j = 0; j < info->realLength; j++) {
     quad = info->quads + j;
     info->width = mathMax(info->width, quad->x1);
     info->height = mathMax(info->height, quad->y1);
   }
-  
-
-  return info;
 }

src/display/gui/font.h

@@ -26,23 +26,6 @@ void fontInit(font_t *font, char *data);
  */
 void fontDispose(font_t *Font);
 
-
-/**
- * Measures (and calculates the quads for) a text prior to rendering it.
- * 
- * @param font Font to use for rendering and measuring
- * @param text Text to measure/render.
- * @returns Font info calculated.
- */
-fonttextinfo_t * fontGetTextInfo(font_t *font, char *text);
-
-/**
- * Disposes a previously calculated font info struct..
- * @param info Info to dispose.
- */
-void fontTextInfoDispose(fonttextinfo_t *info);
-
-
 /**
  * Buffers the vertices of a font text onto a primitive. Requires some info
  * about how the font is meant to render from the text info section.
@@ -67,8 +50,10 @@ 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 info Font text info to clamp into.
+ * @param text Text to clamp.
  * @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 maxWidth);
+void fontTextClamp(font_t *font, fonttextinfo_t *info, char *text,
+  float maxWidth
+);

src/display/primitives/quad.h

@@ -9,6 +9,7 @@
 
 #define QUAD_VERTICE_COUNT 4
 #define QUAD_INDICE_COUNT 6
+#define QUAD_INDICE_PER_QUAD 2
 
 /**
  * Buffers the vertices of a quad onto a primitive.

src/game/game.c

@@ -7,6 +7,8 @@
 
 #include "game.h"
 
+testscene_t testScene;
+
 bool gameInit(game_t *game) {
   // Init the game
   game->name = GAME_NAME;
@@ -15,7 +17,8 @@ bool gameInit(game_t *game) {
   engineInit(&game->engine, game);
   
   // Hand off to the poker logic.
-  pokerInit(&game->poker, &game->engine);
+  testSceneInit(&testScene, game);
+  // pokerInit(&game->poker, &game->engine);
 
   return true;
 }
@@ -25,7 +28,9 @@ bool gameUpdate(game_t *game, float platformDelta) {
   engineUpdateStart(&game->engine, game, platformDelta);
 
   // Hand off to the poker logic
-  pokerUpdate(&game->poker, &game->engine);
+  testSceneRender(&testScene, game);
+  // pokerUpdate(&game->poker, &game->engine);
+
   
   // Hand back to the engine.
   return engineUpdateEnd(&game->engine, game);

src/game/game.h

@@ -7,9 +7,7 @@
 #include <dawn/dawn.h>
 #include "../engine/engine.h"
 #include "../poker/poker.h"
-
+#include "../test/testscene.h"
-#include "../poker/card.h"
-#include "../display/animation/timeline.h"
 
 /**
  * Initialize the game context.

src/platform/glfw/glwfwplatform.c

@@ -40,6 +40,11 @@ int32_t main() {
   game_t *game = malloc(sizeof(game_t));
   GAME_STATE = game;
   input_t *input = &game->engine.input;
+  
+  // Init the render resolution
+  renderSetResolution(&game->engine.render,
+    WINDOW_WIDTH_DEFAULT, WINDOW_HEIGHT_DEFAULT
+  );
 
   // Init the game
   if(gameInit(game)) {
@@ -67,11 +72,6 @@ int32_t main() {
     inputBind(input, INPUT_ACCEPT,       (inputsource_t)GLFW_KEY_ENTER);
     inputBind(input, INPUT_ACCEPT,       (inputsource_t)GLFW_KEY_SPACE);
 
-    // Init the render resolution
-    renderSetResolution(&game->engine.render,
-      WINDOW_WIDTH_DEFAULT, WINDOW_HEIGHT_DEFAULT
-    );
-
     // Update the window title.
     glfwSetWindowTitle(window, GAME_STATE->name);
 

src/poker/poker.c

@@ -13,15 +13,12 @@ void pokerInit(poker_t *poker, engine_t *engine) {
     "shaders/textured.vert", "shaders/textured.frag"
   );
 
-  // Load the main font
-  assetFontLoad(&poker->font, "fonts/opensans/OpenSans-Bold.ttf");
-
   // Initialize the render stuffs.
   pokerFrameInit(poker, &engine->render);
   pokerWorldInit(poker);
   pokerCardInit(poker);
   pokerPlayerInit(poker);
-  pokerTalkInit(poker);
+  // pokerTalkInit(poker);
 
   // Hand over to the deal for the first time.
   pokerMatchInit(poker, engine);
@@ -53,13 +50,11 @@ void pokerUpdate(poker_t *poker, engine_t *engine) {
   }
 
   pokerFrameGui(poker, &engine->render);
-  pokerTalkRender(poker, &engine->input);
+  // pokerTalkRender(poker, &engine->input);
-
-  poker->textLastWidth = poker->guiWidth;
 }
 
 void pokerDispose(poker_t * poker) {
-  pokerTalkDispose(poker);
+  // pokerTalkDispose(poker);
   pokerWorldDispose(poker);
   shaderDispose(&poker->shader);
 }

src/poker/poker.h

@@ -14,7 +14,6 @@
 #include "render/card.h"
 #include "render/player.h"
 #include "render/look.h"
-#include "render/talk.h"
 
 #include "../file/asset.h"
 #include "../display/shader.h"

src/poker/round/match.c

@@ -32,8 +32,4 @@ void pokerMatchUpdate(poker_t *poker, engine_t *engine) {
   pokerLookAtPlayer(&poker->cameraWorld, POKER_SEAT_PLAYER0, (
     t < 1 ? 1 - easeOutQuart(t) : 0
   ));
-
-  if(t > 0.75) {
-    pokerTalk(poker, "Hello World");
-  }
 }

src/poker/round/match.h

@@ -9,7 +9,6 @@
 #include <dawn/dawn.h>
 #include "start.h"
 #include "../render/look.h"
-#include "../render/talk.h"
 
 /**
  * Init the poker match round.

src/test/testscene.c

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "testscene.h"
+
+void testSceneInit(testscene_t *scene, game_t *game) {
+  assetFontLoad(&scene->font, "fonts/opensans/OpenSans-Bold.ttf");
+  assetShaderLoad(&scene->shader,
+    "shaders/textured.vert", "shaders/textured.frag"
+  );
+  
+
+  vnTextBoxInit(&scene->box, &scene->font);
+  scene->box.text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent aliquam volutpat libero, vitae laoreet neque egestas et. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Fusce dui leo, molestie et consectetur quis, blandit eu velit. Suspendisse at dolor sed ligula consectetur luctus. Donec mollis semper lacus id pretium. Maecenas et magna lorem. Nullam non viverra dui. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Pellentesque dapibus facilisis ipsum, eu placerat justo pretium tempus. Quisque vehicula sapien vel sem ullamcorper vestibulum. Mauris pellentesque sapien vel volutpat imperdiet.";
+  scene->box.widthMax = game->engine.render.width;
+  vnTextBoxRebuffer(&scene->box);
+}
+
+void testSceneRender(testscene_t *scene, game_t *game) {
+  if(false) {
+    cameraLookAt(&scene->camera,
+      300, 300, 300,
+      0, 0, 0
+    );
+    cameraPerspective(&scene->camera, 75,
+      game->engine.render.width/game->engine.render.height, 0.01, 1000.0
+    );
+  } else {
+    cameraLookAt(&scene->camera,
+      0, 0, 10,
+      0, 0, 0
+    );
+
+    cameraOrtho(&scene->camera,
+      0, game->engine.render.width,
+      game->engine.render.height, 0,
+      0.01, 1000.0
+    );
+  }
+
+  shaderUse(&scene->shader);
+  shaderUseCamera(&scene->shader, &scene->camera);
+
+  vnTextBoxUpdate(&scene->box, &game->engine);
+  vnTextBoxRender(&scene->box, &scene->shader);
+}

src/test/testscene.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>
+#include "../display/shader.h"
+#include "../display/camera.h"
+#include "../display/gui/font.h"
+#include "../file/asset.h"
+#include "../vn/gui/vntextbox.h"
+#include "../display/gui/font.h"
+
+typedef struct {
+  shader_t shader;
+  camera_t camera;
+  font_t font;
+
+  vntextbox_t box;
+} testscene_t;
+
+void testSceneInit(testscene_t *scene, game_t *game);
+void testSceneRender(testscene_t *scene, game_t *game);

src/vn/conversation.c

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "conversation.h"
+
+void conversationInit(conversation_t *convo) {
+  convo->textCount = 0x00;
+  convo->textCurrent = 0x00;
+}
+
+void conversationNext(conversation_t *convo) {
+  convo->textCurrent++;
+}
+
+conversationtext_t * conversationAdd(conversation_t *convo, uint8_t speaker,
+  char *text
+) {
+  conversationtext_t *txt = convo->texts + (convo->textCount++);
+  txt->text = text;
+  txt->speaker = speaker;
+  return txt;
+}

src/vn/conversation.h

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "../util/array.h"
+#include "../display/animation/timeline.h"
+
+/**
+ * Initialize the conversation set.
+ * @param convo Conversation to initialize.
+ */
+void conversationInit(conversation_t *convo);
+
+/**
+ * Proceed to the next conversation element.
+ * @param convo Conversation to advance.
+ */
+void conversationNext(conversation_t *convo);
+
+/**
+ * Add a text element to the conversation.
+ * 
+ * @param convo Conversation to add to.
+ * @param speaker Speaker that said this thing.
+ * @param text Text to speak
+ * @return The pointer to the text element.
+ */
+conversationtext_t * conversationAdd(conversation_t *convo, uint8_t speaker,
+  char *text
+);

src/vn/gui/vntextbox.c

@@ -0,0 +1,124 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "vntextbox.h"
+
+void vnTextBoxInit(vntextbox_t *box, font_t *font) {
+  box->font = font;
+  box->widthMax = 400;
+  box->text = NULL;
+  box->x = 0, box->y = 0;
+
+  box->linesMax = 1;
+  box->lineCurrent = 0;
+}
+
+void vnTextBoxRebuffer(vntextbox_t *box) {
+  if(box->primitive.indiceCount > 0) {
+    vnTextBoxDispose(box);
+  }
+
+  if(box->text == NULL) return;
+
+  // Rebuffer the text.
+  fontTextClamp(box->font, &box->textInfo, box->text, box->widthMax);
+  fontTextInit(box->font, &box->primitive, &box->textInfo);
+
+  quadInit(&box->testPrimitive, 0,
+    0, 0, 0.3, 0.3,
+    box->textInfo.width, box->textInfo.height, 0.6, 0.6
+  );
+
+  pixel_t pixels[25];
+  for(uint8_t i = 0; i < 25; i++) {
+    pixels[i].r = pixels[i].a = 0xFF;
+    pixels[i].g = pixels[i].b = 0x00;
+  }
+  textureInit(&box->testTexture, 5, 5, pixels);
+}
+
+void vnTextBoxUpdate(vntextbox_t *box, engine_t *engine) {
+  if(vnTextBoxHasScrolled(box)) {
+    if(!inputIsPressed(&engine->input, INPUT_ACCEPT)) return;
+    // "Next text box"
+    printf("Next");
+    box->lineCurrent++;
+    return;
+  }
+
+  bool speedup = inputIsDown(&engine->input, INPUT_ACCEPT);
+  timelineUpdate(&box->animTimeline, engine->time.delta * (speedup ? 1 : 2));
+}
+
+void vnTextBoxRender(vntextbox_t *box, shader_t *shader) {
+  int32_t charStart, charCount, i;
+  if(box->text == NULL) return;
+
+  // Determine where we're rendering the indices up to.
+  charCount = box->animTimeline.current * VN_TEXTBOX_SCROLL_SPEED;
+  if(charCount == 0) return;
+
+  // Clamp to lines if necessary.
+  if(box->linesMax > 0) {
+    if(box->lineCurrent >= box->textInfo.lineCount) return;
+  
+    // From lineCurrent to lineCurrent+lineMax (or max lines in text).
+    i = box->lineCurrent;
+    charStart = 0;// Misusing variable for now.
+    while(i < mathMin(box->lineCurrent+box->linesMax, box->textInfo.lineCount)){
+      charStart += box->textInfo.lines[i].length;// Sum char counts for lines.
+      i++;
+    }
+    i = box->textInfo.lines[box->lineCurrent].start;//i=the starting indice now
+
+    if(charCount >= charStart) {
+      int32_t brhva;
+      brhva = 32;
+    }
+
+    // Select either the scroll position or the total chars for the lowest.
+    charCount = mathMin(charCount - i, charStart);
+    charStart = box->lineCurrent;
+  } else {
+    charStart = 0;
+  }
+
+  // Convert characters into indices, don't render if we can't
+  charStart *= QUAD_INDICE_COUNT;
+  if(charStart >= box->primitive.indiceCount) return;
+
+  // Clamp
+  charCount = mathMin(
+    charCount * QUAD_INDICE_COUNT,
+    box->primitive.indiceCount - charStart
+  );
+  if(charCount < 1) return;
+
+  // Render the debug box.
+  shaderUsePosition(shader, box->x,box->y,0, 0,0,0);
+  shaderUseTexture(shader, &box->testTexture);
+  primitiveDraw(&box->testPrimitive, 0, -1);
+  
+  // Render the Text Box
+  shaderUseTexture(shader, &box->font->texture);
+  primitiveDraw(&box->primitive, charStart, charCount);
+}
+
+void vnTextBoxDispose(vntextbox_t *box) {
+  primitiveDispose(&box->primitive);
+  primitiveDispose(&box->testPrimitive);
+  textureDispose(&box->testTexture);
+  box->primitive.indiceCount = 0;
+}
+
+bool vnTextBoxHasScrolled(vntextbox_t *box) {
+  if(box->text == NULL) return true;
+
+  return (box->animTimeline.current * (
+    VN_TEXTBOX_SCROLL_SPEED * QUAD_INDICE_COUNT
+  )) >= box->primitive.indiceCount;
+}

src/vn/gui/vntextbox.h

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "../../display/primitive.h"
+#include "../../display/shader.h"
+#include "../../display/animation/timeline.h"
+#include "../../display/gui/font.h"
+#include "../../display/primitives/quad.h"
+#include "../../input/input.h"
+
+/**
+ * Initializes the Visual Novel Text Box to its initial state.
+ * 
+ * @param box The box to initialize.
+ * @param font Font for the text box to use by default.
+ */
+void vnTextBoxInit(vntextbox_t *box, font_t *font);
+
+/**
+ * Method required to be called when changing anything within the textbox. This
+ * will recalculate the text widths, fonts, etc.
+ * @param box Box to recalculate for.
+ */
+void vnTextBoxRebuffer(vntextbox_t *box);
+
+/**
+ * Updates the Visual Novel Text Box. This includes handling logic for both, 
+ * the animation and the input controlling for the textbox.
+ * @param box Box to update.
+ * @param engine Engine that the box is being updated by.
+ */
+void vnTextBoxUpdate(vntextbox_t *box, engine_t *engine);
+
+/**
+ * Renders the Visual Novel Text Box. No logic occurs, just renders. Animations
+ * will not be ticked, use update to do this.
+ * @param box Box to render.
+ * @param shader Shader to render to.
+ */
+void vnTextBoxRender(vntextbox_t *box, shader_t *shader);
+
+/**
+ * Disposes a previously created Visual Novel Text Box.
+ * @param box Text Box to dispose.
+ */
+void vnTextBoxDispose(vntextbox_t *box);
+
+/**
+ * Checks the current buffer position of a vn text box and returns true if it has finished
+ * scrolling.
+ * 
+ * @param box Box to check.
+ * @return True if the text box has finished scrolling.
+ */
+bool vnTextBoxHasScrolled(vntextbox_t *box);