YourWishes/Dawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Moved C++ tools out

Browse Source
This commit is contained in:
Dominic Masters
2023-10-31 21:15:03 -05:00
parent da928acb57
commit 8ca8358aa5
98 changed files with 5 additions and 5053 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -83,7 +83,6 @@ assets/borrowed
.VSCode* .VSCode*
/vita /vita
/tools
._* ._*

5
CMakeLists.txt
View File

@ -17,7 +17,7 @@ set(DAWN_CACHE_TARGET "dawn-target")
set(DAWN_ROOT_DIR "${CMAKE_SOURCE_DIR}") set(DAWN_ROOT_DIR "${CMAKE_SOURCE_DIR}")
set(DAWN_BUILD_DIR "${CMAKE_BINARY_DIR}") set(DAWN_BUILD_DIR "${CMAKE_BINARY_DIR}")
set(DAWN_SOURCES_DIR "${DAWN_ROOT_DIR}/src") set(DAWN_SOURCES_DIR "${DAWN_ROOT_DIR}/src")
set(DAWN_TOOLS_DIR "${DAWN_SOURCES_DIR}/dawntools") set(DAWN_TOOLS_DIR "${DAWN_ROOT_DIR}/tools")
set(DAWN_ASSETS_SOURCE_DIR "${DAWN_ROOT_DIR}/assets") set(DAWN_ASSETS_SOURCE_DIR "${DAWN_ROOT_DIR}/assets")
set(DAWN_ASSETS_BUILD_DIR "${DAWN_BUILD_DIR}/assets") set(DAWN_ASSETS_BUILD_DIR "${DAWN_BUILD_DIR}/assets")
set(DAWN_GENERATED_DIR "${DAWN_BUILD_DIR}/generated") set(DAWN_GENERATED_DIR "${DAWN_BUILD_DIR}/generated")
@ -34,6 +34,9 @@ project(Dawn
LANGUAGES C CXX LANGUAGES C CXX
) )
# Add tools
add_subdirectory(tools)
# Add Libraries # Add Libraries
add_subdirectory(lib) add_subdirectory(lib)

3
src/CMakeLists.txt
View File

@ -12,9 +12,6 @@ set(
# Include shared libs # Include shared libs
add_subdirectory(dawnshared) add_subdirectory(dawnshared)
# Include tools
add_subdirectory(dawntools)
# Change what we are building. Pulled from the cmake/targets dir. # Change what we are building. Pulled from the cmake/targets dir.
if(DEFINED DAWN_BUILDING) if(DEFINED DAWN_BUILDING)
add_subdirectory(${DAWN_BUILDING}) add_subdirectory(${DAWN_BUILDING})

60
src/dawntools/prefabtool/CMakeLists.txt
View File

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

65
src/dawntools/prefabtool/PrefabGen.cpp
View File

@ -1,65 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "PrefabGen.hpp"
using namespace Dawn;
void PrefabGen::generate(
std::vector<std::string> *out,
struct Prefab *info,
std::string tabs
) {
struct ClassGenInfo classInfo;
classInfo.clazz = info->name;
classInfo.extend = "SceneItemPrefab<" + info->name + ">";
classInfo.constructorArgs = "Scene *scene, sceneitemid_t id";
classInfo.extendArgs = "scene, id";
struct MethodGenInfo methodAssets;
methodAssets.name = "prefabAssets";
methodAssets.isStatic = true;
methodAssets.type = "std::vector<Asset*>";
methodAssets.args = "AssetManager *man";
line(&methodAssets.body, "std::vector<Asset*> assets;", "");
struct MethodGenInfo methodInit;
methodInit.name = "prefabInit";
methodInit.isOverride = true;
methodInit.args = "AssetManager *man";
classInfo.includes.push_back("prefab/SceneItemPrefab.hpp");
// Generate
int32_t assetNumber = 0;
int32_t childNumber = 0;
int32_t componentNumber = 0;
std::map<std::string, std::string> assetMap;
info->root.ref = "this";
SceneItemGenerator::generate(
assetNumber,
componentNumber,
childNumber,
assetMap,
classInfo.includes,
&classInfo.publicProperties,
&methodInit.body,
&methodAssets.body,
"",
"scene",
&info->root,
""
);
// 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);
}

19
src/dawntools/prefabtool/PrefabGen.hpp
View File

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

28
src/dawntools/prefabtool/PrefabParser.cpp
View File

@ -1,28 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "PrefabParser.hpp"
using namespace Dawn;
std::vector<std::string> PrefabParser::getRequiredAttributes() {
return { "name", "type" };
}
std::map<std::string, std::string> PrefabParser::getOptionalAttributes() {
return { };
}
int32_t PrefabParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct Prefab *out,
std::string *error
) {
out->name = values["name"];
out->type = values["type"];
out->root.registry = out->registry;
return (SceneItemParser()).parse(node, &out->root, error);
}

29
src/dawntools/prefabtool/PrefabParser.hpp
View File

@ -1,29 +0,0 @@
// 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/parser/SceneItemParser.hpp"
namespace Dawn {
struct Prefab {
struct SceneItemComponentRegistry *registry;
struct SceneItem root;
std::string name;
std::string type;
};
class PrefabParser : public XmlParser<struct Prefab> {
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 Prefab *out,
std::string *error
) override;
};
}

69
src/dawntools/prefabtool/PrefabTool.cpp
View File

@ -1,69 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "PrefabTool.hpp"
using namespace Dawn;
std::vector<std::string> PrefabTool::getRequiredFlags() {
return { "input", "output", "sources" };
}
std::map<std::string, std::string> PrefabTool::getOptionalFlags() {
return std::map<std::string, std::string>();
}
int32_t PrefabTool::start() {
File input = File(flags["input"]);
if(!input.exists()) {
std::cout << "Input file " + input.filename + " 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;
}
struct SceneItemComponentRegistry registry;
registry.sources = File::normalizeSlashes(flags["sources"]);
auto xml = Xml::load(data);
std::string error;
struct Prefab prefab;
prefab.registry = &registry;
auto result = ((PrefabParser()).parse(&xml, &prefab, &error));
if(result != 0) {
std::cout << "Failed to parse prefab: " << error << std::endl;
return result;
}
// Generate output
std::vector<std::string> outputData;
PrefabGen::generate(&outputData, &prefab, "");
// Load output file from name and type
File outputFile = File(flags["output"] + "/prefabs/" + prefab.type + "/" + prefab.name + ".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!" << std::endl;
return 1;
}
return 0;
}

18
src/dawntools/prefabtool/PrefabTool.hpp
View File

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

61
src/dawntools/scenetool/CMakeLists.txt
View File

@ -1,61 +0,0 @@
# 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
SceneGen.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="${in}" --output="${DAWN_GENERATED_DIR}/generatedscenes" --sources="${DAWN_SOURCES_DIR}"
COMMENT "Generating scene from ${in}"
DEPENDS ${DEPS}
)
target_include_directories(${DAWN_TARGET_NAME}
PUBLIC
${DAWN_GENERATED_DIR}/generatedscenes
)
add_dependencies(${DAWN_TARGET_NAME} scene_${scene_name})
endfunction()

32
src/dawntools/scenetool/SceneGen.cpp
View File

@ -1,32 +0,0 @@
// 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;
struct MethodGenInfo methodAssets;
struct MethodGenInfo methodInit;
SceneGenerator::generate(
scene,
classInfo,
methodAssets,
methodInit
);
// Add in methods
CodeGen::methodGen(&classInfo.publicCode, methodAssets);
line(&classInfo.publicCode, "", "");
CodeGen::methodGen(&classInfo.publicCode, methodInit);
CodeGen::classGen(out, classInfo);
}

18
src/dawntools/scenetool/SceneGen.hpp
View File

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

69
src/dawntools/scenetool/SceneTool.cpp
View File

@ -1,69 +0,0 @@
// 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 " + input.filename + " 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;
SceneGen::generate(&outputData, &scene, "");
// Load output file from name and type
File outputFile = File(flags["output"] + "/scenes/" + scene.name + ".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;
}

22
src/dawntools/scenetool/SceneTool.hpp
View File

@ -1,22 +0,0 @@
// 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 "util/parser/SceneParser.hpp"
#include "SceneGen.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();
};
}

67
src/dawntools/truetypetool/CMakeLists.txt
View File

@ -1,67 +0,0 @@
# Copyright (c) 2023 Dominic Msters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
project(truetypetool VERSION 3.0)
add_executable(truetypetool)
target_sources(truetypetool
PRIVATE
${DAWN_SHARED_SOURCES}
${DAWN_TOOL_SOURCES}
TrueTypeTool.cpp
)
target_include_directories(truetypetool
PUBLIC
${DAWN_SHARED_INCLUDES}
${DAWN_TOOL_INCLUDES}
${CMAKE_CURRENT_LIST_DIR}
)
# Definitions
target_compile_definitions(truetypetool
PUBLIC
${DAWN_SHARED_DEFINITIONS}
DAWN_TOOL_INSTANCE=TrueTypeTool
DAWN_TOOL_HEADER="TrueTypeTool.hpp"
)
# Libraries
target_link_libraries(truetypetool
PUBLIC
${DAWN_BUILD_HOST_LIBS}
)
# Tool Function
function(tool_truetype target)
# Defaults
set(FILE "" )
# Parse Args
foreach(_PAIR IN LISTS ARGN)
if (_PAIR MATCHES "^([^:]+)=(.*)$")
set(${CMAKE_MATCH_1} ${CMAKE_MATCH_2})
else()
message(FATAL_ERROR "Invalid pair: ${_PAIR}")
endif()
endforeach()
set(DEPS "")
if(DAWN_BUILD_TOOLS)
set(DEPS truetypetool)
endif()
add_custom_target(${target}
COMMAND truetypetool
--output="${DAWN_ASSETS_BUILD_DIR}/${target}.truetype"
--regular="${REGULAR}"
--bold="${BOLD}"
--italics="${ITALICS}"
--bold-italics="${BOLD_ITALICS}"
COMMENT "Generating truetype"
DEPENDS ${DEPS}
)
add_dependencies(dawnassets ${target})
endfunction()

159
src/dawntools/truetypetool/TrueTypeTool.cpp
View File

@ -1,159 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "TrueTypeTool.hpp"
using namespace Dawn;
TrueTypeFile::TrueTypeFile(std::string path) : file(path) {
this->path = path;
// Remove extension
size_t pos = path.find_last_of(".");
std::string filename = path.substr(0, pos);
std::string pathLower = stringToLowercase(path);
style = 0;
if(pathLower.find("bold") != std::string::npos || filename.ends_with("bd") || filename.ends_with("bi")) {
style |= TRUE_TYPE_VARIANT_BOLD;
}
if(pathLower.find("italic") != std::string::npos || filename.ends_with("i") || filename.ends_with("bi")) {
style |= TRUE_TYPE_VARIANT_ITALICS;
}
if(!file.exists()) {
std::cout << "File " << path << " does not exist!" << std::endl;
throw "File not found";
}
if(!file.open(FILE_MODE_READ)) {
std::cout << "Failed to open file " << path << " for reading!" << std::endl;
throw "Unable to open file for reading!";
}
}
TrueTypeFile::~TrueTypeFile() {
}
std::vector<std::string> TrueTypeTool::getRequiredFlags() {
return { "output" };
}
std::map<std::string, std::string> TrueTypeTool::getOptionalFlags() {
return {
{ "regular", "" },
{ "italics", "" },
{ "bold", "" },
{ "bold-italics", "" }
};
}
int32_t TrueTypeTool::start() {
std::vector<TrueTypeFile*> files;
std::vector<std::string> flags = { "regular", "italics", "bold", "bold-italics" };
auto cleanupFiles = [&]() {
auto itFile = files.begin();
while(itFile != files.end()) {
auto file = *itFile;
delete file;
++itFile;
}
};
// For each flag
auto itFlag = flags.begin();
while(itFlag != flags.end()) {
std::string flag = *itFlag;
std::string path = this->flags[flag];
if(path.empty()) {
++itFlag;
continue;
}
try {
auto n = new TrueTypeFile(path);
files.push_back(n);
} catch(const char *e) {
cleanupFiles();
return 1;
}
++itFlag;
}
if(files.size() == 0) {
std::cout << "No valid TTF files provided!" << std::endl;
cleanupFiles();
return 1;
}
// Create the output file
File fileOut = File(this->flags["output"]);
if(!fileOut.mkdirp()) {
std::cout << "Failed to create output directory!" << std::endl;
cleanupFiles();
return 1;
}
if(!fileOut.open(FILE_MODE_WRITE)) {
std::cout << "Failed to open output file for writing!" << std::endl;
cleanupFiles();
return 1;
}
// Prepare to write data
std::string header = "DE_TTF|3.00|";
// Write file count
header += std::to_string(files.size()) + "|";
// For each file
auto itFile = files.begin();
while(itFile != files.end()) {
auto file = *itFile;
// Style
header += std::to_string(file->style);
header += ":";
// File length
header += std::to_string(file->file.length);
header += "|";
++itFile;
}
if(!fileOut.writeRaw((char *)header.c_str(), header.length())) {
std::cout << "Failed to write TTF Header to " << fileOut.filename << std::endl;
cleanupFiles();
return 1;
}
// Now write the data for each file
itFile = files.begin();
while(itFile != files.end()) {
auto file = *itFile;
// Write the file data
file->file.setPosition(0);
if(!fileOut.copyRaw(&file->file, file->file.length)) {
std::cout << "Failed copy output data of " << file->file.filename << std::endl;
cleanupFiles();
return 1;
}
// Write vertical bar
char sep[1];
sep[0] = '|';
fileOut.writeRaw(sep, 1);
++itFile;
}
// Cleanup
cleanupFiles();
// Done
fileOut.close();
return 0;
}

