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

Merge branch 'master' of https://git.wish.moe/YourWishes/Dawn

Browse Source
This commit is contained in:
Dominic Masters
2023-04-25 18:55:00 -07:00
parent 2075985b75 5ce9e1ea5d
commit 37976cfd84
100 changed files with 2026 additions and 1763 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})

27
src/dawn/display/Color.hpp
View File

@ -18,6 +18,33 @@ namespace Dawn {
(float_t)a / 100.0f
};
}
struct Color operator * (const float_t &x) {
return {
(uint8_t)(r * x),
(uint8_t)(g * x),
(uint8_t)(b * x),
(uint8_t)(a * x)
};
}
struct Color operator - (const struct Color &color) {
return {
(uint8_t)(r - color.r),
(uint8_t)(g - color.g),
(uint8_t)(b - color.b),
(uint8_t)(a - color.a)
};
}
struct Color operator + (const struct Color &color) {
return {
(uint8_t)(r + color.r),
(uint8_t)(g + color.g),
(uint8_t)(b + color.b),
(uint8_t)(a + color.a)
};
}
};
#define COLOR_WHITE { 255, 255, 255, 100 }

31
src/dawn/display/animation/SimplerCallbackAnimation.hpp Normal file
View File

@ -0,0 +1,31 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "SimpleAnimation.hpp"
namespace Dawn {
template<typename T>
struct SimplerCallbackAnimation : public SimpleAnimation<T> {
protected:
T value;
void onValueModified() override {
SimpleAnimation<T>::onValueModified();
this->callback(this->value);
}
public:
std::function<void(T)> callback = std::function<void(T)>();
/**
* Construct a new Simple Function Animation object
*/
SimplerCallbackAnimation() :
SimpleAnimation<T>(&value)
{
}
};
}

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
)

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

@ -0,0 +1,37 @@
// 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(this, nullptr);
}
}
void VNManager::setEvent(VNEvent *event) {
this->currentEvent = event;
}
void VNManager::setFlag(std::string key, std::string value) {
this->flags[key] = value;
}
std::string VNManager::getFlag(std::string key) {
if(this->flags.find(key) == this->flags.end()) return "";
return this->flags[key];
}
void VNManager::onDispose() {
}

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

@ -0,0 +1,73 @@
// 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 IVNEventParent {
public:
VNEvent *currentEvent = nullptr;
};
class VNManager :
public SceneItemComponent,
public IVNEventParent
{
protected:
std::vector<VNEvent*> events;
std::map<std::string, std::string> flags;
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);
/**
* Sets a flag for the visual novel.
*
* @param key Key of the flag.
* @param value Value of the flag.
*/
void setFlag(std::string key, std::string value);
/**
* Gets a flag for the visual novel.
*
* @param key Key of the flag.
* @return Value of the flag, or an empty string if it doesn't exist.
*/
std::string getFlag(std::string key);
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
)

49
src/dawn/games/vn/events/VNAnimateEvent.hpp Normal file
View File

@ -0,0 +1,49 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "VNEvent.hpp"
#include "display/animation/SimplerCallbackAnimation.hpp"
namespace Dawn {
template<typename T>
class VNAnimateEvent : public VNEvent {
public:
T from;
T to;
float_t duration;
protected:
SimplerCallbackAnimation<T> animation;
void onStart() override {
if(duration > 0) {
animation.clear();
animation.addKeyframe(0, from);
animation.addKeyframe(duration, to);
animation.callback = [&](T v){
this->setValue(v);
};
// On-end
useEvent([&]() {
this->next();
}, animation.event2AnimationEnd);
useEvent([&](float_t delta) {
animation.tick(delta);
}, getScene()->eventSceneUpdate);
} else {
this->setValue(to);
this->next();
}
}
virtual void setValue(T value) = 0;
};
}

45
src/dawn/games/vn/events/VNChoiceEvent.hpp Normal file
View File

