Prefab Generator Refactor

src/dawnliminal/CMakeLists.txt

@@ -18,6 +18,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_prefab(${LIMINAL_ASSETS_DIR}/VNTextbox.xml)
@@ -25,3 +26,4 @@ tool_truetype(font_main ${DAWN_ASSETS_DIR}/ark-pixel.ttf)
 
 tool_prefab(${LIMINAL_ASSETS_DIR}/prefabs/EthPrefab.xml)
 tool_texture(texture_eth ${LIMINAL_ASSETS_DIR}/textures/eth.png)
+tool_texture(texture_border ${LIMINAL_ASSETS_DIR}/textures/texture_test.png)

src/dawntools/CMakeLists.txt

@@ -16,10 +16,14 @@ set(
 )
 
 # Tool-Utils
+set(DAWN_TOOL_SOURCES "")
 include(util/CMakeLists.txt)
+include(util/parser/CMakeLists.txt)
+include(util/generator/CMakeLists.txt)
 
 # Tools
 add_subdirectory(prefabtool)
+add_subdirectory(scenetool)
 add_subdirectory(texturetool)
 add_subdirectory(truetypetool)
 add_subdirectory(vnscenetool)

src/dawntools/prefabtool/CMakeLists.txt

@@ -12,13 +12,9 @@ target_sources(prefabtool
   PRIVATE
     ${DAWN_SHARED_SOURCES}
     ${DAWN_TOOL_SOURCES}
-    PrefabAssetParser.cpp
     PrefabTool.cpp
     PrefabGen.cpp
-    PrefabChildParser.cpp
     PrefabParser.cpp
-    PrefabRegistry.cpp
-    PrefabComponentParser.cpp
 )
 
 # Includes

src/dawntools/prefabtool/PrefabComponentParser.cpp

@@ -1,89 +0,0 @@
-// Copyright (c) 2023 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#include "PrefabComponentParser.hpp"
-
-using namespace Dawn;
-
-std::vector<std::string> PrefabComponentParser::getRequiredAttributes() {
-  return { };
-}
-
-std::map<std::string, std::string> PrefabComponentParser::getOptionalAttributes() {
-  return { { "ref", "" } };
-}
-
-int32_t PrefabComponentParser::onParse(
-  Xml *node,
-  std::map<std::string, std::string> values,
-  struct PrefabComponent *out,
-  std::string *error
-) {
-  // Check if values contains key "ref" and has a string of size more than 0
-  if(values.find("ref") != values.end() && values["ref"].size() > 0) {
-    out->ref = values["ref"];
-  }
-
-  // Get the ruleset.
-  auto ruleset = out->registry->getRuleset(node->node);
-  if(ruleset.name.size() == 0) {
-    *error =  "Unknown prefab node type: " + node->node;
-    return 1;
-  }
-
-  out->include = ruleset.include;
-  out->type = node->node;
-
-  // Define parser types here.
-
-  // Iterate all the optional attributes and store within the out if present
-  auto itOptional = ruleset.optional.begin();
-  while(itOptional != ruleset.optional.end()) {
-    // Determine the parser to use
-    auto name = itOptional->first;
-    auto type = itOptional->second;
-
-    std::function<std::string(std::string, std::string*)> parser = rawParser;
-    if(type.find("string") != std::string::npos) {
-      parser = stringParser;
-    } else if(type.find("float") != std::string::npos) {
-      parser = floatParser;
-    } else if(type.find("Color") != std::string::npos) {
-      parser = colorParser;
-    } else if(type.find("vec2") != std::string::npos) {
-      parser = vec2Parser;
-    } else if(type.find("vec3") != std::string::npos) {
-      parser = vec3Parser;
-    } else if(type.find("vec4") != std::string::npos) {
-      parser = vec4Parser;
-    } else if(type == "int32_t" || type == "int") {
-      parser = intParser;
-    } else if(type == "bool_t") {
-      parser = boolParser;
-    } else if(type == "flag_t") {
-      parser = rawParser;
-    } else if(type.starts_with("enum")) {
-      parser = rawParser;
-    } else if(type.find("*") == (type.size() - 1)) {
-      type = type.substr(0, type.size() - 1);
-      parser = rawParser;
-    } else if(name[0] == '*') {
-      name = name.substr(1, name.size());
-      parser = rawParser;
-    } else {
-      *error = "Unknown parser for type: " + type + "::" + name;
-      return 1;
-    }
-
-    if(node->attributes.find(name) != node->attributes.end()) {
-      auto raw = node->attributes[name];
-      out->values[name] = parser(raw, error);
-      if(error->size() != 0) return 1;
-    }
-    ++itOptional;
-  }
-
-  return 0;
-}

src/dawntools/prefabtool/PrefabGen.cpp