31
src/dawntools/truetypetool/TrueTypeTool.hpp
View File

@ -1,31 +0,0 @@
// 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 "display/font/truetype/TrueTypeShared.hpp"
#include "util/string.hpp"
namespace Dawn {
class TrueTypeFile {
public:
flag_t style;
std::string path;
File file;
TrueTypeFile(std::string path);
~TrueTypeFile();
};
class TrueTypeTool : public DawnTool {
protected:
std::vector<std::string> getRequiredFlags() override;
std::map<std::string, std::string> getOptionalFlags() override;
public:
int32_t start();
};
}

19
src/dawntools/util/CMakeLists.txt
View File

@ -1,19 +0,0 @@
# 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}/DawnTool.cpp
${D}/File.cpp
${D}/Language.cpp
${D}/CodeGen.cpp
${D}/Directory.cpp
CACHE INTERNAL
${DAWN_CACHE_TARGET}
)

100
src/dawntools/util/CodeGen.cpp
View File

@ -1,100 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "CodeGen.hpp"
using namespace Dawn;
void CodeGen::line(
std::vector<std::string> *out,
std::string contents,
std::string tabs
) {
out->push_back(tabs + contents);
}
void CodeGen::lines(
std::vector<std::string> *out,
std::vector<std::string> lines,
std::string tabs
) {
auto itLine = lines.begin();
while(itLine != lines.end()) {
line(out, *itLine, tabs);
++itLine;
}
}
void CodeGen::classGen(
std::vector<std::string> *out,
struct ClassGenInfo info
) {
std::vector<std::string> buffer;
line(out, "#pragma once", "");
line(out, "", "");
// Includes
if(info.includes.size() > 0) {
// iterate over info.includes
std::vector<std::string> included;
auto itInclude = info.includes.begin();
while(itInclude != info.includes.end()) {
// skip if already included
if(std::find(included.begin(), included.end(), *itInclude) != included.end()) {
++itInclude;
continue;
}
if(itInclude->find("#include") == std::string::npos) {
line(out, "#include \"" + *itInclude + "\"", "");
} else {
line(out, *itInclude, "");
}
included.push_back(*itInclude);
++itInclude;
}
line(out, "", "");
}
line(out, "namespace Dawn {", "");
auto itTemplates = info.classTemplates.begin();
while(itTemplates != info.classTemplates.end()) {
line(out, "template<" + itTemplates->second + " " + itTemplates->first + ">", " ");
++itTemplates;
}
line(out, "class " + info.clazz + (info.extend.size() == 0 ? "{" : " : public " + info.extend + " {" ), " ");
if(info.protectedCode.size() > 0) {
line(out, "protected:", " ");
lines(out, info.protectedProperties, " ");
line(out, "", " ");
lines(out, info.protectedCode, " ");
}
if(info.publicCode.size() > 0 || info.constructorArgs.size() > 0 || info.constructorCode.size() > 0) {
line(out, "public:", " ");
lines(out, info.publicProperties, " ");
line(out, "", " ");
line(out, info.clazz + "(" + info.constructorArgs + ")" + (info.extend.size() > 0 ? " : " + info.extend + "(" + info.extendArgs + ")" : "") + " {", " ");
lines(out, info.constructorCode, " ");
line(out, "}", " ");
if(info.publicCode.size() > 0) {
line(out, "", " ");
lines(out, info.publicCode, " ");
}
}
line(out, "};", " ");
line(out, "}", "");
}
void CodeGen::methodGen(
std::vector<std::string> *out,
struct MethodGenInfo info
) {
line(out, (info.isStatic ? "static " : "") + info.type + " " + info.name + "(" + info.args + ") " + ( info.isOverride ? "override " : "" ) + "{", "");
lines(out, info.body, " ");
line(out, "}", "");
}

87
src/dawntools/util/CodeGen.hpp
View File

@ -1,87 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "dawnsharedlibs.hpp"
namespace Dawn {
struct ClassGenInfo {
std::vector<std::string> includes;
std::string clazz = "Unknown";
std::string extend = "";
std::string constructorArgs = "";
std::string extendArgs = "";
std::map<std::string, std::string> classTemplates;
std::vector<std::string> constructorCode;
std::vector<std::string> protectedCode;
std::vector<std::string> protectedProperties;
std::vector<std::string> publicCode;
std::vector<std::string> publicProperties;
};
struct MethodGenInfo {
std::string name;
std::string type = "void";
std::vector<std::string> body;
std::string args = "";
bool_t isStatic = false;
bool_t isOverride = false;
};
class CodeGen {
protected:
/**
* Append a line of code to the output buffer.
*
* @param out Output buffer to append to.
* @param contents Line of code to append to the buffer.
* @param tabs Prepended string of spaces/tabs.
*/
static void line(
std::vector<std::string> *out,
std::string contents,
std::string tabs
);
/**
* Append an array of lines to the output buffer.
*
* @param out Output buffer to append to.
* @param lines List of lines of code to append to the buffer.
* @param tabs Prepended string of tabs/spaces to prepend to EACH line.
*/
static void lines(
std::vector<std::string> *out,
std::vector<std::string> lines,
std::string tabs
);
/**
* Generate code of a class
*
* @param out Output buffer to write the class to.
* @param info Information about how the class should be generated.
*/
static void classGen(
std::vector<std::string> *out,
struct ClassGenInfo info
);
/**
* Generate code of a method/function.
*
* @param out Output buffer to write the method to.
* @param info Information about how the method should be generated.
*/
static void methodGen(
std::vector<std::string> *out,
struct MethodGenInfo info
);
};
}

81
src/dawntools/util/DawnTool.cpp
View File

@ -1,81 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "DawnTool.hpp"
#include "util/memory.hpp"
#if !defined(DAWN_TOOL_INSTANCE)
#error Dawn Tool Instance, e.g. LanguageTool has not been defined
#endif
#if !defined(DAWN_TOOL_HEADER)
#error Dawn Tool Include, e.g. LanguageTool.hpp has not been defined
#endif
#include DAWN_TOOL_HEADER
using namespace Dawn;
std::vector<std::string> DawnTool::getRequiredFlags() {
return std::vector<std::string>();
}
std::map<std::string, std::string> DawnTool::getOptionalFlags() {
return std::map<std::string, std::string>();
}
int32_t DawnTool::exec(const int32_t argc, const char *argv[]) {
// Set up flags
flags = this->getOptionalFlags();
// Parse args
for(int32_t i = 0; i < argc; i++) {
std::string a(argv[i]);
this->args.push_back(a);
// First arg is the path, we ignore it.
if(i == 0) continue;
// Is this a flag-like arg, as in has "--[name]=[value]"
if(a.size() < 5) continue;
if(a[0] != '-' || a[1] != '-') continue;
// Remove --
auto flag = a.erase(0, 2);
// Ensure = is present
auto equalPos = flag.find('=');
if(equalPos == std::string::npos) continue;
// Get prefix and val and store
auto prefix = flag.substr(0, equalPos);
auto val = flag.substr(equalPos + 1);
if(val.size() == 0) continue;
flags[prefix] = val;
}
// Now validate flags
auto required = this->getRequiredFlags();
auto itReq = required.begin();
while(itReq != required.end()) {
auto match = flags.find(*itReq);
if(match == flags.end()) {
std::cout << "Missing required flag \"" + *itReq + "\"!" << std::endl;
return 1;
}
++itReq;
}
return this->start();
}
int main(const int32_t argc, const char *argv[]) {
memoryInit();
DAWN_TOOL_INSTANCE *self = new DAWN_TOOL_INSTANCE();
int32_t ret = self->exec(argc, argv);
delete self;
if(ret == 0) memoryDispose();
return ret;
}

57
src/dawntools/util/DawnTool.hpp
View File

@ -1,57 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "dawnsharedlibs.hpp"
#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
#include <iterator>
namespace Dawn {
class DawnTool {
protected:
std::vector<std::string> args;
std::map<std::string, std::string> flags;
/**
* Get the required flags for this tool. These flags will be checked in
* the passed args to the CLI.
*
* @return Array of required flags.
*/
virtual std::vector<std::string> getRequiredFlags();
/**
* Get the optional flags for this tool. Mapped by key value pair where
* the value is some default value you want for your tool.
*
* @return Array of optional flags.
*/
virtual std::map<std::string, std::string> getOptionalFlags();
public:
int32_t *test;
/**
* Execute the Dawn Tool from the CLI, functionally identically to main()
*
* @param argc Count of arguments in the array.
* @param argv Array of arguments.
* @return int32_t
*/
int32_t exec(const int32_t argc, const char *argv[]);
/**
* Overridable start method after the tool has been set up.
*
* @return 0 for success, otherwise for failure.
*/
virtual int32_t start() = 0;
};
}
int main(const int32_t argc, const char *argv[]);

58
src/dawntools/util/Directory.cpp
View File

@ -1,58 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "Directory.hpp"
using namespace Dawn;
Directory::Directory(std::string dirname) {
this->filename = File::normalizeSlashes(dirname);
}
bool_t Directory::open() {
if(!this->exists()) return false;
if (handle != std::filesystem::end(handle)) return true;
handle = std::filesystem::directory_iterator(filename);
return handle != std::filesystem::end(handle);
}
bool_t Directory::isOpen() {
return handle != std::filesystem::end(handle);
}
void Directory::close() {
if(this->isOpen()) {
handle = std::filesystem::directory_iterator();
}
}
bool_t Directory::exists() {
return std::filesystem::exists(filename);
}
void Directory::mkdirp() {
File::mkdirp(this->filename);
}
std::map<std::string, enum DirectoryChildType> Directory::readDirectory() {
this->close();
if(!this->open()) return {};
std::map<std::string, enum DirectoryChildType> children;
for(const auto& entry : handle) {
if (entry.is_directory()) {
children[entry.path().filename().string()] = DIRECTORY_CHILD_TYPE_DIRECTORY;
} else if (entry.is_regular_file()) {
children[entry.path().filename().string()] = DIRECTORY_CHILD_TYPE_FILE;
}
}
this->close();
return children;
}
Directory::~Directory() {
this->close();
}

60
src/dawntools/util/Directory.hpp
View File