@ -0,0 +1,45 @@
// 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 VNChoiceEvent : public VNEvent {
public:
std::string text;
std::string key;
std::map<std::string, std::string> choices;
int32_t choice = 0;
protected:
void onStart() override {
choice = 0;
std::cout << "CHOICE: " << text << std::endl;
for(auto& choice : choices) {
std::cout << " " << choice.first << ": " << choice.second << std::endl;
}
useEvent([&](float_t delta) {
auto im = &getScene()->game->inputManager;
if(im->isPressed(INPUT_BIND_ACCEPT)) {
auto it = choices.begin();
std::advance(it, choice);
std::string choiceMade = it->first;
std::cout << "Choice made " << choiceMade << std::endl;
this->manager->setFlag(this->key, choiceMade);
this->next();
} else if(im->isPressed(INPUT_BIND_NEGATIVE_Y)) {
choice = mathClamp<int32_t>((choice - 1), 0, choices.size() - 1);
std::cout << "Current choice: state" << choice << std::endl;
} else if(im->isPressed(INPUT_BIND_POSITIVE_Y)) {
choice = mathClamp<int32_t>((choice + 1), 0, choices.size() - 1);
std::cout << "Current choice: state" << choice << std::endl;
}
}, getScene()->eventSceneUpdate);
}
};
}

21
src/dawn/games/vn/events/VNChoiceSetEvent.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 "VNEvent.hpp"
namespace Dawn {
class VNChoiceSetEvent : public VNEvent {
public:
std::string key;
std::string value;
protected:
void onStart() override {
this->manager->setFlag(this->key, this->value);
this->next();
}
};
}

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 << "Dummy VN Event" << std::endl;
this->next();
}
};
}

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

@ -0,0 +1,50 @@
// 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(
IVNEventParent *parent,
VNEvent *previous
) {
this->parent = parent;
finished = false;
this->onStart();
}
Scene * VNEvent::getScene() {
return this->manager->getScene();
}
VNEvent * VNEvent::getNextEvent() {
return this->doNext;
}
void VNEvent::next() {
assertNotNull(this->manager);
assertNotNull(this->parent);
this->end();
auto next = this->getNextEvent();
this->manager->currentEvent = next;
if(next != nullptr) next->start(this->parent, this);
}
void VNEvent::end() {
this->finished = true;
this->unsubscribeAllEvents();
this->onEnd();
this->eventFinished.invoke();
}
void VNEvent::onStart() {}
void VNEvent::onEnd() {}

91
src/dawn/games/vn/events/VNEvent.hpp Normal file
View File

