Added code support, not great but hey it works

src/dawntools/util/generator/CMakeLists.txt

@@ -10,6 +10,7 @@ set(
     ${DAWN_TOOL_SOURCES}
     ${D}/SceneItemGenerator.cpp
     ${D}/SceneAssetGenerator.cpp
+    ${D}/SceneCodeGenerator.cpp
     ${D}/SceneGenerator.cpp
     ${D}/SceneItemComponentGenerator.cpp
 

src/dawntools/util/generator/SceneCodeGenerator.cpp

@@ -0,0 +1,28 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneCodeGenerator.hpp"
+
+using namespace Dawn;
+
+void SceneCodeGenerator::generate(
+  std::vector<std::string> *publicProperties,
+  std::vector<std::string> *initBody,
+  struct SceneCode *code,
+  std::string tabs
+) {
+  switch(code->codeType) {
+    case SCENE_CODE_TYPE_PROPERTIES:
+      line(publicProperties, code->code, "");
+      break;
+    
+    case SCENE_CODE_TYPE_INIT:
+      line(initBody, code->code, "");
+      break;
+
+    default:
+      break;
+  }
+}

src/dawntools/util/generator/SceneCodeGenerator.hpp

@@ -0,0 +1,20 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "util/parser/SceneCodeParser.hpp"
+#include "util/CodeGen.hpp"
+
+namespace Dawn {
+  class SceneCodeGenerator : public CodeGen {
+    public:
+      static void generate(
+        std::vector<std::string> *publicProperties,
+        std::vector<std::string> *initBody,
+        struct SceneCode *code,
+        std::string tabs
+      );
+  };
+}

src/dawntools/util/generator/SceneGenerator.cpp

@@ -76,4 +76,16 @@ void SceneGenerator::generate(
 
   // Seal methods
   line(&methodAssets.body, "return assets;", "");
+
+  // Code
+  auto itCode = scene->code.begin();
+  while(itCode != scene->code.end()) {
+    SceneCodeGenerator::generate(
+      &classInfo.publicProperties,
+      &methodInit.body,
+      &(*itCode),
+      ""
+    );
+    ++itCode;
+  }
 }

src/dawntools/util/generator/SceneItemGenerator.cpp

@@ -122,4 +122,16 @@ void SceneItemGenerator::generate(
   if(!parentRef.empty()) {
     line(initBody, name + "->transform.setParent(&"+parentRef+"->transform);", "");
   }
+
+  // Code
+  auto itCode = item->code.begin();
+  while(itCode != item->code.end()) {
+    SceneCodeGenerator::generate(
+      publicProperties,
+      initBody,
+      &(*itCode),
+      ""
+    );
+    ++itCode;
+  }
 }

src/dawntools/util/generator/SceneItemGenerator.hpp

@@ -7,6 +7,7 @@
 #include "SceneItemComponentGenerator.hpp"
 #include "SceneAssetGenerator.hpp"
 #include "util/parser/SceneItemParser.hpp"
+#include "util/generator/SceneCodeGenerator.hpp"
 
 namespace Dawn {
   class SceneItemGenerator : public CodeGen {

src/dawntools/util/parser/CMakeLists.txt

@@ -11,6 +11,7 @@ set(
     ${D}/SceneParser.cpp
     ${D}/SceneItemParser.cpp
     ${D}/SceneAssetParser.cpp
+    ${D}/SceneCodeParser.cpp
     ${D}/SceneItemComponentParser.cpp
     ${D}/SceneItemComponentRegistry.cpp
 

src/dawntools/util/parser/SceneCodeParser.cpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneCodeParser.hpp"
+
+using namespace Dawn;
+
+std::vector<std::string> SceneCodeParser::getRequiredAttributes() {
+  return { "type" };
+}
+
+std::map<std::string, std::string> SceneCodeParser::getOptionalAttributes() {
+  return {};
+}
+
+int32_t SceneCodeParser::onParse(
+  Xml *node,
+  std::map<std::string, std::string> values,
+  struct SceneCode *out,
+  std::string *error
+) {
+  // Get the type
+  std::string type = values["type"];
+  if(type == "properties") {
+    out->codeType = SCENE_CODE_TYPE_PROPERTIES;
+  } else if(type == "init") {
+    out->codeType = SCENE_CODE_TYPE_INIT;
+  } else {
+    *error = "Invalid type '" + type + "' for SceneCode.";
+    return -1;
+  }
+
+  // Get the code
+  out->code = node->value;
+
+  return 0;
+}

src/dawntools/util/parser/SceneCodeParser.hpp

@@ -0,0 +1,32 @@
+// 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 {
+  enum SceneCodeType {
+    SCENE_CODE_TYPE_PROPERTIES,
+    SCENE_CODE_TYPE_INIT
+  };
+
+  struct SceneCode {
+    enum SceneCodeType codeType;
+    std::string code;
+  };
+
+  class SceneCodeParser : public XmlParser<struct SceneCode> {
+    public:
+      virtual std::vector<std::string> getRequiredAttributes();
+      virtual std::map<std::string, std::string> getOptionalAttributes();
+
+      virtual int32_t onParse(
+        Xml *node,
+        std::map<std::string, std::string> values,
+        struct SceneCode *out,
+        std::string *error
+      );
+  };
+}

src/dawntools/util/parser/SceneItemParser.cpp

@@ -71,6 +71,12 @@ int32_t SceneItemParser::onParse(
       auto ret = (SceneAssetParser()).parse(c, &asset, error);
       if(ret != 0) return ret;
       out->assets.push_back(asset);
+
+    } else if(c->node == "code") {
+      struct SceneCode code;
+      auto ret = (SceneCodeParser()).parse(c, &code, error);
+      if(ret != 0) return ret;
+      out->code.push_back(code);
       
     } else {
       struct SceneItemComponent component;

src/dawntools/util/parser/SceneItemParser.hpp

@@ -6,6 +6,7 @@
 #pragma once
 #include "util/parser/SceneItemComponentParser.hpp"
 #include "util/parser/SceneAssetParser.hpp"
+#include "util/parser/SceneCodeParser.hpp"
 
 namespace Dawn {
   struct SceneItem {
@@ -19,6 +20,7 @@ namespace Dawn {
     std::vector<struct SceneItemComponent> components;
     std::vector<struct SceneItem> children;
     std::vector<struct SceneAsset> assets;
+    std::vector<struct SceneCode> code;
   };
 
   class SceneItemParser : public XmlParser<struct SceneItem> {

src/dawntools/util/parser/SceneParser.cpp

@@ -40,6 +40,12 @@ int32_t SceneParser::onParse(
       ret = (SceneItemParser()).parse(child, &item, error);
       if(ret != 0) return 1;
       out->items.push_back(item);
+      
+    } else if(child->node == "code") {
+      struct SceneCode code;
+      ret = (SceneCodeParser()).parse(child, &code, error);
+      if(ret != 0) return ret;
+      out->code.push_back(code);
     }
 
     ++itChildren;

src/dawntools/util/parser/SceneParser.hpp

@@ -5,12 +5,14 @@
 
 #pragma once
 #include "util/parser/SceneItemParser.hpp"
+#include "util/parser/SceneCodeParser.hpp"
 
 namespace Dawn {
   struct Scene {
     std::string name;
     std::string extend;
     std::vector<struct SceneItem> items;
+    std::vector<struct SceneCode> code;
     struct SceneItemComponentRegistry *registry;
   };