@ -1,60 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/File.hpp"
#include <filesystem>
namespace Dawn {
enum DirectoryChildType {
DIRECTORY_CHILD_TYPE_FILE,
DIRECTORY_CHILD_TYPE_DIRECTORY
};
class Directory {
public:
std::string filename;
std::filesystem::directory_iterator handle;
Directory(std::string dir);
/**
* Opens a connection to the directory.
* @return True if success, otherwise for failure.
*/
bool_t open();
/**
* Returns if the directory is open.
* @return True if open, otherwise false.
*/
bool_t isOpen();
/**
* Closes the directory.
*/
void close();
/**
* Returns if the directory exists.
* @return True if exists, otherwise false.
*/
bool_t exists();
/**
* Creates the directory and all parent directories.
*/
void mkdirp();
/**
* Reads the directory and returns a list of files.
*
* @return List of filenames/directories within this directory.
*/
std::map<std::string, enum DirectoryChildType> readDirectory();
~Directory();
};
}

264
src/dawntools/util/File.cpp
View File

@ -1,264 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "File.hpp"
using namespace Dawn;
std::string File::normalizeSlashes(std::string str) {
size_t i = 0;
while(i < str.size()) {
auto c = str[i];
if(c == '\\' || c == '/') str[i] = FILE_PATH_SEP;
++i;
}
return str;
}
void File::mkdirp(std::string path) {
std::string buffer;
char c;
size_t i = 0;
bool_t inFile;
bool_t hasMore;
inFile = false;
hasMore = false;
while(c = path[i]) {
if((c == '\\' || c == '/') && i > 0) {
fileMkdir(buffer.c_str(), 0755);
inFile = false;
hasMore = false;
buffer += FILE_PATH_SEP;
i++;
continue;
}
if(c == '.') inFile = true;
hasMore = true;
buffer += c;
i++;
}
if(!inFile && hasMore) {
fileMkdir(buffer.c_str(), 0755);
}
}
//
File::File(std::string filename) {
this->filename = File::normalizeSlashes(filename);
}
bool_t File::open(enum FileMode mode) {
assertNull(this->file, "File is already open");
this->mode = mode;
this->file = fopen(
this->filename.c_str(),
mode == FILE_MODE_READ ? "rb" : "wb"
);
if(this->file == NULL) return false;
if(mode == FILE_MODE_READ) {
fseek(this->file, 0, SEEK_END);
this->length = ftell(this->file);
fseek(this->file, 0, SEEK_SET);
if(this->length <= 0) {
this->close();
return false;
}
} else {
this->length = 0;
}
return true;
}
bool_t File::isOpen() {
return this->file != nullptr;
}
bool_t File::exists() {
if(this->file != nullptr) return true;
FILE *f = fopen(this->filename.c_str(), "rb");
if(f == NULL || f == nullptr) return false;
fclose(f);
return true;
}
void File::close() {
assertNotNull(this->file, "File::close: File is not open");
fclose(this->file);
this->file = nullptr;
}
bool_t File::mkdirp() {
File::mkdirp(this->filename);
return true;
}
bool_t File::readString(std::string *out) {
assertNotNull(out, "File::readString: Out cannot be null");
if(!this->isOpen()) {
if(!this->open(FILE_MODE_READ)) return false;
}
assertTrue(this->mode == FILE_MODE_READ, "File::readString: File must be open in read mode");
out->clear();
size_t i = 0;
char buffer[FILE_BUFFER_SIZE + 1];// +1 for null term
while(i != this->length) {
size_t amt = mathMin<size_t>(FILE_BUFFER_SIZE, (this->length - i));
auto amtRead = fread(buffer, sizeof(char), amt, this->file);
if(amtRead != amt) return false;
i += amtRead;
buffer[amtRead] = '\0';
out->append(buffer);
}
return true;
}
size_t File::readAhead(char *buffer, size_t max, char needle) {
assertNotNull(buffer, "File::readAhead: Buffer cannot be null");
assertTrue(max > 0, "File::readAhead: Max must be greater than 0");
if(!this->isOpen()) {
if(!this->open(FILE_MODE_READ)) return 0;
}
assertTrue(this->mode == FILE_MODE_READ, "File::readAhead: File must be open in read mode");
// Buffer
size_t pos = ftell(this->file);
size_t amountLeftToRead = mathMin<size_t>(max, this->length - pos);
char temporary[FILE_BUFFER_SIZE];
size_t n = 0;
while(amountLeftToRead > 0) {
size_t toRead = mathMin<size_t>(amountLeftToRead, FILE_BUFFER_SIZE);
amountLeftToRead -= toRead;
// Read bytes
size_t read = fread(temporary, sizeof(char), toRead, this->file);
// Read error?
if(toRead != read) return 0;
// Did we read the needle?
size_t i = 0;
while(i < read) {
char c = temporary[i++];
if(c == needle) {
return n;
} else {
buffer[n++] = c;
}
}
}
// Needle was not found.
return -1;
}
size_t File::readToBuffer(char **buffer) {
if(!this->isOpen()) {
if(!this->open(FILE_MODE_READ)) return 0;
}
assertTrue(this->mode == FILE_MODE_READ, "File::readToBuffer: File must be open in read mode");
if((*buffer) == nullptr) *buffer = (char*)malloc(this->length);
fseek(this->file, 0, SEEK_SET);
auto l = fread((*buffer), sizeof(char), this->length, this->file);
return l;
}
size_t File::readRaw(char *buffer, size_t max) {
assertNotNull(buffer, "File::readRaw: Buffer cannot be null");
assertTrue(max > 0, "File::readRaw: Max must be greater than 0");
if(!this->isOpen()) {
if(!this->open(FILE_MODE_READ)) return 0;
}
assertTrue(this->mode == FILE_MODE_READ, "File::readRaw: File must be open in read mode");
return fread(buffer, sizeof(char), max, this->file);
}
bool_t File::writeString(std::string in) {
if(!this->isOpen() && !this->open(FILE_MODE_WRITE)) return false;
assertTrue(this->mode == FILE_MODE_WRITE, "File::writeString: File must be open in write mode");
return this->writeRaw((char *)in.c_str(), in.size()) && this->length == in.size();
}
bool_t File::writeRaw(char *data, size_t len) {
if(!this->isOpen() && !this->open(FILE_MODE_WRITE)) return false;
assertTrue(this->mode == FILE_MODE_WRITE, "File::writeRaw: File must be open in write mode");
assertTrue(len > 0, "File::writeRaw: Length must be greater than 0");
this->length = fwrite(data, sizeof(char_t), len, this->file);
return true;
}
bool_t File::copyRaw(File *otherFile, size_t length) {
assertTrue(length > 0, "File::copyRaw: Length must be greater than 0");
assertTrue(otherFile->isOpen(), "File::copyRaw: Other file must be open");
char buffer[FILE_BUFFER_SIZE];
size_t amountLeftToRead = length;
size_t read = 0;
while(amountLeftToRead > 0) {
auto iRead = otherFile->readRaw(buffer, mathMin<size_t>(FILE_BUFFER_SIZE, amountLeftToRead));
if(iRead == 0) return false;
this->writeRaw(buffer, iRead);
amountLeftToRead -= iRead;
read += iRead;
}
assertTrue(read == length, "File::copyRaw: Read length does not match expected length");
return true;
}
void File::setPosition(size_t n) {
fseek(this->file, 0, SEEK_SET);
fseek(this->file, n, SEEK_CUR);
}
std::string File::getFileName(bool_t withExt) {
// Remove all but last slash
std::string basename;
size_t lastSlash = this->filename.find_last_of('/');
if(lastSlash == std::string::npos) {
basename = this->filename;
} else {
basename = this->filename.substr(lastSlash + 1);
}
// Do we need to remove ext?
if(withExt) return basename;
size_t lastDot = basename.find_last_of('.');
if(lastDot == std::string::npos) return basename;
return basename.substr(0, lastDot);
}
std::string File::getExtension() {
// Remove all but last slash
std::string basename;
size_t lastSlash = this->filename.find_last_of('/');
if(lastSlash == std::string::npos) {
basename = this->filename;
} else {
basename = this->filename.substr(lastSlash + 1);
}
size_t lastDot = basename.find_last_of('.');
if(lastDot == std::string::npos) return "";
return basename.substr(lastDot + 1);
}
File::~File() {
if(this->file != nullptr) this->close();
}

183
src/dawntools/util/File.hpp
View File

@ -1,183 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "assert/assert.hpp"
#include "util/mathutils.hpp"
#if defined(_MSC_VER)
#include <direct.h>
#include <windows.h>
#define getcwd _getcwd
#define FILE_PATH_SEP '\\'
#define fileMkdir(path, perms) _mkdir(path)
#elif defined(__GNUC__)
#include <unistd.h>
#include <dirent.h>
#include <sys/stat.h>
#define FILE_PATH_SEP '/'
#define fileMkdir(path, perms) mkdir(path, perms)
#endif
#include <errno.h>
#define FILE_BUFFER_SIZE 512
namespace Dawn {
enum FileMode {
FILE_MODE_READ,
FILE_MODE_WRITE
};
class File {
private:
enum FileMode mode;
public:
static std::string normalizeSlashes(std::string str);
static void mkdirp(std::string path);
std::string filename;
size_t length;
FILE *file = nullptr;
/**
* Constructs a new File interface class.
*
* @param filename Filename that you want to interface with.
*/
File(std::string filename);
/**
* Opens a connection to the file.
*
* @param mode File mode to use for this interface.
* @return True if success, otherwise for failure.
*/
bool_t open(enum FileMode mode);
/**
* Returns whether or not the file connection is currently opened.
*
* @return True if the connection is open, otherwise if it's not.
*/
bool_t isOpen();
/**
* Returns whether or not the file exists. Will open the connection if it
* does exist.
*
* @return True if exists, otherwsie if it doesn't.
*/
bool_t exists();
/**
* Closes the currently open interface to the file. Done automatically
* when this object is disposed.
*/
void close();
/**
* Makes all directories above this file's filename.
*
* @return True if successful, otherwise false.
*/
bool_t mkdirp();
/**
* Reads the entire contents of a file to the given output string buffer.
* This is a bit dangerous since the length of the file isn't checked
* against the memory to be consumed.
*
* @param out Pointer to a string where the output data will be stored.
* @return True if the read was successful, otherwise false.
*/
bool_t readString(std::string *out);
/**
* Reads ahead from the current position to a specific needle (character).
*
* @param buffer Buffer to output read chars to.
* @param max Max length of the buffer / amount of chars to read ahead.
* @param needle The character (needle) to look for.
* @return Amount of chars read, or <= 0 on error.
*/
size_t readAhead(
char *buffer,
size_t max,
char needle
);
/**
* Reads the contents of this file into a given buffer. If buffer is null
* then the buffer will be allocated and returned.
*
* @param buffer Pointer to buffer to read to.
* @return The size of the read data.
*/
size_t readToBuffer(char **buffer);
/**
* Reads the contents of this file into a given buffer.
*
* @param buffer Pointer to buffer to read to.
* @param max Max length of the buffer.
* @return Amount of bytes read.
*/
size_t readRaw(char *buffer, size_t max);
/**
* Writes the entire contents of a string to a file.
*
* @param in String to write to this file.
* @return True if written successfully, otherwise false.
*/
bool_t writeString(std::string in);
/**
* Write raw bytes to the file.
*
* @param data Data to write.
* @param size Size of the data to write.
* @return True if written successfully, otherwise false.
*/
bool_t writeRaw(char *data, size_t size);
/**
* Write raw bytes to the file from another file.
*
* @param otherFile Other file to read from.
* @param length Length of the data to read.
* @return True if written successfully, otherwise false.
*/
bool_t copyRaw(File *otherFile, size_t length);
/**
* Set the position of the cursor of the file reader.
*
* @param pos Position to set.
*/
void setPosition(size_t pos);
/**
* Get the file name of this file, optionally with the extension.
*
* @param withExtension If true, the extension will be included.
* @return The file name.
*/
std::string getFileName(bool_t withExtension = true);
/**
* Returns the extension of this file.
*
* @return The extension of this file.
*/
std::string getExtension();
/**
* Destruct the File manager.
*/
~File();
};
}

55
src/dawntools/util/Image.cpp
View File

