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

Starting new VN Structure

Browse Source
This commit is contained in:
Dominic Masters
2023-04-18 09:55:11 -07:00
parent 60a5a98ec5
commit 6d86fc10bc
72 changed files with 803 additions and 1761 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
cmake/targets/target-liminal-linux64-glfw/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
set(DAWN_BUILDING dawnliminal CACHE INTERNAL ${DAWN_CACHE_TARGET})
set(DAWN_TARGET_LINUX64 true CACHE INTERNAL ${DAWN_CACHE_TARGET})
set(DAWN_TARGET_GLFW true CACHE INTERNAL ${DAWN_CACHE_TARGET})
set(DAWN_TARGET_NAME "Liminal" CACHE INTERNAL ${DAWN_CACHE_TARGET})
set(DAWN_VISUAL_NOVEL true CACHE INTERNAL ${DAWN_CACHE_TARGET})

4
src/dawn/games/CMakeLists.txt
View File

@ -4,9 +4,9 @@
# https://opensource.org/licenses/MIT
# Subdirs
add_subdirectory(poker)
# add_subdirectory(poker)
add_subdirectory(tictactoe)
if(DAWN_VISUAL_NOVEL)
add_subdirectory(visualnovel)
add_subdirectory(vn)
endif()

16
src/dawn/games/visualnovel/CMakeLists.txt
View File

@ -1,16 +0,0 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
VisualNovelManager.cpp
)
# Subdirs
add_subdirectory(components)
add_subdirectory(events)
add_subdirectory(scene)
add_subdirectory(ui)

85
src/dawn/games/visualnovel/VisualNovelManager.cpp
View File

@ -1,85 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VisualNovelManager.hpp"
#include "visualnovel/scene/SimpleVNScene.hpp"
using namespace Dawn;
VisualNovelManager::VisualNovelManager(SceneItem *item) :
SceneItemComponent(item)
{
}
void VisualNovelManager::onStart() {
SceneItemComponent::onStart();
this->uiCanvas = getScene()->findComponent<UICanvas>();
assertNotNull(this->uiCanvas);
this->textBox = this->uiCanvas->findElement<VisualNovelTextbox>();
this->fader = this->uiCanvas->findElement<VisualNovelFader>();
assertNotNull(this->textBox);
this->getScene()->eventSceneUnpausedUpdate.addListener(this, &VisualNovelManager::onUnpausedUpdate);
// Handle queuing simple VN Manager
auto scene = this->getScene();
auto sceneAsSimple = dynamic_cast<SimpleVNScene*>(scene);
if(sceneAsSimple != nullptr) {
this->setEvent(sceneAsSimple->getVNEvent());
}
if(this->currentEvent != nullptr) this->currentEvent->start(nullptr);
}
void VisualNovelManager::onUnpausedUpdate() {
if(this->currentEvent == nullptr) return;
if(!this->currentEvent->hasStarted) this->currentEvent->start(nullptr);
if(this->currentEvent->update()) return;
this->setEvent(this->currentEvent->end());
}
VisualNovelManager::~VisualNovelManager() {
if(this->currentEvent != nullptr) {
delete this->currentEvent;
}
this->getScene()->eventSceneUnpausedUpdate.removeListener(this, &VisualNovelManager::onUnpausedUpdate);
}
// // // // // // // // // // // // // // // // // // // // // // // // // // //
IVisualNovelEvent::IVisualNovelEvent(VisualNovelManager *man) {
assertNotNull(man);
this->manager = man;
}
void IVisualNovelEvent::start(IVisualNovelEvent *previous) {
this->hasStarted = true;
this->onStart(previous);
}
bool_t IVisualNovelEvent::update() {
return this->onUpdate();
}
IVisualNovelEvent * IVisualNovelEvent::end() {
this->onEnd();
if(this->doNext != nullptr) {
auto next = this->doNext;
this->doNext = nullptr;
return next;
}
return nullptr;
}
IVisualNovelEvent::~IVisualNovelEvent() {
if(this->doNext != nullptr) delete this->doNext;
}

124
src/dawn/games/visualnovel/VisualNovelManager.hpp
View File

@ -1,124 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "scene/SceneItemComponent.hpp"
#include "visualnovel/ui/VisualNovelTextbox.hpp"
#include "visualnovel/ui/VisualNovelFader.hpp"
namespace Dawn {
class IVisualNovelEvent;
class VisualNovelManager : public SceneItemComponent {
private:
IVisualNovelEvent* currentEvent = nullptr;
public:
UICanvas *uiCanvas = nullptr;
VisualNovelTextbox *textBox = nullptr;
VisualNovelFader *fader = nullptr;
AudioSource *audioBackground = nullptr;
AudioSource *audioCharacter = nullptr;
/** Event listener for unpaused scene updates. */
void onUnpausedUpdate();
/**
* Constructs a visual novel manager, scene item component.
*
* @param item Item that the VN manager belongs to.
*/
VisualNovelManager(SceneItem *item);
/**
* Sets the currently active visual novel event. This is assumed to be
* the only way to handle events (no multiples currently).
*
* @param event Event to set.
*/
template <class T>
T * setEvent(T *event) {
auto oldCurrent = this->currentEvent;
this->currentEvent = event;
if(this->hasInitialized && event != nullptr) event->start(oldCurrent);
delete oldCurrent;
return event;
}
/**
* Override to the SceneItemComponent on start event.
*
*/
void onStart() override;
/**
* Dispose / Cleanup the VN manager.
*
*/
~VisualNovelManager();
friend class IVisualNovelEvent;
};
class IVisualNovelEvent {
protected:
VisualNovelManager *manager;
IVisualNovelEvent *doNext = nullptr;
bool_t hasStarted = false;
virtual void onStart(IVisualNovelEvent *previous) = 0;
virtual bool_t onUpdate() = 0;
virtual void onEnd() = 0;
public:
IVisualNovelEvent(VisualNovelManager *manager);
/**
* Chains an event to be executed after this event has finished.
*
* @param next Event to process next.
* @return Whatever you pass in to next.
*/
template<class T>
T * then(T *next) {
this->doNext = next;
return next;
}
/**
* Begins this visual novel event, internally updates some flags and
* calls the event to do its own start logic.
*
* @param previous Previous event, this is for doing logic based chains.
*/
void start(IVisualNovelEvent *previous);
/**
* Performs a tick on this event. The event can then decide whether or not
* it has finished processing.
*
* @return True if the event is still active, otherwise false.
*/
bool_t update();
/**
* End this current event. Returns the "next event" to process. Most of
* the events can handle this with the simple ->then() chaining, but some
* events may chose to do complex if-style logic.
*
* @return Event to run next.
*/
IVisualNovelEvent * end();
/**
* Dispose the VN event.
*/
virtual ~IVisualNovelEvent();
friend class VisualNovelManager;
};
}

56
src/dawn/games/visualnovel/components/SimpleVisualNovelBackground.cpp
View File

@ -1,56 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "SimpleVisualNovelBackground.hpp"
using namespace Dawn;
SimpleVisualNovelBackground * SimpleVisualNovelBackground::create(Scene *s) {
auto item = s->createSceneItem();
// item->addComponent<MeshRenderer>();
item->addComponent<MeshHost>();
item->addComponent<SimpleTexturedMaterial>();
auto background = item->addComponent<SimpleVisualNovelBackground>();
return background;
}
SimpleVisualNovelBackground::SimpleVisualNovelBackground(SceneItem *item) :
SceneItemComponent(item)
{
}
std::vector<SceneItemComponent*> SimpleVisualNovelBackground::getDependencies(){
return std::vector<SceneItemComponent*>{
this->material = this->item->getComponent<SimpleTexturedMaterial>(),
this->meshHost = this->item->getComponent<MeshHost>()
};
}
void SimpleVisualNovelBackground::setTexture(Texture *texture) {
assertNotNull(texture);
this->material->texture = texture;
// Since we go both negative and positive, actual height is doubled
float_t aspect = (float_t)texture->getWidth() / (float_t)texture->getHeight();
float_t height = 0.5f;
QuadMesh::bufferQuadMeshWithZ(&this->meshHost->mesh,
glm::vec2(-aspect * height, -height), glm::vec2(0, 1),
glm::vec2( aspect * height, height), glm::vec2(1, 0),
0.0f, 0, 0
);
}
void SimpleVisualNovelBackground::onStart() {
assertNotNull(this->material);
assertNotNull(this->meshHost);
QuadMesh::initQuadMesh(&this->meshHost->mesh,
glm::vec2(-1, -1), glm::vec2(0, 1),
glm::vec2(1, 1), glm::vec2(1, 0),
0.0f
);
}

