Finally finished VN textbox

src/dawn/games/vn/components/VNTextboxScroller.cpp

@@ -10,95 +10,83 @@ using namespace Dawn;
 
 VNTextboxScroller::VNTextboxScroller(SceneItem *item) :
   SceneItemComponent(item),
-  label(nullptr)
+  label(nullptr),
+  visibleLines(4)
 {
 }
 
 void VNTextboxScroller::onStart() {
-  // assertNotNull(label);
+  assertNotNull(label);
 
-  // std::function<void()> x = [&]{
+  std::function<void()> x = [&]{
-  //   this->lineCurrent = 0;
+    this->lineCurrent = 0;
-  //   this->timeCharacter = 0;
+    this->timeCharacter = 0;
-  //   this->label->startQuad = 0;
+    this->label->quadStart = 0;
-  //   this->label->quadCount = 0;
+    this->label->quadCount = 0;
-  //   this->readyToClose = false;
+    this->readyToClose = false;
-  // };
+  };
-  // x();
 
-  // useEvent(x, this->label->eventTextChanged);
+  useEvent(x, this->label->eventTextChanged);
+  useEffect(x, visibleLines)();
 
-  // useEvent([&](float_t delta){
+  useEvent([&](float_t delta){
-  //   auto game = this->getGame();
+    auto game = this->getGame();
 
-  //   this->timeCharacter += delta;
+    this->timeCharacter += delta;
-  //   if(this->hasRevealedAllCurrentCharacters()) {
+    if(this->hasRevealedAllCurrentCharacters()) {
-  //     if(this->hasRevealedAllCharacters()) {
+      if(this->hasRevealedAllCharacters()) {
-  //       if(!this->readyToClose) {
+        if(!this->readyToClose) {
-  //         this->readyToClose = true;
+          this->readyToClose = true;
-  //         this->eventReadyToClose.invoke();
+          this->eventReadyToClose.invoke();
-  //       }
+        }
-  //     } else {
+      } else {
-  //       if(game->inputManager.isPressed(INPUT_BIND_ACCEPT)) {
+        if(game->inputManager.isPressed(INPUT_BIND_ACCEPT)) {
-  //         this->lineCurrent += this->getCountOfVisibleLines();
+          this->lineCurrent += this->visibleLines;
-  //         this->label->startQuad = 0;
+          this->label->quadStart = this->label->lines[this->lineCurrent].quadStart;
-  //         for(int32_t i = 0; i < this->lineCurrent; i++) {
+          this->label->quadCount = 0;
-  //           this->label->startQuad += this->label->measure.getQuadsOnLine(i);
+          this->timeCharacter = 0.0f;
-  //         }
-  //         this->label->quadCount = 0;
-  //         this->timeCharacter = 0.0f;
-  //       }
-  //     }
-  //     return;
-  //   }
 
-  //   auto lastTimeCharacter = mathFloor<int32_t>(this->timeCharacter);
+          this->label->textOffset = (
-  //   if(game->inputManager.isDown(INPUT_BIND_ACCEPT)) {
+            -this->label->lines[this->lineCurrent].position
-  //     this->timeCharacter += game->timeManager.delta * VN_TEXTBOX_SPEED_FASTER;
+          );
-  //   } else {
+        }
-  //     this->timeCharacter += game->timeManager.delta * VN_TEXTBOX_SPEED;
+      }
-  //   }
+      return;
+    }
 
-  //   auto newCount = mathFloor<int32_t>(this->timeCharacter);
+    auto lastTimeCharacter = mathFloor<int32_t>(this->timeCharacter);
-  //   if(newCount == this->label->quadCount) return;
+    if(game->inputManager.isDown(INPUT_BIND_ACCEPT)) {
-  //   this->label->quadCount = mathFloor<int32_t>(this->timeCharacter);
+      this->timeCharacter += game->timeManager.delta * VN_TEXTBOX_SPEED_FASTER;
-  //   this->eventCharacterRevealed.invoke();
+    } else {
-  // }, getScene()->eventSceneUpdate);
+      this->timeCharacter += game->timeManager.delta * VN_TEXTBOX_SPEED;
-  assertUnreachable();
+    }
-}
 
-size_t VNTextboxScroller::getCountOfVisibleLines() {
+    auto newCount = mathFloor<int32_t>(this->timeCharacter);
-  // float_t y = this->label->getHeight();
+    if(newCount == this->label->quadCount) return;
-  // size_t i = 1;
+    this->label->quadCount = mathFloor<int32_t>(this->timeCharacter);
-  // for(i = this->label->measure.getLineCount(); i > 0; --i) {
+    this->eventCharacterRevealed.invoke();
-  //   if(y >= this->label->measure.getHeightOfLineCount(i)) {
+  }, getScene()->eventSceneUpdate);
-  //     return i;
-  //   }
-  // }
-  // return this->label->measure.getLineCount();
-  assertUnreachable();
 }
 
 bool_t VNTextboxScroller::hasRevealedAllCurrentCharacters() {
-  // int32_t quadsTotal = 0;
+  int32_t quadsTotal = 0;
-  // for(
+  for(
-  //   size_t i = this->lineCurrent;
+    size_t i = this->lineCurrent;
-  //   i < mathMin<size_t>(
+    i < mathMin<size_t>(
-  //     this->label->measure.getLineCount(),
+      this->label->lines.size(),
-  //     this->lineCurrent + this->getCountOfVisibleLines()
+      this->lineCurrent + this->visibleLines
-  //   );
+    );
-  //   i++
+    i++
-  // ) {
+  ) {
-  //   quadsTotal += this->label->measure.getQuadsOnLine(i);
+    quadsTotal += this->label->lines[i].quadCount;
-  // }
+  }
-  // return mathFloor<int32_t>(this->timeCharacter) >= quadsTotal;
+  return mathFloor<int32_t>(this->timeCharacter) >= quadsTotal;
-  assertUnreachable();
 }
 
 bool_t VNTextboxScroller::hasRevealedAllCharacters() {
-  // return (
+  return (
-  //   this->lineCurrent + this->getCountOfVisibleLines() >=
+    this->lineCurrent + this->visibleLines >=
-  //   this->label->measure.getLineCount()
+    this->label->lines.size()
-  // );
+  );
   assertUnreachable();
 }