@ -1,55 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "Image.hpp"
#ifndef STB_IMAGE_IMPLEMENTATION
#define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>
#endif
#ifndef STB_IMAGE_RESIZE_IMPLEMENTATION
#define STB_IMAGE_RESIZE_IMPLEMENTATION
#include <stb_image_resize.h>
#endif
#ifndef STB_IMAGE_WRITE_IMPLEMENTATION
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include <stb_image_write.h>
#endif
void imageCopy(
uint8_t *source, int32_t sourceWidth, int32_t sourceHeight,
uint8_t *dest, int32_t destWidth, int32_t destHeight,
int32_t cropX, int32_t cropY, int32_t cropWidth, int32_t cropHeight,
int32_t pasteX, int32_t pasteY,
int32_t channels
) {
int32_t x, y, c;
int32_t absX, absY;
int32_t sourceIndex, targetIndex;
if(cropX == -1) cropX = 0;
if(cropY == -1) cropY = 0;
if(cropWidth == -1) cropWidth = sourceWidth;
if(cropHeight == -1) cropHeight = sourceHeight;
if(pasteX == -1) pasteX = 0;
if(pasteY == -1) pasteY = 0;
for(x = cropX; x < cropX + cropWidth; x++) {
for(y = cropY; y < cropY + cropHeight; y++) {
absX = x - cropX + pasteX;
absY = y - cropY + pasteY;
if(absX >= destWidth || absY >= destHeight || absX < 0 || absY < 0)continue;
targetIndex = absY * destWidth + absX;
sourceIndex = y * sourceWidth + x;
for(c = 0; c < channels; c++) {
dest[(targetIndex*channels) + c] = source[(sourceIndex*channels) + c];
}
}
}
}

38
src/dawntools/util/Image.hpp
View File

@ -1,38 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "File.hpp"
#include <stb_image.h>
#include <stb_image_resize.h>
#include <stb_image_write.h>
/**
* Unused currently.
*
* @param source
* @param sourceWidth
* @param sourceHeight
* @param dest
* @param destWidth
* @param destHeight
* @param cropX
* @param cropY
* @param cropWidth
* @param cropHeight
* @param pasteX
* @param pasteY
* @param channels
*/
void imageCopy(
uint8_t *source, int32_t sourceWidth, int32_t sourceHeight,
uint8_t *dest, int32_t destWidth, int32_t destHeight,
int32_t cropX, int32_t cropY, int32_t cropWidth, int32_t cropHeight,
int32_t pasteX, int32_t pasteY,
int32_t channels
);

36
src/dawntools/util/Language.cpp
View File

@ -1,36 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "Language.hpp"
using namespace Dawn;
int32_t languageSaveStrings(
std::string languagesDir,
std::vector<struct LanguageString> strings
) {
if(languagesDir.size() <= 0) {
std::cout << "Languages dir is not defined" << std::endl;
return 1;
}
File file(languagesDir);
if(!file.mkdirp()) {
std::cout << "Failed to create languages string output dir " << file.filename << std::endl;
return 1;
}
// Now convert to xml
std::string buffer;
auto it = strings.begin();
while(it != strings.end()) {
auto s = *it;
buffer += s.lang + "|" + s.key + "|" + s.text + "|";
++it;
}
file.writeString(buffer);
return 0;
}

26
src/dawntools/util/Language.hpp
View File

@ -1,26 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/Xml.hpp"
#include "util/File.hpp"
struct LanguageString {
std::string key;
std::string lang;
std::string text;
};
/**
* Shorthand method to save a list of languages to a file.
*
* @param languagesDir Directory where the language(s) are to be stored.
* @param strings List of strings to store.
* @return 0 for success, otherwise for failure.
*/
static int32_t languageSaveStrings(
std::string languagesDir,
std::vector<struct LanguageString> strings
);

113
src/dawntools/util/XmlParser.hpp
View File

@ -1,113 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/Xml.hpp"
namespace Dawn {
template<typename T>
class XmlParser {
protected:
/**
* Get the required attributes for this Xml Node to have.
*
* @return Vector of strings of required attribute keys.
*/
virtual std::vector<std::string> getRequiredAttributes() = 0;
/**
* Return optional attributes with defaults for this node to have.
*
* @return Key-Value Pair of optional attributes and defaults.
*/
virtual std::map<std::string, std::string> getOptionalAttributes() = 0;
/**
* Callback to be invoked upon successful parse of this node.
*
* @param node Node that was parsed.
* @param values KVP of values from the required and optional attrs.
* @param output Templated output of the parse from this method.
* @param error Pointer to a string to write-out any errors.
* @return Non 0 for error, 0 for success.
*/
virtual int32_t onParse(
Xml *node,
std::map<std::string, std::string> values,
T *output,
std::string *error
) = 0;
public:
/**
* Common parse method to parse a duration from a value string.
*
* @param duration Duration string to parse.
* @return The parsed duration.
*/
static std::string parseDuration(std::string duration) {
std::string dur = duration;
if(dur.find('.') == std::string::npos) dur += ".0";
return dur + "f";
}
/**
* Common parse method to parse an easing from a value string.
*
* @param e Easing string to parse.
* @return The parsed ease.
*/
static std::string parseEase(std::string e) {
if(e == "out-quad") return "&easeOutQuad";
if(e == "linear") return "&easeLinear";
return "";
}
/**
* Handles parsing of an Xml node.
*
* @param xml Xml node to parse.
* @param output Output struct to put the output data.
* @param error Pointer to the string for errors to be stored.
* @return 0 for success, otherwise for error.
*/
int32_t parse(Xml *xml, T *output, std::string *error) {
std::map<std::string, std::string> values;
// First get the required attributes
auto required = this->getRequiredAttributes();
auto itRequired = required.begin();
while(itRequired != required.end()) {
auto s = *itRequired;
auto attr = xml->attributes.find(s);
if(attr == xml->attributes.end()) {
std::cout << "Missing required attribute \"" << s << "\" on node \"" << xml->node << "\"" << std::endl;
return 1;
}
values[s] = attr->second;
++itRequired;
}
// Now get the optional attributes
auto optional = this->getOptionalAttributes();
auto itOptional = optional.begin();
while(itOptional != optional.end()) {
auto key = itOptional->first;
auto defaultValue = itOptional->second;
auto attr = xml->attributes.find(key);
if(attr == xml->attributes.end()) {
values[key] = defaultValue;
} else {
values[key] = attr->second;
}
++itOptional;
}
// Now send to parser
return this->onParse(xml, values, output, error);
}
};
}

19
src/dawntools/util/generator/CMakeLists.txt
View File

@ -1,19 +0,0 @@
# 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}
)

53
src/dawntools/util/generator/SceneAssetGenerator.cpp
View File

@ -1,53 +0,0 @@
// 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 + "\"));", "");
}

23
src/dawntools/util/generator/SceneAssetGenerator.hpp
View File

@ -1,23 +0,0 @@
// 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
);
};
}

33
src/dawntools/util/generator/SceneCodeGenerator.cpp
View File

@ -1,33 +0,0 @@
// 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;
}
}

21
src/dawntools/util/generator/SceneCodeGenerator.hpp
View File

@ -1,21 +0,0 @@
// 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
);
};
}

103
src/dawntools/util/generator/SceneGenerator.cpp
View File

@ -1,103 +0,0 @@
// 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;", "");
}

21
src/dawntools/util/generator/SceneGenerator.hpp
View File

@ -1,21 +0,0 @@
// 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
);
};
}

43
src/dawntools/util/generator/SceneItemComponentGenerator.cpp
View File

@ -1,43 +0,0 @@
// 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);
}

24
src/dawntools/util/generator/SceneItemComponentGenerator.hpp
View File

@ -1,24 +0,0 @@
// 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
);
};
}

213
src/dawntools/util/generator/SceneItemGenerator.cpp
View File

@ -1,213 +0,0 @@
// 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);", "");
}
}

47
src/dawntools/util/generator/SceneItemGenerator.hpp
View File

@ -1,47 +0,0 @@
// 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
);
};
}

20
src/dawntools/util/parser/CMakeLists.txt
View File

@ -1,20 +0,0 @@
# 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}/SceneParser.cpp
${D}/SceneItemParser.cpp
${D}/SceneAssetParser.cpp
${D}/SceneCodeParser.cpp
${D}/SceneItemComponentParser.cpp
${D}/SceneItemComponentRegistry.cpp
CACHE INTERNAL
${DAWN_CACHE_TARGET}
)

40
src/dawntools/util/parser/SceneAssetParser.cpp
View File

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

34
src/dawntools/util/parser/SceneAssetParser.hpp
View File

@ -1,34 +0,0 @@
// 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 SceneAssetType {
SCENE_ASSET_TYPE_TEXTURE,
SCENE_ASSET_TYPE_TRUETYPE_FONT
};
struct SceneAsset {
SceneAssetType type;
std::string fileName;
std::string usageName;
std::string ref;
};
class SceneAssetParser : public XmlParser<SceneAsset> {
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 SceneAsset *out,
std::string *error
);
};
}

41
src/dawntools/util/parser/SceneCodeParser.cpp
View File

@ -1,41 +0,0 @@
// 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 if(type == "include") {
out->codeType = SCENE_CODE_TYPE_INCLUDE;
} else {
*error = "Invalid type '" + type + "' for SceneCode.";
return -1;
}
// Get the code
out->code = node->textContent;
return 0;
}

33
src/dawntools/util/parser/SceneCodeParser.hpp
View File

@ -1,33 +0,0 @@
// 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,
SCENE_CODE_TYPE_INCLUDE
};
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
);
};
}

80
src/dawntools/util/parser/SceneItemComponentParser.cpp
View File

@ -1,80 +0,0 @@
// 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;
}
auto itInnerXml = ruleset.innerXml.begin();
while(itInnerXml != ruleset.innerXml.end()) {
auto name = itInnerXml->first;
auto type = itInnerXml->second;
out->values[name] = stringParser(node->innerXml, error);
if(error->size() != 0) return 1;
++itInnerXml;
}
return 0;
}

30
src/dawntools/util/parser/SceneItemComponentParser.hpp
View File

@ -1,30 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/parser/SceneItemComponentRegistry.hpp"
#include "util/parser/TypeParsers.hpp"
namespace Dawn {
struct SceneItemComponent {
struct SceneItemComponentRegistry *registry;
std::string include;
std::string type;
std::map<std::string, std::string> values;
std::string ref;
};
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 SceneItemComponent *out,
std::string *error
) override;
};
}

203
src/dawntools/util/parser/SceneItemComponentRegistry.cpp
View File

