Scene change support

src/dawn/asset/Asset.hpp

@@ -14,7 +14,7 @@ namespace Dawn {
       AssetManager *assetManager;
       std::string name;
       uint8_t state = 0x00;
-      bool loaded = false;
+      bool_t loaded = false;
       Event<> eventLoaded;
       StateEvent<> event2Loaded;
 

src/dawn/asset/AssetLoader.hpp

@@ -95,11 +95,11 @@ namespace Dawn {
        * @return The count of bytes read.
        */
       template<class T>
-      size_t loadBufferedCallback(T *instance, bool (T::*callback)(uint8_t n)) {
+      size_t loadBufferedCallback(T *instance, bool_t (T::*callback)(uint8_t n)) {
         uint8_t buffer[1024];
         size_t read, length;
         int32_t i;
-        bool result;
+        bool_t result;
 
         assertNotNull(instance);
         assertNotNull(callback);

src/dawn/display/Transform.cpp

@@ -147,7 +147,7 @@ void Transform::setWorldTransform(glm::mat4 transform) {
 
 
 void Transform::setParent(Transform *parent) {
-  assertTrue(parent != this);
+  assertTrue(parent == nullptr || parent != this);
   
   auto currentParent = this->getParent();
   if(currentParent == parent) return;
@@ -190,6 +190,6 @@ Transform::~Transform() {
   auto it = this->children.begin();
   while(it != this->children.end()) {
     (*it)->setParent(nullptr);
-    ++it;
+    it = this->children.begin();
   }
 }

src/dawn/display/font/truetype/TrueTypeFaceTexture.cpp

@@ -32,6 +32,8 @@ TrueTypeFaceTexture::TrueTypeFaceTexture(
       assertUnreachable();
     }
 
+    if(face->glyph->bitmap.width == 0 || face->glyph->bitmap.rows == 0) continue;
+
     // Update the width and height
     w = mathMax<size_t>(w, face->glyph->bitmap.width);
     h += face->glyph->bitmap.rows;

src/dawn/game/DawnGame.cpp

@@ -33,6 +33,13 @@ int32_t DawnGame::update(float_t delta) {
   
   this->renderManager.update();
 
+  if(this->sceneToCutTo != nullptr) {
+    delete this->scene;
+    this->scene = nullptr;
+    this->scene = this->sceneToCutTo;
+    this->sceneToCutTo = nullptr;
+  }
+
   return DAWN_GAME_UPDATE_RESULT_SUCCESS;
 }
 

src/dawn/games/vn/events/VNSceneChangeEvent.hpp

@@ -0,0 +1,25 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "VNEvent.hpp"
+#include "scene/Scene.hpp"
+
+namespace Dawn {
+  template<class T>
+  class VNSceneChangeEvent : public VNEvent {
+    protected:
+      void onStart() override {
+        auto game = this->manager->getGame();
+        T *nextScene = new T(this->manager->getGame());
+
+        auto assets = nextScene->getRequiredAssets();
+        game->assetManager.queueLoad(assets);
+        game->assetManager.syncLoad();
+        nextScene->stage();
+        game->sceneCutover(nextScene);
+      }
+  };
+}

src/dawn/scene/components/ui/CMakeLists.txt

@@ -10,6 +10,7 @@ target_sources(${DAWN_TARGET_NAME}
     UIComponent.cpp
     UIComponentRenderable.cpp
     UIImage.cpp
+    UIEmpty.cpp
     UIBorder.cpp
 )
 

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

@@ -0,0 +1,15 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "UIEmpty.hpp"
+
+using namespace Dawn;
+
+UIEmpty::UIEmpty(SceneItem *item) : UIComponent(item) { }
+
+float_t UIEmpty::getContentWidth() { return 0.0f; }
+float_t UIEmpty::getContentHeight() { return 0.0f; }
+float_t UIEmpty::getChildOffsetX() { return 0.0f; }
+float_t UIEmpty::getChildOffsetY() { return 0.0f; }

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

@@ -0,0 +1,18 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "UIComponent.hpp"
+
+namespace Dawn {
+  class UIEmpty : public UIComponent {
+    public:
+      UIEmpty(SceneItem *item);
+      float_t getContentWidth() override;
+      float_t getContentHeight() override;
+      float_t getChildOffsetX() override;
+      float_t getChildOffsetY() override;
+  };
+}

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

@@ -211,7 +211,9 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
 
     // Now, iterate each character
     for(int32_t i = 0; i < len; i++) {
-      char ch = text.text[i];
+      std::u32string::value_type ch = text.text[i];
+      // FT_ULong ch = text.text[i];
+      char c = text.text[i];
 
       // Handle special characters
       if(ch == '\n') {
@@ -228,8 +230,7 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
       assertTrue(ch != '\n');
 
       // Get font data.
-      FT_ULong c = ch;
-      auto charInfo = realText.texture->getCharacterData(c);
+      auto charInfo = realText.texture->getCharacterData(ch);
 
       // Word wrapping
       if(

src/dawnliminal/game/LiminalGame.cpp

@@ -4,12 +4,12 @@
 // https://opensource.org/licenses/MIT
 
 #include "game/DawnGame.hpp"
-#include "vnscenes/Scene1Prologue.hpp"
+#include "vnscenes/Scene1Prologue0.hpp"
 #include "scenes/HelloWorldScene.hpp"
 
 using namespace Dawn;
 
 Scene * Dawn::dawnGameGetInitialScene(DawnGame *game) {
   // return new HelloWorldScene(game);
-  return new Scene1Prologue(game);
+  return new Scene1Prologue0(game);
 }

src/dawnshared/display/font/truetype/TrueTypeShared.hpp

@@ -6,8 +6,8 @@
 #pragma once
 #include "util/flag.hpp"
 
-#define TRUE_TYPE_CHAR_BEGIN 32
-#define TRUE_TYPE_CHAR_END 192
+#define TRUE_TYPE_CHAR_BEGIN 0x00
+#define TRUE_TYPE_CHAR_END 0xFF
 
 #define TRUE_TYPE_VARIANT_BOLD FLAG_DEFINE(0)
 #define TRUE_TYPE_VARIANT_ITALICS FLAG_DEFINE(1)

src/dawntools/util/File.cpp

@@ -21,8 +21,8 @@ void File::mkdirp(std::string path) {
   std::string buffer;
   char c;
   size_t i = 0;
-  bool inFile;
-  bool hasMore;
+  bool_t inFile;
+  bool_t hasMore;
 
   inFile = false;
   hasMore = false;

src/dawntools/vnscenetool/VNSceneGen.cpp

@@ -135,6 +135,12 @@ void VNSceneGen::test(
       break;
     }
 
+    case VN_SCENE_EVENT_TYPE_SCENE_CHANGE:
+      initType = "VNSceneChangeEvent<" + event->sceneChange.scene + ">";
+      toInclude = "games/vn/events/VNSceneChangeEvent.hpp";
+      includes->push_back(event->sceneChange.include);
+      break;
+
     default:
       std::cout << "Unknown event type: " << event->type << std::endl;
       assertUnreachable();

src/dawntools/vnscenetool/events/CMakeLists.txt

@@ -17,4 +17,5 @@ target_sources(vnscenetool
     VNChoiceEventParser.cpp
     VNChoiceSetEventParser.cpp
     VNIfEventParser.cpp
+    VNSceneChangeEventParser.cpp
 )

src/dawntools/vnscenetool/events/VNSceneChangeEventParser.cpp

@@ -0,0 +1,33 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "VNSceneChangeEventParser.hpp"
+
+using namespace Dawn;
+
+std::vector<std::string> VNSceneChangeEventParser::getRequiredAttributes() {
+  return { "scene" };
+}
+
+std::map<std::string, std::string> VNSceneChangeEventParser::getOptionalAttributes() {
+  return {};
+}
+
+int32_t VNSceneChangeEventParser::onParse(
+  Xml *node,
+  std::map<std::string, std::string> values,
+  struct VNSceneChangeEvent *out,
+  std::string *error
+) {
+  out->include = values["scene"] + ".hpp";
+
+  // Find last slash and take all string after that
+  size_t lastSlash = values["scene"].find_last_of('/');
+  if(lastSlash != std::string::npos) {
+    out->scene = values["scene"].substr(lastSlash+1);
+  }
+
+  return 0;
+}

src/dawntools/vnscenetool/events/VNSceneChangeEventParser.hpp

@@ -0,0 +1,26 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "util/XmlParser.hpp"
+
+namespace Dawn {
+  struct VNSceneChangeEvent {
+    std::string scene;
+    std::string include;
+  };
+
+  class VNSceneChangeEventParser : public XmlParser<struct VNSceneChangeEvent> {
+    protected:
+      std::vector<std::string> getRequiredAttributes() override;
+      std::map<std::string, std::string> getOptionalAttributes() override;
+      int32_t onParse(
+        Xml *node,
+        std::map<std::string, std::string> values,
+        struct VNSceneChangeEvent *out,
+        std::string *error
+      ) override;
+  };
+}

src/dawntools/vnscenetool/events/VNSceneEventsParser.cpp

@@ -80,6 +80,11 @@ int32_t VNSceneEventsParser::onParse(
       ret = (VNIfEventParser()).parse(child, &event.ifEvent, error);
       if(ret != 0) return ret;
 
+    } else if(child->node == "scene-change") {
+      event.type = VN_SCENE_EVENT_TYPE_SCENE_CHANGE;
+      ret = (VNSceneChangeEventParser()).parse(child, &event.sceneChange, error);
+      if(ret != 0) return ret;
+
     } else {
       *error = "Unknown child node '" + child->node + "'";
       return -1;

src/dawntools/vnscenetool/events/VNSceneEventsParser.hpp

@@ -14,6 +14,7 @@
 #include "VNChoiceEventParser.hpp"
 #include "VNChoiceSetEventParser.hpp"
 #include "VNIfEventParser.hpp"
+#include "VNSceneChangeEventParser.hpp"
 
 namespace Dawn {
   struct VNSceneEvent;
@@ -32,7 +33,8 @@ namespace Dawn {
     VN_SCENE_EVENT_TYPE_GOTO_MARKER,
     VN_SCENE_EVENT_TYPE_CHOICES,
     VN_SCENE_EVENT_TYPE_CHOICE_SET,
-    VN_SCENE_EVENT_TYPE_IF
+    VN_SCENE_EVENT_TYPE_IF,
+    VN_SCENE_EVENT_TYPE_SCENE_CHANGE
   };
 
   struct VNParallelEvent {
@@ -58,6 +60,7 @@ namespace Dawn {
     struct VNChoiceEvent choices;
     struct VNChoiceSetEvent choiceSet;
     struct VNIfEvent ifEvent;
+    struct VNSceneChangeEvent sceneChange;
   };
 
   class VNSceneEventsParser : public XmlParser<struct VNSceneEventList> {