Added a great scene generator

src/dawnliminal/CMakeLists.txt

@@ -19,7 +19,7 @@ add_subdirectory(save)
 # Assets
 set(LIMINAL_ASSETS_DIR ${DAWN_ASSETS_DIR}/games/liminal)
 tool_scene(${LIMINAL_ASSETS_DIR}/scenes/scene-base.xml)
-tool_vnscene(${LIMINAL_ASSETS_DIR}/test.xml)
+# tool_vnscene(${LIMINAL_ASSETS_DIR}/test.xml)
 
 tool_prefab(${LIMINAL_ASSETS_DIR}/VNTextbox.xml)
 tool_truetype(font_main ${DAWN_ASSETS_DIR}/ark-pixel.ttf)

src/dawnliminal/game/LiminalGame.cpp

@@ -5,11 +5,11 @@
 
 #include "game/DawnGame.hpp"
 #include "scenes/HelloWorldScene.hpp"
-#include "vnscenes/TestScene.hpp"
+#include "scenes/TestScene.hpp"
 
 using namespace Dawn;
 
 Scene * Dawn::dawnGameGetInitialScene(DawnGame *game) {
-  return new HelloWorldScene(game);
+  // return new HelloWorldScene(game);
-  // return new TestScene(game);
+  return new TestScene(game);
 }

src/dawntools/prefabtool/PrefabGen.cpp

@@ -48,6 +48,7 @@ void PrefabGen::generate(
     &methodInit.body,
     &methodAssets.body,
     "",
+    "scene",
     &info->root,
     ""
   );

src/dawntools/scenetool/CMakeLists.txt

@@ -16,6 +16,7 @@ target_sources(scenetool
     ${DAWN_TOOL_SOURCES}
     SceneTool.cpp
     SceneParser.cpp
+    SceneGen.cpp
 )
 
 # Includes

src/dawntools/scenetool/SceneGen.cpp

@@ -0,0 +1,69 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneGen.hpp"
+
+using namespace Dawn;
+
+void SceneGen::generate(
+  std::vector<std::string> *out,
+  struct Scene *scene,
+  std::string tabs
+) {
+  struct ClassGenInfo classInfo;
+  classInfo.clazz = scene->name;
+  classInfo.extend = "Scene";
+  classInfo.constructorArgs = "DawnGame *game";
+  classInfo.extendArgs = "game";
+
+  struct MethodGenInfo methodAssets;
+  methodAssets.name = "getRequiredAssets";
+  methodAssets.isOverride = true;
+  methodAssets.type = "std::vector<Asset*>";
+  line(&methodAssets.body, "auto assMan = &this->game->assetManager;", "");
+  line(&methodAssets.body, "std::vector<Asset*> assets;", "");
+
+  struct MethodGenInfo methodInit;
+  methodInit.name = "stage";
+  methodInit.isOverride = true;
+
+  classInfo.includes.push_back("scene/Scene.hpp");
+
+
+  // Generate
+  int32_t assetNumber = 0;
+  int32_t childNumber = 0;
+  int32_t componentNumber = 0;
+  std::map<std::string, std::string> assetMap;
+
+  auto sceneItems = scene->items.begin();
+  while(sceneItems != scene->items.end()) {
+    SceneItemGenerator::generate(
+      assetNumber,
+      componentNumber,
+      childNumber,
+      assetMap,
+      classInfo.includes,
+      &classInfo.publicProperties,
+      &methodInit.body,
+      &methodAssets.body,
+      "",
+      "this",
+      &(*sceneItems),
+      ""
+    );
+    ++sceneItems;
+  }
+
+  // Seal methods
+  line(&methodAssets.body, "return assets;", "");
+
+  // Add in methods
+  CodeGen::methodGen(&classInfo.publicCode, methodAssets);
+  line(&classInfo.publicCode, "", "");
+  CodeGen::methodGen(&classInfo.publicCode, methodInit);
+
+  CodeGen::classGen(out, classInfo);
+}

src/dawntools/scenetool/SceneGen.hpp

@@ -0,0 +1,19 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "SceneParser.hpp"
+#include "util/generator/SceneItemGenerator.hpp"
+
+namespace Dawn {
+  class SceneGen : public CodeGen {
+    public:
+      static void generate(
+        std::vector<std::string> *out,
+        struct Scene *scene,
+        std::string tabs
+      );
+  };
+}