44
src/dawn/games/visualnovel/components/SimpleVisualNovelBackground.hpp
View File

@ -1,44 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "scene/components/Components.hpp"
#include "scene/components/display/material/SimpleTexturedMaterial.hpp"
namespace Dawn {
class SimpleVisualNovelBackground : public SceneItemComponent {
public:
SimpleTexturedMaterial *material;
MeshHost *meshHost;
/**
* Create a simple Visual Novel Background prefab.
*
* @param scene Scene to add this background to.
* @return Created background Scene Item.
*/
static SimpleVisualNovelBackground * create(Scene *scene);
/**
* Construct a Simple Visual Novel Background. Simple Background is used
* for a quick up and running Visual Novel scene, but does not have any
* special effects or controls beyond updating a texture and mesh.
*
* @param item Scene Item this background belongs to.
*/
SimpleVisualNovelBackground(SceneItem *item);
std::vector<SceneItemComponent*> getDependencies() override;
void onStart() override;
/**
* Set the texture for the background. Auto updates the material and the
* dimensions of the internal quad.
*
* @param texture Texture to use.
*/
void setTexture(Texture *texture);
};
}

25
src/dawn/games/visualnovel/components/VisualNovelCharacter.cpp
View File

@ -1,25 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VisualNovelCharacter.hpp"
using namespace Dawn;
VisualNovelCharacter::VisualNovelCharacter(SceneItem *item) :
SceneItemComponent(item)
{
}
std::vector<SceneItemComponent*> VisualNovelCharacter::getDependencies() {
return std::vector<SceneItemComponent*>{
(this->material = this->item->getComponent<SimpleTexturedMaterial>()),
(this->tiledSprite = this->item->getComponent<TiledSprite>())
};
}
void VisualNovelCharacter::onStart() {
assertNotNull(this->material);
assertNotNull(this->tiledSprite);
}

37
src/dawn/games/visualnovel/components/VisualNovelCharacter.hpp
View File

@ -1,37 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "scene/SceneItemComponent.hpp"
#include "asset/assets/AudioAsset.hpp"
#include "scene/components/display/material/SimpleTexturedMaterial.hpp"
#include "scene/components/display/TiledSprite.hpp"
#include "scene/components/audio/AudioSource.hpp"
namespace Dawn {
struct VisualNovelCharacterEmotion {
int32_t tile = 0;
AudioAsset *talkSound = nullptr;
AudioAsset *emotionSound = nullptr;
};
class VisualNovelCharacter : public SceneItemComponent {
public:
std::string nameKey = "character.unknown";
SimpleTexturedMaterial *material = nullptr;
TiledSprite *tiledSprite = nullptr;
/**
* Visual Novel Character Component. Mostly logic-less but provides nice
* interfaces for sibling components.
*
* @param item Item that this component belongs to.
*/
VisualNovelCharacter(SceneItem *item);
std::vector<SceneItemComponent*> getDependencies() override;
void onStart() override;
};
}

18
src/dawn/games/visualnovel/events/CMakeLists.txt
View File

@ -1,18 +0,0 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
VisualNovelFadeEvent.cpp
VisualNovelTextboxEvent.cpp
VisualNovelChangeSimpleBackgroundEvent.cpp
VisualNovelEmptyEvent.cpp
)
# Subdirs
add_subdirectory(animation)
add_subdirectory(characters)
add_subdirectory(timing)

38
src/dawn/games/visualnovel/events/VisualNovelCallbackEvent.hpp
View File

@ -1,38 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "visualnovel/VisualNovelManager.hpp"
namespace Dawn {
template<class T>
class VisualNovelCallbackEvent : public IVisualNovelEvent {
protected:
T *instance;
void (T::*callback)();
void onStart(IVisualNovelEvent *previous) {
}
bool_t onUpdate() {
return false;
}
void onEnd() {
((*this->instance).*(this->callback))();
}
public:
VisualNovelCallbackEvent(
VisualNovelManager *manager,
T *instance,
void (T::*callback)()
) : IVisualNovelEvent(manager) {
this->instance = instance;
this->callback = callback;
}
};
}

32
src/dawn/games/visualnovel/events/VisualNovelChangeSimpleBackgroundEvent.cpp
View File

@ -1,32 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VisualNovelChangeSimpleBackgroundEvent.hpp"
#include "game/DawnGame.hpp"
using namespace Dawn;
VisualNovelChangeSimpleBackgroundEvent::VisualNovelChangeSimpleBackgroundEvent(
VisualNovelManager *manager, Texture *texture
) : IVisualNovelEvent(manager) {
this->texture = texture;
}
void VisualNovelChangeSimpleBackgroundEvent::onStart(IVisualNovelEvent *prev) {
auto back = this->manager->getScene()
->findComponent<SimpleVisualNovelBackground>()
;
assertNotNull(back);
back->setTexture(this->texture);
}
bool_t VisualNovelChangeSimpleBackgroundEvent::onUpdate() {
return false;
}
void VisualNovelChangeSimpleBackgroundEvent::onEnd() {
}

25
src/dawn/games/visualnovel/events/VisualNovelChangeSimpleBackgroundEvent.hpp
View File

@ -1,25 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "visualnovel/VisualNovelManager.hpp"
#include "visualnovel/components/SimpleVisualNovelBackground.hpp"
namespace Dawn {
class VisualNovelChangeSimpleBackgroundEvent : public IVisualNovelEvent {
protected:
Texture *texture = nullptr;
void onStart(IVisualNovelEvent *previous) override;
bool_t onUpdate() override;
void onEnd() override;
public:
VisualNovelChangeSimpleBackgroundEvent(
VisualNovelManager *manager,
Texture *texture
);
};
}

25
src/dawn/games/visualnovel/events/VisualNovelEmptyEvent.cpp
View File

@ -1,25 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VisualNovelEmptyEvent.hpp"
using namespace Dawn;
VisualNovelEmptyEvent::VisualNovelEmptyEvent(VisualNovelManager *man) :
IVisualNovelEvent(man)
{
}
void VisualNovelEmptyEvent::onStart(IVisualNovelEvent *prev) {
}
bool_t VisualNovelEmptyEvent::onUpdate() {
return false;
}
void VisualNovelEmptyEvent::onEnd() {
}

19
src/dawn/games/visualnovel/events/VisualNovelEmptyEvent.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 "visualnovel/VisualNovelManager.hpp"
namespace Dawn {
class VisualNovelEmptyEvent : public IVisualNovelEvent {
protected:
void onStart(IVisualNovelEvent *previous) override;
bool_t onUpdate() override;
void onEnd() override;
public:
VisualNovelEmptyEvent(VisualNovelManager *manager);
};
}

35
src/dawn/games/visualnovel/events/VisualNovelFadeEvent.cpp
View File

@ -1,35 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VisualNovelFadeEvent.hpp"
using namespace Dawn;
VisualNovelFadeEvent::VisualNovelFadeEvent(
VisualNovelManager *man,
struct Color color,
bool_t fadeIn,
easefunction_t *ease,
float_t duration
) : VisualNovelSimpleAnimationEvent(man, &duration) {
this->color = color;
this->fadeIn = fadeIn;
this->duration = duration;
this->simpleAnimation.easing = ease;
}
void VisualNovelFadeEvent::onStart(IVisualNovelEvent *previous) {
VisualNovelSimpleAnimationEvent::onStart(previous);
this->simpleAnimation = SimpleAnimation<float_t>(&this->manager->fader->color.a);
this->manager->fader->color = this->color;
this->manager->fader->color.a = this->fadeIn ? 0.0f : 1.0f;
this->simpleAnimation.addKeyframe(
0.0f, this->fadeIn ? 0.0f : 1.0f
);
this->simpleAnimation.addKeyframe(
this->duration, this->fadeIn ? 1.0f : 0.0f
);
}

