Moved C++ tools out

archive/dawntools/util/generator/CMakeLists.txt

@@ -0,0 +1,19 @@
+# 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}/SceneCodeGenerator.cpp
+    ${D}/SceneGenerator.cpp
+    ${D}/SceneItemComponentGenerator.cpp
+
+  CACHE INTERNAL
+    ${DAWN_CACHE_TARGET}
+)

archive/dawntools/util/generator/SceneAssetGenerator.cpp

@@ -0,0 +1,53 @@
+// 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> *publicProperties,
+  std::vector<std::string> *initBody,
+  std::vector<std::string> *assetsBody,
+  struct SceneAsset *asset,
+  std::string tabs
+) {
+  std::string assetType = "";
+
+  bool_t componentInit = true;
+  if(asset->ref.empty()) {
+    asset->usageName = "asset" + std::to_string(assetNumber++);
+  } else {
+    asset->usageName = asset->ref;
+  }
+
+  switch(asset->type) {
+    case SCENE_ASSET_TYPE_TEXTURE:
+      assetType = "TextureAsset";
+      assetMap[asset->fileName] = "&" + asset->usageName + "->texture";
+      assetMap[asset->usageName] = "&" + asset->usageName + "->texture";
+      break;
+
+    case SCENE_ASSET_TYPE_TRUETYPE_FONT:
+      assetType = "TrueTypeAsset";
+      assetMap[asset->fileName] = asset->usageName;
+      assetMap[asset->usageName] = asset->usageName;
+      break;
+
+    default:
+      assertUnreachable("SceneAssetGenerator::generate: Unknown asset type");
+  }
+
+  if(!asset->ref.empty()) {
+    line(publicProperties, assetType + " *" + asset->usageName + " = nullptr;", "");
+    line(initBody, asset->usageName + " = man->get<" + assetType + ">(\"" + asset->fileName + "\");", "");
+  } else {
+    line(initBody, "auto " + asset->usageName + " = man->get<" + assetType + ">(\"" + asset->fileName + "\");", "");
+  }
+
+  line(assetsBody, "assets.push_back(man->get<" + assetType + ">(\"" + asset->fileName + "\"));", "");
+}

archive/dawntools/util/generator/SceneAssetGenerator.hpp

@@ -0,0 +1,23 @@
+// 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> *publicProperties,
+        std::vector<std::string> *initBody,
+        std::vector<std::string> *assetsBody,
+        struct SceneAsset *asset,
+        std::string tabs
+      );
+  };
+}

archive/dawntools/util/generator/SceneCodeGenerator.cpp

@@ -0,0 +1,33 @@
+// 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,
+  std::vector<std::string> *includes,
+  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;
+
+    case SCENE_CODE_TYPE_INCLUDE:
+      line(includes, code->code, "");
+      break;
+
+    default:
+      break;
+  }
+}

archive/dawntools/util/generator/SceneCodeGenerator.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/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,
+        std::vector<std::string> *includes,
+        struct SceneCode *code,
+        std::string tabs
+      );
+  };
+}

archive/dawntools/util/generator/SceneGenerator.cpp