@ -1,203 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "SceneItemComponentRegistry.hpp"
using namespace Dawn;
struct SceneItemComponentRuleset SceneItemComponentRegistry::parseFile(
File *file,
std::string clazz
) {
assertNotNull(file, "SceneItemCOmponentRegistry::parseFile: File is null");
std::string data;
if(!file->readString(&data)) {
std::cout << "Failed to read ruleset file!" << std::endl;
return { .name = "" };
}
// Begin scanning contentsr
// std::string include = this->sources;
auto toRemove = File::normalizeSlashes(this->sources + FILE_PATH_SEP);
auto includePath = file->filename.substr(toRemove.size(), file->filename.size() - toRemove.size());
// Now locate the first subdir since we don't want to include the root path (e.g. dawn, dawnrose, etc)
auto firstSlash = includePath.find(FILE_PATH_SEP);
if(firstSlash != std::string::npos) {
includePath = includePath.substr(firstSlash + 1, includePath.size() - firstSlash - 1);
}
struct SceneItemComponentRuleset ruleset;
// Replace all file seps with slashes
size_t pos = 0;
while ((pos = includePath.find(FILE_PATH_SEP, pos)) != std::string::npos) {
includePath.replace(pos, 1, "/");
pos += 1;
}
ruleset.include = includePath;
ruleset.name = clazz;
std::regex_constants::syntax_option_type regexFlags;
#if defined(__GNUC__)
regexFlags = std::regex_constants::ECMAScript | std::regex_constants::multiline;
#else
regexFlags = std::regex_constants::ECMAScript;
#endif
// First, let's look for what class(es) this class extends
std::regex regexClassName("class\\s+\\w+\\s+:\\s+", regexFlags);
std::smatch match;
if(std::regex_search(data, match, regexClassName)) {
// Now find the next "{"
auto matchStart = match.position() + match.length();
auto openBracePos = data.find("{", matchStart);
if(openBracePos == std::string::npos) {
std::cout << "Failed to find open brace for class!" << std::endl;
return { .name = "" };
}
// Match each of the class names
std::regex regexClass("(public\\s+(\\w+))[,\\s{]+", regexFlags);
std::sregex_iterator itClass(data.begin() + matchStart, data.begin() + openBracePos, regexClass);
std::sregex_iterator endClass;
while(itClass != endClass) {
// Get the class name
auto className = itClass->str(2);
itClass++;
// We don't parse interface classes
if(className[0] == 'I') continue;
ruleset.extends.push_back(className);
}
}
// Find each instance of "@optional" when it's used within a comment
// e.g. // @optional or /* @optional */ in the string data.1
std::regex regex("^\\s*(?:\\/\\/|\\/\\*){1}\\s*\\@(optional|innerXml)\\s*(?:\\*\\/)?\\s*$", regexFlags);
std::sregex_iterator it(data.begin(), data.end(), regex);
std::sregex_iterator end;
while(it != end) {
// Extract the kind of parameter this is
std::smatch match;
if(!std::regex_search(data, match, regex)) {
std::cout << "Failed to determine parameter type!" << std::endl;
return { .name = "" };
}
std::string paramType = match[1].str();
// Find the next ";"
auto endPos = data.find(";", it->position() + it->length());
if(endPos == std::string::npos) {
std::cout << "Failed to find end of line for attribute!" << std::endl;
return { .name = "" };
}
// Go backwards see if there's an equals sign after the match but before endPos
auto equalsPos = data.rfind("=", endPos);
// If there's an equals sign, we search backwards from there,
// otherwise we search backwards from the ;
auto varStart = it->position() + it->length() + 1;
size_t lastSearchPos = (
(equalsPos == std::string::npos || equalsPos <= varStart) ?
endPos :
equalsPos
);
// Now we have our string
auto varLength = lastSearchPos - varStart;
auto variableString = data.substr(varStart, varLength);
// Now (should) be able to extract the type;
std::regex regex2("^\\s*(?:[\\S]+<)?([\\w*:_\\s]+)(?:[\\S]+)? (\\**[\\w]+)\\s*$", regexFlags);
std::smatch match2;
if(!std::regex_search(variableString, match2, regex2)) {
std::cout << "Failed to extract type and name from variable string! " << variableString << std::endl;
return { .name = "" };
}
// Now we have our type and name
auto type = match2[1].str();
auto name = match2[2].str();
// Now store depending on the type
if(paramType == "optional") {
ruleset.selfOptional[name] = type;
} else if(paramType == "innerXml") {
ruleset.innerXml[name] = type;
} else {
assertUnreachable("SceneItemComponentRegistry::parseFile: Unknown parameter type");
}
++it;
}
return ruleset;
}
struct SceneItemComponentRuleset SceneItemComponentRegistry::getRuleset(std::string type) {
if(this->rulesets.find(type) != this->rulesets.end()) {
return this->rulesets[type];
}
std::vector<std::string> pathsToScan;
pathsToScan.push_back(this->sources);
auto it = pathsToScan.begin();
while(it != pathsToScan.end()) {
auto str = *it;
pathsToScan.erase(it);
Directory dir = Directory(str);
auto children = dir.readDirectory();
auto itChildren = children.begin();
while(itChildren != children.end()) {
if(itChildren->second == DIRECTORY_CHILD_TYPE_DIRECTORY) {
pathsToScan.push_back(str + "/" + itChildren->first);
++itChildren;
continue;
}
if(itChildren->first != type+".hpp") {
++itChildren;
continue;
}
// Load ruleset
File file(str + "/" + itChildren->first);
auto parsed = SceneItemComponentRegistry::parseFile(&file, type);
if(parsed.name == "") {
std::cout << "Parsing error occured on " << type << std::endl;
return parsed;
}
// Update optionals
parsed.optional.insert(parsed.selfOptional.begin(), parsed.selfOptional.end());
// Recursively parse children
auto itExtends = parsed.extends.begin();
while(itExtends != parsed.extends.end()) {
auto ruleset = this->getRuleset(*itExtends);
if(ruleset.name == "") {
++itExtends;
continue;
}
// Merge ruleset
parsed.optional.insert(ruleset.optional.begin(), ruleset.optional.end());
++itExtends;
}
this->rulesets[type] = parsed;
return parsed;
}
it = pathsToScan.begin();
};
return { .name = "" };
}

41
src/dawntools/util/parser/SceneItemComponentRegistry.hpp
View File

@ -1,41 +0,0 @@
// 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/Directory.hpp"
#include "util/XmlParser.hpp"
#include "util/CodeGen.hpp"
#include "util/string.hpp"
#include <regex>
namespace Dawn {
struct SceneItemComponentRuleset {
std::string name;
std::string include;
std::map<std::string, std::string> selfOptional;
std::map<std::string, std::string> innerXml;
std::map<std::string, std::string> optional;
std::vector<std::string> extends;
};
struct SceneItemComponentRegistry {
std::string sources;
std::map<std::string, struct SceneItemComponentRuleset> rulesets;
struct SceneItemComponentRuleset parseFile(
File *file,
std::string clazz
);
/**
* Gets a prefab component ruleset for a specific scene item component type.
*
* @param type Scene Item Component Type to get ruleset for.
* @return The found ruleset, or an empty ruleset if not found.
*/
struct SceneItemComponentRuleset getRuleset(std::string type);
};
}

152
src/dawntools/util/parser/SceneItemParser.cpp
View File

@ -1,152 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "SceneItemParser.hpp"
using namespace Dawn;
std::vector<std::string> SceneItemParser::getRequiredAttributes() {
return std::vector<std::string>();
}
std::map<std::string, std::string> SceneItemParser::getOptionalAttributes() {
return {
{ "ref", "" },
{ "position", "" },
{ "lookAt", "" },
{ "scale", "" },
{ "prefab", "" },
{ "alignment", "" },
{ "alignX", "" },
{ "aignY", "" },
{ "menuX", "" },
{ "menuY", "" },
{ "label", "" }
};
}
int32_t SceneItemParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct SceneItem *out,
std::string *error
) {
out->ref = values["ref"];
if(values["position"].size() > 0) {
out->position = vec3Parser(values["position"], error);
if(error->size() > 0) return 1;
}
if(values["alignment"].size() > 0) {
out->alignment = vec4Parser(values["alignment"], error);
if(error->size() > 0) return 1;
}
if(values["alignX"].size() > 0) {
out->alignX = uiComponentAlignParser(values["alignX"], error);
if(error->size() > 0) return 1;
}
if(values["alignY"].size() > 0) {
out->alignY = uiComponentAlignParser(values["alignY"], error);
if(error->size() > 0) return 1;
}
if(values["menuX"].size() > 0) {
out->menuX = intParser(values["menuX"], error);
if(error->size() > 0) return 1;
}
if(values["menuY"].size() > 0) {
out->menuY = intParser(values["menuY"], error);
if(error->size() > 0) return 1;
}
if(values["scale"].size() > 0) {
out->scale = vec3Parser(values["scale"], error);
if(error->size() > 0) return 1;
}
if(values["label"].size() > 0) {
out->label = stringParser(values["label"], error);
if(error->size() > 0) return 1;
}
if(values["lookAt"].size() > 0) {
auto lookAtSplit = stringSplit(values["lookAt"], ",");
if(lookAtSplit.size() != 6) {
*error = "Invalid lookAt value: " + values["lookAt"];
return 1;
}
out->lookAtPosition = vec3Parser(lookAtSplit[0] + "," + lookAtSplit[1] + "," + lookAtSplit[2], error);
if(error->size() > 0) return 1;
out->lookAtTarget = vec3Parser(lookAtSplit[3] + "," + lookAtSplit[4] + "," + lookAtSplit[5], error);
if(error->size() > 0) return 1;
}
out->prefab = values["prefab"];
struct SceneItemDependency dep;
auto itChildren = node->childNodes.begin();
while(itChildren != node->childNodes.end()) {
if(itChildren->nodeType != XML_NODE_TYPE_ELEMENT) {
++itChildren;
continue;
}
// Parse child nodes, they may be components or not
auto c = itChildren->child;
if(c->node == "child" || c->node == "item") {
struct SceneItem child;
child.registry = out->registry;
auto ret = (SceneItemParser()).parse(c, &child, error);
if(ret != 0) return ret;
out->children.push_back(child);
// Add a dependency. This solves the reference order problem.
struct SceneItemDependency dep;
dep.type = SCENE_ITEM_DEPENDENCY_TYPE_ITEM;
dep.position = out->children.size() - 1;
out->dependencies.push_back(dep);
} else if(c->node == "asset") {
struct SceneAsset asset;
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);
// Add Dep
dep.type = SCENE_ITEM_DEPENDENCY_TYPE_CODE;
dep.position = out->code.size() - 1;
out->dependencies.push_back(dep);
} else {
struct SceneItemComponent component;
component.registry = out->registry;
auto ret = (SceneItemComponentParser()).parse(c, &component, error);
if(ret != 0) return ret;
out->components.push_back(component);
// Add dep
struct SceneItemDependency dep;
dep.type = SCENE_ITEM_DEPENDENCY_TYPE_COMPONENT;
dep.position = out->components.size() - 1;
out->dependencies.push_back(dep);
}
++itChildren;
}
return 0;
}

55
src/dawntools/util/parser/SceneItemParser.hpp
View File

@ -1,55 +0,0 @@
// 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/parser/SceneAssetParser.hpp"
#include "util/parser/SceneCodeParser.hpp"
namespace Dawn {
enum SceneItemDependencyType {
SCENE_ITEM_DEPENDENCY_TYPE_ITEM,
SCENE_ITEM_DEPENDENCY_TYPE_COMPONENT,
SCENE_ITEM_DEPENDENCY_TYPE_CODE,
};
struct SceneItemDependency {
enum SceneItemDependencyType type;
size_t position;
};
struct SceneItem {
struct SceneItemComponentRegistry *registry;
std::string ref;
std::string position;
std::string alignment;
std::string alignX;
std::string alignY;
std::string lookAtPosition;
std::string lookAtTarget;
std::string scale;
std::string prefab;
std::string menuX;
std::string menuY;
std::string label;
std::vector<struct SceneItemComponent> components;
std::vector<struct SceneItem> children;
std::vector<struct SceneAsset> assets;
std::vector<struct SceneCode> code;
std::vector<struct SceneItemDependency> dependencies;
};
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 SceneItem *out,
std::string *error
) override;
};
}

78
src/dawntools/util/parser/SceneParser.cpp
View File

@ -1,78 +0,0 @@
// 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 {
{ "extend", "" }
};
}
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"];
out->extend = values["extend"];
struct SceneItemDependency dep;
//Parse the children
auto itChildren = node->childNodes.begin();
while(itChildren != node->childNodes.end()) {
if(itChildren->nodeType != XML_NODE_TYPE_ELEMENT) {
++itChildren;
continue;
}
Xml *child = itChildren->child;
if(child->node == "asset") {
struct SceneAsset asset;
auto ret = (SceneAssetParser()).parse(child, &asset, error);
if(ret != 0) return ret;
out->assets.push_back(asset);
} else 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);
//Add the dependency
dep.type = SCENE_ITEM_DEPENDENCY_TYPE_ITEM;
dep.position = out->items.size() - 1;
out->dependencies.push_back(dep);
} else if(child->node == "code") {
struct SceneCode code;
ret = (SceneCodeParser()).parse(child, &code, error);
if(ret != 0) return ret;
out->code.push_back(code);
//Add the dependency
dep.type = SCENE_ITEM_DEPENDENCY_TYPE_CODE;
dep.position = out->code.size() - 1;
out->dependencies.push_back(dep);
}
++itChildren;
}
return 0;
}