src/dawntools/scenetool/SceneTool.cpp

@@ -42,10 +42,9 @@ int32_t SceneTool::start() {
     return result;
   }
 
-
   // Generate output
   std::vector<std::string> outputData;
-  // VNSceneGen::generate(&outputData, &scene, "");
+  SceneGen::generate(&outputData, &scene, "");
 
   // Load output file from name and type
   File outputFile = File(flags["output"] + "/scenes/TestScene.hpp");

src/dawntools/scenetool/SceneTool.hpp

@@ -8,6 +8,7 @@
 #include "util/File.hpp"
 #include "util/Xml.hpp"
 #include "SceneParser.hpp"
+#include "SceneGen.hpp"
 
 namespace Dawn {
   class SceneTool : public DawnTool {

src/dawntools/util/generator/SceneItemGenerator.cpp

@@ -17,23 +17,42 @@ void SceneItemGenerator::generate(
   std::vector<std::string> *initBody,
   std::vector<std::string> *assetBody,
   std::string parentRef,
+  std::string sceneRef,
   struct SceneItem *item,
   std::string tabs
 ) {
-  auto name = "itm" + std::to_string(childNumber++);
+  // Determine interface
+  std::string name = "itm" + std::to_string(childNumber++);
+  std::string itemType = "SceneItem";
 
   if(item->ref == "this") {
     name = item->ref;
   } else {
-    bool_t init = true;
+    // Determine name
-    if(item->ref.size() > 0) {
+    if(!item->ref.empty()) name = item->ref;
-      init = false;
+
-      name = item->ref;
+    // Initialize, either prefab or created.
-      if(item->ref != "this") {
+    if(!item->prefab.empty()) {
-        line(publicProperties, "SceneItemComponent *" + name + " = nullptr;", "");
+      // Determine prefab name, type and include
+      std::string prefabName = item->prefab;
+      if(prefabName.find("/") != std::string::npos) {
+        prefabName = prefabName.substr(prefabName.find_last_of("/") + 1);
       }
+      itemType = prefabName;
+
+      // Create prefab
+      includes.push_back(item->prefab + ".hpp");
+      line(initBody, (item->ref.empty() ? "auto " : "") + name + " = " + prefabName + "::create(" + sceneRef + ");", "");
+      line(assetBody, "vectorAppend(&assets, " + prefabName + "::getRequiredAssets(assMan));", "");
+    } else {
+      // Not a prefab, init empty child.
+      line(initBody, (item->ref.empty() ? "auto " : "") + name + " = " + sceneRef + "->createSceneItem();", "");
+    }
+    
+    // Property/Ref defintion
+    if(!item->ref.empty() && item->ref != "this") {
+      line(publicProperties, itemType + " *" + name + " = nullptr;", "");
     }
-    line(initBody, (init ? "auto " : "") + name + " = scene->createSceneItem();", "");
   }
 
   // Process extra properties
@@ -88,6 +107,7 @@ void SceneItemGenerator::generate(
       initBody,
       assetBody,
       name,
+      sceneRef,
       &(*itChildren),
       ""
     );

src/dawntools/util/generator/SceneItemGenerator.hpp

@@ -21,6 +21,7 @@ namespace Dawn {
         std::vector<std::string> *initBody,
         std::vector<std::string> *assetBody,
         std::string parentRef,
+        std::string sceneRef,
         struct SceneItem *item,
         std::string tabs
       );

src/dawntools/util/parser/SceneItemParser.cpp

@@ -15,7 +15,8 @@ std::map<std::string, std::string> SceneItemParser::getOptionalAttributes() {
   return {
     { "ref", "" },
     { "position", "" },
-    { "scale", "" }
+    { "scale", "" },
+    { "prefab", "" }
   };
 }
 
@@ -37,6 +38,8 @@ int32_t SceneItemParser::onParse(
     if(error->size() > 0) return 1;
   }
 
+  out->prefab = values["prefab"];
+
   auto itChildren = node->children.begin();
   while(itChildren != node->children.end()) {
     // Parse child nodes, they may be components or not

src/dawntools/util/parser/SceneItemParser.hpp

@@ -13,6 +13,7 @@ namespace Dawn {
     std::string ref;
     std::string position;
     std::string scale;
+    std::string prefab;
     std::vector<struct SceneItemComponent> components;
     std::vector<struct SceneItem> children;
     std::vector<struct SceneAsset> assets;