36
src/dawn/games/visualnovel/events/VisualNovelFadeEvent.hpp
View File

@ -1,36 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "visualnovel/events/animation/VisualNovelSimpleAnimationEvent.hpp"
namespace Dawn {
class VisualNovelFadeEvent : public VisualNovelSimpleAnimationEvent<float_t> {
protected:
struct Color color;
bool_t fadeIn;
float_t duration;
void onStart(IVisualNovelEvent *previous) override;
public:
/**
* Create a new visual novel event for fading the screen in/out.
*
* @param man Manager that this VN event belongs to.
* @param color Color to fade to/from.
* @param fadeIn True to make the color go from 0 to 1 opacity.
* @param ease Easing function to use.
* @param duration How long does the fade take.
*/
VisualNovelFadeEvent(
VisualNovelManager *man,
struct Color color,
bool_t fadeIn,
easefunction_t *ease,
float_t duration
);
};
}

59
src/dawn/games/visualnovel/events/VisualNovelTextboxEvent.cpp
View File

@ -1,59 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VisualNovelTextboxEvent.hpp"
using namespace Dawn;
VisualNovelTextboxEvent::VisualNovelTextboxEvent(
VisualNovelManager *manager,
VisualNovelCharacter *character,
struct VisualNovelCharacterEmotion emotion,
std::string languageKey
) : IVisualNovelEvent(manager) {
this->character = character;
this->languageKey = languageKey;
this->emotion = emotion;
}
VisualNovelTextboxEvent::VisualNovelTextboxEvent(
VisualNovelManager *manager,
std::string languageKey
) : IVisualNovelEvent(manager) {
this->character = nullptr;
this->languageKey = languageKey;
}
void VisualNovelTextboxEvent::onStart(IVisualNovelEvent *previous) {
if(this->manager->textBox == nullptr) return;
this->manager->textBox->setText(this->languageKey);
this->manager->textBox->setCharacter(this->character);
if(this->character != nullptr) {
this->character->tiledSprite->setTile(this->emotion.tile);
}
if(this->emotion.emotionSound != nullptr) {
if(this->manager->audioCharacter != nullptr) {
this->manager->audioCharacter->stop();
this->manager->audioCharacter->loop = false;
this->manager->audioCharacter->setAudioData(this->emotion.emotionSound);
this->manager->audioCharacter->play();
}
} else if(this->emotion.talkSound != nullptr) {
this->manager->textBox->setTalkingSound(this->emotion.talkSound);
}
this->manager->textBox->show();
}
bool_t VisualNovelTextboxEvent::onUpdate() {
return this->manager->textBox->isVisible();
}
void VisualNovelTextboxEvent::onEnd() {
}

42
src/dawn/games/visualnovel/events/VisualNovelTextboxEvent.hpp
View File

@ -1,42 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "visualnovel/VisualNovelManager.hpp"
#include "visualnovel/components/VisualNovelCharacter.hpp"
namespace Dawn {
class VisualNovelTextboxEvent : public IVisualNovelEvent {
protected:
std::string languageKey;
VisualNovelCharacter *character;
struct VisualNovelCharacterEmotion emotion;
void onStart(IVisualNovelEvent *previous) override;
bool_t onUpdate() override;
void onEnd() override;
public:
/**
* Create a new Textbox Event. This will queue a conversation item for the
* textbox to display.
*
* @param manager Visual Novel Manager instance for this event.
* @param character Character that is intended to be speaking.
* @param languageKey Language Key to talk.
*/
VisualNovelTextboxEvent(
VisualNovelManager *manager,
VisualNovelCharacter *character,
struct VisualNovelCharacterEmotion emotion,
std::string languageKey
);
VisualNovelTextboxEvent(
VisualNovelManager *manager,
std::string languageKey
);
};
}

27
src/dawn/games/visualnovel/events/animation/VisualNovelAnimationEvent.cpp
View File

@ -1,27 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VisualNovelAnimationEvent.hpp"
#include "game/DawnGame.hpp"
using namespace Dawn;
VisualNovelAnimationEvent::VisualNovelAnimationEvent(
VisualNovelManager *manager
) : IVisualNovelEvent(manager) {
}
void VisualNovelAnimationEvent::onStart(IVisualNovelEvent *previous) {
}
bool_t VisualNovelAnimationEvent::onUpdate() {
this->animation->tick(this->manager->getGame()->timeManager.delta);
return !this->animation->finished;
}
void VisualNovelAnimationEvent::onEnd() {
}

22
src/dawn/games/visualnovel/events/animation/VisualNovelAnimationEvent.hpp
View File

@ -1,22 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "visualnovel/VisualNovelManager.hpp"
#include "display/animation/Animation.hpp"
namespace Dawn {
class VisualNovelAnimationEvent : public IVisualNovelEvent {
protected:
struct Animation *animation;
void onStart(IVisualNovelEvent *previous) override;
bool_t onUpdate() override;
void onEnd() override;
public:
VisualNovelAnimationEvent(VisualNovelManager *manager);
};
}

26
src/dawn/games/visualnovel/events/animation/VisualNovelSimpleAnimationEvent.hpp
View File

@ -1,26 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "VisualNovelAnimationEvent.hpp"
#include "display/animation/SimpleAnimation.hpp"
namespace Dawn {
template<typename T>
class VisualNovelSimpleAnimationEvent : public VisualNovelAnimationEvent {
public:
struct SimpleAnimation<T> simpleAnimation;
VisualNovelSimpleAnimationEvent(
VisualNovelManager *man,
T *modifies
) :
VisualNovelAnimationEvent(man),
simpleAnimation(modifies)
{
this->animation = &this->simpleAnimation;
}
};
}

24
src/dawn/games/visualnovel/events/animation/VisualNovelSimpleCallbackAnimationEvent.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 "VisualNovelAnimationEvent.hpp"
#include "display/animation/SimpleCallbackAnimation.hpp"
namespace Dawn {
template<typename T, class I>
class VisualNovelSimpleCallbackAnimationEvent :
public VisualNovelAnimationEvent
{
public:
struct SimpleCallbackAnimation<T, I> callbackAnimation;
VisualNovelSimpleCallbackAnimationEvent(VisualNovelManager *man) :
VisualNovelAnimationEvent(man)
{
this->animation = &callbackAnimation;
}
};
}

11
src/dawn/games/visualnovel/events/characters/CMakeLists.txt
View File

@ -1,11 +0,0 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
VisualNovelFadeCharacterEvent.cpp
VisualNovelTransformItemEvent.cpp
)

28
src/dawn/games/visualnovel/events/characters/VisualNovelFadeCharacterEvent.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 "VisualNovelFadeCharacterEvent.hpp"
using namespace Dawn;
VisualNovelFadeCharacterEvent::VisualNovelFadeCharacterEvent(
VisualNovelManager *man,
VisualNovelCharacter *character,
bool_t fadeIn,
easefunction_t *ease,
float_t duration
) : VisualNovelSimpleAnimationEvent<float_t>(
man,
&character->material->color.a
) {
this->simpleAnimation.easing = ease;
if(fadeIn) {
this->simpleAnimation.addKeyframe(0.0f, 0.0f);
this->simpleAnimation.addKeyframe(duration, 1.0f);
} else {
this->simpleAnimation.addKeyframe(0.0f, 1.0f);
this->simpleAnimation.addKeyframe(duration, 0.0f);
}
}