@@ -0,0 +1,103 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneGenerator.hpp"
+
+using namespace Dawn;
+
+void SceneGenerator::generate(
+  struct Scene *scene,
+  struct ClassGenInfo &classInfo,
+  struct MethodGenInfo &methodAssets,
+  struct MethodGenInfo &methodInit
+) {
+  assertNotNull(scene, "SceneGenerator::generate: Scene cannot be null");
+
+  std::map<std::string, std::string> assetMap;
+  int32_t assetNumber = 0;
+  std::string baseClassName = "Scene";
+  
+  classInfo.clazz = scene->name;
+  classInfo.constructorArgs = "DawnGame *game";
+  classInfo.extendArgs = "game";
+
+  // Determine extends
+  if(scene->extend.empty()) {
+    classInfo.includes.push_back("scene/Scene.hpp");
+  } else {
+    classInfo.includes.push_back(scene->extend + ".hpp");
+
+    // Get last slash of scene->extend
+    auto lastSlash = scene->extend.find_last_of('/');
+    baseClassName = scene->extend;
+    if(lastSlash != std::string::npos) {
+      baseClassName = scene->extend.substr(lastSlash + 1);
+    }
+  }
+  classInfo.extend = baseClassName;
+
+  methodAssets.name = "getRequiredAssets";
+  methodAssets.isOverride = true;
+  methodAssets.type = "std::vector<Asset*>";
+  line(&methodAssets.body, "auto man = &this->game->assetManager;", "");
+
+  methodInit.name = "stage";
+  methodInit.isOverride = true;
+
+  if(scene->extend.empty()) {
+    line(&methodAssets.body, "std::vector<Asset*> assets;", "");
+  } else {
+    line(&methodAssets.body, "std::vector<Asset*> assets = " + baseClassName + "::getRequiredAssets();", "");
+    line(&methodInit.body, baseClassName + "::stage();", "");
+  }
+
+  // Scene assets
+  line(&methodInit.body, "auto man = &this->game->assetManager;", "");
+
+  auto itAssets = scene->assets.begin();
+  while(itAssets != scene->assets.end()) {
+    SceneAssetGenerator::generate(
+      assetMap,
+      assetNumber,
+      &classInfo.publicProperties,
+      &methodInit.body,
+      &methodAssets.body,
+      &(*itAssets),
+      ""
+    );
+    ++itAssets;
+  }
+
+  // Generate
+  int32_t childNumber = 0;
+  int32_t componentNumber = 0;
+  std::vector<struct SceneItemComponent> componentsUnused;
+
+  auto itDeps = scene->dependencies.begin();
+  while(itDeps != scene->dependencies.end()) {
+    auto dep = *itDeps;
+    SceneItemGenerator::generateDependency(
+      assetNumber,
+      componentNumber,
+      childNumber,
+      assetMap,
+      classInfo.includes,
+      &classInfo.publicProperties,
+      &methodInit.body,
+      &methodAssets.body,
+      "",
+      "this",
+      componentsUnused,
+      scene->items,
+      scene->code,
+      dep
+    );
+    ++itDeps;
+  }
+
+
+  // Seal methods
+  line(&methodAssets.body, "return assets;", "");
+}

archive/dawntools/util/generator/SceneGenerator.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/parser/SceneParser.hpp"
+#include "SceneItemGenerator.hpp"
+#include "util/CodeGen.hpp"
+
+namespace Dawn {
+  class SceneGenerator : public CodeGen {
+    public:
+      static void generate(
+        struct Scene *scene,
+        struct ClassGenInfo &classInfo,
+        struct MethodGenInfo &methodAssets,
+        struct MethodGenInfo &methodInit
+      );
+  };
+}

archive/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);
+}

archive/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
+      );
+  };
+}

archive/dawntools/util/generator/SceneItemGenerator.cpp