32
src/dawntools/util/parser/SceneParser.hpp
View File

@ -1,32 +0,0 @@
// 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"
#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;
std::vector<struct SceneAsset> assets;
struct SceneItemComponentRegistry *registry;
std::vector<struct SceneItemDependency> dependencies;
};
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;
};
}

36
src/dawntools/util/string.hpp
View File

@ -1,36 +0,0 @@
/**
* Copyright (c) 2023 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "dawnsharedlibs.hpp"
/**
* Remove all instances of a character from a C-Styled string.
*
* @param string String to remove characters from.
* @param remove Character to remove.
*/
static inline void stringRemoveAll(char *string, char remove) {
size_t len = strlen(string);
size_t i, j;
i = 0;
while(i < len) {
char c = string[i];
if(c != remove) {
i++;
continue;
}
j = i + 1;
while(j < len) {
string[j-1] = string[j];
j++;
}
len--;
}
}

64
src/dawntools/vnscenetool/CMakeLists.txt
View File

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

233
src/dawntools/vnscenetool/VNSceneGen.cpp
View File

@ -1,233 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNSceneGen.hpp"
using namespace Dawn;
void VNSceneGen::test(
std::string eventName,
struct VNSceneEvent *event,
int32_t *eventIndex,
std::vector<std::string> *eventInit,
std::vector<std::string> *eventChain,
std::vector<std::string> *includes
) {
std::string initType = "";
std::string toInclude = "";
std::string initArgs = "";
std::vector<std::string> eventInitAfter;
switch(event->type) {
case VN_SCENE_EVENT_TYPE_TEXT:
initType = "VNTextEvent";
toInclude = "games/vn/events/VNTextEvent.hpp";
line(&eventInitAfter, eventName + "->" + "text = " + event->text.texts.begin()->text + ";", "");
break;
case VN_SCENE_EVENT_TYPE_POSITION:
initType = "VNPositionEvent";
toInclude = "games/vn/events/VNPositionEvent.hpp";
line(&eventInitAfter, eventName + "->item = " + event->position.item + ";", "");
if(event->position.x != "") line(&eventInitAfter, eventName + "->" + "to.x = " + event->position.x + ";", "");
if(event->position.y != "") line(&eventInitAfter, eventName + "->" + "to.y = " + event->position.y + ";", "");
if(event->position.z != "") line(&eventInitAfter, eventName + "->" + "to.z = " + event->position.z + ";", "");
break;
case VN_SCENE_EVENT_TYPE_SET:
initType = "VNSetEvent<" + event->set.type + ">";
toInclude = "games/vn/events/VNSetEvent.hpp";
line(&eventInitAfter, eventName + "->modifies = &" + event->set.property + ";", "");
line(&eventInitAfter, eventName + "->value = " + event->set.to + ";", "");
break;
case VN_SCENE_EVENT_TYPE_WAIT:
initType = "VNWaitEvent";
toInclude = "games/vn/events/VNWaitEvent.hpp";
line(&eventInitAfter, eventName + "->duration = " + event->wait.duration + ";", "");
break;
case VN_SCENE_EVENT_TYPE_PARALLEL: {
initType = "VNParallelEvent";
toInclude = "games/vn/events/VNParallelEvent.hpp";
auto itParallel = event->parallel.events.events.begin();
while(itParallel != event->parallel.events.events.end()) {
std::string pEventName = "pEvent" + std::to_string((*eventIndex)++);
VNSceneGen::test(
pEventName,
&(*itParallel),
eventIndex,
eventInit,
eventChain,
includes
);
line(&eventInitAfter, eventName + "->events.push_back(" + pEventName + ");", "");
line(&eventInitAfter, "", "");
++itParallel;
}
break;
}
case VN_SCENE_EVENT_TYPE_MARKER:
initType = "VNDummyEvent";
toInclude = "games/vn/events/VNDummyEvent.hpp";
line(&eventInitAfter, "auto marker_" + event->marker.name + " = " + eventName + ";", "");
break;
case VN_SCENE_EVENT_TYPE_GOTO_MARKER:
initType = "VNDummyEvent";
toInclude = "games/vn/events/VNDummyEvent.hpp";
line(eventChain, eventName + "->then(marker_" + event->gotoMarker.name + ");", "");
break;
case VN_SCENE_EVENT_TYPE_CHOICES: {
initType = "VNChoiceEvent";
toInclude = "games/vn/events/VNChoiceEvent.hpp";
line(&eventInitAfter, eventName + "->key = \"" + event->choices.key+ "\";", "");
line(&eventInitAfter, eventName + "->text = " + event->choices.titles.begin()->text + ";", "");
auto itChoices = event->choices.choices.begin();
while(itChoices != event->choices.choices.end()) {
line(&eventInitAfter, eventName + "->choices[\"" + itChoices->value + "\"] = " + itChoices->texts.begin()->text + ";", "");
++itChoices;
}
break;
}
case VN_SCENE_EVENT_TYPE_CHOICE_SET:
initType = "VNChoiceSetEvent";
toInclude = "games/vn/events/VNChoiceSetEvent.hpp";
line(&eventInitAfter, eventName + "->key = \"" + event->choiceSet.key + "\";", "");
line(&eventInitAfter, eventName + "->value = \"" + event->choiceSet.value + "\";", "");
break;
case VN_SCENE_EVENT_TYPE_IF: {
initType = "VNIfEvent";
toInclude = "games/vn/events/VNIfEvent.hpp";
line(&eventInitAfter, eventName + "->key = \"" + event->ifEvent.key + "\";", "");
line(&eventInitAfter, eventName + "->value = \"" + event->ifEvent.value + "\";", "");
std::string ifPrevious = "";
std::string ifFirst = "";
auto itIf = event->ifEvent.events.events.begin();
while(itIf != event->ifEvent.events.events.end()) {
std::string ifEventName = "ifEvent" + std::to_string((*eventIndex)++);
VNSceneGen::test(
ifEventName,
&(*itIf),
eventIndex,
eventInit,
eventChain,
includes
);
if(!ifPrevious.empty()) line(eventChain, ifPrevious + "->then(" + ifEventName + ");", "");
ifPrevious = ifEventName;
if(ifFirst == "") ifFirst = ifEventName;
++itIf;
}
if(ifFirst == "" || ifPrevious == "") {
std::cout << "If event must have at least one event" << std::endl;
assertUnreachable("VNSCeneGen::test: If event must have at least one event");
}
line(eventChain, eventName + "->ifTrue = " + ifFirst + ";", "");
line(eventChain, eventName + "->ifEnd = " + ifPrevious + ";", "");
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;
}
case VN_SCENE_EVENT_SET_DEFAULT_FONT: {
initType = "VNSetDefaultFontEvent";
toInclude = "games/vn/events/VNSetDefaultFontEvent.hpp";
std::string strFont = "<font ";
auto sdf = event->setDefaultFont;
if(!sdf.font.empty()) strFont += "font=" + stringParser(sdf.font, NULL);
if(!sdf.fontSize.empty()) strFont += " size=\"" + floatParser(sdf.fontSize, NULL) + "\"";
if(!sdf.color.empty()) strFont += " color=\"" + colorParser(sdf.color, NULL) + "\"";
if(!sdf.style.empty()) strFont += " style=" + stringParser(sdf.style, NULL);
strFont += ">{{ text }}</font>";
line(&eventInitAfter, eventName + "->font = " + stringParser(strFont, NULL) + ";", "");
break;
}
default:
std::cout << "Unknown event type: " << event->type << std::endl;
assertUnreachable("VNSceneGen::test: Unknown event type");
}
if(!toInclude.empty()) includes->push_back(toInclude);
line(eventInit, "auto " + eventName + " = vnManager->createEvent<" + initType + ">(" + initArgs + ");", "");
lines(eventInit, eventInitAfter, "");
}
void VNSceneGen::generate(
std::vector<std::string> *out,
struct VNScene *scene,
std::string tabs
) {
struct ClassGenInfo classInfo;
struct MethodGenInfo methodAssets;
struct MethodGenInfo methodInit;
// Load Scene
SceneGenerator::generate(
&scene->scene,
classInfo,
methodAssets,
methodInit
);
// Events
classInfo.includes.push_back("games/vn/events/VNDummyEvent.hpp");
line(&methodInit.body, "assertNotNull(vnManager, \"VNSceneGenInit - VN Manager is null?\");", "");
line(&methodInit.body, "VNEvent *previous = vnManager->createEvent<VNDummyEvent>();", "");
line(&methodInit.body, "auto eventStart = previous;", "");
int32_t eventIndex = 0;
auto itEvents = scene->events.events.begin();
std::string previous = "eventStart";
std::vector<std::string> eventInit;
std::vector<std::string> eventChain;
while(itEvents != scene->events.events.end()) {
line(&eventInit, "", "");
std::string eventName = "event" + std::to_string(eventIndex++);
VNSceneGen::test(
eventName,
&(*itEvents),
&eventIndex,
&eventInit,
&eventChain,
&classInfo.includes
);
if(!previous.empty()) line(&eventChain, previous + "->then(" + eventName + ");", "");
previous = eventName;
if(itEvents->type == VN_SCENE_EVENT_TYPE_GOTO_MARKER) previous = "";
++itEvents;
}
lines(&methodInit.body, eventInit, "");
lines(&methodInit.body, eventChain, "");
line(&methodInit.body, "vnManager->setEvent(eventStart);", "");
// Add in methods
CodeGen::methodGen(&classInfo.publicCode, methodAssets);
line(&classInfo.publicCode, "", "");
CodeGen::methodGen(&classInfo.publicCode, methodInit);
CodeGen::classGen(out, classInfo);
}

29
src/dawntools/vnscenetool/VNSceneGen.hpp
View File

@ -1,29 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "VNSceneParser.hpp"
#include "util/CodeGen.hpp"
#include "util/generator/SceneGenerator.hpp"
namespace Dawn {
class VNSceneGen : public CodeGen {
public:
static void test(
std::string eventName,
struct VNSceneEvent *event,
int32_t *eventIndex,
std::vector<std::string> *eventInit,
std::vector<std::string> *eventChain,
std::vector<std::string> *includes
);
static void generate(
std::vector<std::string> *out,
struct VNScene *scene,
std::string tabs
);
};
}

47
src/dawntools/vnscenetool/VNSceneItemParser.cpp
View File

@ -1,47 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNSceneItemParser.hpp"
using namespace Dawn;
std::vector<std::string> VNSceneItemParser::getRequiredAttributes() {
return { "prefab" };
}
std::map<std::string, std::string> VNSceneItemParser::getOptionalAttributes() {
return {
{ "ref", "" }
};
}
int32_t VNSceneItemParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNSceneItem *out,
std::string *error
) {
out->ref = values["ref"];
out->prefab = values["prefab"];
// Split prefab by / and use the last part as the class name
std::string clazz = out->prefab;
size_t pos = clazz.find_last_of('/');
if(pos != std::string::npos) clazz = clazz.substr(pos+1);
out->className = clazz;
// Make sure prefab and className is not empty
if(out->prefab.empty()) {
*error = "Prefab cannot be empty.";
return -1;
}
if(out->className.empty()) {
*error = "Class name cannot be empty.";
return -1;
}
return 0;
}

27
src/dawntools/vnscenetool/VNSceneItemParser.hpp
View File

@ -1,27 +0,0 @@
// 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 VNSceneItem {
std::string ref;
std::string prefab;
std::string className;
};
class VNSceneItemParser : public XmlParser<struct VNSceneItem> {
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 VNSceneItem *out,
std::string *error
) override;
};
}

50
src/dawntools/vnscenetool/VNSceneParser.cpp
View File