24
src/dawn/games/visualnovel/events/characters/VisualNovelFadeCharacterEvent.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 "visualnovel/events/animation/VisualNovelSimpleAnimationEvent.hpp"
#include "visualnovel/components/VisualNovelCharacter.hpp"
#include "scene/components/display/Material.hpp"
namespace Dawn {
class VisualNovelFadeCharacterEvent :
public VisualNovelSimpleAnimationEvent<float_t>
{
public:
VisualNovelFadeCharacterEvent(
VisualNovelManager *man,
VisualNovelCharacter *character,
bool_t fadeIn,
easefunction_t *ease,
float_t duration
);
};
}

53
src/dawn/games/visualnovel/events/characters/VisualNovelTransformItemEvent.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 "VisualNovelTransformItemEvent.hpp"
using namespace Dawn;
VisualNovelTransformItemEvent::VisualNovelTransformItemEvent(
VisualNovelManager *man,
SceneItem *item,
glm::vec3 start,
glm::vec3 end,
easefunction_t *ease,
float_t duration
) : VisualNovelSimpleCallbackAnimationEvent<glm::vec3, Transform>(man) {
assertNotNull(item);
this->item = item;
this->callbackAnimation.setCallback(
&item->transform, &Transform::setLocalPosition
);
if(duration != 0) {
this->callbackAnimation.addKeyframe(0.0f, start);
}
this->callbackAnimation.addKeyframe(duration, end);
}
VisualNovelTransformItemEvent::VisualNovelTransformItemEvent(
VisualNovelManager *man,
SceneItem *item,
glm::vec3 end,
easefunction_t *ease,
float_t duration
) : VisualNovelSimpleCallbackAnimationEvent<glm::vec3, Transform>(man) {
assertNotNull(item);
this->item = item;
this->callbackAnimation.setCallback(
&item->transform, &Transform::setLocalPosition
);
if(duration != 0) this->relative = true;
this->callbackAnimation.addKeyframe(duration, end);
}
void VisualNovelTransformItemEvent::onStart(IVisualNovelEvent *previous) {
if(this->relative) {
this->callbackAnimation.addKeyframe(0.0f, this->item->transform.getLocalPosition());
}
VisualNovelSimpleCallbackAnimationEvent::onStart(previous);
}

36
src/dawn/games/visualnovel/events/characters/VisualNovelTransformItemEvent.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 "visualnovel/events/animation/VisualNovelSimpleCallbackAnimationEvent.hpp"
namespace Dawn {
class VisualNovelTransformItemEvent :
public VisualNovelSimpleCallbackAnimationEvent<glm::vec3, Transform>
{
protected:
bool_t relative = false;
SceneItem *item = nullptr;
void onStart(IVisualNovelEvent *previous) override;
public:
VisualNovelTransformItemEvent(
VisualNovelManager *man,
SceneItem *item,
glm::vec3 start,
glm::vec3 end,
easefunction_t *ease,
float_t duration
);
VisualNovelTransformItemEvent(
VisualNovelManager *man,
SceneItem *item,
glm::vec3 end,
easefunction_t *ease,
float_t duration
);
};
}

11
src/dawn/games/visualnovel/events/timing/CMakeLists.txt
View File

@ -1,11 +0,0 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
VisualNovelBatchEvent.cpp
VisualNovelPauseEvent.cpp
)

66
src/dawn/games/visualnovel/events/timing/VisualNovelBatchEvent.cpp
View File

@ -1,66 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VisualNovelBatchEvent.hpp"
using namespace Dawn;
VisualNovelBatchEvent::VisualNovelBatchEvent(
VisualNovelManager *man,
std::vector<IVisualNovelEvent*> events
) : IVisualNovelEvent(man) {
this->activeEvents = events;
}
void VisualNovelBatchEvent::onStart(IVisualNovelEvent *previous) {
auto it = this->activeEvents.begin();
while(it != this->activeEvents.end()) {
auto evt = *it;
evt->start(previous);
++it;
}
}
bool_t VisualNovelBatchEvent::onUpdate() {
bool_t result;
auto it = this->activeEvents.begin();
while(it != this->activeEvents.end()) {
auto evt = *it;
result = evt->update();
if(result) {
++it;
continue;
}
auto subNext = evt->end();
// In future I may remove this and instead immediately queue the next thing.
assertNull(subNext);
it = this->activeEvents.erase(it);
this->inactiveEvents.push_back(evt);
}
return this->activeEvents.size() > 0;
}
void VisualNovelBatchEvent::onEnd() {
}
VisualNovelBatchEvent::~VisualNovelBatchEvent() {
auto itActive = this->activeEvents.begin();
while(itActive != this->activeEvents.end()) {
auto evt = *itActive;
delete evt;
++itActive;
}
auto itInactive = this->inactiveEvents.begin();
while(itInactive != this->inactiveEvents.end()) {
auto evt = *itInactive;
delete evt;
++itInactive;
}
}

27
src/dawn/games/visualnovel/events/timing/VisualNovelBatchEvent.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 "visualnovel/VisualNovelManager.hpp"
namespace Dawn {
class VisualNovelBatchEvent : public IVisualNovelEvent {
protected:
std::vector<IVisualNovelEvent*> activeEvents;
std::vector<IVisualNovelEvent*> inactiveEvents;
void onStart(IVisualNovelEvent *previous) override;
bool_t onUpdate() override;
void onEnd() override;
public:
VisualNovelBatchEvent(
VisualNovelManager *man,
std::vector<IVisualNovelEvent*> events
);
~VisualNovelBatchEvent();
};
}

28
src/dawn/games/visualnovel/events/timing/VisualNovelPauseEvent.cpp
View File

@ -1,28 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VisualNovelPauseEvent.hpp"
#include "game/DawnGame.hpp"
using namespace Dawn;
VisualNovelPauseEvent::VisualNovelPauseEvent(
VisualNovelManager *manager, float_t duration
) : IVisualNovelEvent(manager) {
this->duration = duration;
}
void VisualNovelPauseEvent::onStart(IVisualNovelEvent *prev) {
this->time = 0;
}
bool_t VisualNovelPauseEvent::onUpdate() {
this->time += this->manager->getGame()->timeManager.delta;
return this->time < this->duration;
}
void VisualNovelPauseEvent::onEnd() {
}

28
src/dawn/games/visualnovel/events/timing/VisualNovelPauseEvent.hpp
View File

@ -1,28 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "visualnovel/VisualNovelManager.hpp"
namespace Dawn {
class VisualNovelPauseEvent : public IVisualNovelEvent {
protected:
float_t time;
float_t duration;
void onStart(IVisualNovelEvent *previous) override;
bool_t onUpdate() override;
void onEnd() override;
public:
/**
* Create a new Visual Novel Pause Event.
*
* @param manager Manager this event belongs to.
* @param duration Duration to pause for.
*/
VisualNovelPauseEvent(VisualNovelManager *manager, float_t duration);
};
}

61
src/dawn/games/visualnovel/scene/SimpleVNScene.cpp
View File

@ -1,61 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "SimpleVNScene.hpp"
#include "prefabs/ui/VisualNovelTextboxPrefab.hpp"
using namespace Dawn;
SimpleVNScene::SimpleVNScene(DawnGame *game) : Scene(game) {
}
void SimpleVNScene::vnStage() {
}
std::vector<Asset*> SimpleVNScene::getRequiredAssets() {
auto assMan = &this->game->assetManager;
std::vector<Asset*> assets;
vectorAppend(&assets, VisualNovelTextboxPrefab::getRequiredAssets(assMan));
return assets;
}
void SimpleVNScene::stage() {
auto assMan = &this->game->assetManager;
// Camera
this->camera = Camera::create(this);
this->camera->transform->lookAt(
glm::vec3(0, 0, 2),
glm::vec3(0, 0, 0)
);
this->background = SimpleVisualNovelBackground::create(this);
this->canvas = UICanvas::create(this);
// Stage VN Items
this->vnStage();
// UI
this->textbox = VisualNovelTextboxPrefab::create(this->canvas);
// VN Manager
auto vnManagerItem = this->createSceneItem();
this->vnManager = vnManagerItem->addComponent<VisualNovelManager>();
// Audio
auto listenerItem = this->createSceneItem();
this->audioListener = listenerItem->addComponent<AudioListener>();
auto audioBackgroundItem = this->createSceneItem();
vnManager->audioBackground = audioBackgroundItem->addComponent<AudioSource>();
auto audioCharacterItem = this->createSceneItem();
vnManager->audioCharacter = audioCharacterItem->addComponent<AudioSource>();
// Fader (Drawn over the top of everything else)
this->vnFader = VisualNovelFader::create(canvas);
}

