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

VNSceneGen is more or less working

Browse Source
This commit is contained in:
Dominic Masters
2023-05-18 21:39:59 -07:00
parent 02589c0b98
commit a42ddd8e9e
9 changed files with 267 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/dawnliminal/game/LiminalGame.cpp
View File

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

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

@ -13,73 +13,15 @@ void SceneGen::generate(
std::string tabs std::string tabs
) { ) {
struct ClassGenInfo classInfo; struct ClassGenInfo classInfo;
classInfo.clazz = scene->name;
classInfo.constructorArgs = "DawnGame *game";
classInfo.extendArgs = "game";
std::string baseClassName = "Scene";
// 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('/');
if(lastSlash != std::string::npos) {
baseClassName = scene->extend.substr(lastSlash + 1);
} else {
baseClassName = scene->extend;
}
}
classInfo.extend = baseClassName;
// classInfo.extend = "Scene";
struct MethodGenInfo methodAssets; struct MethodGenInfo methodAssets;
methodAssets.name = "getRequiredAssets";
methodAssets.isOverride = true;
methodAssets.type = "std::vector<Asset*>";
line(&methodAssets.body, "auto assMan = &this->game->assetManager;", "");
struct MethodGenInfo methodInit; struct MethodGenInfo methodInit;
methodInit.name = "stage";
methodInit.isOverride = true;
if(scene->extend.empty()) { SceneGenerator::generate(
line(&methodAssets.body, "std::vector<Asset*> assets;", ""); scene,
} else { classInfo,
line(&methodAssets.body, "std::vector<Asset*> assets = " + baseClassName + "::getRequiredAssets();", ""); methodAssets,
line(&methodInit.body, baseClassName + "::stage();", ""); methodInit
}
// Generate
int32_t assetNumber = 0;
int32_t childNumber = 0;
int32_t componentNumber = 0;
std::map<std::string, std::string> assetMap;
auto sceneItems = scene->items.begin();
while(sceneItems != scene->items.end()) {
SceneItemGenerator::generate(
assetNumber,
componentNumber,
childNumber,
assetMap,
classInfo.includes,
&classInfo.publicProperties,
&methodInit.body,
&methodAssets.body,
"",
"this",
&(*sceneItems),
""
); );
++sceneItems;
}
// Seal methods
line(&methodAssets.body, "return assets;", "");
// Add in methods // Add in methods
CodeGen::methodGen(&classInfo.publicCode, methodAssets); CodeGen::methodGen(&classInfo.publicCode, methodAssets);

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