@ -0,0 +1,91 @@
// 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"
#include "scene/SceneItem.hpp"
namespace Dawn {
class VNEvent : public StateOwner {
public:
StateEvent<> eventFinished;
/**
* Invoked by a parent VN Manager. This is the start of the event.
*
* @param parent The VN Event Parent. Usually the manager but not always.
* @param previous The previous event that was running before this one.
*/
void start(
IVNEventParent *parent,
VNEvent *previous
);
protected:
VNManager *manager = nullptr;
IVNEventParent *parent = nullptr;
VNEvent *doNext = nullptr;
VNEvent *previous = nullptr;
bool_t finished = false;
/**
* 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 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;
};
}

28
src/dawn/games/vn/events/VNIfEvent.hpp Normal file
View File

@ -0,0 +1,28 @@
// 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 VNIfEvent : public VNEvent {
public:
std::string key;
std::string value;
VNEvent *ifTrue = nullptr;
VNEvent * getNextEvent() override {
if(this->manager.getFlag(key) == value) {
return ifTrue;
}
return VNEvent::getNextEvent();
}
protected:
void onStart() override {
this->next();
}
}
}

40
src/dawn/games/vn/events/VNParallelEvent.hpp Normal file
View File

@ -0,0 +1,40 @@
// 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 VNParallelEvent :
public VNEvent,
public IVNEventParent
{
public:
std::vector<VNEvent*> events;
protected:
int32_t eventCount;
int32_t eventCompleteCount;
void onStart() override {
eventCount = 0;
eventCompleteCount = 0;
auto itEvents = this->events.begin();
while(itEvents != this->events.end()) {
auto event = *itEvents;
eventCount++;
useEvent([&]{
eventCompleteCount++;
if(eventCompleteCount >= eventCount) this->next();
}, event->eventFinished);
event->start(this, this);
itEvents++;
}
}
};
}

51
src/dawn/games/vn/events/VNPositionEvent.hpp Normal file
View File

@ -0,0 +1,51 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "VNAnimateEvent.hpp"
#define VN_POSITION_EVENT_VALUE_UNCHANGED std::numeric_limits<float>::min()
namespace Dawn {
class VNPositionEvent : public VNAnimateEvent<glm::vec3> {
public:
SceneItem *item = nullptr;
VNPositionEvent() {
from = glm::vec3(
VN_POSITION_EVENT_VALUE_UNCHANGED,
VN_POSITION_EVENT_VALUE_UNCHANGED,
VN_POSITION_EVENT_VALUE_UNCHANGED
);
to = glm::vec3(
VN_POSITION_EVENT_VALUE_UNCHANGED,
VN_POSITION_EVENT_VALUE_UNCHANGED,
VN_POSITION_EVENT_VALUE_UNCHANGED
);
}
protected:
SimplerCallbackAnimation<glm::vec3> animation;
void onStart() override {
assertNotNull(item);
auto start = item->transform.getLocalPosition();
if(from.x == VN_POSITION_EVENT_VALUE_UNCHANGED) start.x = from.x;
if(from.y == VN_POSITION_EVENT_VALUE_UNCHANGED) start.y = from.y;
if(from.z == VN_POSITION_EVENT_VALUE_UNCHANGED) start.z = from.z;
if(to.x == VN_POSITION_EVENT_VALUE_UNCHANGED) to.x = start.x;
if(to.y == VN_POSITION_EVENT_VALUE_UNCHANGED) to.y = start.y;
if(to.z == VN_POSITION_EVENT_VALUE_UNCHANGED) to.z = start.z;
VNAnimateEvent::onStart();
}
void setValue(glm::vec3 value) override {
this->item->transform.setLocalPosition(value);
}
};
}

27
src/dawn/games/vn/events/VNSetEvent.hpp 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
#pragma once
#include "VNAnimateEvent.hpp"
namespace Dawn {
template<typename T>
class VNSetEvent : public VNAnimateEvent<T> {
public:
T *modifies = nullptr;
protected:
void onStart() override {
assertNotNull(this->modifies);
this->from = *modifies;
VNAnimateEvent<T>::onStart();
}
void setValue(T value) override {
*modifies = value;
}
};
}

26
src/dawn/games/vn/events/VNTextEvent.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 "VNEvent.hpp"
namespace Dawn {
class VNTextEvent : public VNEvent {
public:
std::string text;
protected:
void onStart() override {
std::cout << "TEXT: " << text << std::endl;
useEvent([&](float_t delta) {
if(getScene()->game->inputManager.isPressed(INPUT_BIND_ACCEPT)) {
std::cout << "Text Advance" << std::endl;
this->next();
}
}, getScene()->eventSceneUpdate);
}
};
}

16
src/dawn/games/vn/events/VNWaitEvent.hpp Normal file
View File

@ -0,0 +1,16 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "VNAnimateEvent.hpp"
namespace Dawn {
class VNWaitEvent : public VNAnimateEvent<float_t> {
protected:
void setValue(float_t value) override {
// Do nothing
}
};
}

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();
}
};
}

5
src/dawn/state/StateEvent.hpp
View File

@ -39,8 +39,9 @@ namespace Dawn {
* @param args Arguments for this event to pass to the listeners.
*/
void invoke(A... args) {
auto it = this->_eventListeners.begin();
while(it != this->_eventListeners.end()) {
auto copy = this->_eventListeners;
auto it = copy.begin();
while(it != copy.end()) {
it->listener(args...);
++it;
}

21
src/dawnliminal/CMakeLists.txt 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
# 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)
# Assets
set(LIMINAL_ASSETS_DIR ${DAWN_ASSETS_DIR}/games/liminal)
tool_vnscene(${LIMINAL_ASSETS_DIR}/test.xml)

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
)

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

@ -0,0 +1,15 @@
// 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"
#include "vnscenes/TestScene.hpp"
using namespace Dawn;
Scene * Dawn::dawnGameGetInitialScene(DawnGame *game) {
// return new HelloWorldScene(game);
return new TestScene(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;
}

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

@ -0,0 +1,88 @@
// 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"
#include "games/vn/events/VNTextEvent.hpp"
#include "games/vn/events/VNPositionEvent.hpp"
#include "games/vn/events/VNSetEvent.hpp"
#include "games/vn/events/VNChoiceEvent.hpp"
#include "games/vn/events/VNParallelEvent.hpp"
#include "games/vn/events/VNWaitEvent.hpp"
namespace Dawn {
class HelloWorldScene : public Scene {
protected:
Camera *camera;
UICanvas *canvas;
int32_t test = 0;
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>();
auto positionEvent = vnManager->createEvent<VNPositionEvent>();
positionEvent->to.x = 2.0f;
positionEvent->item = cube;
positionEvent->duration = 3.0f;
auto vnTextEvent = vnManager->createEvent<VNTextEvent>();
vnTextEvent->text = "Hello World!";
auto setPropertyEvent = vnManager->createEvent<VNSetEvent<int32_t>>();
setPropertyEvent->modifies = &test;
setPropertyEvent->to = 10;
auto choiceEvent = vnManager->createEvent<VNChoiceEvent>();
choiceEvent->text = "Choice?";
choiceEvent->choices["state0"] = "State 0";
choiceEvent->choices["state1"] = "State 1";
choiceEvent->choices["state2"] = "State 2";
choiceEvent->choices["state3"] = "State 3";
auto parallelEvent = vnManager->createEvent<VNParallelEvent>();
auto wait0 = vnManager->createEvent<VNWaitEvent>();
wait0->duration = 1.0f;
parallelEvent->events.push_back(wait0);
auto wait1 = vnManager->createEvent<VNWaitEvent>();
wait1->duration = 3.0f;
parallelEvent->events.push_back(wait1);
eventTest
->then(parallelEvent)
->then(positionEvent)
// ->then(vnTextEvent)
// ->then(setPropertyEvent)
// ->then(choiceEvent)
;
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)

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

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

176
src/dawntools/vnscenetool/VNSceneGen.cpp Normal file
View File

@ -0,0 +1,176 @@
// 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> *body,
std::vector<std::string> *includes
) {
std::string initType = "";
std::string toInclude = "";
std::string initArgs = "";
std::vector<std::string> afterLines;
switch(event->type) {
case VN_SCENE_EVENT_TYPE_TEXT:
initType = "VNTextEvent";
toInclude = "games/vn/events/VNTextEvent.hpp";
line(&afterLines, eventName + "->" + "text = \"" + event->text.texts.begin()->text + "\";", "");
break;
case VN_SCENE_EVENT_TYPE_POSITION:
initType = "VNPositionEvent";
toInclude = "games/vn/events/VNPositionEvent.hpp";
line(&afterLines, eventName + "->item = " + event->position.item + ";", "");
if(event->position.x != "") line(&afterLines, eventName + "->" + "to.x = " + event->position.x + ";", "");
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_SET:
initType = "VNSetEvent<" + event->set.type + ">";
toInclude = "games/vn/events/VNSetEvent.hpp";
line(&afterLines, eventName + "->modifies = &" + event->set.property + ";", "");
line(&afterLines, eventName + "->to = " + event->set.to + ";", "");
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:
initType = "VNWaitEvent";
toInclude = "games/vn/events/VNWaitEvent.hpp";
line(&afterLines, 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,
&afterLines,
includes
);
line(&afterLines, eventName + "->events.push_back(" + pEventName + ");", "");
line(&afterLines, "", "");
++itParallel;
}
break;
}
case VN_SCENE_EVENT_TYPE_MARKER:
initType = "VNDummyEvent";
toInclude = "games/vn/events/VNDummyEvent.hpp";
line(&afterLines, "auto marker_" + event->marker.name + " = " + eventName + ";", "");
break;
default:
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, "");
}
void VNSceneGen::generate(
std::vector<std::string> *out,
struct VNScene *scene,
std::string tabs
) {
struct ClassGenInfo classInfo;
classInfo.clazz = "TestScene";
classInfo.extend = "Scene";
classInfo.constructorArgs = "DawnGame *game";
classInfo.extendArgs = "game";
classInfo.includes.push_back("scene/Scene.hpp");
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;
methodStage.name = "stage";
methodStage.isOverride = "true";
line(&methodStage.body, "// test", "");
// TEST
line(&methodStage.body, "auto canvas = UICanvas::create(this);", "");
line(&methodStage.body, "", "");
classInfo.includes.push_back("scene/components/display/Camera.hpp");
line(&methodStage.body, "auto camera = Camera::create(this);", "");
line(&methodStage.body, "camera->fov = 0.436332f;", "");
line(&methodStage.body, "camera->transform->lookAt(glm::vec3(10, 10, 10), glm::vec3(0, 0, 0));", "");
// Items
int32_t itemRefIndex = 0;
auto itItems = scene->items.begin();
while(itItems != scene->items.end()) {
struct VNSceneItem item = *itItems;
if(item.ref.empty()) item.ref = "item" + std::to_string(itemRefIndex++);
classInfo.includes.push_back(item.prefab + ".hpp");
line(&methodStage.body, "", "");
line(&methodStage.body, "auto " + item.ref + " = " + item.className + "::create(this);", "");
++itItems;
}
line(&methodStage.body, "", "");
// Events
classInfo.includes.push_back("games/vn/components/VNManager.hpp");
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);
}

27
src/dawntools/vnscenetool/VNSceneGen.hpp 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
#pragma once
#include "VNSceneParser.hpp"
#include "util/CodeGen.hpp"
namespace Dawn {
class VNSceneGen : public CodeGen {
public:
static void test(
std::string eventName,
struct VNSceneEvent *event,
int32_t *eventIndex,
std::vector<std::string> *body,
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 Normal file
View File

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

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

@ -0,0 +1,51 @@
// 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 == "item") {
struct VNSceneItem item;
ret = (VNSceneItemParser()).parse(child, &item, error);
if(ret != 0) return ret;
out->items.push_back(item);
} else if(child->node == "events") {
ret = (VNSceneEventsParser()).parse(child, &out->events, error);
if(ret != 0) return ret;
} else {
// Unknown node
*error = "Unknown node '" + child->node + "' in <vnscene>";
return -1;
}
itChildren++;
}
return 0;
}

27
src/dawntools/vnscenetool/VNSceneParser.hpp 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
#pragma once
#include "VNSceneItemParser.hpp"
#include "events/VNSceneEventsParser.hpp"
namespace Dawn {
struct VNScene {
std::vector<struct VNSceneItem> items;
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 Normal file
View File

@ -0,0 +1,65 @@
// 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 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/TestScene.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 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/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();
};
}

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

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

26
src/dawntools/vnscenetool/events/VNGoToMarkerEventParser.cpp 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
#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 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 "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;
};
}

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