55
src/dawn/games/visualnovel/scene/SimpleVNScene.hpp
View File

@ -1,55 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "scene/Scene.hpp"
#include "game/DawnGame.hpp"
#include "util/array.hpp"
#include "scene/components/Components.hpp"
#include "scene/components/audio/AudioListener.hpp"
#include "visualnovel/VisualNovelManager.hpp"
#include "visualnovel/events/VisualNovelTextboxEvent.hpp"
#include "visualnovel/events/timing/VisualNovelPauseEvent.hpp"
#include "visualnovel/events/VisualNovelFadeEvent.hpp"
#include "visualnovel/events/VisualNovelCallbackEvent.hpp"
#include "visualnovel/events/VisualNovelChangeSimpleBackgroundEvent.hpp"
namespace Dawn {
class SimpleVNScene : public Scene {
protected:
Camera *camera = nullptr;
UICanvas *canvas = nullptr;
VisualNovelTextbox *textbox = nullptr;
SimpleVisualNovelBackground *background = nullptr;
VisualNovelFader *vnFader = nullptr;
VisualNovelManager *vnManager = nullptr;
AudioListener *audioListener = nullptr;
/**
* Internal method to stage the VN scene.
*/
virtual void vnStage();
public:
/**
* Constructs a new Simple VN Scene. Custom class that implements the most
* common VN Things.
*
* @param game
*/
SimpleVNScene(DawnGame *game);
std::vector<Asset*> getRequiredAssets() override;
void stage() override;
/**
* Returns the first VN event for the scene. Called by the VN Manager for
* simple scenes.
*
* @return First VN event to be queued.
*/
virtual IVisualNovelEvent * getVNEvent() = 0;
};
}

25
src/dawn/games/visualnovel/ui/VisualNovelFader.cpp
View File

@ -1,25 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VisualNovelFader.hpp"
using namespace Dawn;
VisualNovelFader::VisualNovelFader(UICanvas *canvas) : UISprite(canvas) {
}
VisualNovelFader * VisualNovelFader::create(UICanvas *canvas) {
assertNotNull(canvas);
auto item = canvas->addElement<VisualNovelFader>();
item->setTransform(
UI_COMPONENT_ALIGN_STRETCH, UI_COMPONENT_ALIGN_STRETCH,
glm::vec4(0, 0, 0, 0),
0.0f
);
item->color = COLOR_BLACK_TRANSPARENT;
return item;
}

32
src/dawn/games/visualnovel/ui/VisualNovelFader.hpp
View File

@ -1,32 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "ui/UISprite.hpp"
#include "ui/UIEmpty.hpp"
namespace Dawn {
class VisualNovelFader : public UISprite {
private:
public:
/**
* Quickly create a visual novel fader.
*
* @param canvas Canvas the fader belongs to.
* @return Created VN Fader.
*/
static VisualNovelFader * create(UICanvas *canvas);
/**
* Construct a new Visual Novel Fader. VN Fader is just a sprite that is
* easily found by the VN Manager for the purpose of adding transitions to
* a VN scene.
*
* @param canvas Canvas for this component.
*/
VisualNovelFader(UICanvas *canvas);
};
}

250
src/dawn/games/visualnovel/ui/VisualNovelTextbox.cpp
View File

@ -1,250 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VisualNovelTextbox.hpp"
#include "game/DawnGame.hpp"
#include "visualnovel/VisualNovelManager.hpp"
using namespace Dawn;
VisualNovelTextbox::VisualNovelTextbox(UICanvas *canvas) :
UIComponent(canvas),
selfParent(canvas),
border(canvas),
label(canvas)
{
// Self Parent
this->selfParent.setTransform(
UI_COMPONENT_ALIGN_STRETCH, UI_COMPONENT_ALIGN_STRETCH,
glm::vec4(0, 0, 0, 0),
0.0f
);
// Border
this->selfParent.addChild(&this->border);
this->border.setTransform(
UI_COMPONENT_ALIGN_STRETCH, UI_COMPONENT_ALIGN_STRETCH,
glm::vec4(0, 0, 0, 0),
0.0f
);
// Label
this->selfParent.addChild(&this->label);
this->label.startQuad = 0;
this->label.quadCount = 0;
this->canvas->getScene()->eventSceneUnpausedUpdate.addListener(
this, &VisualNovelTextbox::textboxOnSceneUpdate
);
}
void VisualNovelTextbox::show() {
if(this->isVisible()) return;
this->visible = true;
this->addChild(&this->selfParent);
if(this->talkSound != nullptr) {
auto vnManager = this->getVisualNovelManager();
assertNotNull(vnManager);
assertNotNull(vnManager->audioCharacter);
vnManager->audioCharacter->stop();
vnManager->audioCharacter->setAudioData(this->talkSound);
vnManager->audioCharacter->loop = true;
vnManager->audioCharacter->play();
}
}
void VisualNovelTextbox::hide() {
if(!this->isVisible()) return;
if(this->talkSound != nullptr) {
auto vnManager = this->getVisualNovelManager();
assertNotNull(vnManager);
assertNotNull(vnManager->audioCharacter);
vnManager->audioCharacter->stop();
}
this->visible = false;
this->removeChild(&this->selfParent);
this->eventHidden.invoke();
}
bool_t VisualNovelTextbox::isVisible() {
return this->visible;
}
VisualNovelManager * VisualNovelTextbox::getVisualNovelManager() {
return this->getScene()->findComponent<VisualNovelManager>();
}
void VisualNovelTextbox::updatePositions() {
UIComponent::updatePositions();
this->lineCurrent = 0;
this->timeCharacter = 0;
this->label.setTransform(
UI_COMPONENT_ALIGN_STRETCH,
UI_COMPONENT_ALIGN_STRETCH,
glm::vec4(
this->border.getBorderSize() + this->labelPadding,
this->border.getBorderSize() + this->labelPadding
),
1.0f
);
this->label.startQuad = 0;
this->label.quadCount = 0;
}
void VisualNovelTextbox::textboxOnSceneUpdate() {
DawnGame *game = this->canvas->getGame();
if(this->hasRevealedAllCurrentCharacters()) {
if(this->hasRevealedAllCharacters()) {
if(game->inputManager.isPressed(INPUT_BIND_ACCEPT)) {
this->hide();
}
} else {
if(game->inputManager.isPressed(INPUT_BIND_ACCEPT)) {
this->lineCurrent += this->getCountOfVisibleLines();
this->label.startQuad = 0;
for(int32_t i = 0; i < this->lineCurrent; i++) {
this->label.startQuad += this->label.measure.getQuadsOnLine(i);
}
this->label.quadCount = 0;
this->timeCharacter = 0.0f;
this->label.setTransform(
UI_COMPONENT_ALIGN_STRETCH,
UI_COMPONENT_ALIGN_STRETCH,
glm::vec4(
glm::vec2(
this->border.getBorderSize().x + this->labelPadding.x,
this->border.getBorderSize().y + this->labelPadding.y -
this->label.measure.getHeightOfLineCount(this->lineCurrent)
),
this->border.getBorderSize() + this->labelPadding
),
5.0f
);
this->eventNewPage.invoke();
}
}
if(this->talkSound != nullptr) {
auto vnManager = this->getVisualNovelManager();
assertNotNull(vnManager);
assertNotNull(vnManager->audioCharacter);
vnManager->audioCharacter->stop();
}
return;
}
auto lastTimeCharacter = mathFloor<int32_t>(this->timeCharacter);
if(game->inputManager.isDown(INPUT_BIND_ACCEPT)) {
this->timeCharacter += game->timeManager.delta * VISUAL_NOVEL_TEXTBOX_SPEED_FASTER;
} else {
this->timeCharacter += game->timeManager.delta * VISUAL_NOVEL_TEXTBOX_SPEED;
}
auto newTimeCharacter = mathFloor<int32_t>(this->timeCharacter);
if(newTimeCharacter == lastTimeCharacter) return;
this->label.quadCount = newTimeCharacter;
this->eventCharacterRevealed.invoke();
}
int32_t VisualNovelTextbox::getCountOfVisibleLines() {
int32_t i = 1;
glm::vec2 innerSize = this->border.getInnerSize() - this->labelPadding;
for(i = this->label.measure.getLineCount(); i > 0; --i) {
if(innerSize.y >= this->label.measure.getHeightOfLineCount(i)) {
return i;
}
}
return this->label.measure.getLineCount();
}
std::vector<struct ShaderPassItem> VisualNovelTextbox::getSelfPassItems(
glm::mat4 projection,
glm::mat4 view,
glm::mat4 transform
) {
return std::vector<struct ShaderPassItem>();
}
void VisualNovelTextbox::setFont(Font *font) {
this->label.setFont(font);
this->label.updateMesh();
}
void VisualNovelTextbox::setText(std::string key, float_t fontSize) {
this->label.setText(key);
this->label.setFontSize(fontSize);
this->label.updateMesh();
}
void VisualNovelTextbox::setCharacter(VisualNovelCharacter *character) {
this->character = character;
this->talkSound = nullptr;
}
void VisualNovelTextbox::setTalkingSound(AudioAsset *asset) {
this->talkSound = asset;
}
void VisualNovelTextbox::setText(std::string key) {
this->label.setText(key);
this->label.updateMesh();
}
void VisualNovelTextbox::setFontSize(float_t fontSize) {
this->label.setFontSize(fontSize);
this->label.updateMesh();
}
float_t VisualNovelTextbox::getFontSize() {
return this->label.getFontSize();
}
void VisualNovelTextbox::setLabelPadding(glm::vec2 padding) {
this->labelPadding = padding;
this->updatePositions();
}
glm::vec2 VisualNovelTextbox::getLabelPadding() {
return this->labelPadding;
}
bool_t VisualNovelTextbox::hasRevealedAllCurrentCharacters() {
int32_t quadsTotal = 0;
for(
int32_t i = this->lineCurrent;
i < mathMin<int32_t>(
this->label.measure.getLineCount(),
this->lineCurrent + this->getCountOfVisibleLines()
);
i++
) {
quadsTotal += this->label.measure.getQuadsOnLine(i);
}
return mathFloor<int32_t>(this->timeCharacter) >= quadsTotal;
}
bool_t VisualNovelTextbox::hasRevealedAllCharacters() {
return (
this->lineCurrent + this->getCountOfVisibleLines() >=
this->label.measure.getLineCount()
);
}
VisualNovelTextbox::~VisualNovelTextbox() {
this->canvas->getScene()->eventSceneUnpausedUpdate.removeListener(
this, &VisualNovelTextbox::textboxOnSceneUpdate
);
}