src/dawn/games/vn/components/VNTextboxScroller.hpp

@@ -17,6 +17,9 @@ namespace Dawn {
       // @optional
       StateProperty<UILabel*> label;
 
+      // @optional
+      StateProperty<int32_t> visibleLines;
+
       StateEvent<> eventReadyToClose;
       StateEvent<> eventCharacterRevealed;
 
@@ -28,14 +31,6 @@ namespace Dawn {
       VNTextboxScroller(SceneItem *item);
       virtual void onStart() override;
 
-      /**
-       * Returns the count of visible lines within the textbox. Mostly used for
-       * when we need to decide how to wrap.
-       * 
-       * @return The count of visible lines.
-       */
-      size_t getCountOfVisibleLines();
-
       /**
        * Returns true if all of the characters that can be made visible for the
        * current textbox size have finished revealing, or false if not.

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

@@ -30,15 +30,19 @@ std::vector<struct ShaderPassItem> UILabel::getUIRenderPasses() {
   auto canvas = this->getCanvas();
   auto shader = getGame()->renderManager.fontShader;
 
+  glm::mat4 model = transform->getWorldTransform();
+  // Translate
+  model = glm::translate(model, glm::vec3(this->textOffset, 0.0f));
+
   struct ShaderPassItem item;
   item.shader = shader;
   item.mesh = &this->mesh;
-  item.matrixValues[shader->paramModel] = transform->getWorldTransform();
+  item.matrixValues[shader->paramModel] = model;
   item.parameterBuffers[shader->bufferUiCanvas] = &canvas->shaderBuffer;
   item.parameterBuffers[shader->bufferFont] = &this->shaderBuffer;
   item.renderFlags = RENDER_MANAGER_RENDER_FLAG_BLEND;
-  item.start = quadStart * QUAD_VERTICE_COUNT;
+  item.start = quadStart * QUAD_INDICE_COUNT;
-  item.count = quadCount == -1 ? -1 : quadCount * QUAD_VERTICE_COUNT;
+  item.count = quadCount == -1 ? -1 : quadCount * QUAD_INDICE_COUNT;
 
   // Map texture slots
   auto it = textureMap.begin();
@@ -74,10 +78,22 @@ std::vector<struct ShaderPassItem> UILabel::getUIRenderPasses() {
 }
 
 float_t UILabel::getContentWidth() {
-  return 1;
+  float_t w = 0;
+  auto it = lines.begin();
+  while(it != lines.end()) {
+    w = mathMax<float_t>(w, it->width);
+    ++it;
+  }
+  return w;
 }
 
 float_t UILabel::getContentHeight() {
+  float_t h = 0;
+  auto it = lines.begin();
+  while(it != lines.end()) {
+    h += it->height;
+    ++it;
+  }
   return 1;
 }
 
@@ -103,6 +119,8 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
   // Prepare values shared across all text parts/styles
   float_t lineWidth = 0;
   struct UILabelLine currentLine;
+  currentLine.quadStart = quadCountTotal;
+  currentLine.position = position;
 
   // Now generate quads
   itText = newTexts.begin();
@@ -142,6 +160,8 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
     auto len = text.text.length();
     float_t wordWidth = 0;
     int32_t lastSpaceCharacter = -1;
+    
+    currentLine.height = mathMax<float_t>(currentLine.height, realText.style.size);
 
     std::function<void(int32_t)> fnInsertNewline = [&](int32_t i){
       if(i != len) {
@@ -174,6 +194,12 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
 
       currentLine = UILabelLine();
       currentLine.quadStart = quadCountTotal;
+      currentLine.position = position;
+      currentLine.height = realText.style.size;
+      // Here I subtract line height from the line position because we start
+      // by moving the text down by the initial line height, so we need to
+      // compensate for that.
+      currentLine.position.y -= realText.style.size;
     };
 
     // Now, iterate each character
@@ -303,4 +329,7 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
   // Update
   textsBuffered = realNewTexts;
   texts = newTexts;
+
+  // Event
+  this->eventTextChanged.invoke();
 }

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

@@ -30,6 +30,8 @@ namespace Dawn {
 
   struct UILabelLine {
     float_t width = 0.0f;
+    float_t height = 0.0f;
+    glm::vec2 position;
     int32_t quadStart = -1;
     int32_t quadCount = 0;
   };
@@ -45,9 +47,13 @@ namespace Dawn {
       int32_t quadCount = -1;
       int32_t quadCountTotal = -1;
 
+      glm::vec2 textOffset = glm::vec2(0.0f, 0.0f);
+
       std::vector<struct UILabelText> texts;
       std::vector<struct UILabelText> textsBuffered;
       std::vector<struct UILabelLine> lines;
+      
+      StateEvent<> eventTextChanged;
 
       UILabel(SceneItem *item);