@ -1,50 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNSceneParser.hpp"
using namespace Dawn;
std::vector<std::string> VNSceneParser::getRequiredAttributes() {
return { };
}
std::map<std::string, std::string> VNSceneParser::getOptionalAttributes() {
return { };
}
int32_t VNSceneParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNScene *out,
std::string *error
) {
//
int32_t ret;
// First, pass as a standard scene
ret = (SceneParser()).parse(node, &out->scene, error);
if(ret != 0) return ret;
// Now pass the VN Events
auto itChildren = node->childNodes.begin();
while(itChildren != node->childNodes.end()) {
if(itChildren->nodeType != XML_NODE_TYPE_ELEMENT) {
++itChildren;
continue;
}
Xml *child = itChildren->child;
if(child->node != "events") {
++itChildren;
continue;
}
ret = (VNSceneEventsParser()).parse(child, &out->events, error);
if(ret != 0) return ret;
break;
}
return 0;
}

28
src/dawntools/vnscenetool/VNSceneParser.hpp
View File

@ -1,28 +0,0 @@
// 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 "VNSceneItemParser.hpp"
#include "events/VNSceneEventsParser.hpp"
namespace Dawn {
struct VNScene {
struct Scene scene;
struct VNSceneEventList events;
};
class VNSceneParser : public XmlParser<struct VNScene> {
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 VNScene *out,
std::string *error
) override;
};
}

65
src/dawntools/vnscenetool/VNSceneTool.cpp
View File

@ -1,65 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNSceneTool.hpp"
using namespace Dawn;
std::vector<std::string> VNSceneTool::getRequiredFlags() {
return { "input", "output" };
}
std::map<std::string, std::string> VNSceneTool::getOptionalFlags() {
return std::map<std::string, std::string>();
}
int32_t VNSceneTool::start() {
File input = File(flags["input"]);
if(!input.exists()) {
std::cout << "Input file " + input.filename + " 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 VNScene scene;
auto result = ((VNSceneParser()).parse(&xml, &scene, &error));
if(result != 0) {
std::cout << "Failed to parse scene: " << 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"] + "/vnscenes/" + scene.scene.name + ".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!" << std::endl;
return 1;
}
return 0;
}

21
src/dawntools/vnscenetool/VNSceneTool.hpp
View File

@ -1,21 +0,0 @@
// 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 "VNSceneParser.hpp"
#include "VNSceneGen.hpp"
#include "util/File.hpp"
namespace Dawn {
class VNSceneTool : public DawnTool {
protected:
std::vector<std::string> getRequiredFlags() override;
std::map<std::string, std::string> getOptionalFlags() override;
public:
int32_t start();
};
}

22
src/dawntools/vnscenetool/events/CMakeLists.txt
View File

@ -1,22 +0,0 @@
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(vnscenetool
PRIVATE
VNMarkerParser.cpp
VNSceneEventsParser.cpp
VNPositionEventParser.cpp
VNTextEventParser.cpp
VNSetEventParser.cpp
VNWaitEventParser.cpp
VNParallelEventParser.cpp
VNGoToMarkerEventParser.cpp
VNChoiceEventParser.cpp
VNChoiceSetEventParser.cpp
VNIfEventParser.cpp
VNSceneChangeEventParser.cpp
VNSetDefaultFontEventParser.cpp
)

110
src/dawntools/vnscenetool/events/VNChoiceEventParser.cpp
View File

@ -1,110 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNChoiceEventParser.hpp"
using namespace Dawn;
std::vector<std::string> VNChoiceParser::getRequiredAttributes() {
return { "value" };
}
std::map<std::string, std::string> VNChoiceParser::getOptionalAttributes() {
return { };
}
int32_t VNChoiceParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNChoice *out,
std::string *error
) {
int32_t ret;
auto itChildren = node->childNodes.begin();
while(itChildren != node->childNodes.end()) {
if(itChildren->nodeType != XML_NODE_TYPE_ELEMENT) {
++itChildren;
continue;
}
Xml *child = itChildren->child;
// Parse strings
if(child->node == "string") {
VNText text;
ret = (VNTextParser()).parse(child, &text, error);
if(ret != 0) return ret;
out->texts.push_back(text);
} else {
*error = "Unknown child node for choice event '" + child->node + "'";
return -1;
}
itChildren++;
}
out->value = values["value"];
return 0;
}
// // // // // // // // // // // // // // // // // // // // // // // // // // //
std::vector<std::string> VNChoicesEventParser::getRequiredAttributes() {
return { "key" };
}
std::map<std::string, std::string> VNChoicesEventParser::getOptionalAttributes() {
return { };
}
int32_t VNChoicesEventParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNChoiceEvent *out,
std::string *error
) {
int32_t ret;
auto itChildren = node->childNodes.begin();
while(itChildren != node->childNodes.end()) {
if(itChildren->nodeType != XML_NODE_TYPE_ELEMENT) {
++itChildren;
continue;
}
Xml *child = itChildren->child;
// Parse strings
if(child->node == "title") {
auto itChildren2 = child->childNodes.begin();
while(itChildren2 != child->childNodes.end()) {
if(itChildren2->nodeType != XML_NODE_TYPE_ELEMENT) {
++itChildren2;
continue;
}
VNText text;
ret = (VNTextParser()).parse(itChildren2->child, &text, error);
if(ret != 0) return ret;
out->titles.push_back(text);
++itChildren2;
}
} else if(child->node == "choice") {
VNChoice choice;
ret = (VNChoiceParser()).parse(child, &choice, error);
if(ret != 0) return ret;
out->choices.push_back(choice);
} else {
*error = "Unknown child node for choices event '" + child->node + "'";
return -1;
}
itChildren++;
}
out->key = values["key"];
return 0;
}

44
src/dawntools/vnscenetool/events/VNChoiceEventParser.hpp
View File

@ -1,44 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "VNTextEventParser.hpp"
namespace Dawn {
struct VNChoice {
std::vector<struct VNText> texts;
std::string value;
};
struct VNChoiceEvent {
std::vector<struct VNText> titles;
std::vector<struct VNChoice> choices;
std::string key;
};
class VNChoiceParser : public XmlParser<struct VNChoice> {
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 VNChoice *out,
std::string *error
) override;
};
class VNChoicesEventParser : public XmlParser<struct VNChoiceEvent> {
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 VNChoiceEvent *out,
std::string *error
) override;
};
}

27
src/dawntools/vnscenetool/events/VNChoiceSetEventParser.cpp
View File

@ -1,27 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNChoiceSetEventParser.hpp"
using namespace Dawn;
std::vector<std::string> VNChoiceSetEventParser::getRequiredAttributes() {
return { "key", "value" };
}
std::map<std::string, std::string> VNChoiceSetEventParser::getOptionalAttributes() {
return {};
}
int32_t VNChoiceSetEventParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNChoiceSetEvent *out,
std::string *error
) {
out->key = values["key"];
out->value = values["value"];
return 0;
}

26
src/dawntools/vnscenetool/events/VNChoiceSetEventParser.hpp
View File

@ -1,26 +0,0 @@
// 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 VNChoiceSetEvent {
std::string key;
std::string value;
};
class VNChoiceSetEventParser : public XmlParser<VNChoiceSetEvent> {
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 VNChoiceSetEvent *out,
std::string *error
) override;
};
}

26
src/dawntools/vnscenetool/events/VNGoToMarkerEventParser.cpp
View File

@ -1,26 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNGoToMarkerEventParser.hpp"
using namespace Dawn;
std::vector<std::string> VNGoToMarkerEventParser::getRequiredAttributes() {
return { "name" };
}
std::map<std::string, std::string> VNGoToMarkerEventParser::getOptionalAttributes() {
return {};
}
int32_t VNGoToMarkerEventParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNGoToMarkerEvent *out,
std::string *error
) {
out->name = values["name"];
return 0;
}

25
src/dawntools/vnscenetool/events/VNGoToMarkerEventParser.hpp
View File

@ -1,25 +0,0 @@
// 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 VNGoToMarkerEvent {
std::string name;
};
class VNGoToMarkerEventParser : public XmlParser<struct VNGoToMarkerEvent> {
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 VNGoToMarkerEvent *out,
std::string *error
) override;
};
}

30
src/dawntools/vnscenetool/events/VNIfEventParser.cpp
View File

@ -1,30 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNIfEventParser.hpp"
#include "VNSceneEventsParser.hpp"
using namespace Dawn;
std::vector<std::string> VNIfEventParser::getRequiredAttributes() {
return { "key", "value" };
}
std::map<std::string, std::string> VNIfEventParser::getOptionalAttributes() {
return {};
}
int32_t VNIfEventParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNIfEvent *out,
std::string *error
) {
//Get the key and value
out->key = values["key"];
out->value = values["value"];
return (VNSceneEventsParser()).parse(node, &out->events, error);
}

23
src/dawntools/vnscenetool/events/VNIfEventParser.hpp
View File

@ -1,23 +0,0 @@
// 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 VNIfEvent;
class VNIfEventParser : public XmlParser<struct VNIfEvent> {
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 VNIfEvent *out,
std::string *error
) override;
};
}

32
src/dawntools/vnscenetool/events/VNMarkerParser.cpp
View File

@ -1,32 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNMarkerParser.hpp"
using namespace Dawn;
std::vector<std::string> VNMarkerParser::getRequiredAttributes() {
return { "name" };
}
std::map<std::string, std::string> VNMarkerParser::getOptionalAttributes() {
return {};
}
int32_t VNMarkerParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNMarker *out,
std::string *error
) {
// Ensure name only contains letters, and numbers, no spaces or symbols
if(!std::regex_match(values["name"], std::regex("^[a-zA-Z0-9]+$"))) {
*error = "Marker name " + values["name"] + " must only contain letters and numbers.";
return -1;
}
out->name = values["name"];
return 0;
}

26
src/dawntools/vnscenetool/events/VNMarkerParser.hpp
View File

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

27
src/dawntools/vnscenetool/events/VNParallelEventParser.cpp
View File

@ -1,27 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNParallelEventParser.hpp"
#include "VNSceneEventsParser.hpp"
using namespace Dawn;
std::vector<std::string> VNParallelEventParser::getRequiredAttributes() {
return std::vector<std::string>();
}
std::map<std::string, std::string> VNParallelEventParser::getOptionalAttributes() {
return std::map<std::string, std::string>();
}
int32_t VNParallelEventParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNParallelEvent *out,
std::string *error
) {
// Parse all children
return (VNSceneEventsParser()).parse(node, &out->events, error);
}

23
src/dawntools/vnscenetool/events/VNParallelEventParser.hpp
View File

@ -1,23 +0,0 @@
// 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 VNParallelEvent;
class VNParallelEventParser : public XmlParser<struct VNParallelEvent> {
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 VNParallelEvent *out,
std::string *error
) override;
};
}

33
src/dawntools/vnscenetool/events/VNPositionEventParser.cpp
View File

@ -1,33 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNPositionEventParser.hpp"
using namespace Dawn;
std::vector<std::string> VNPositionEventParser::getRequiredAttributes() {
return { "item" };
}
std::map<std::string, std::string> VNPositionEventParser::getOptionalAttributes() {
return {
{ "x", "" },
{ "y", "" },
{ "z", "" }
};
}
int32_t VNPositionEventParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNPositionEvent *out,
std::string *error
) {
out->x = values["x"];
out->y = values["y"];
out->z = values["z"];
out->item = values["item"];
return 0;
}

28
src/dawntools/vnscenetool/events/VNPositionEventParser.hpp
View File

@ -1,28 +0,0 @@
// 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 VNPositionEvent {
std::string x = "";
std::string y = "";
std::string z = "";
std::string item = "";
};
class VNPositionEventParser : public XmlParser<struct VNPositionEvent> {
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 VNPositionEvent *out,
std::string *error
) override;
};
}

33
src/dawntools/vnscenetool/events/VNSceneChangeEventParser.cpp
View File

@ -1,33 +0,0 @@
// 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;
}

26
src/dawntools/vnscenetool/events/VNSceneChangeEventParser.hpp
View File

@ -1,26 +0,0 @@
// 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;
};
}

109
src/dawntools/vnscenetool/events/VNSceneEventsParser.cpp
View File