167
src/dawn/games/visualnovel/ui/VisualNovelTextbox.hpp
View File

@ -1,167 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "ui/UISprite.hpp"
#include "ui/UIBorder.hpp"
#include "ui/UILabel.hpp"
#include "ui/UIEmpty.hpp"
#include "util/mathutils.hpp"
#include "visualnovel/components/VisualNovelCharacter.hpp"
#define VISUAL_NOVEL_TEXTBOX_SPEED 25.0f
#define VISUAL_NOVEL_TEXTBOX_SPEED_FASTER 40.0f
namespace Dawn {
class VisualNovelManager;
class VisualNovelTextbox : public UIComponent {
private:
int32_t lineCurrent = 0;
glm::vec2 labelPadding = glm::vec2(0, 0);
UIEmpty selfParent;
float_t timeCharacter = 0.0f;
bool_t visible = false;
VisualNovelCharacter *character = nullptr;
AudioAsset *talkSound = nullptr;
void updatePositions() override;
std::vector<struct ShaderPassItem> getSelfPassItems(
glm::mat4 projection,
glm::mat4 view,
glm::mat4 transform
) override;
/**
* Listens for scene updates.
*/
void textboxOnSceneUpdate();
/**
* Returns the count of visible lines within the textbox. Mostly used for
* when we need to decide how to wrap.
*
* @return The count of visible lines.
*/
int32_t getCountOfVisibleLines();
public:
UIBorder border;
UILabel label;
Event<> eventCharacterRevealed;
Event<> eventCurrentCharactersRevealed;
Event<> eventNewPage;
Event<> eventAllCharactersRevealed;
Event<> eventHidden;
Event<> eventVisible;
/**
* Constructs a VN Textbox.
*
* @param canvas Canvas that this textbox belongs to.
*/
VisualNovelTextbox(UICanvas *canvas);
void show();
void hide();
bool_t isVisible();
/**
* Returns the visual novel manager (if applicable).
*
* @return Visual Novel Manager instance.
*/
VisualNovelManager * getVisualNovelManager();
/**
* Sets the font for this vn textbox. Passed to the underlying label.
*
* @param font Font to set for this textbox.
*/
void setFont(Font *font);
/**
* Sets the string (label) for this textbox.
*
* @param text Localized string key to set.
* @param fontSize Font size of the string.
*/
void setText(std::string key, float_t fontSize);
/**
* Sets the string (label) for this textbox.
*
* @param text Localized string key to set.
*/
void setText(std::string key);
/**
* Sets the VN Character for this text.
*
* @param character Character to set.
*/
void setCharacter(VisualNovelCharacter *character);
/**
* Set the sound to use whenever the text is scrolling to represent a
* character talking.
*
* @param sound Sound asset to use.
*/
void setTalkingSound(AudioAsset *sound);
/**
* Sets the font size to use.
*
* @param fontSize Font size to use.
*/
void setFontSize(float_t fontSize);
/**
* Returns the current font size.
*
* @return Font size.
*/
float_t getFontSize();
/**
* Sets the padding of the label. This will increase the spacing between
* the text and the border.
*
* @param padding Padding to set.
*/
void setLabelPadding(glm::vec2 padding);
/**
* Returns the current label padding.
*
* @return The current label padding.
*/
glm::vec2 getLabelPadding();
/**
* Returns true if all of the characters that can be made visible for the
* current textbox size have finished revealing, or false if not.
*
* @return True if above statement is met.
*/
bool_t hasRevealedAllCurrentCharacters();
/**
* Returns true only when every character passed previously in setText
* has been revealed by scrolling.
*
* @return True if above statement is true.
*/
bool_t hasRevealedAllCharacters();
/**
* Cleans the VN Textbox.
*/
~VisualNovelTextbox();
};
}

8
src/dawn/games/vn/CMakeLists.txt Normal file
View File

@ -0,0 +1,8 @@
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Subdirs
add_subdirectory(components)
add_subdirectory(events)

4
src/dawn/games/visualnovel/scene/CMakeLists.txt → src/dawn/games/vn/components/CMakeLists.txt
View File

@ -1,4 +1,4 @@
# Copyright (c) 2022 Dominic Masters
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
@ -6,5 +6,5 @@
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
SimpleVNScene.cpp
VNManager.cpp
)

36
src/dawn/games/vn/components/VNManager.cpp Normal file
View File

@ -0,0 +1,36 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNManager.hpp"
#include "games/vn/events/VNEvent.hpp"
using namespace Dawn;
VNManager::VNManager(SceneItem *item) :
SceneItemComponent(item)
{
}
void VNManager::onStart() {
if(this->currentEvent != nullptr) {
this->currentEvent->start(nullptr);
}
}
void VNManager::setEvent(VNEvent *event) {
this->currentEvent = event;
}
void VNManager::nextEvent() {
if(this->currentEvent == nullptr) return;
auto old = this->currentEvent;
old->end();
this->currentEvent = old->getNextEvent();
if(this->currentEvent != nullptr) this->currentEvent->start(old);
}
void VNManager::onDispose() {
}

60
src/dawn/games/vn/components/VNManager.hpp Normal file
View File