@ -4,8 +4,7 @@
// https://opensource.org/licenses/MIT // https://opensource.org/licenses/MIT
#pragma once #pragma once
#include "util/parser/SceneParser.hpp" #include "util/generator/SceneGenerator.hpp"
#include "util/generator/SceneItemGenerator.hpp"
namespace Dawn { namespace Dawn {
class SceneGen : public CodeGen { class SceneGen : public CodeGen {

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

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

79
src/dawntools/util/generator/SceneGenerator.cpp Normal file
View File

@ -0,0 +1,79 @@
// 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
) {
classInfo.clazz = scene->name;
classInfo.constructorArgs = "DawnGame *game";
classInfo.extendArgs = "game";
std::string baseClassName = "Scene";
// 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 assMan = &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();", "");
}
// Generate
int32_t assetNumber = 0;
int32_t childNumber = 0;
int32_t componentNumber = 0;
std::map<std::string, std::string> assetMap;
auto sceneItems = scene->items.begin();
while(sceneItems != scene->items.end()) {
SceneItemGenerator::generate(
assetNumber,
componentNumber,
childNumber,
assetMap,
classInfo.includes,
&classInfo.publicProperties,
&methodInit.body,
&methodAssets.body,
"",
"this",
&(*sceneItems),
""
);
++sceneItems;
}
// Seal methods
line(&methodAssets.body, "return assets;", "");
}

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

@ -0,0 +1,21 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/parser/SceneParser.hpp"
#include "SceneItemGenerator.hpp"
#include "util/CodeGen.hpp"
namespace Dawn {
class SceneGenerator : public CodeGen {
public:
static void generate(
struct Scene *scene,
struct ClassGenInfo &classInfo,
struct MethodGenInfo &methodAssets,
struct MethodGenInfo &methodInit
);
};
}

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

@ -14,139 +14,138 @@ void VNSceneGen::test(
std::vector<std::string> *body, std::vector<std::string> *body,
std::vector<std::string> *includes std::vector<std::string> *includes
) { ) {
std::string initType = "";
std::string toInclude = "";
std::string initArgs = "";
std::vector<std::string> afterLines;
// std::string initType = ""; switch(event->type) {
// std::string toInclude = ""; case VN_SCENE_EVENT_TYPE_TEXT:
// std::string initArgs = ""; initType = "VNTextEvent";
// std::vector<std::string> afterLines; toInclude = "games/vn/events/VNTextEvent.hpp";
line(&afterLines, eventName + "->" + "text = \"" + event->text.texts.begin()->text + "\";", "");
break;
// switch(event->type) { case VN_SCENE_EVENT_TYPE_POSITION:
// case VN_SCENE_EVENT_TYPE_TEXT: initType = "VNPositionEvent";
// initType = "VNTextEvent"; toInclude = "games/vn/events/VNPositionEvent.hpp";
// toInclude = "games/vn/events/VNTextEvent.hpp"; line(&afterLines, eventName + "->item = " + event->position.item + ";", "");
// line(&afterLines, eventName + "->" + "text = \"" + event->text.texts.begin()->text + "\";", ""); if(event->position.x != "") line(&afterLines, eventName + "->" + "to.x = " + event->position.x + ";", "");
// break; if(event->position.y != "") line(&afterLines, eventName + "->" + "to.y = " + event->position.y + ";", "");
if(event->position.z != "") line(&afterLines, eventName + "->" + "to.z = " + event->position.z + ";", "");
break;
// case VN_SCENE_EVENT_TYPE_POSITION: case VN_SCENE_EVENT_TYPE_SET:
// initType = "VNPositionEvent"; initType = "VNSetEvent<" + event->set.type + ">";
// toInclude = "games/vn/events/VNPositionEvent.hpp"; toInclude = "games/vn/events/VNSetEvent.hpp";
// line(&afterLines, eventName + "->item = " + event->position.item + ";", ""); line(&afterLines, eventName + "->modifies = &" + event->set.property + ";", "");
// if(event->position.x != "") line(&afterLines, eventName + "->" + "to.x = " + event->position.x + ";", ""); line(&afterLines, eventName + "->to = " + event->set.to + ";", "");
// if(event->position.y != "") line(&afterLines, eventName + "->" + "to.y = " + event->position.y + ";", ""); if(event->set.from != "") line(&afterLines, eventName + "->from = " + event->set.from + ";", "");
// if(event->position.z != "") line(&afterLines, eventName + "->" + "to.z = " + event->position.z + ";", ""); if(event->set.duration != "") line(&afterLines, eventName + "->duration = " + event->set.duration + ";", "");
// break; break;
// case VN_SCENE_EVENT_TYPE_SET: case VN_SCENE_EVENT_TYPE_WAIT:
// initType = "VNSetEvent<" + event->set.type + ">"; initType = "VNWaitEvent";
// toInclude = "games/vn/events/VNSetEvent.hpp"; toInclude = "games/vn/events/VNWaitEvent.hpp";
// line(&afterLines, eventName + "->modifies = &" + event->set.property + ";", ""); line(&afterLines, eventName + "->duration = " + event->wait.duration + ";", "");
// line(&afterLines, eventName + "->to = " + event->set.to + ";", ""); break;
// if(event->set.from != "") line(&afterLines, eventName + "->from = " + event->set.from + ";", "");
// if(event->set.duration != "") line(&afterLines, eventName + "->duration = " + event->set.duration + ";", "");
// break;
// case VN_SCENE_EVENT_TYPE_WAIT: case VN_SCENE_EVENT_TYPE_PARALLEL: {
// initType = "VNWaitEvent"; initType = "VNParallelEvent";
// toInclude = "games/vn/events/VNWaitEvent.hpp"; toInclude = "games/vn/events/VNParallelEvent.hpp";
// line(&afterLines, eventName + "->duration = " + event->wait.duration + ";", "");
// break;
// case VN_SCENE_EVENT_TYPE_PARALLEL: { auto itParallel = event->parallel.events.events.begin();
// initType = "VNParallelEvent"; while(itParallel != event->parallel.events.events.end()) {
// toInclude = "games/vn/events/VNParallelEvent.hpp"; std::string pEventName = "pEvent" + std::to_string((*eventIndex)++);
VNSceneGen::test(
pEventName,
&(*itParallel),
eventIndex,
&afterLines,
includes
);
line(&afterLines, eventName + "->events.push_back(" + pEventName + ");", "");
line(&afterLines, "", "");
++itParallel;
}
break;
}
// auto itParallel = event->parallel.events.events.begin(); case VN_SCENE_EVENT_TYPE_MARKER:
// while(itParallel != event->parallel.events.events.end()) { initType = "VNDummyEvent";
// std::string pEventName = "pEvent" + std::to_string((*eventIndex)++); toInclude = "games/vn/events/VNDummyEvent.hpp";
// VNSceneGen::test( line(&afterLines, "auto marker_" + event->marker.name + " = " + eventName + ";", "");
// pEventName, break;
// &(*itParallel),
// eventIndex,
// &afterLines,
// includes
// );
// line(&afterLines, eventName + "->events.push_back(" + pEventName + ");", "");
// line(&afterLines, "", "");
// ++itParallel;
// }
// break;
// }
// case VN_SCENE_EVENT_TYPE_MARKER: case VN_SCENE_EVENT_TYPE_GOTO_MARKER:
// initType = "VNDummyEvent"; initType = "VNDummyEvent";
// toInclude = "games/vn/events/VNDummyEvent.hpp"; toInclude = "games/vn/events/VNDummyEvent.hpp";
// line(&afterLines, "auto marker_" + event->marker.name + " = " + eventName + ";", ""); line(&afterLines, eventName + "->then(marker_" + event->gotoMarker.name + ");", "");
// break; break;
// case VN_SCENE_EVENT_TYPE_GOTO_MARKER: case VN_SCENE_EVENT_TYPE_CHOICES: {
// initType = "VNDummyEvent"; initType = "VNChoiceEvent";
// toInclude = "games/vn/events/VNDummyEvent.hpp"; toInclude = "games/vn/events/VNChoiceEvent.hpp";
// line(&afterLines, eventName + "->then(marker_" + event->gotoMarker.name + ");", ""); line(&afterLines, eventName + "->key = \"" + event->choices.key+ "\";", "");
// break; line(&afterLines, eventName + "->text = \"" + event->choices.titles.begin()->text + "\";", "");
auto itChoices = event->choices.choices.begin();
while(itChoices != event->choices.choices.end()) {
line(&afterLines, eventName + "->choices[\"" + itChoices->value + "\"] = \"" + itChoices->texts.begin()->text + "\";", "");
++itChoices;
}
break;
}
// case VN_SCENE_EVENT_TYPE_CHOICES: { case VN_SCENE_EVENT_TYPE_CHOICE_SET:
// initType = "VNChoiceEvent"; initType = "VNChoiceSetEvent";
// toInclude = "games/vn/events/VNChoiceEvent.hpp"; toInclude = "games/vn/events/VNChoiceSetEvent.hpp";
// line(&afterLines, eventName + "->key = \"" + event->choices.key+ "\";", ""); line(&afterLines, eventName + "->key = \"" + event->choiceSet.key + "\";", "");
// line(&afterLines, eventName + "->text = \"" + event->choices.titles.begin()->text + "\";", ""); line(&afterLines, eventName + "->value = \"" + event->choiceSet.value + "\";", "");
// auto itChoices = event->choices.choices.begin(); break;
// while(itChoices != event->choices.choices.end()) {
// line(&afterLines, eventName + "->choices[\"" + itChoices->value + "\"] = \"" + itChoices->texts.begin()->text + "\";", "");
// ++itChoices;
// }
// break;
// }
// case VN_SCENE_EVENT_TYPE_CHOICE_SET: case VN_SCENE_EVENT_TYPE_IF: {
// initType = "VNChoiceSetEvent"; initType = "VNIfEvent";
// toInclude = "games/vn/events/VNChoiceSetEvent.hpp"; toInclude = "games/vn/events/VNIfEvent.hpp";
// line(&afterLines, eventName + "->key = \"" + event->choiceSet.key + "\";", ""); line(&afterLines, eventName + "->key = \"" + event->ifEvent.key + "\";", "");
// line(&afterLines, eventName + "->value = \"" + event->choiceSet.value + "\";", ""); line(&afterLines, eventName + "->value = \"" + event->ifEvent.value + "\";", "");
// break;
// case VN_SCENE_EVENT_TYPE_IF: { std::string ifPrevious = "";
// initType = "VNIfEvent"; std::string ifFirst = "";
// toInclude = "games/vn/events/VNIfEvent.hpp"; auto itIf = event->ifEvent.events.events.begin();
// line(&afterLines, eventName + "->key = \"" + event->ifEvent.key + "\";", ""); while(itIf != event->ifEvent.events.events.end()) {
// line(&afterLines, eventName + "->value = \"" + event->ifEvent.value + "\";", ""); std::string ifEventName = "ifEvent" + std::to_string((*eventIndex)++);
VNSceneGen::test(
ifEventName,
&(*itIf),
eventIndex,
&afterLines,
includes
);
if(!ifPrevious.empty()) line(&afterLines, ifPrevious + "->then(" + ifEventName + ");", "");
ifPrevious = ifEventName;
if(ifFirst == "") ifFirst = ifEventName;
++itIf;
}
// std::string ifPrevious = ""; if(ifFirst == "" || ifPrevious == "") {
// std::string ifFirst = ""; std::cout << "If event must have at least one event" << std::endl;
// auto itIf = event->ifEvent.events.events.begin(); assertUnreachable();
// while(itIf != event->ifEvent.events.events.end()) { }
// std::string ifEventName = "ifEvent" + std::to_string((*eventIndex)++);
// VNSceneGen::test(
// ifEventName,
// &(*itIf),
// eventIndex,
// &afterLines,
// includes
// );
// if(!ifPrevious.empty()) line(&afterLines, ifPrevious + "->then(" + ifEventName + ");", "");
// ifPrevious = ifEventName;
// if(ifFirst == "") ifFirst = ifEventName;
// ++itIf;
// }
// if(ifFirst == "" || ifPrevious == "") { line(&afterLines, eventName + "->ifTrue = " + ifFirst + ";", "");
// std::cout << "If event must have at least one event" << std::endl; line(&afterLines, eventName + "->ifEnd = " + ifPrevious + ";", "");
// assertUnreachable(); break;
// } }
// line(&afterLines, eventName + "->ifTrue = " + ifFirst + ";", ""); default:
// line(&afterLines, eventName + "->ifEnd = " + ifPrevious + ";", ""); std::cout << "Unknown event type: " << event->type << std::endl;
// break; assertUnreachable();
// } }
// default: if(!toInclude.empty()) includes->push_back(toInclude);
// std::cout << "Unknown event type: " << event->type << std::endl;
// assertUnreachable();
// }
// if(!toInclude.empty()) includes->push_back(toInclude); line(body, "auto " + eventName + " = vnManager->createEvent<" + initType + ">(" + initArgs + ");", "");
lines(body, afterLines, "");
// line(body, "auto " + eventName + " = vnManager->createEvent<" + initType + ">(" + initArgs + ");", "");
// lines(body, afterLines, "");
} }
void VNSceneGen::generate( void VNSceneGen::generate(
@ -154,86 +153,52 @@ void VNSceneGen::generate(
struct VNScene *scene, struct VNScene *scene,
std::string tabs std::string tabs
) { ) {
std::cout << "Gen Scene" << std::endl; struct ClassGenInfo classInfo;
struct MethodGenInfo methodAssets;
struct MethodGenInfo methodInit;
// struct ClassGenInfo classInfo;
// classInfo.clazz = "TestScene";
// classInfo.extend = "Scene";
// classInfo.constructorArgs = "DawnGame *game";
// classInfo.extendArgs = "game";
// classInfo.includes.push_back("scene/Scene.hpp"); // Load Scene
SceneGenerator::generate(
&scene->scene,
classInfo,
methodAssets,
methodInit
);
// struct MethodGenInfo methodAssets;
// methodAssets.name = "getRequiredAssets";
// methodAssets.isOverride = true;
// methodAssets.type = "std::vector<Asset*>";
// line(&methodAssets.body, "auto assMan = &this->game->assetManager;", "");
// line(&methodAssets.body, "std::vector<Asset*> assets;", "");
// line(&methodAssets.body, "return assets;", "");
// struct MethodGenInfo methodStage; // Events
// methodStage.name = "stage"; classInfo.includes.push_back("games/vn/components/VNManager.hpp");
// methodStage.isOverride = "true"; line(&methodInit.body, "auto vnItem = this->createSceneItem();", "");
// line(&methodStage.body, "// test", ""); line(&methodInit.body, "auto vnManager = vnItem->addComponent<VNManager>();", "");
line(&methodInit.body, "VNEvent *previous = vnManager->createEvent<VNDummyEvent>();", "");
line(&methodInit.body, "auto eventStart = previous;", "");
// // TEST int32_t eventIndex = 0;
// line(&methodStage.body, "auto canvas = UICanvas::create(this);", ""); auto itEvents = scene->events.events.begin();
// line(&methodStage.body, "", ""); std::string previous = "eventStart";
while(itEvents != scene->events.events.end()) {
// classInfo.includes.push_back("scene/components/display/Camera.hpp"); line(&methodInit.body, "", "");
// line(&methodStage.body, "auto camera = Camera::create(this);", ""); std::string eventName = "event" + std::to_string(eventIndex++);
// line(&methodStage.body, "camera->fov = 0.436332f;", ""); VNSceneGen::test(
// line(&methodStage.body, "camera->transform->lookAt(glm::vec3(10, 10, 10), glm::vec3(0, 0, 0));", ""); eventName,
&(*itEvents),
// // Items &eventIndex,
// int32_t itemRefIndex = 0; &methodInit.body,
// auto itItems = scene->items.begin(); &classInfo.includes
// while(itItems != scene->items.end()) { );
// struct VNSceneItem item = *itItems; line(&methodInit.body, previous + "->then(" + eventName + ");", "");
// if(item.ref.empty()) item.ref = "item" + std::to_string(itemRefIndex++); previous = eventName;
// classInfo.includes.push_back(item.prefab + ".hpp"); ++itEvents;
}
// line(&methodStage.body, "", ""); line(&methodInit.body, "", "");
// line(&methodStage.body, "auto " + item.ref + " = " + item.className + "::create(this);", ""); line(&methodInit.body, "vnManager->setEvent(eventStart);", "");
// ++itItems;
// } // Add in methods
CodeGen::methodGen(&classInfo.publicCode, methodAssets);
// line(&methodStage.body, "", ""); line(&classInfo.publicCode, "", "");
CodeGen::methodGen(&classInfo.publicCode, methodInit);
// // Events
// classInfo.includes.push_back("games/vn/components/VNManager.hpp"); CodeGen::classGen(out, classInfo);
// line(&methodStage.body, "auto vnItem = this->createSceneItem();", "");
// line(&methodStage.body, "auto vnManager = vnItem->addComponent<VNManager>();", "");
// line(&methodStage.body, "VNEvent *previous = vnManager->createEvent<VNDummyEvent>();", "");
// line(&methodStage.body, "auto eventStart = previous;", "");
// int32_t eventIndex = 0;
// auto itEvents = scene->events.events.begin();
// std::string previous = "eventStart";
// while(itEvents != scene->events.events.end()) {
// line(&methodStage.body, "", "");
// std::string eventName = "event" + std::to_string(eventIndex++);
// VNSceneGen::test(
// eventName,
// &(*itEvents),
// &eventIndex,
// &methodStage.body,
// &classInfo.includes
// );
// line(&methodStage.body, previous + "->then(" + eventName + ");", "");
// previous = eventName;
// ++itEvents;
// }
// line(&methodStage.body, "", "");
// line(&methodStage.body, "vnManager->setEvent(eventStart);", "");
// // Add in methods
// CodeGen::methodGen(&classInfo.protectedCode, methodAssets);
// line(&classInfo.protectedCode, "", "");
// CodeGen::methodGen(&classInfo.protectedCode, methodStage);
// CodeGen::classGen(out, classInfo);
} }

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

@ -6,6 +6,7 @@
#pragma once #pragma once
#include "VNSceneParser.hpp" #include "VNSceneParser.hpp"
#include "util/CodeGen.hpp" #include "util/CodeGen.hpp"
#include "util/generator/SceneGenerator.hpp"
namespace Dawn { namespace Dawn {
class VNSceneGen : public CodeGen { class VNSceneGen : public CodeGen {

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

@ -42,7 +42,7 @@ int32_t VNSceneTool::start() {
VNSceneGen::generate(&outputData, &scene, ""); VNSceneGen::generate(&outputData, &scene, "");
// Load output file from name and type // Load output file from name and type
File outputFile = File(flags["output"] + "/vnscenes/TestScene.hpp"); File outputFile = File(flags["output"] + "/vnscenes/" + scene.scene.name + ".hpp");
if(!outputFile.mkdirp()) { if(!outputFile.mkdirp()) {
std::cout << "Failed to create output directory!" << std::endl; std::cout << "Failed to create output directory!" << std::endl;
return 1; return 1;