@@ -32,123 +32,25 @@ void PrefabGen::generate(
 
   classInfo.includes.push_back("prefab/SceneItemPrefab.hpp");
 
-  // Process assets
+  // Generate
   int32_t assetNumber = 0;
-  std::map<std::string, std::string> assetMap;
-  auto processAsset = [&](struct PrefabAsset a) {
-    std::string assetType = "";
-    a.usageName = "asset" + std::to_string(assetNumber++);
-    switch(a.type) {
-      case PREFAB_ASSET_TYPE_TEXTURE:
-        assetType = "TextureAsset";
-        assetMap[a.fileName] = "&" + a.usageName + "->texture";
-        break;
-
-      case PREFAB_ASSET_TYPE_TRUETYPE_FONT:
-        assetType = "TrueTypeAsset";
-        assetMap[a.fileName] = "&" + a.usageName + "->font";
-        break;
-
-      default:
-        assertUnreachable();
-    }
-    line(&methodInit.body, "auto " + a.usageName + " = man->get<" + assetType + ">(\"" + a.fileName + "\");", "");
-    line(&methodAssets.body, "assets.push_back(man->get<" + assetType + ">(\"" + a.fileName + "\"));", "");
-  };
-
-  // Load self assets
-  auto itAssets = info->root.assets.begin();
-  while(itAssets != info->root.assets.end()) {
-    processAsset(*itAssets);
-    ++itAssets;
-  }
-  // TODO: Load child assets?
-  line(&methodInit.body, "", "");
-
-  // Process root and all of its children
   int32_t childNumber = 0;
   int32_t componentNumber = 0;
-
+  std::map<std::string, std::string> assetMap;
-  auto processComponent = [&](struct PrefabComponent c, std::string item) {
+  info->root.ref = "this";
-    auto componentName = "cmp" + std::to_string(componentNumber++);
+  SceneItemGenerator::generate(
-    bool_t componentInit = true;
+    assetNumber,
-    if(c.ref.size() > 0) {
+    componentNumber,
-      componentInit = false;
+    childNumber,
-      componentName = c.ref;
+    assetMap,
-      line(&classInfo.publicProperties, c.type + " *" + c.ref + " = nullptr;", "");
+    classInfo.includes,
-    }
+    &classInfo.publicProperties,
-
+    &methodInit.body,
-    // Initialize
+    &methodAssets.body,
-    line(&methodInit.body, (componentInit ? "auto " : "") + componentName + " = " + item + "->addComponent<" + c.type + ">();", "");
+    "",
-
+    &info->root,
-    // Now set each property
+    ""
-    auto itValues = c.values.begin();
+  );
-    while(itValues != c.values.end()) {
-      auto value = itValues->second;
-      if(assetMap.find(value) != assetMap.end()) {
-        value = assetMap[value];
-      }
-      line(&methodInit.body, componentName + "->" + itValues->first + " = " + value + ";", "");
-      ++itValues;
-    }
-
-    classInfo.includes.push_back(c.include);
-  };
-
-  std::function<void(struct PrefabChild &, std::string)> processChild;
-  processChild = [&](struct PrefabChild &child, std::string parent) {
-    auto name = "itm" + std::to_string(childNumber++);
-    bool_t init = true;
-    if(child.ref.size() > 0) {
-      init = false;
-      name = child.ref;
-      line(&classInfo.publicProperties, "SceneItemComponent *" + name + " = nullptr;", "");
-    }
-    line(&methodInit.body, (init ? "auto " : "") + name + " = scene->createSceneItem();", "");
-
-    // Process extra properties
-    if(child.position.size() > 0) {
-      line(&methodInit.body, name + "->transform.setLocalPosition(" + child.position + ");", "");
-    }
-
-    if(child.scale.size() > 0) {
-      line(&methodInit.body, name + "->transform.setLocalScale(" + child.scale + ");", "");
-    }
-
-    // Add components for children
-    auto itComponents = child.components.begin();
-    while(itComponents != child.components.end()) {
-      auto c = *itComponents;
-      processComponent(c, name);
-      ++itComponents;
-    }
-
-    // Process sub children
-    auto itChildren = child.children.begin();
-    while(itChildren != child.children.end()) {
-      processChild(*itChildren, name);
-      ++itChildren;
-    }
-
-    // Set parent
-    line(&methodInit.body, name + "->transform.setParent(&"+parent+"->transform);", "");
-  };
-  
-  // Process each child
-  auto itChildren = info->root.children.begin();
-  while(itChildren != info->root.children.end()) {
-    processChild(*itChildren, "this");
-    line(&methodInit.body, "", "");
-    ++itChildren;
-  }
-
-  // Process self components
-  auto itComponents = info->root.components.begin();
-  while(itComponents != info->root.components.end()) {
-    auto c = *itComponents;
-    processComponent(c, "this");
-    ++itComponents;
-  }
   
   // Seal methods
   line(&methodAssets.body, "return assets;", "");

src/dawntools/prefabtool/PrefabGen.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 #include "PrefabParser.hpp"
+#include "util/generator/SceneItemGenerator.hpp"
 
 namespace Dawn {
   class PrefabGen : public CodeGen {

src/dawntools/prefabtool/PrefabParser.cpp

@@ -24,5 +24,5 @@ int32_t PrefabParser::onParse(
   out->name = values["name"];
   out->type = values["type"];
   out->root.registry = out->registry;
-  return (PrefabChildParser()).parse(node, &out->root, error);
+  return (SceneItemParser()).parse(node, &out->root, error);
 }

src/dawntools/prefabtool/PrefabParser.hpp

@@ -4,13 +4,13 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "PrefabComponentParser.hpp"
+#include "util/parser/SceneItemComponentParser.hpp"
-#include "PrefabChildParser.hpp"
+#include "util/parser/SceneItemParser.hpp"
 
 namespace Dawn {
   struct Prefab {
-    struct PrefabRegistry *registry;
+    struct SceneItemComponentRegistry *registry;
-    struct PrefabChild root;
+    struct SceneItem root;
     std::string name;
     std::string type;
   };

src/dawntools/prefabtool/PrefabTool.cpp

@@ -28,7 +28,7 @@ int32_t PrefabTool::start() {
     return 1;
   }
 
-  struct PrefabRegistry registry;
+  struct SceneItemComponentRegistry registry;
   registry.sources = File::normalizeSlashes(flags["sources"]);
 
   auto xml = Xml::load(data);
@@ -41,7 +41,6 @@ int32_t PrefabTool::start() {
     return result;
   }
 
-
   // Generate output
   std::vector<std::string> outputData;
   PrefabGen::generate(&outputData, &prefab, "");

src/dawntools/scenetool/CMakeLists.txt

@@ -0,0 +1,61 @@
+# Copyright (c) 2023 Dominic Msters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Texture Build Tool
+project(scenetool VERSION 1.0)
+add_executable(scenetool)
+
+# Subdirs
+
+# Sources
+target_sources(scenetool
+  PRIVATE
+    ${DAWN_SHARED_SOURCES}
+    ${DAWN_TOOL_SOURCES}
+    SceneTool.cpp
+    SceneParser.cpp
+)
+
+# Includes
+target_include_directories(scenetool
+  PUBLIC
+    ${DAWN_SHARED_INCLUDES}
+    ${DAWN_TOOL_INCLUDES}
+    ${CMAKE_CURRENT_LIST_DIR}
+)
+
+# Definitions
+target_compile_definitions(scenetool
+  PUBLIC
+    ${DAWN_SHARED_DEFINITIONS}
+    DAWN_TOOL_INSTANCE=SceneTool
+    DAWN_TOOL_HEADER="SceneTool.hpp"
+)
+
+# Libraries
+target_link_libraries(scenetool
+  PUBLIC
+    ${DAWN_BUILD_HOST_LIBS}
+)
+
+# Tool Function
+function(tool_scene in)
+  set(DEPS "")
+  if(DAWN_BUILD_TOOLS)
+    set(DEPS scenetool)
+  endif()
+
+  STRING(REGEX REPLACE "[\.|\\|\/]" "-" scene_name ${in})
+  add_custom_target(scene_${scene_name}
+    COMMAND scenetool --input="${DAWN_ASSETS_SOURCE_DIR}/${in}" --output="${DAWN_GENERATED_DIR}/generatedscenes" --sources="${DAWN_SOURCES_DIR}"
+    COMMENT "Generating prefab from ${in}"
+    DEPENDS ${DEPS}
+  )
+  target_include_directories(${DAWN_TARGET_NAME}
+    PUBLIC
+      ${DAWN_GENERATED_DIR}/generatedscenes
+  )
+  add_dependencies(${DAWN_TARGET_NAME} scene_${scene_name})
+endfunction()

src/dawntools/scenetool/SceneParser.cpp

@@ -0,0 +1,49 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneParser.hpp"
+
+using namespace Dawn;
+
+std::vector<std::string> SceneParser::getRequiredAttributes() {
+  return { "name" };
+}
+
+std::map<std::string, std::string> SceneParser::getOptionalAttributes() {
+  return {};
+}
+
+int32_t SceneParser::onParse(
+  Xml *node,
+  std::map<std::string, std::string> values,
+  struct Scene *out,
+  std::string *error
+) {
+  int32_t ret;
+
+  //Create the scene item
+  out->name = values["name"];
+
+  //Parse the children
+  auto itChildren = node->children.begin();
+  while(itChildren != node->children.end()) {
+    Xml *child = *itChildren;
+    
+    if(child->node == "item") {
+      struct SceneItem item;
+      item.registry = out->registry;
+      ret = (SceneItemParser()).parse(child, &item, error);
+      if(ret != 0) return 1;
+      out->items.push_back(item);
+    } else {
+      *error = "Unknown node type " + child->node;
+      return 1;
+    }
+
+    ++itChildren;
+  }
+
+  return 0;
+}

src/dawntools/scenetool/SceneParser.hpp

@@ -0,0 +1,27 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "util/parser/SceneItemParser.hpp"
+
+namespace Dawn {
+  struct Scene {
+    std::string name;
+    std::vector<struct SceneItem> items;
+    struct SceneItemComponentRegistry *registry;
+  };
+
+  class SceneParser : public XmlParser<struct Scene> {
+    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 Scene *out,
+        std::string *error
+      ) override;
+  };
+}

src/dawntools/scenetool/SceneTool.cpp

@@ -0,0 +1,71 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneTool.hpp"
+
+using namespace Dawn;
+
+std::vector<std::string> SceneTool::getRequiredFlags() {
+  return { "input", "output", "sources" };
+}
+
+std::map<std::string, std::string> SceneTool::getOptionalFlags() {
+  return std::map<std::string, std::string>();
+}
+
+int32_t SceneTool::start() {
+  File input = File(flags["input"]);
+  if(!input.exists()) {
+    std::cout << "Input file does not exist!" << std::endl;
+    return 1;
+  }
+
+  std::string data;
+  if(!input.readString(&data)) {
+    std::cout << "Failed to read input file!" << std::endl;
+    return 1;
+  }
+
+  auto xml = Xml::load(data);
+  std::string error;
+
+  struct Scene scene;
+  struct SceneItemComponentRegistry registry;
+  registry.sources = File::normalizeSlashes(flags["sources"]);
+  scene.registry = &registry;
+
+  auto result = ((SceneParser()).parse(&xml, &scene, &error));
+  if(result != 0) {
+    std::cout << "Failed to parse scene " << input.filename << "::" << error << std::endl;
+    return result;
+  }
+
+
+  // Generate output
+  std::vector<std::string> outputData;
+  // VNSceneGen::generate(&outputData, &scene, "");
+
+  // Load output file from name and type
+  File outputFile = File(flags["output"] + "/scenes/TestScene.hpp");
+  if(!outputFile.mkdirp()) {
+    std::cout << "Failed to create output directory!" << std::endl;
+    return 1;
+  }
+
+  // Combine vector into single string
+  std::string outputDataStr = "";
+  auto it = outputData.begin();
+  while(it != outputData.end()) {
+    outputDataStr += *it + "\n";
+    ++it; 
+  }
+  
+  if(!outputFile.writeString(outputDataStr)) {
+    std::cout << "Failed to write output file! " << input.filename << std::endl;
+    return 1;
+  }
+
+  return 0;
+}

src/dawntools/scenetool/SceneTool.hpp

@@ -0,0 +1,21 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "util/DawnTool.hpp"
+#include "util/File.hpp"
+#include "util/Xml.hpp"
+#include "SceneParser.hpp"
+
+namespace Dawn {
+  class SceneTool : public DawnTool {
+    protected:
+      std::vector<std::string> getRequiredFlags() override;
+      std::map<std::string, std::string> getOptionalFlags() override;
+
+    public:
+      int32_t start();
+  };
+}

src/dawntools/util/CMakeLists.txt

@@ -7,6 +7,7 @@ set(D ${CMAKE_CURRENT_LIST_DIR})
 
 set(
   DAWN_TOOL_SOURCES
+    ${DAWN_TOOL_SOURCES}
     ${D}/DawnTool.cpp
     ${D}/File.cpp
     ${D}/Language.cpp

src/dawntools/util/generator/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Copyright (c) 2023 Dominic Msters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+set(D ${CMAKE_CURRENT_LIST_DIR})
+
+set(
+  DAWN_TOOL_SOURCES
+    ${DAWN_TOOL_SOURCES}
+    ${D}/SceneItemGenerator.cpp
+    ${D}/SceneAssetGenerator.cpp
+    ${D}/SceneItemComponentGenerator.cpp
+
+  CACHE INTERNAL
+    ${DAWN_CACHE_TARGET}
+)

src/dawntools/util/generator/SceneAssetGenerator.cpp

@@ -0,0 +1,38 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneAssetGenerator.hpp"
+
+using namespace Dawn;
+
+void SceneAssetGenerator::generate(
+  std::map<std::string, std::string> &assetMap,
+  int32_t &assetNumber,
+  std::vector<std::string> *initBody,
+  std::vector<std::string> *assetsBody,
+  struct SceneAsset *asset,
+  std::string tabs
+) {
+  std::string assetType = "";
+  asset->usageName = "asset" + std::to_string(assetNumber++);
+
+  switch(asset->type) {
+    case SCENE_ASSET_TYPE_TEXTURE:
+      assetType = "TextureAsset";
+      assetMap[asset->fileName] = "&" + asset->usageName + "->texture";
+      break;
+
+    case SCENE_ASSET_TYPE_TRUETYPE_FONT:
+      assetType = "TrueTypeAsset";
+      assetMap[asset->fileName] = "&" + asset->usageName + "->font";
+      break;
+
+    default:
+      assertUnreachable();
+  }
+
+  line(initBody, "auto " + asset->usageName + " = man->get<" + assetType + ">(\"" + asset->fileName + "\");", "");
+  line(assetsBody, "assets.push_back(man->get<" + assetType + ">(\"" + asset->fileName + "\"));", "");
+}

src/dawntools/util/generator/SceneAssetGenerator.hpp

@@ -0,0 +1,22 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "util/parser/SceneAssetParser.hpp"
+#include "util/CodeGen.hpp"
+
+namespace Dawn {
+  class SceneAssetGenerator : public CodeGen {
+    public:
+      static void generate(
+        std::map<std::string, std::string> &assetMap,
+        int32_t &assetNumber,
+        std::vector<std::string> *initBody,
+        std::vector<std::string> *assetsBody,
+        struct SceneAsset *asset,
+        std::string tabs
+      );
+  };
+}

src/dawntools/util/generator/SceneItemComponentGenerator.cpp

@@ -0,0 +1,43 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneItemComponentGenerator.hpp"
+
+using namespace Dawn;
+
+void SceneItemComponentGenerator::generate(
+  std::map<std::string, std::string> &assetMap,
+  int32_t &componentNumber,
+  std::vector<std::string> &includes,
+  std::string itemRef,
+  std::vector<std::string> *publicProperties,
+  std::vector<std::string> *initBody,
+  struct SceneItemComponent *component,
+  std::string tabs
+) {
+  auto componentName = "cmp" + std::to_string(componentNumber++);
+  bool_t componentInit = true;
+  if(component->ref.size() > 0) {
+    componentInit = false;
+    componentName = component->ref;
+    line(publicProperties, component->type + " *" + component->ref + " = nullptr;", "");
+  }
+
+  // Initialize
+  line(initBody, (componentInit ? "auto " : "") + componentName + " = " + itemRef + "->addComponent<" + component->type + ">();", "");
+
+  // Now set each property
+  auto itValues = component->values.begin();
+  while(itValues != component->values.end()) {
+    auto value = itValues->second;
+    if(assetMap.find(value) != assetMap.end()) {
+      value = assetMap[value];
+    }
+    line(initBody, componentName + "->" + itValues->first + " = " + value + ";", "");
+    ++itValues;
+  }
+
+  includes.push_back(component->include);
+}

src/dawntools/util/generator/SceneItemComponentGenerator.hpp

@@ -0,0 +1,24 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "util/parser/SceneItemComponentParser.hpp"
+#include "util/CodeGen.hpp"
+
+namespace Dawn {
+  class SceneItemComponentGenerator : public CodeGen {
+    public:
+      static void generate(
+        std::map<std::string, std::string> &assetMap,
+        int32_t &componentNumber,
+        std::vector<std::string> &includes,
+        std::string itemRef,
+        std::vector<std::string> *publicProperties,
+        std::vector<std::string> *initBody,
+        struct SceneItemComponent *component,
+        std::string tabs
+      );
+  };
+}

src/dawntools/util/generator/SceneItemGenerator.cpp

@@ -0,0 +1,101 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneItemGenerator.hpp"
+
+using namespace Dawn;
+
+void SceneItemGenerator::generate(
+  int32_t &assetNumber,
+  int32_t &componentNumber,
+  int32_t &childNumber,
+  std::map<std::string, std::string> &assetMap,
+  std::vector<std::string> &includes,
+  std::vector<std::string> *publicProperties,
+  std::vector<std::string> *initBody,
+  std::vector<std::string> *assetBody,
+  std::string parentRef,
+  struct SceneItem *item,
+  std::string tabs
+) {
+  auto name = "itm" + std::to_string(childNumber++);
+
+  if(item->ref == "this") {
+    name = item->ref;
+  } else {
+    bool_t init = true;
+    if(item->ref.size() > 0) {
+      init = false;
+      name = item->ref;
+      if(item->ref != "this") {
+        line(publicProperties, "SceneItemComponent *" + name + " = nullptr;", "");
+      }
+    }
+    line(initBody, (init ? "auto " : "") + name + " = scene->createSceneItem();", "");
+  }
+
+  // Process extra properties
+  if(item->position.size() > 0) {
+    line(initBody, name + "->transform.setLocalPosition(" + item->position + ");", "");
+  }
+
+  if(item->scale.size() > 0) {
+    line(initBody, name + "->transform.setLocalScale(" + item->scale + ");", "");
+  }
+
+  // Add assets
+  auto itAssets = item->assets.begin();
+  while(itAssets != item->assets.end()) {
+    SceneAssetGenerator::generate(
+      assetMap,
+      assetNumber,
+      initBody,
+      assetBody,
+      &(*itAssets),
+      ""
+    );
+    ++itAssets;
+  }
+
+  // Add components for children
+  auto itComponents = item->components.begin();
+  while(itComponents != item->components.end()) {
+    SceneItemComponentGenerator::generate(
+      assetMap,
+      componentNumber,
+      includes,
+      name,
+      publicProperties,
+      initBody,
+      &(*itComponents),
+      ""
+    );
+    ++itComponents;
+  }
+
+  // Process sub children
+  auto itChildren = item->children.begin();
+  while(itChildren != item->children.end()) {
+    SceneItemGenerator::generate(
+      assetNumber,
+      componentNumber,
+      childNumber,
+      assetMap,
+      includes,
+      publicProperties,
+      initBody,
+      assetBody,
+      name,
+      &(*itChildren),
+      ""
+    );
+    ++itChildren;
+  }
+
+  // Set parent
+  if(!parentRef.empty()) {
+    line(initBody, name + "->transform.setParent(&"+parentRef+"->transform);", "");
+  }
+}

src/dawntools/util/generator/SceneItemGenerator.hpp

@@ -0,0 +1,28 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "SceneItemComponentGenerator.hpp"
+#include "SceneAssetGenerator.hpp"
+#include "util/parser/SceneItemParser.hpp"
+
+namespace Dawn {
+  class SceneItemGenerator : public CodeGen {
+    public:
+      static void generate(
+        int32_t &assetNumber,
+        int32_t &componentNumber,
+        int32_t &childNumber,
+        std::map<std::string, std::string> &assetMap,
+        std::vector<std::string> &includes,
+        std::vector<std::string> *publicProperties,
+        std::vector<std::string> *initBody,
+        std::vector<std::string> *assetBody,
+        std::string parentRef,
+        struct SceneItem *item,
+        std::string tabs
+      );
+  };
+}

src/dawntools/util/parser/CMakeLists.txt

@@ -0,0 +1,18 @@
+# Copyright (c) 2023 Dominic Msters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+set(D ${CMAKE_CURRENT_LIST_DIR})
+
+set(
+  DAWN_TOOL_SOURCES
+    ${DAWN_TOOL_SOURCES}
+    ${D}/SceneItemParser.cpp
+    ${D}/SceneAssetParser.cpp
+    ${D}/SceneItemComponentParser.cpp
+    ${D}/SceneItemComponentRegistry.cpp
+
+  CACHE INTERNAL
+    ${DAWN_CACHE_TARGET}
+)

src/dawntools/util/parser/SceneAssetParser.cpp

@@ -3,30 +3,30 @@
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
-#include "PrefabAssetParser.hpp"
+#include "SceneAssetParser.hpp"
 
 using namespace Dawn;
 
-std::vector<std::string> PrefabAssetParser::getRequiredAttributes() {
+std::vector<std::string> SceneAssetParser::getRequiredAttributes() {
   return { "type", "name" };
 }
 
-std::map<std::string, std::string> PrefabAssetParser::getOptionalAttributes() {
+std::map<std::string, std::string> SceneAssetParser::getOptionalAttributes() {
   return { };
 }
 
-int32_t PrefabAssetParser::onParse(
+int32_t SceneAssetParser::onParse(
   Xml *node,
   std::map<std::string, std::string> values,
-  struct PrefabAsset *out,
+  struct SceneAsset *out,
   std::string *error
 ) {
   out->fileName = values["name"];
   
   if(values["type"] == "texture") {
-    out->type = PREFAB_ASSET_TYPE_TEXTURE;
+    out->type = SCENE_ASSET_TYPE_TEXTURE;
   } else if(values["type"] == "truetype") {
-    out->type = PREFAB_ASSET_TYPE_TRUETYPE_FONT;
+    out->type = SCENE_ASSET_TYPE_TRUETYPE_FONT;
   } else {
     *error = "Unknown asset type '" + values["type"] + "'";
     return 1;

src/dawntools/util/parser/SceneAssetParser.hpp

@@ -7,18 +7,18 @@
 #include "util/XmlParser.hpp"
 
 namespace Dawn {
-  enum PrefabAssetType {
+  enum SceneAssetType {
-    PREFAB_ASSET_TYPE_TEXTURE,
+    SCENE_ASSET_TYPE_TEXTURE,
-    PREFAB_ASSET_TYPE_TRUETYPE_FONT
+    SCENE_ASSET_TYPE_TRUETYPE_FONT
   };
 
-  struct PrefabAsset {
+  struct SceneAsset {
-    PrefabAssetType type;
+    SceneAssetType type;
     std::string fileName;
     std::string usageName;
   };
 
-  class PrefabAssetParser : public XmlParser<PrefabAsset> {
+  class SceneAssetParser : public XmlParser<SceneAsset> {
     public:
       virtual std::vector<std::string> getRequiredAttributes();
       virtual std::map<std::string, std::string> getOptionalAttributes();
@@ -26,7 +26,7 @@ namespace Dawn {
       virtual int32_t onParse(
         Xml *node,
         std::map<std::string, std::string> values,
-        struct PrefabAsset *out,
+        struct SceneAsset *out,
         std::string *error
       );
   };

src/dawntools/util/parser/SceneItemComponentParser.cpp

@@ -0,0 +1,70 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneItemComponentParser.hpp"
+
+using namespace Dawn;
+
+std::vector<std::string> SceneItemComponentParser::getRequiredAttributes() {
+  return { };
+}
+
+std::map<std::string, std::string> SceneItemComponentParser::getOptionalAttributes() {
+  return { { "ref", "" } };
+}
+
+int32_t SceneItemComponentParser::onParse(
+  Xml *node,
+  std::map<std::string, std::string> values,
+  struct SceneItemComponent *out,
+  std::string *error
+) {
+  // Check if values contains key "ref" and has a string of size more than 0
+  if(values.find("ref") != values.end() && values["ref"].size() > 0) {
+    out->ref = values["ref"];
+  }
+
+  // Get the ruleset.
+  auto ruleset = out->registry->getRuleset(node->node);
+  if(ruleset.name.size() == 0) {
+    *error =  "Unknown prefab node type: " + node->node;
+    return 1;
+  }
+
+  out->include = ruleset.include;
+  out->type = node->node;
+
+  // Define parser types here.
+
+  // Iterate all the optional attributes and store within the out if present
+  auto itOptional = ruleset.optional.begin();
+  while(itOptional != ruleset.optional.end()) {
+    // Determine the parser to use
+    auto name = itOptional->first;
+    auto type = itOptional->second;
+
+    std::function<std::string(std::string, std::string*)> parser = rawParser;
+    try {
+      parser = parserFromTypeName(type);
+    } catch(std::string err) {
+      if(name[0] == '*') {
+        name = name.substr(1, name.size());
+        parser = rawParser;
+      } else {
+        *error = "Unknown parser for type: " + type + "::" + name;
+        return 1;
+      }
+    }
+
+    if(node->attributes.find(name) != node->attributes.end()) {
+      auto raw = node->attributes[name];
+      out->values[name] = parser(raw, error);
+      if(error->size() != 0) return 1;
+    }
+    ++itOptional;
+  }
+
+  return 0;
+}

src/dawntools/util/parser/SceneItemComponentParser.hpp

@@ -4,26 +4,26 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "PrefabRegistry.hpp"
+#include "util/parser/SceneItemComponentRegistry.hpp"
-#include "Parsers.hpp"
+#include "util/parser/TypeParsers.hpp"
 
 namespace Dawn {
-  struct PrefabComponent {
+  struct SceneItemComponent {
-    struct PrefabRegistry *registry;
+    struct SceneItemComponentRegistry *registry;
     std::string include;
     std::string type;
     std::map<std::string, std::string> values;
     std::string ref;
   };
 
-  class PrefabComponentParser : public XmlParser<struct PrefabComponent> {
+  class SceneItemComponentParser : public XmlParser<struct SceneItemComponent> {
     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 PrefabComponent *out,
+        struct SceneItemComponent *out,
         std::string *error
       ) override;
   };

src/dawntools/util/parser/SceneItemComponentRegistry.cpp

@@ -3,11 +3,11 @@
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
-#include "PrefabRegistry.hpp"
+#include "SceneItemComponentRegistry.hpp"
 
 using namespace Dawn;
 
-struct PrefabComponentParserRuleset PrefabRegistry::parseFile(
+struct SceneItemComponentRuleset SceneItemComponentRegistry::parseFile(
   File *file,
   std::string clazz
 ) {
@@ -30,7 +30,7 @@ struct PrefabComponentParserRuleset PrefabRegistry::parseFile(
     includePath = includePath.substr(firstSlash + 1, includePath.size() - firstSlash - 1);
   }
   
-  struct PrefabComponentParserRuleset ruleset;
+  struct SceneItemComponentRuleset ruleset;
   // Replace all file seps with slashes
   size_t pos = 0;
   while ((pos = includePath.find(FILE_PATH_SEP, pos)) != std::string::npos) {
@@ -120,7 +120,7 @@ struct PrefabComponentParserRuleset PrefabRegistry::parseFile(
   return ruleset;
 }
 
-struct PrefabComponentParserRuleset PrefabRegistry::getRuleset(std::string type) {
+struct SceneItemComponentRuleset SceneItemComponentRegistry::getRuleset(std::string type) {
   if(this->rulesets.find(type) != this->rulesets.end()) {
     return this->rulesets[type];
   }
@@ -152,7 +152,7 @@ struct PrefabComponentParserRuleset PrefabRegistry::getRuleset(std::string type)
 
       // Load ruleset
       File file(str + "/" + itChildren->first);
-      auto parsed = PrefabRegistry::parseFile(&file, type);
+      auto parsed = SceneItemComponentRegistry::parseFile(&file, type);
       if(parsed.name == "") {
         std::cout << "Parsing error occured on " << type << std::endl;
         return parsed;

src/dawntools/util/parser/SceneItemComponentRegistry.hpp

@@ -12,7 +12,7 @@
 #include <regex>
 
 namespace Dawn {
-  struct PrefabComponentParserRuleset {
+  struct SceneItemComponentRuleset {
     std::string name;
     std::string include;
     std::map<std::string, std::string> selfOptional;
@@ -20,12 +20,11 @@ namespace Dawn {
     std::vector<std::string> extends;
   };
 
-
+  struct SceneItemComponentRegistry {
-  struct PrefabRegistry {
     std::string sources;
-    std::map<std::string, struct PrefabComponentParserRuleset> rulesets;
+    std::map<std::string, struct SceneItemComponentRuleset> rulesets;
 
-    struct PrefabComponentParserRuleset parseFile(
+    struct SceneItemComponentRuleset parseFile(
       File *file,
       std::string clazz
     );
@@ -36,6 +35,6 @@ namespace Dawn {
      * @param type Scene Item Component Type to get ruleset for.
      * @return The found ruleset, or an empty ruleset if not found.
      */
-    struct PrefabComponentParserRuleset getRuleset(std::string type);
+    struct SceneItemComponentRuleset getRuleset(std::string type);
   };
 }

src/dawntools/util/parser/SceneItemParser.cpp

@@ -3,15 +3,15 @@
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
-#include "PrefabChildParser.hpp"
+#include "SceneItemParser.hpp"
 
 using namespace Dawn;
 
-std::vector<std::string> PrefabChildParser::getRequiredAttributes() {
+std::vector<std::string> SceneItemParser::getRequiredAttributes() {
   return std::vector<std::string>();
 }
 
-std::map<std::string, std::string> PrefabChildParser::getOptionalAttributes() {
+std::map<std::string, std::string> SceneItemParser::getOptionalAttributes() {
   return {
     { "ref", "" },
     { "position", "" },
@@ -19,10 +19,10 @@ std::map<std::string, std::string> PrefabChildParser::getOptionalAttributes() {
   };
 }
 
-int32_t PrefabChildParser::onParse(
+int32_t SceneItemParser::onParse(
   Xml *node,
   std::map<std::string, std::string> values,
-  struct PrefabChild *out,
+  struct SceneItem *out,
   std::string *error
 ) {
   out->ref = values["ref"];
@@ -41,23 +41,24 @@ int32_t PrefabChildParser::onParse(
   while(itChildren != node->children.end()) {
     // Parse child nodes, they may be components or not
     auto c = *itChildren;
-    if(c->node == "child") {
+  
-      struct PrefabChild child;
+    if(c->node == "child" || c->node == "item") {
+      struct SceneItem child;
       child.registry = out->registry;
-      auto ret = (PrefabChildParser()).parse(c, &child, error);
+      auto ret = (SceneItemParser()).parse(c, &child, error);
       if(ret != 0) return ret;
       out->children.push_back(child);
       
     } else if(c->node == "asset") {
-      struct PrefabAsset asset;
+      struct SceneAsset asset;
-      auto ret = (PrefabAssetParser()).parse(c, &asset, error);
+      auto ret = (SceneAssetParser()).parse(c, &asset, error);
       if(ret != 0) return ret;
       out->assets.push_back(asset);
       
     } else {
-      struct PrefabComponent component;
+      struct SceneItemComponent component;
       component.registry = out->registry;
-      auto ret = (PrefabComponentParser()).parse(c, &component, error);
+      auto ret = (SceneItemComponentParser()).parse(c, &component, error);
       if(ret != 0) return ret;
       out->components.push_back(component);
     }

src/dawntools/util/parser/SceneItemParser.hpp

@@ -4,28 +4,28 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "PrefabComponentParser.hpp"
+#include "util/parser/SceneItemComponentParser.hpp"
-#include "PrefabAssetParser.hpp"
+#include "util/parser/SceneAssetParser.hpp"
 
 namespace Dawn {
-  struct PrefabChild {
+  struct SceneItem {
-    struct PrefabRegistry *registry;
+    struct SceneItemComponentRegistry *registry;
     std::string ref;
     std::string position;
     std::string scale;
-    std::vector<struct PrefabComponent> components;
+    std::vector<struct SceneItemComponent> components;
-    std::vector<struct PrefabChild> children;
+    std::vector<struct SceneItem> children;
-    std::vector<struct PrefabAsset> assets;
+    std::vector<struct SceneAsset> assets;
   };
 
-  class PrefabChildParser : public XmlParser<struct PrefabChild> {
+  class SceneItemParser : public XmlParser<struct SceneItem> {
     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 PrefabChild *out,
+        struct SceneItem *out,
         std::string *error
       ) override;
   };

src/dawntools/util/parser/TypeParsers.hpp

@@ -99,4 +99,37 @@ namespace Dawn {
   static inline std::string colorParser(std::string v, std::string *error) {
     return rawParser(v, error);
   }
+
+  static inline std::function<std::string(std::string, std::string*)> parserFromTypeName(std::string type) {
+    std::function<std::string(std::string, std::string*)> parser = rawParser;
+
+    if(type.find("string") != std::string::npos) {
+      parser = stringParser;
+    } else if(type.find("float") != std::string::npos) {
+      parser = floatParser;
+    } else if(type.find("Color") != std::string::npos) {
+      parser = colorParser;
+    } else if(type.find("vec2") != std::string::npos) {
+      parser = vec2Parser;
+    } else if(type.find("vec3") != std::string::npos) {
+      parser = vec3Parser;
+    } else if(type.find("vec4") != std::string::npos) {
+      parser = vec4Parser;
+    } else if(type == "int32_t" || type == "int") {
+      parser = intParser;
+    } else if(type == "bool_t") {
+      parser = boolParser;
+    } else if(type == "flag_t") {
+      parser = rawParser;
+    } else if(type.starts_with("enum")) {
+      parser = rawParser;
+    } else if(type.find("*") == (type.size() - 1)) {
+      type = type.substr(0, type.size() - 1);
+      parser = rawParser;
+    } else {
+      throw std::string("Invalid parser type");
+    }
+
+    return parser;
+  }
 }