@ -0,0 +1,60 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "scene/SceneItemComponent.hpp"
namespace Dawn {
class VNEvent;
class VNManager : public SceneItemComponent {
protected:
std::vector<VNEvent*> events;
VNEvent *currentEvent = nullptr;
public:
/**
* Constructs a visual novel manager, scene item component.
*
* @param item Item that the VN manager belongs to.
*/
VNManager(SceneItem *item);
/**
* Creats an event for you to decide how to queue.
*/
template<class T>
T * createEvent() {
auto event = new T();
event->init(this);
this->events.push_back(event);
return event;
}
/**
* Sets the currently active visual novel event. This is assumed to be
* the only way to handle events (no multiples currently).
*
* @param event Event to set.
*/
void setEvent(VNEvent *event);
void nextEvent();
// template <class T>
// T * setEvent(T *event) {
// auto oldCurrent = this->currentEvent;
// this->currentEvent = event;
// if(this->hasInitialized && event != nullptr) event->start(oldCurrent);
// delete oldCurrent;
// return event;
// }
void onStart() override;
void onDispose() override;
friend class VNEvent;
};
}

4
src/dawn/games/visualnovel/events/animation/CMakeLists.txt → src/dawn/games/vn/events/CMakeLists.txt
View File

@ -1,4 +1,4 @@
# Copyright (c) 2022 Dominic Masters
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
@ -6,5 +6,5 @@
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
VisualNovelAnimationEvent.cpp
VNEvent.cpp
)

17
src/dawn/games/vn/events/VNDummyEvent.hpp Normal file
View File

@ -0,0 +1,17 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "VNEvent.hpp"
namespace Dawn {
class VNDummyEvent : public VNEvent {
protected:
void onStart() override {
std::cout << "Test" << std::endl;
this->next();
}
};
}

38
src/dawn/games/vn/events/VNEvent.cpp Normal file
View File

@ -0,0 +1,38 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNEvent.hpp"
using namespace Dawn;
void VNEvent::init(VNManager *manager) {
this->manager = manager;
}
void VNEvent::start(VNEvent *previous) {
this->onStart();
}
Scene * VNEvent::getScene() {
return this->manager->getScene();
}
VNEvent * VNEvent::getNextEvent() {
return this->doNext;
}
void VNEvent::next() {
assertNotNull(this->manager);
assertTrue(this->manager->currentEvent == this);
this->manager->nextEvent();
}
void VNEvent::end() {
this->unsubscribeAllEvents();
this->onEnd();
}
void VNEvent::onStart() {}
void VNEvent::onEnd() {}

79
src/dawn/games/vn/events/VNEvent.hpp 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
#pragma once
#include "games/vn/components/VNManager.hpp"
namespace Dawn {
class VNEvent : public StateOwner {
protected:
VNManager *manager = nullptr;
VNEvent *doNext = nullptr;
VNEvent *previous = nullptr;
/**
* Initializes the event. This is called by the VNManager, and should not
* be called by anything else.
* @param manager The VNManager that is running this event.
*/
void init(VNManager *manager);
/**
* Invoked by the VNManager, this is the start of the event.
* @param previous The previous event that was running before this one.
*/
void start(VNEvent *previous);
/**
* Invoked by the VNManager, this is the end of the event. Perform the
* necessary cleanup, but remember that events may be re-started again
* later.
*/
void end();
/**
* Overrideable method that is called when the event is started.
*/
virtual void onStart();
/**
* Overrideable method that is called when the event is ended.
*/
virtual void onEnd();
public:
/**
* Returns the scene this event is running in.
* @return Pointer to the scene.
*/
Scene * getScene();
/**
* End this event and move on to the next event.
*/
void next();
/**
* Returns the next event to be executed after this one. Can be overridden
* to return a different event other than the doNext event.
* @return Pointer to the next event.
*/
virtual VNEvent * getNextEvent();
/**
* Chains an event to be executed after this event has finished.
*
* @param next Event to process next.
* @return Whatever you pass in to next.
*/
template<class T>
T * then(T *next) {
this->doNext = next;
return next;
}
friend class VNManager;
};
}

4
src/dawn/prefabs/SimpleSpinningCubePrefab.hpp
View File

@ -6,8 +6,8 @@
#pragma once
#include "prefab/SceneItemPrefab.hpp"
#include "display/mesh/CubeMesh.hpp"
#include "scene/components/display/MeshRenderer.hpp"
#include "scene/components/display/CubeMeshHost.hpp"
#include "scene/components/display/mesh/MeshRenderer.hpp"
#include "scene/components/display/mesh/CubeMeshHost.hpp"
#include "scene/components/display/material/SimpleTexturedMaterial.hpp"
#include "scene/components/example/ExampleSpin.hpp"
#include "scene/components/physics/3d/CubeCollider.hpp"

56
src/dawn/state/State.hpp
View File

@ -44,6 +44,36 @@ namespace Dawn {
private:
std::vector<IStateEvent*> eventsSubscribed;
std::vector<IStateOwnerEventLegacy*> eventLegacyBridge;
protected:
/**
* Removes all currently subscribed effects and events.
*/
void unsubscribeAllEvents() {
auto providers = this->_stateProviderListeners;
auto itProvider = providers.begin();
while(itProvider != providers.end()) {
(*itProvider)();
++itProvider;
}
auto it = this->eventsSubscribed.begin();
while(it != this->eventsSubscribed.end()) {
(*it)->_stateOwnerDestroyed(this);
++it;
}
auto itBridge = this->eventLegacyBridge.begin();
while(itBridge != this->eventLegacyBridge.end()) {
(*itBridge)->removeListener();
delete *itBridge;
++itBridge;
}
this->_stateProviderListeners.clear();
this->eventsSubscribed.clear();
this->eventLegacyBridge.clear();
}
public:
std::vector<std::function<void()>> _stateProviderListeners;
@ -123,7 +153,11 @@ namespace Dawn {
auto itProp = props.begin();
while(itProp != props.end()) {
auto property = *itProp;
if(property->owner == nullptr) { property->owner = this; } else { assertTrue(property->owner == this); }
if(property->owner == nullptr) {
property->owner = this;
} else {
assertTrue(property->owner == this);
}
property->_effectListners.push_back(fn);
++itProp;
}
@ -230,25 +264,7 @@ namespace Dawn {
* useEffects or useEvents.
*/
virtual ~StateOwner() {
auto providers = this->_stateProviderListeners;
auto itProvider = providers.begin();
while(itProvider != providers.end()) {
(*itProvider)();
++itProvider;
}
auto it = this->eventsSubscribed.begin();
while(it != this->eventsSubscribed.end()) {
(*it)->_stateOwnerDestroyed(this);
++it;
}
auto itBridge = this->eventLegacyBridge.begin();
while(itBridge != this->eventLegacyBridge.end()) {
(*itBridge)->removeListener();
delete *itBridge;
++itBridge;
}
this->unsubscribeAllEvents();
}
};
}

17
src/dawnliminal/CMakeLists.txt Normal file
View File

@ -0,0 +1,17 @@
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Build Project
add_executable(${DAWN_TARGET_NAME})
# Includes
target_include_directories(${DAWN_TARGET_NAME}
PUBLIC
${CMAKE_CURRENT_LIST_DIR}
)
# Subdirs
add_subdirectory(game)
add_subdirectory(save)

5
src/dawn/games/visualnovel/ui/CMakeLists.txt → src/dawnliminal/game/CMakeLists.txt
View File

@ -1,4 +1,4 @@
# Copyright (c) 2022 Dominic Masters
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
@ -6,6 +6,5 @@
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
VisualNovelFader.cpp
VisualNovelTextbox.cpp
LiminalGame.cpp
)

13
src/dawnliminal/game/LiminalGame.cpp Normal file
View File

@ -0,0 +1,13 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "game/DawnGame.hpp"
#include "scenes/HelloWorldScene.hpp"
using namespace Dawn;
Scene * Dawn::dawnGameGetInitialScene(DawnGame *game) {
return new HelloWorldScene(game);
}