@ -0,0 +1,32 @@
// 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 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 <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 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 "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 Normal file
View File

@ -0,0 +1,23 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/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 Normal file
View File

@ -0,0 +1,33 @@
// 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 Normal file
View File

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

74
src/dawntools/vnscenetool/events/VNSceneEventsParser.cpp Normal file
View File

@ -0,0 +1,74 @@
// 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->children.begin();
while(itChildren != node->children.end()) {
Xml *child = *itChildren;
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 {
*error = "Unknown child node '" + child->node + "'";
return -1;
}
if(ret != 0) return ret;
out->events.push_back(event);
itChildren++;
}
return 0;
}

56
src/dawntools/vnscenetool/events/VNSceneEventsParser.hpp Normal file
View File

@ -0,0 +1,56 @@
// 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"
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
};
struct VNParallelEvent {
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;
};
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;
};
}

45
src/dawntools/vnscenetool/events/VNSetEventParser.cpp Normal file
View File

@ -0,0 +1,45 @@
// 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", "" },
{ "from", "" },
{ "duration", "" },
{ "curve", "" }
};
}
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"];
out->from = values["from"];
out->duration = values["duration"];
out->curve = values["curve"];
return 0;
}

30
src/dawntools/vnscenetool/events/VNSetEventParser.hpp Normal file
View File

@ -0,0 +1,30 @@
// 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 from = "";
std::string duration = "";
std::string curve = "";
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;
};
}

43
src/dawntools/vnscenetool/events/VNTextEventParser.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 "VNTextEventParser.hpp"
using namespace Dawn;
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
) {
auto itChildren = node->children.begin();
while(itChildren != node->children.end()) {
Xml *child = *itChildren;
// Parse strings
if(child->node == "string") {
VNText text;
text.language = child->attributes["lang"];
text.text = child->value;
out->texts.push_back(text);
} else {
*error = "Unknown child node '" + child->node + "'";
return -1;
}
itChildren++;
}
return 0;
}

30
src/dawntools/vnscenetool/events/VNTextEventParser.hpp Normal file
View File

@ -0,0 +1,30 @@
// 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 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 Normal file
View File

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