@ -1,109 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNSceneEventsParser.hpp"
#include "VNParallelEventParser.hpp"
using namespace Dawn;
std::vector<std::string> VNSceneEventsParser::getRequiredAttributes() {
return { };
}
std::map<std::string, std::string> VNSceneEventsParser::getOptionalAttributes() {
return { };
}
int32_t VNSceneEventsParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNSceneEventList *out,
std::string *error
) {
int32_t ret;
auto itChildren = node->childNodes.begin();
while(itChildren != node->childNodes.end()) {
if(itChildren->nodeType != XML_NODE_TYPE_ELEMENT) {
++itChildren;
continue;
}
Xml *child = itChildren->child;
struct VNSceneEvent event;
// Parse event(s)
if(child->node == "text") {
event.type = VN_SCENE_EVENT_TYPE_TEXT;
ret = (VNTextEventParser()).parse(child, &event.text, error);
if(ret != 0) return ret;
} else if(child->node == "position") {
event.type = VN_SCENE_EVENT_TYPE_POSITION;
ret = (VNPositionEventParser()).parse(child, &event.position, error);
if(ret != 0) return ret;
} else if(child->node == "set") {
event.type = VN_SCENE_EVENT_TYPE_SET;
ret = (VNSetEventParser()).parse(child, &event.set, error);
if(ret != 0) return ret;
} else if(child->node == "wait") {
event.type = VN_SCENE_EVENT_TYPE_WAIT;
ret = (VNWaitEventParser()).parse(child, &event.wait, error);
if(ret != 0) return ret;
} else if(child->node == "parallel") {
event.type = VN_SCENE_EVENT_TYPE_PARALLEL;
ret = (VNParallelEventParser()).parse(child, &event.parallel, error);
if(ret != 0) return ret;
} else if(child->node == "marker") {
event.type = VN_SCENE_EVENT_TYPE_MARKER;
ret = (VNMarkerParser()).parse(child, &event.marker, error);
if(ret != 0) return ret;
} else if(child->node == "goto-marker") {
event.type = VN_SCENE_EVENT_TYPE_GOTO_MARKER;
ret = (VNGoToMarkerEventParser()).parse(child, &event.gotoMarker, error);
if(ret != 0) return ret;
} else if(child->node == "choices") {
event.type = VN_SCENE_EVENT_TYPE_CHOICES;
ret = (VNChoicesEventParser()).parse(child, &event.choices, error);
if(ret != 0) return ret;
} else if(child->node == "choice-set") {
event.type = VN_SCENE_EVENT_TYPE_CHOICE_SET;
ret = (VNChoiceSetEventParser()).parse(child, &event.choiceSet, error);
if(ret != 0) return ret;
} else if(child->node == "if") {
event.type = VN_SCENE_EVENT_TYPE_IF;
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 if(child->node == "set-default-font" || child->node == "set-font") {
event.type = VN_SCENE_EVENT_SET_DEFAULT_FONT;
ret = (VNSetDefaultFontEventParser()).parse(child, &event.setDefaultFont, error);
if(ret != 0) return ret;
} else {
*error = "Unknown child node '" + child->node + "'";
return -1;
}
if(ret != 0) return ret;
out->events.push_back(event);
itChildren++;
}
return 0;
}

80
src/dawntools/vnscenetool/events/VNSceneEventsParser.hpp
View File

@ -1,80 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "VNTextEventParser.hpp"
#include "VNPositionEventParser.hpp"
#include "VNSetEventParser.hpp"
#include "VNWaitEventParser.hpp"
#include "VNParallelEventParser.hpp"
#include "VNMarkerParser.hpp"
#include "VNGoToMarkerEventParser.hpp"
#include "VNChoiceEventParser.hpp"
#include "VNChoiceSetEventParser.hpp"
#include "VNIfEventParser.hpp"
#include "VNSceneChangeEventParser.hpp"
#include "VNSetDefaultFontEventParser.hpp"
namespace Dawn {
struct VNSceneEvent;
struct VNSceneEventList {
std::vector<struct VNSceneEvent> events;
};
enum VNSceneEventType {
VN_SCENE_EVENT_TYPE_TEXT,
VN_SCENE_EVENT_TYPE_POSITION,
VN_SCENE_EVENT_TYPE_SET,
VN_SCENE_EVENT_TYPE_WAIT,
VN_SCENE_EVENT_TYPE_PARALLEL,
VN_SCENE_EVENT_TYPE_MARKER,
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_SCENE_CHANGE,
VN_SCENE_EVENT_SET_DEFAULT_FONT
};
struct VNParallelEvent {
struct VNSceneEventList events;
};
struct VNIfEvent {
std::string key;
std::string value;
struct VNSceneEventList events;
};
struct VNSceneEvent {
enum VNSceneEventType type;
struct VNTextEvent text;
struct VNPositionEvent position;
struct VNSetEvent set;
struct VNWaitEvent wait;
struct VNParallelEvent parallel;
struct VNMarker marker;
struct VNGoToMarkerEvent gotoMarker;
struct VNChoiceEvent choices;
struct VNChoiceSetEvent choiceSet;
struct VNIfEvent ifEvent;
struct VNSceneChangeEvent sceneChange;
struct VNSetFont setDefaultFont;
};
class VNSceneEventsParser : public XmlParser<struct VNSceneEventList> {
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 VNSceneEventList *out,
std::string *error
) override;
};
}

46
src/dawntools/vnscenetool/events/VNSetDefaultFontEventParser.cpp
View File

@ -1,46 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNSetDefaultFontEventParser.hpp"
using namespace Dawn;
std::map<std::string, std::string> VNSetDefaultFontEventParser::getOptionalAttributes() {
return {
{ "font", "font_main" },
{ "style", "" },
{ "size", "" },
{ "color", "" }
};
}
std::vector<std::string> VNSetDefaultFontEventParser::getRequiredAttributes() {
return {};
}
int32_t VNSetDefaultFontEventParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNSetFont *out,
std::string *error
) {
//Get the font
out->font = values["font"];
if(out->font.empty()) {
*error = "Font is required.";
return 1;
}
//Get the style
out->style = values["style"];
//Get the size
out->fontSize = values["size"];
//Get the color
out->color = values["color"];
return 0;
}

28
src/dawntools/vnscenetool/events/VNSetDefaultFontEventParser.hpp
View File

@ -1,28 +0,0 @@
// 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 VNSetFont {
std::string font;
std::string style;
std::string fontSize;
std::string color;
};
class VNSetDefaultFontEventParser : public XmlParser<struct VNSetFont> {
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 VNSetFont *out,
std::string *error
) override;
};
}

39
src/dawntools/vnscenetool/events/VNSetEventParser.cpp
View File

@ -1,39 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNSetEventParser.hpp"
using namespace Dawn;
std::vector<std::string> VNSetEventParser::getRequiredAttributes() {
return { "property", "type" };
}
std::map<std::string, std::string> VNSetEventParser::getOptionalAttributes() {
return {
{ "to", "" },
{ "value", "" }
};
}
int32_t VNSetEventParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNSetEvent *out,
std::string *error
) {
if(values["to"] != "") {
out->to = values["to"];
} else if(values["value"] != "") {
out->to = values["value"];
} else {
*error = "Either 'to' or 'value' must be specified";
return -1;
}
out->type = values["type"];
out->property = values["property"];
return 0;
}

27
src/dawntools/vnscenetool/events/VNSetEventParser.hpp
View File

@ -1,27 +0,0 @@
// 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 VNSetEvent {
std::string property = "";
std::string to = "";
std::string type = "";
};
class VNSetEventParser : public XmlParser<struct VNSetEvent> {
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 VNSetEvent *out,
std::string *error
) override;
};
}

82
src/dawntools/vnscenetool/events/VNTextEventParser.cpp
View File

@ -1,82 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNTextEventParser.hpp"
#include "util/parser/TypeParsers.hpp"
using namespace Dawn;
std::vector<std::string> VNTextParser::getRequiredAttributes() {
return { "lang" };
}
std::map<std::string, std::string> VNTextParser::getOptionalAttributes() {
return { };
}
int32_t VNTextParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNText *out,
std::string *error
) {
std::string innerXml = node->innerXml;
// Split by newlines, then trim each line.
std::vector<std::string> lines = stringSplit(innerXml, "\n");
std::vector<std::string> finalLines;
for(auto it = lines.begin(); it != lines.end(); ++it) {
auto newLine = stringTrim(*it);
if(newLine.length() > 0) finalLines.push_back(newLine);
}
std::string finalXml = stringJoin(finalLines, "\n");
out->language = values["lang"];
out->text = stringParser(finalXml, error);
return error->length() == 0 ? 0 : -1;
}
// // // // // // // // // // // // // // // // // // // // // // // // // // //
std::vector<std::string> VNTextEventParser::getRequiredAttributes() {
return { };
}
std::map<std::string, std::string> VNTextEventParser::getOptionalAttributes() {
return { };
}
int32_t VNTextEventParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
struct VNTextEvent *out,
std::string *error
) {
int32_t ret;
auto itChildren = node->childNodes.begin();
while(itChildren != node->childNodes.end()) {
if(itChildren->nodeType != XML_NODE_TYPE_ELEMENT) {
++itChildren;
continue;
}
Xml *child = itChildren->child;
// Parse strings
if(child->node == "string") {
VNText text;
ret = (VNTextParser()).parse(child, &text, error);
if(ret != 0) return ret;
out->texts.push_back(text);
} else {
*error = "Unknown child node for text event '" + child->node + "'";
return -1;
}
itChildren++;
}
return 0;
}

42
src/dawntools/vnscenetool/events/VNTextEventParser.hpp
View File

@ -1,42 +0,0 @@
// 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 VNText {
std::string language;
std::string text;
};
struct VNTextEvent {
std::vector<VNText> texts;
};
class VNTextParser : public XmlParser<struct VNText> {
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 VNText *out,
std::string *error
) override;
};
class VNTextEventParser : public XmlParser<struct VNTextEvent> {
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 VNTextEvent *out,
std::string *error
) override;
};
}

35
src/dawntools/vnscenetool/events/VNWaitEventParser.cpp
View File

@ -1,35 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNWaitEventParser.hpp"
using namespace Dawn;
std::vector<std::string> VNWaitEventParser::getRequiredAttributes() {
return { };
}
std::map<std::string, std::string> VNWaitEventParser::getOptionalAttributes() {
return { { "duration", "" }, { "time", "" } };
}
int32_t VNWaitEventParser::onParse(
Xml *node,
std::map<std::string, std::string> values,
VNWaitEvent *out,
std::string *error
) {
//Get the duration
if(!values["duration"].empty()) {
out->duration = values["duration"];
} else if(!values["time"].empty()) {
out->duration = values["time"];
} else {
*error = "No duration specified.";
return -1;
}
return 0;
}

25
src/dawntools/vnscenetool/events/VNWaitEventParser.hpp
View File

@ -1,25 +0,0 @@
// 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 VNWaitEvent {
std::string duration;
};
class VNWaitEventParser : public XmlParser<VNWaitEvent> {
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,
VNWaitEvent *out,
std::string *error
) override;
};
}

10
src/dawntools/CMakeLists.txt → tools/CMakeLists.txt
View File

@ -15,16 +15,6 @@ set(
CACHE INTERNAL ${DAWN_CACHE_TARGET} CACHE INTERNAL ${DAWN_CACHE_TARGET}
) )
# Tool-Utils
set(DAWN_TOOL_SOURCES "")
include(util/CMakeLists.txt)
include(util/parser/CMakeLists.txt)
include(util/generator/CMakeLists.txt)
# Tools # Tools
add_subdirectory(assetstool) add_subdirectory(assetstool)
add_subdirectory(prefabtool)
add_subdirectory(scenetool)
add_subdirectory(texturetool) add_subdirectory(texturetool)
add_subdirectory(truetypetool)
add_subdirectory(vnscenetool)

0
src/dawntools/assetstool/CMakeLists.txt → tools/assetstool/CMakeLists.txt
View File

0
src/dawntools/assetstool/assetstool.py → tools/assetstool/assetstool.py
View File

0
src/dawntools/texturetool/CMakeLists.txt → tools/texturetool/CMakeLists.txt
View File

0
src/dawntools/texturetool/texturetool.py → tools/texturetool/texturetool.py
View File