19
src/dawnliminal/input/InputBinds.hpp Normal file
View File

@ -0,0 +1,19 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "input/InputManager.hpp"
#define INPUT_BIND(n) ((inputbind_t)n)
#define INPUT_BIND_ACCEPT INPUT_BIND(1)
#define INPUT_BIND_NEGATIVE_X INPUT_BIND(2)
#define INPUT_BIND_POSITIVE_X INPUT_BIND(3)
#define INPUT_BIND_NEGATIVE_Y INPUT_BIND(4)
#define INPUT_BIND_POSITIVE_Y INPUT_BIND(5)
#define INPUT_BIND_MOUSE_X INPUT_BIND(6)
#define INPUT_BIND_MOUSE_Y INPUT_BIND(7)
#define INPUT_BIND_MOUSE_CLICK INPUT_BIND(8)
#define INPUT_BIND_CANCEL INPUT_BIND(9)

19
src/dawn/games/visualnovel/components/CMakeLists.txt → src/dawnliminal/save/CMakeLists.txt
View File

@ -1,11 +1,10 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
SimpleVisualNovelBackground.cpp
VisualNovelCharacter.cpp
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
LiminalSave.cpp
)

12
src/dawnliminal/save/LiminalSave.cpp Normal file
View File

@ -0,0 +1,12 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "save/SaveManager.hpp"
using namespace Dawn;
bool_t Dawn::saveValidateFile(struct SaveFile raw) {
return false;
}

48
src/dawnliminal/scenes/HelloWorldScene.hpp Normal file
View File

@ -0,0 +1,48 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "scene/Scene.hpp"
#include "scene/components/display/Camera.hpp"
#include "prefabs/SimpleSpinningCubePrefab.hpp"
#include "games/vn/components/VNManager.hpp"
#include "games/vn/events/VNDummyEvent.hpp"
namespace Dawn {
class HelloWorldScene : public Scene {
protected:
Camera *camera;
UICanvas *canvas;
void stage() override {
canvas = UICanvas::create(this);
camera = Camera::create(this);
camera->fov = 0.436332f;
camera->transform->lookAt(glm::vec3(10, 10, 10), glm::vec3(0, 0, 0));
auto cube = SimpleSpinningCubePrefab::create(this);
auto vnItem = this->createSceneItem();
auto vnManager = vnItem->addComponent<VNManager>();
auto eventTest = vnManager->createEvent<VNDummyEvent>();
eventTest
->then(vnManager->createEvent<VNDummyEvent>())
->then(vnManager->createEvent<VNDummyEvent>())
;
vnManager->setEvent(eventTest);
}
std::vector<Asset*> getRequiredAssets() override {
auto assMan = &this->game->assetManager;
std::vector<Asset*> assets;
return assets;
}
public:
HelloWorldScene(DawnGame *game) : Scene(game) {}
};
}

2
src/dawnrose/scene/components/HurtHazard.cpp
View File

@ -40,8 +40,6 @@ void HurtHazard::onStart() {
otherHealth->damage({
.amount = damage
});
std::cout << "Trigger" << std::endl;
}, this->trigger->eventTriggerEnter);
}, this->trigger)();
}

17
src/dawnrose/scene/components/entity/EntityInteractable.cpp Normal file
View File

@ -0,0 +1,17 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "EntityInteractable.hpp"
using namespace Dawn;
EntityInteractable::EntityInteractable(SceneItem* item) : SceneItemComponent(item) {
}
void EntityInteractable::interact() {
std::cout << "Interact!" << std::endl;
}

20
src/dawnrose/scene/components/entity/EntityInteractable.hpp Normal file
View File

@ -0,0 +1,20 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "scene/SceneItemComponent.hpp"
#include "scene/components/physics/2d/TriggerController2D.hpp"
namespace Dawn {
class EntityInteractable : public SceneItemComponent {
public:
EntityInteractable(SceneItem *item);
/**
* Called when one entity interacts with this entity.
*/
void interact();
};
}

27
src/dawnrose/scene/components/entity/EntityInteractor.cpp Normal file
View File

@ -0,0 +1,27 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "EntityInteractor.hpp"
using namespace Dawn;
EntityInteractor::EntityInteractor(SceneItem* item) :
trigger(nullptr),
SceneItemComponent(item)
{
}
void EntityInteractor::onStart() {
this->evtTriggerEnter = [&]{};
useEffect([&]{
this->evtTriggerEnter();
if(this->trigger == nullptr) return;
this->evtTriggerEnter = useEvent([&](EntityInteractable *interactable) {
interactable->interact();
}, this->trigger->eventTriggerEnter);
}, this->trigger)();
}

21
src/dawnrose/scene/components/entity/EntityInteractor.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 "EntityInteractable.hpp"
namespace Dawn {
class EntityInteractor : public SceneItemComponent {
private:
std::function<void()> evtTriggerEnter;
public:
// @optional
StateProperty<TriggerController2D*> trigger;
EntityInteractor(SceneItem* item);
void onStart() override;
};
}

3
src/dawntools/CMakeLists.txt
View File

@ -20,4 +20,5 @@ include(util/CMakeLists.txt)
# Tools
add_subdirectory(prefabtool)
add_subdirectory(texturetool)
add_subdirectory(texturetool)
# add_subdirectory(vnscenetool)

63
src/dawntools/vnscenetool/CMakeLists.txt Normal file
View File

@ -0,0 +1,63 @@
# 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
VNSceneEventsParser.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 "[\.|\\|\/]" "-" prefab_name ${in})
add_custom_target(prefab_${prefab_name}
COMMAND vnscenetool --input="${DAWN_ASSETS_SOURCE_DIR}/${in}"
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()

42
src/dawntools/vnscenetool/VNSceneEventsParser.cpp Normal file
View File

@ -0,0 +1,42 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "VNSceneEventsParser.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 VNSceneEvent *out,
std::string *error
) {
int32_t ret;
auto itChildren = node->children.begin();
while(itChildren != node->children.end()) {
Xml *child = *itChildren;
// Parse event(s)
if(child->node == "position") {
struct VNPosition position;
ret = (VNPositionParser()).parse(child, &position, error);
if(ret != 0) return ret;
out->position = position;
}
itChildren++;
}
return 0;
}

26
src/dawntools/vnscenetool/VNSceneEventsParser.hpp Normal file
View File

@ -0,0 +1,26 @@
// 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 "events/VNPositionParser.hpp"
namespace Dawn {
struct VNSceneEvent {
int32_t bruh;
};
class VNSceneEventsParser : public XmlParser<struct VNSceneEvent> {
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 VNSceneEvent *out,
std::string *error
) override;
};
}

44
src/dawntools/vnscenetool/VNSceneParser.cpp Normal file
View File

@ -0,0 +1,44 @@
// 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;
auto itChildren = node->children.begin();
while(itChildren != node->children.end()) {
Xml *child = *itChildren;
// Parse event(s)
if(child->node == "events") {
struct VNSceneEvent scene;
ret = (VNSceneEventsParser()).parse(child, &scene, error);
if(ret != 0) return ret;
out->events.push_back(scene);
}
itChildren++;
}
return 0;
}

25
src/dawntools/vnscenetool/VNSceneParser.hpp Normal file
View File

@ -0,0 +1,25 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "VNSceneEventsParser.hpp"
namespace Dawn {
struct VNScene {
std::vector<struct VNSceneEvent> 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;
};
}

43
src/dawntools/vnscenetool/VNSceneTool.cpp Normal file
View File

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

20
src/dawntools/vnscenetool/VNSceneTool.hpp Normal file
View File

@ -0,0 +1,20 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/DawnTool.hpp"
#include "VNSceneParser.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();
};
}

10
src/dawntools/vnscenetool/events/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(vnscenetool
PRIVATE
VNPositionParser.cpp
)

25
src/dawntools/vnscenetool/events/VNPositionParser.cpp Normal file
View File

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

6
src/dawntools/vnscenetool/events/VNPositionParser.hpp Normal file
View File

@ -0,0 +1,6 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once