@@ -0,0 +1,213 @@
+// 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::generateDependency(
+  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 name,
+  std::string sceneRef,
+  std::vector<struct SceneItemComponent> &components,
+  std::vector<struct SceneItem> &children,
+  std::vector<struct SceneCode> &code,
+  struct SceneItemDependency dep
+) {
+  switch(dep.type) {
+    case SCENE_ITEM_DEPENDENCY_TYPE_CODE: {
+      auto i = &code[dep.position];
+      SceneCodeGenerator::generate(
+        publicProperties,
+        initBody,
+        &includes,
+        i,
+        ""
+      );
+      line(initBody, "", "");
+      break;
+    }
+      
+    case SCENE_ITEM_DEPENDENCY_TYPE_COMPONENT: {
+      auto i = &components[dep.position];
+      SceneItemComponentGenerator::generate(
+        assetMap,
+        componentNumber,
+        includes,
+        name,
+        publicProperties,
+        initBody,
+        i,
+        ""
+      );
+      line(initBody, "", "");
+      break;
+    }
+
+    case SCENE_ITEM_DEPENDENCY_TYPE_ITEM: {
+      auto i = &children[dep.position];
+      SceneItemGenerator::generate(
+        assetNumber,
+        componentNumber,
+        childNumber,
+        assetMap,
+        includes,
+        publicProperties,
+        initBody,
+        assetBody,
+        name,
+        sceneRef,
+        i,
+        ""
+      );
+      line(initBody, "", "");
+      break;
+    }
+
+    default:
+      assertUnreachable("SceneItemGenerator::generateDependency: Unknown dependency type");
+  }
+}
+
+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,
+  std::string sceneRef,
+  struct SceneItem *item,
+  std::string tabs
+) {
+  assertNotNull(publicProperties, "SceneItemGenerator::generate: publicProperties cannot be null");
+  assertNotNull(initBody, "SceneItemGenerator::generate: initBody cannot be null");
+  assertNotNull(assetBody, "SceneItemGenerator::generate: assetBody cannot be null");
+  assertNotNull(item, "SceneItemGenerator::generate: item cannot be null");
+
+  // Determine interface
+  std::string name = "itm" + std::to_string(childNumber++);
+  std::string itemType = "SceneItem";
+
+  if(item->ref == "this") {
+    name = item->ref;
+  } else {
+    // Determine name
+    if(!item->ref.empty()) name = item->ref;
+
+    // Initialize, either prefab or created.
+    if(!item->prefab.empty()) {
+      // 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(man));", "");
+    } 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;", "");
+    }
+  }
+
+  // Process extra properties
+  if(item->position.size() > 0) {
+    line(initBody, name + "->transform.setLocalPosition(" + item->position + ");", "");
+  }
+
+  if(item->alignment.size() > 0) {
+    line(initBody, name + "->uiItem->alignment = " + item->alignment + ";", "");
+  }
+
+  if(item->alignX.size() > 0) {
+    line(initBody, name + "->uiItem->alignX = " + item->alignX + ";", "");
+  }
+
+  if(item->alignY.size() > 0) {
+    line(initBody, name + "->uiItem->alignY = " + item->alignY + ";", "");
+  }
+
+  if(item->menuX.size() > 0) {
+    line(initBody, name + "->menuItem->menuX = " + item->menuX + ";", "");
+  }
+  
+  if(item->menuY.size() > 0) {
+    line(initBody, name + "->menuItem->menuY = " + item->menuY + ";", "");
+  }
+
+  if(item->scale.size() > 0) {
+    line(initBody, name + "->transform.setLocalScale(" + item->scale + ");", "");
+  }
+
+  if(item->lookAtPosition.size() > 0) {
+    line(initBody, name + "->transform.lookAt(" + item->lookAtPosition + ", " + item->lookAtTarget + ");", "");
+  }
+
+  if(!item->label.empty()) {
+    line(initBody, name + "->label->text = " + item->label + ";", "");
+  }
+
+  // Add assets
+  auto itAssets = item->assets.begin();
+  while(itAssets != item->assets.end()) {
+    SceneAssetGenerator::generate(
+      assetMap,
+      assetNumber,
+      publicProperties,
+      initBody,
+      assetBody,
+      &(*itAssets),
+      ""
+    );
+    ++itAssets;
+  }
+
+  // Add the dependencies
+  auto itDeps = item->dependencies.begin();
+  while(itDeps != item->dependencies.end()) {
+    auto dep = *itDeps;
+    SceneItemGenerator::generateDependency(
+      assetNumber,
+      componentNumber,
+      childNumber,
+      assetMap,
+      includes,
+      publicProperties,
+      initBody,
+      assetBody,
+      name,
+      sceneRef,
+      item->components,
+      item->children,
+      item->code,
+      dep
+    );
+    ++itDeps;
+  }
+
+  // Set parent
+  if(!parentRef.empty()) {
+    line(initBody, name + "->transform.setParent(&"+parentRef+"->transform);", "");
+  }
+}

archive/dawntools/util/generator/SceneItemGenerator.hpp

@@ -0,0 +1,47 @@
+// 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"
+#include "util/generator/SceneCodeGenerator.hpp"
+
+namespace Dawn {
+  class SceneItemGenerator : public CodeGen {
+    public:
+      static void generateDependency(
+        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 name,
+        std::string sceneRef,
+        std::vector<struct SceneItemComponent> &components,
+        std::vector<struct SceneItem> &children,
+        std::vector<struct SceneCode> &code,
+        struct SceneItemDependency dep
+      );
+
+      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,
+        std::string sceneRef,
+        struct SceneItem *item,
+        std::string tabs
+      );
+  };
+}