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

Simplified DawnGAme a lot

Browse Source
This commit is contained in:
Dominic Masters
2023-03-15 15:50:29 -07:00
parent cc7091717c
commit 646f8b057a
31 changed files with 564 additions and 714 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cmake/targets/CMakeLists.txt
View File

@ -6,14 +6,12 @@
# Check for build target, or default. This is pretty much not guaranteed. # Check for build target, or default. This is pretty much not guaranteed.
if(NOT DEFINED DAWN_BUILD_TARGET) if(NOT DEFINED DAWN_BUILD_TARGET)
if(WIN32) if(WIN32)
set(DAWN_BUILD_TARGET "target-helloworld-win32-glfw") set(DAWN_BUILD_TARGET "target-rose-win32-glfw")
elseif(UNIX AND NOT APPLE) elseif(UNIX AND NOT APPLE)
set(DAWN_BUILD_TARGET "target-helloworld-linux64-glfw") set(DAWN_BUILD_TARGET "target-rose-linux64-glfw")
endif() endif()
endif() endif()
# set(DAWN_BUILD_TARGET "target-helloworld-vita")
# Now validate we have a build target for real # Now validate we have a build target for real
if(NOT DEFINED DAWN_BUILD_TARGET) if(NOT DEFINED DAWN_BUILD_TARGET)
message(FATAL_ERROR "You need to define a DAWN_BUILD_TARGET") message(FATAL_ERROR "You need to define a DAWN_BUILD_TARGET")

9
cmake/targets/target-rose-linux64-glfw/CMakeLists.txt Normal file
View File

@ -0,0 +1,9 @@
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
set(DAWN_BUILDING dawnrose 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 "Rose" CACHE INTERNAL ${DAWN_CACHE_TARGET})

1
src/dawn/CMakeLists.txt
View File

@ -26,6 +26,7 @@ target_sources(${DAWN_TARGET_NAME}
# Subdirs # Subdirs
add_subdirectory(asset) add_subdirectory(asset)
add_subdirectory(display) add_subdirectory(display)
add_subdirectory(game)
add_subdirectory(games) add_subdirectory(games)
add_subdirectory(input) add_subdirectory(input)
add_subdirectory(locale) add_subdirectory(locale)

18
src/dawnosui/game/CMakeLists.txt → src/dawn/game/CMakeLists.txt
View File

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

83
src/dawnhelloworld/game/DawnGame.cpp → src/dawn/game/DawnGame.cpp
View File

@ -1,43 +1,42 @@
// Copyright (c) 2023 Dominic Masters // Copyright (c) 2023 Dominic Masters
// //
// This software is released under the MIT License. // This software is released under the MIT License.
// https://opensource.org/licenses/MIT // https://opensource.org/licenses/MIT
#include "DawnGame.hpp" #include "DawnGame.hpp"
#include "scenes/HelloWorldScene.hpp"
using namespace Dawn;
using namespace Dawn;
DawnGame::DawnGame(DawnHost *host) :
DawnGame::DawnGame(DawnHost *host) : host(host),
host(host), renderManager(this),
renderManager(this), inputManager(this),
inputManager(this), saveManager(this)
saveManager(this) {
{ }
}
int32_t DawnGame::init() {
int32_t DawnGame::init() { this->assetManager.init();
this->assetManager.init(); this->renderManager.init();
this->renderManager.init();
this->scene = dawnGameGetInitialScene(this);
this->scene = new HelloWorldScene(this);
return DAWN_GAME_INIT_RESULT_SUCCESS;
return DAWN_GAME_INIT_RESULT_SUCCESS; }
}
int32_t DawnGame::update(float_t delta) {
int32_t DawnGame::update(float_t delta) { this->assetManager.update();
this->assetManager.update(); this->inputManager.update();
this->inputManager.update(); this->timeManager.update(delta);
this->timeManager.update(delta);
if(this->scene != nullptr) this->scene->update();
if(this->scene != nullptr) this->scene->update();
this->renderManager.update();
this->renderManager.update();
return DAWN_GAME_UPDATE_RESULT_SUCCESS;
return DAWN_GAME_UPDATE_RESULT_SUCCESS; }
}
void DawnGame::sceneCutover(Scene *scene) {
void DawnGame::sceneCutover(Scene *scene) { if(scene == nullptr) scene = this->scene;
if(scene == nullptr) scene = this->scene; this->sceneToCutTo = scene;
this->sceneToCutTo = scene;
} }

41
src/dawn/game/_DawnGame.hpp → src/dawn/game/DawnGame.hpp
View File

@ -22,12 +22,25 @@
namespace Dawn { namespace Dawn {
class DawnHost; class DawnHost;
class IDawnGame { class DawnGame {
protected: private:
// SceneItemComponentList componentList; Scene *sceneToCutTo = nullptr;
public: public:
DawnHost *host;
Scene *scene = nullptr; Scene *scene = nullptr;
AssetManager assetManager;
TimeManager timeManager;
RenderManager renderManager;
InputManager inputManager;
SaveManager saveManager;
/**
* Construct a new game instance.
*
* @param host Host that executed this game instantiation.
*/
DawnGame(DawnHost *host);
/** /**
* Initialize the game. This is performed by the host at a time that is * Initialize the game. This is performed by the host at a time that is
@ -38,7 +51,7 @@ namespace Dawn {
* @param host Pointer to the host that is running this game. * @param host Pointer to the host that is running this game.
* @return The game initialize result. * @return The game initialize result.
*/ */
virtual int32_t init() = 0; int32_t init();
/** /**
* Performs a game update operation. This operation should occur exactly * Performs a game update operation. This operation should occur exactly
@ -52,7 +65,7 @@ namespace Dawn {
* @param delta Time delta to tick the game by. * @param delta Time delta to tick the game by.
* @return The game update result. * @return The game update result.
*/ */
virtual int32_t update(float_t delta) = 0; int32_t update(float_t delta);
/** /**
* Changes to a new scene, will dispose the currently active scene as part * Changes to a new scene, will dispose the currently active scene as part
@ -61,13 +74,15 @@ namespace Dawn {
* *
* @param scene Scene to cut over to. * @param scene Scene to cut over to.
*/ */
virtual void sceneCutover(Scene *scene) = 0; void sceneCutover(Scene *scene);
/**
* Cleanup the memory of the DawnGame instance.
*/
virtual ~IDawnGame() {
}
}; };
/**
* Unimplemented by default, required by the game as the basic entry point
* for which scene should be used by default.
*
* @param game Game that is requesting this scene.
* @return Pointer to a scene that you wish to have as the default scene.
*/
Scene * dawnGameGetInitialScene(DawnGame *game);
} }

432
src/dawn/save/SaveManager.cpp
View File

@ -1,217 +1,217 @@
// Copyright (c) 2022 Dominic Masters // Copyright (c) 2022 Dominic Masters
// //
// This software is released under the MIT License. // This software is released under the MIT License.
// https://opensource.org/licenses/MIT // https://opensource.org/licenses/MIT
#include "SaveManager.hpp" #include "SaveManager.hpp"
#include "game/DawnGame.hpp" #include "game/DawnGame.hpp"
using namespace Dawn; using namespace Dawn;
SaveManager::SaveManager(DawnGame *game) { SaveManager::SaveManager(DawnGame *game) {
this->game = game; this->game = game;
} }
void SaveManager::saveFile() { void SaveManager::saveFile() {
savedata_t value; savedata_t value;
assertTrue(this->currentSaveSlot >= 0); assertTrue(this->currentSaveSlot >= 0);
// Update metadata // Update metadata
auto timestamp = this->game->timeManager.getTimestamp(); auto timestamp = this->game->timeManager.getTimestamp();
value.i64 = timestamp; value.i64 = timestamp;
this->currentSave.set(SAVE_KEY_TIMESTAMP, value); this->currentSave.set(SAVE_KEY_TIMESTAMP, value);
value.i16 = this->currentSaveSlot; value.i16 = this->currentSaveSlot;
this->currentSave.set(SAVE_KEY_SLOT, value); this->currentSave.set(SAVE_KEY_SLOT, value);
// Now open output buffer. // Now open output buffer.
char filename[SAVE_MANAGER_FILENAME_LENGTH]; char filename[SAVE_MANAGER_FILENAME_LENGTH];
sprintf(filename, "savefile_%u.save", this->currentSaveSlot); sprintf(filename, "savefile_%u.save", this->currentSaveSlot);
FILE *fptr = fopen(filename, "wb"); FILE *fptr = fopen(filename, "wb");
if(fptr == NULL) { if(fptr == NULL) {
printf("Error opening %s\n", filename); printf("Error opening %s\n", filename);
assertUnreachable(); assertUnreachable();
return; return;
} }
// Now begin buffering data. First we start with the common phrase, the engine // Now begin buffering data. First we start with the common phrase, the engine
// version, the timestamp. In future we will store the MD5 here too. // version, the timestamp. In future we will store the MD5 here too.
char buffer[SAVE_MANAGER_BUFFER_LENGTH]; char buffer[SAVE_MANAGER_BUFFER_LENGTH];
auto len = sprintf(buffer, "DE_SAVE|%s|%lld|", "1.00", timestamp); auto len = sprintf(buffer, "DE_SAVE|%s|%lld|", "1.00", timestamp);
fwrite(buffer, sizeof(char), len, fptr); fwrite(buffer, sizeof(char), len, fptr);
// Now buffer out the data, this is almost certain to change over time. // Now buffer out the data, this is almost certain to change over time.
auto it = this->currentSave.values.begin(); auto it = this->currentSave.values.begin();
while(it != this->currentSave.values.end()) { while(it != this->currentSave.values.end()) {
uint8_t *buffer = (uint8_t *)&it->second; uint8_t *buffer = (uint8_t *)&it->second;
char delim = '|'; char delim = '|';
fwrite(it->first.c_str(), sizeof(char), strlen(it->first.c_str()), fptr); fwrite(it->first.c_str(), sizeof(char), strlen(it->first.c_str()), fptr);
fwrite(&delim, sizeof(char), 1, fptr); fwrite(&delim, sizeof(char), 1, fptr);
fwrite(buffer, sizeof(uint8_t), sizeof(savedata_t) / sizeof(uint8_t), fptr); fwrite(buffer, sizeof(uint8_t), sizeof(savedata_t) / sizeof(uint8_t), fptr);
fwrite(&delim, sizeof(char), 1, fptr); fwrite(&delim, sizeof(char), 1, fptr);
++it; ++it;
} }
// Buffering done, close the file buffer. // Buffering done, close the file buffer.
fclose(fptr); fclose(fptr);
this->currentSave.hasChanges = false; this->currentSave.hasChanges = false;
} }
enum SaveLoadResult SaveManager::loadFile() { enum SaveLoadResult SaveManager::loadFile() {
this->currentSave.reset(); this->currentSave.reset();
assertTrue(this->currentSaveSlot >= 0); assertTrue(this->currentSaveSlot >= 0);
// Load file // Load file
struct SaveFile temporaryFile; struct SaveFile temporaryFile;
char filename[SAVE_MANAGER_FILENAME_LENGTH]; char filename[SAVE_MANAGER_FILENAME_LENGTH];
sprintf(filename, "savefile_%u.save", this->currentSaveSlot); sprintf(filename, "savefile_%u.save", this->currentSaveSlot);
FILE *fptr = fopen(filename, "rb"); FILE *fptr = fopen(filename, "rb");
if(fptr == NULL) { if(fptr == NULL) {
return SAVE_LOAD_RESULT_FILE_NOT_PRESENT; return SAVE_LOAD_RESULT_FILE_NOT_PRESENT;
} }
// Let's read how long the file is first. // Let's read how long the file is first.
fseek(fptr, 0, SEEK_END); fseek(fptr, 0, SEEK_END);
auto len = ftell(fptr); auto len = ftell(fptr);
// Now let's just ensure the file isn't too small, this starts by us making // Now let's just ensure the file isn't too small, this starts by us making
// sure we have at least "DE_SAVE|%s|%lld|", the string is unknown length, // sure we have at least "DE_SAVE|%s|%lld|", the string is unknown length,
// but we can be 100% sure of the rest of the file size. So we take // but we can be 100% sure of the rest of the file size. So we take
// 7+1+1+1+19+1=30 // 7+1+1+1+19+1=30
if(len < 30) { if(len < 30) {
fclose(fptr); fclose(fptr);
return SAVE_LOAD_RESULT_TOO_SMALL; return SAVE_LOAD_RESULT_TOO_SMALL;
} }
// Rewind. // Rewind.
fseek(fptr, 0, SEEK_SET); fseek(fptr, 0, SEEK_SET);
// Ok let's buffer the first 8 characters to validate "DE_SAVE|" // Ok let's buffer the first 8 characters to validate "DE_SAVE|"
char buffer[SAVE_MANAGER_BUFFER_LENGTH]; char buffer[SAVE_MANAGER_BUFFER_LENGTH];
auto read = fread(buffer, sizeof(char), SAVE_MANAGER_BUFFER_LENGTH, fptr); auto read = fread(buffer, sizeof(char), SAVE_MANAGER_BUFFER_LENGTH, fptr);
if( if(
read < 8 || read < 8 ||
buffer[0] != 'D' || buffer[0] != 'D' ||
buffer[1] != 'E' || buffer[1] != 'E' ||
buffer[2] != '_' || buffer[2] != '_' ||
buffer[3] != 'S' || buffer[3] != 'S' ||
buffer[4] != 'A' || buffer[4] != 'A' ||
buffer[5] != 'V' || buffer[5] != 'V' ||
buffer[6] != 'E' || buffer[6] != 'E' ||
buffer[7] != '|' buffer[7] != '|'
) { ) {
fclose(fptr); fclose(fptr);
return SAVE_LOAD_RESULT_CORRUPTED_DE_SAVE; return SAVE_LOAD_RESULT_CORRUPTED_DE_SAVE;
} }
// Now read ahead to the next vertical bar, that will give us the engine // Now read ahead to the next vertical bar, that will give us the engine
// version // version
char *bufferCurrent = buffer + 8; char *bufferCurrent = buffer + 8;
char *p = stringFindNext(bufferCurrent, '|', 10); char *p = stringFindNext(bufferCurrent, '|', 10);
if(p == NULL) { if(p == NULL) {
fclose(fptr); fclose(fptr);
return SAVE_LOAD_RESULT_CORRUPTED_VERSION; return SAVE_LOAD_RESULT_CORRUPTED_VERSION;
} }
*p = '\0'; *p = '\0';
char *version = bufferCurrent; char *version = bufferCurrent;
bufferCurrent = p + 1; bufferCurrent = p + 1;
// Now read the timestamp string. // Now read the timestamp string.
p = stringFindNext(bufferCurrent, '|', 64); p = stringFindNext(bufferCurrent, '|', 64);
if(p == NULL) { if(p == NULL) {
fclose(fptr); fclose(fptr);
return SAVE_LOAD_RESULT_CORRUPTED_TIMESTAMP; return SAVE_LOAD_RESULT_CORRUPTED_TIMESTAMP;
} }
*p = '\0'; *p = '\0';
char *strTimestamp = bufferCurrent; char *strTimestamp = bufferCurrent;
// Parse timestamp // Parse timestamp
int64_t timestamp = strtoll(strTimestamp, NULL, 10); int64_t timestamp = strtoll(strTimestamp, NULL, 10);
if(timestamp == 0) { if(timestamp == 0) {
fclose(fptr); fclose(fptr);
return SAVE_LOAD_RESULT_CORRUPTED_TIMESTAMP; return SAVE_LOAD_RESULT_CORRUPTED_TIMESTAMP;
} }
// Now begin parsing the data in the save file. We start here, at the end of // Now begin parsing the data in the save file. We start here, at the end of
// the previous string, so it will INCLUDE "|" at the first char. // the previous string, so it will INCLUDE "|" at the first char.
read = p - buffer; read = p - buffer;
while(read < (len-1)) { while(read < (len-1)) {
// Rewind and then buffer the next set of bytes // Rewind and then buffer the next set of bytes
fseek(fptr, (long)read, SEEK_SET); fseek(fptr, (long)read, SEEK_SET);
if(fread(buffer, sizeof(char), SAVE_MANAGER_BUFFER_LENGTH, fptr) <= 1) { if(fread(buffer, sizeof(char), SAVE_MANAGER_BUFFER_LENGTH, fptr) <= 1) {
break; break;
} }
// Because we finish the last string INCLUDING "|", then we skip it here. // Because we finish the last string INCLUDING "|", then we skip it here.
bufferCurrent = buffer + 1; bufferCurrent = buffer + 1;
// Now, read the key // Now, read the key
p = stringFindNext(bufferCurrent, '|', SAVE_MANAGER_BUFFER_LENGTH); p = stringFindNext(bufferCurrent, '|', SAVE_MANAGER_BUFFER_LENGTH);
if(p == NULL) { if(p == NULL) {
fclose(fptr); fclose(fptr);
return SAVE_LOAD_RESULT_CORRUPTED_DATA_KEY; return SAVE_LOAD_RESULT_CORRUPTED_DATA_KEY;
} }
*p = '\0'; *p = '\0';
char *key = bufferCurrent; char *key = bufferCurrent;
// Validate the string lengths // Validate the string lengths
if(strlen(key) <= 0) { if(strlen(key) <= 0) {
fclose(fptr); fclose(fptr);
return SAVE_LOAD_RESULT_CORRUPTED_DATA_KEY; return SAVE_LOAD_RESULT_CORRUPTED_DATA_KEY;
} }
// Now read the value // Now read the value
bufferCurrent = p + 1; bufferCurrent = p + 1;
savedata_t destination; savedata_t destination;
uint8_t *ptrValue = (uint8_t*)bufferCurrent; uint8_t *ptrValue = (uint8_t*)bufferCurrent;
memoryCopy(ptrValue, &destination, sizeof(savedata_t)); memoryCopy(ptrValue, &destination, sizeof(savedata_t));
// Now advance the pointer... // Now advance the pointer...
p = bufferCurrent + sizeof(savedata_t); p = bufferCurrent + sizeof(savedata_t);
if(*p != '|') { if(*p != '|') {
fclose(fptr); fclose(fptr);
return SAVE_LOAD_RESULT_CORRUPTED_DATA_VALUE; return SAVE_LOAD_RESULT_CORRUPTED_DATA_VALUE;
} }
// Set the value. // Set the value.
temporaryFile.set(std::string(key), destination); temporaryFile.set(std::string(key), destination);
read += (p - buffer); read += (p - buffer);
} }
// Close file // Close file
fclose(fptr); fclose(fptr);
// OK Let's validate that everything was read OK // OK Let's validate that everything was read OK
if(temporaryFile.get(SAVE_KEY_TIMESTAMP).i64 != timestamp) { if(temporaryFile.get(SAVE_KEY_TIMESTAMP).i64 != timestamp) {
return SAVE_LOAD_RESULT_MISMATCH_TIMESTAMP; return SAVE_LOAD_RESULT_MISMATCH_TIMESTAMP;
} }
// Now pass off to the loader // Now pass off to the loader
if(this->validateSave(temporaryFile) != false) { if(saveValidateFile(temporaryFile) != false) {
return SAVE_LOAD_RESULT_ERROR; return SAVE_LOAD_RESULT_ERROR;
} }
// Unmark changes. In future I may need to do more complex testing, e.g. if // Unmark changes. In future I may need to do more complex testing, e.g. if
// the game has a newer version that updates save files some how. // the game has a newer version that updates save files some how.
this->currentSave.hasChanges = false; this->currentSave.hasChanges = false;
return SAVE_LOAD_SUCCESS; return SAVE_LOAD_SUCCESS;
} }
void SaveManager::deleteFile(int16_t slot) { void SaveManager::deleteFile(int16_t slot) {
assertTrue(slot >= 0); assertTrue(slot >= 0);
} }
void SaveManager::useSlot(int16_t slot) { void SaveManager::useSlot(int16_t slot) {
assertTrue(slot >= 0); assertTrue(slot >= 0);
this->currentSaveSlot = slot; this->currentSaveSlot = slot;
this->currentSave.reset(); this->currentSave.reset();
} }
std::vector<int16_t> SaveManager::getUsedSlots() { std::vector<int16_t> SaveManager::getUsedSlots() {
std::vector<int16_t> slots; std::vector<int16_t> slots;
return slots; return slots;
} }

180
src/dawn/save/SaveManager.hpp
View File

@ -1,91 +1,91 @@
// Copyright (c) 2022 Dominic Masters // Copyright (c) 2022 Dominic Masters
// //
// This software is released under the MIT License. // This software is released under the MIT License.
// https://opensource.org/licenses/MIT // https://opensource.org/licenses/MIT
#pragma once #pragma once
#include "SaveFile.hpp" #include "SaveFile.hpp"
#include "util/string.hpp" #include "util/string.hpp"
#define SAVE_KEY_TIMESTAMP "meta.timestamp" #define SAVE_KEY_TIMESTAMP "meta.timestamp"
#define SAVE_KEY_SLOT "meta.slot" #define SAVE_KEY_SLOT "meta.slot"
#define SAVE_MANAGER_BUFFER_LENGTH 128 #define SAVE_MANAGER_BUFFER_LENGTH 128
#define SAVE_MANAGER_FILENAME_LENGTH 512 #define SAVE_MANAGER_FILENAME_LENGTH 512
namespace Dawn { namespace Dawn {
class DawnGame; class DawnGame;
enum SaveLoadResult { enum SaveLoadResult {
SAVE_LOAD_SUCCESS, SAVE_LOAD_SUCCESS,
SAVE_LOAD_RESULT_FILE_NOT_PRESENT, SAVE_LOAD_RESULT_FILE_NOT_PRESENT,
SAVE_LOAD_RESULT_TOO_SMALL, SAVE_LOAD_RESULT_TOO_SMALL,
SAVE_LOAD_RESULT_CORRUPTED_DE_SAVE, SAVE_LOAD_RESULT_CORRUPTED_DE_SAVE,
SAVE_LOAD_RESULT_CORRUPTED_VERSION, SAVE_LOAD_RESULT_CORRUPTED_VERSION,
SAVE_LOAD_RESULT_CORRUPTED_TIMESTAMP, SAVE_LOAD_RESULT_CORRUPTED_TIMESTAMP,
SAVE_LOAD_RESULT_CORRUPTED_DATA_KEY, SAVE_LOAD_RESULT_CORRUPTED_DATA_KEY,
SAVE_LOAD_RESULT_CORRUPTED_DATA_VALUE, SAVE_LOAD_RESULT_CORRUPTED_DATA_VALUE,
SAVE_LOAD_RESULT_MISMATCH_TIMESTAMP, SAVE_LOAD_RESULT_MISMATCH_TIMESTAMP,
SAVE_LOAD_RESULT_ERROR SAVE_LOAD_RESULT_ERROR
}; };
class SaveManager { /**
protected: * Reads a save file and then validates all of the values. If a value is
int16_t currentSaveSlot = -1; * not validated then it will NOT be retained.
struct SaveFile currentSave; *
* @param file Save file to read from.
/** * @return Whether or not the save file is corrupt, false for not corrupt.
* Reads a save file and then validates all of the values. If a value is */
* not validated then it will NOT be retained. bool_t saveValidateFile(struct SaveFile raw);
*
* @param file Save file to read from. class SaveManager {
* @return Whether or not the save file is corrupt, false for not corrupt. protected:
*/ int16_t currentSaveSlot = -1;
virtual bool_t validateSave(struct SaveFile raw) = 0; struct SaveFile currentSave;
public: public:
DawnGame *game; DawnGame *game;
/** /**
* Create a new Save Manager. Used by the game instance to decide when/how * Create a new Save Manager. Used by the game instance to decide when/how
* to perform saving. * to perform saving.
* *
* @param game Game that this save manager belongs to. * @param game Game that this save manager belongs to.
*/ */
SaveManager(DawnGame *game); SaveManager(DawnGame *game);
/** /**
* Immediately save the game to the given file. This will invoke the * Immediately save the game to the given file. This will invoke the
* game's custom writer to write the output data to the save file. * game's custom writer to write the output data to the save file.
*/ */
void saveFile(); void saveFile();
/** /**
* Loads the current slotted save file. Invokes the internal managers read * Loads the current slotted save file. Invokes the internal managers read
* function. * function.
*/ */
enum SaveLoadResult loadFile(); enum SaveLoadResult loadFile();
/** /**
* Deletes the given save file slot. We use slots here because we need to * Deletes the given save file slot. We use slots here because we need to
* be able to delete a file without reading it (in case of corruption). * be able to delete a file without reading it (in case of corruption).
* *
* @param slot Slot to delete. * @param slot Slot to delete.
*/ */
void deleteFile(int16_t slot); void deleteFile(int16_t slot);
/** /**
* Determines which save slot to use. * Determines which save slot to use.
* *
* @param slot Save slot to use. * @param slot Save slot to use.
*/ */
void useSlot(int16_t slot); void useSlot(int16_t slot);
/** /**
* Returns a list of used save slots, does not confirm if they are corrupt * Returns a list of used save slots, does not confirm if they are corrupt
* or not, just whether they are in existance or not. * or not, just whether they are in existance or not.
* *
* @return List of used save slots. * @return List of used save slots.
*/ */
std::vector<int16_t> getUsedSlots(); std::vector<int16_t> getUsedSlots();
}; };
} }

1
src/dawn/scene/CMakeLists.txt
View File

@ -9,7 +9,6 @@ target_sources(${DAWN_TARGET_NAME}
Scene.cpp Scene.cpp
SceneItem.cpp SceneItem.cpp
SceneItemComponent.cpp SceneItemComponent.cpp
SceneItemComponentList.cpp
) )
# Subdirs # Subdirs

38
src/dawn/scene/SceneItemComponentList.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 "dawnlibs.hpp"
namespace Dawn {
struct SceneItemComponentRegister {
uint8_t i;
};
class SceneItemComponentList {
private:
std::vector<struct SceneItemComponentRegister> components;
protected:
/**
* Request the list to append a scene item component of type T
* to the registry.
*
* @tparam T Parameter type of the SceneItemComponent
*/
template<class T>
void append() {
struct SceneItemComponentRegister r;
this->components.push_back(r);
}
public:
/**
* Initialies the scene item component list. This constructor is generated
* at build time from the scene item component registry tool.
*/
SceneItemComponentList();
};
}

5
src/dawnhelloworld/CMakeLists.txt
View File

@ -14,7 +14,4 @@ target_include_directories(${DAWN_TARGET_NAME}
# Subdirs # Subdirs
add_subdirectory(game) add_subdirectory(game)
add_subdirectory(save) add_subdirectory(save)
# Assets
tool_bitmapfont(testbitmap bmfont.png 16 16)

2
src/dawnhelloworld/game/CMakeLists.txt
View File

@ -6,5 +6,5 @@
# Sources # Sources
target_sources(${DAWN_TARGET_NAME} target_sources(${DAWN_TARGET_NAME}
PRIVATE PRIVATE
DawnGame.cpp HelloGame.cpp
) )

28
src/dawnhelloworld/game/DawnGame.hpp
View File

@ -1,28 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "game/_DawnGame.hpp"
#include "save/DawnGameSaveManager.hpp"
namespace Dawn {
class DawnGame : public IDawnGame {
private:
Scene *sceneToCutTo = nullptr;
public:
DawnHost *host;
RenderManager renderManager;
AssetManager assetManager;
InputManager inputManager;
TimeManager timeManager;
DawnGameSaveManager saveManager;
DawnGame(DawnHost *host);
int32_t init() override;
int32_t update(float_t delta) override;
void sceneCutover(Scene *scene) override;
};
}

13
src/dawnhelloworld/game/HelloGame.cpp Normal file
View File

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

2
src/dawnhelloworld/save/CMakeLists.txt
View File

@ -6,5 +6,5 @@
# Sources # Sources
target_sources(${DAWN_TARGET_NAME} target_sources(${DAWN_TARGET_NAME}
PRIVATE PRIVATE
DawnGameSaveManager.cpp HelloSave.cpp
) )

28
src/dawnhelloworld/save/DawnGameSaveManager.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 "DawnGameSaveManager.hpp"
using namespace Dawn;
DawnGameSaveManager::DawnGameSaveManager(DawnGame *game) : SaveManager(game) {
}
bool_t DawnGameSaveManager::validateSave(struct SaveFile raw) {
if(!raw.has(POKER_SAVE_KEY_EXAMPLE)) return true;
this->currentSave.copy(raw, POKER_SAVE_KEY_EXAMPLE);
return false;
}
void DawnGameSaveManager::setExample(int32_t val) {
savedata_t value;
value.i32 = val;
this->currentSave.set(POKER_SAVE_KEY_EXAMPLE, value);
}
int32_t DawnGameSaveManager::getExample() {
return this->currentSave.get(POKER_SAVE_KEY_EXAMPLE).i32;
}

22
src/dawnhelloworld/save/DawnGameSaveManager.hpp
View File

@ -1,22 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "save/SaveManager.hpp"
#define POKER_SAVE_KEY_EXAMPLE "poker.example"
namespace Dawn {
class DawnGameSaveManager : public SaveManager {
protected:
virtual bool_t validateSave(struct SaveFile raw) override;
public:
DawnGameSaveManager(DawnGame *game);
void setExample(int32_t value);
int32_t getExample();
};
}

8
src/dawn/scene/SceneItemComponentList.cpp → src/dawnhelloworld/save/HelloSave.cpp
View File

@ -3,6 +3,10 @@
// This software is released under the MIT License. // This software is released under the MIT License.
// https://opensource.org/licenses/MIT // https://opensource.org/licenses/MIT
#include "SceneItemComponentList.hpp" #include "save/SaveManager.hpp"
using namespace Dawn; using namespace Dawn;
bool_t Dawn::saveValidateFile(struct SaveFile raw) {
return false;
}

7
src/dawnosui/display/CMakeLists.txt
View File

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

6
src/dawnosui/display/shader/CMakeLists.txt
View File

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

94
src/dawnosui/display/shader/TestBackgroundShader.hpp
View File

@ -1,94 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "display/shader/Shader.hpp"
#include "scene/components/Components.hpp"
namespace Dawn {
class TestBackgroundShader : public Shader {
public:
shaderparameter_t paramProjection;
shaderparameter_t paramView;
shaderparameter_t paramTime;
std::map<shaderparameter_t, enum ShaderParameterType>
getParameters() override {
std::map<shaderparameter_t, enum ShaderParameterType> ps;
ps[paramTime] = SHADER_PARAMETER_TYPE_FLOAT;
return ps;
}
void setDefaultParameters(Material &material) override {
material.floatValues[this->paramTime] = 0.0f;
}
void setGlobalParameters(glm::mat4 proj, glm::mat4 view) override {
this->setMatrix(this->paramProjection, proj);
this->setMatrix(this->paramView, view);
}
void setMeshParameters(glm::mat4 transform) override {}
void bindTexture(
shaderparameter_t param,
Texture *texture
) override {}
void compile() override {
this->compileShader(R"GLSL(
#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec2 aTexCoord;
uniform mat4 u_Proj;
uniform mat4 u_View;
out vec2 o_TextCoord;
void main() {
gl_Position = u_Proj * u_View * vec4(aPos, 1.0);
o_TextCoord = vec2(aTexCoord.x, aTexCoord.y);
}
)GLSL", R"GLSL(
#version 330 core
out vec4 o_Color;
in vec2 o_TextCoord;
uniform float u_Time;
void main() {
highp float tSpan = 4.0;
highp float halfTSpan = tSpan / 2.0;
highp float t = mod(u_Time, tSpan);
if(t > halfTSpan) {
t = halfTSpan + (halfTSpan - t);
}
t = t / halfTSpan;
highp float x = o_TextCoord.x;
highp float y = o_TextCoord.y;
float h = sin(x + u_Time) / 4 + 0.5;
highp float r = (0.6 + ((y * t) / 5.0));
highp float g = 0.4 + ((x * t) / (10 + (t * 3)));
highp float b = 0.8 + ((0.2 * t) - (x / 5));
highp float global = 0.7 + ((0.1 + (y * 0.6)) / h / 4.0);
o_Color = vec4(
r * global,
g * global,
b * global,
1.0
);
}
)GLSL"
);
this->paramProjection = this->getParameterByName("u_Proj");
this->paramView = this->getParameterByName("u_View");
this->paramTime = this->getParameterByName("u_Time");
}
};
}

69
src/dawnosui/game/DawnPokerGame.cpp
View File

@ -1,69 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "DawnPokerGame.hpp"
using namespace Dawn;
std::shared_ptr<Material> material;
std::shared_ptr<TestBackgroundShader> shader;
DawnGame::DawnGame(DawnHost &host) :
host(host),
renderManager(*this),
inputManager(*this)
{
}
int32_t DawnGame::init() {
this->assetManager.init();
this->renderManager.init();
this->scene = std::make_shared<Scene>(*this);
auto cameraObject = this->scene->createSceneItem();
auto camera = cameraObject->addComponent<Camera>();
camera->type = CAMERA_TYPE_ORTHONOGRAPHIC;
camera->orthoLeft = 0.0f;
camera->orthoRight = 1.0f;
camera->orthoTop = 0.0f;
camera->orthoBottom = 1.0f;
camera->transform.lookAt(glm::vec3(0, 0, 10), glm::vec3(0, 0, 0));
// camera->transform.lookAt(glm::vec3(50, 50, 50), glm::vec3(0, 0, 0));
auto quad = this->scene->createSceneItem();
auto meshRenderer = quad->addComponent<MeshRenderer>();
meshRenderer->mesh = std::make_shared<Mesh>();
meshRenderer->mesh->createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
QuadMesh::bufferQuadMesh(meshRenderer->mesh.get(),
glm::vec2(0, 0), glm::vec2(0, 0),
glm::vec2(1.0f, 1.0f), glm::vec2(1.0f, 1.0f),
0, 0
);
shader = std::make_shared<TestBackgroundShader>();
shader->compile();
material = quad->addComponent<Material>();
material->setShader(shader);
return DAWN_GAME_INIT_RESULT_SUCCESS;
}
int32_t DawnGame::update(float_t delta) {
this->assetManager.update();
this->inputManager.update();
this->timeManager.update(delta);
if(this->scene != nullptr) this->scene->update();
material->floatValues[shader->paramTime] = this->timeManager.time;
this->renderManager.update();
return DAWN_GAME_UPDATE_RESULT_SUCCESS;
}
DawnGame::~DawnGame() {
}

10
src/dawnosui/game/DawnPokerGame.hpp
View File

@ -1,10 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "game/DawnGame.hpp"
#include "scene/components/Components.hpp"
#include "display/mesh/QuadMesh.hpp"
#include "display/shader/TestBackgroundShader.hpp"

9
src/dawnosui/input/InputBinds.hpp
View File

@ -1,9 +0,0 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "input/InputManager.hpp"
#define INPUT_BIND_ACCEPT ((inputbind_t)1)

37
src/dawnosui/CMakeLists.txt → src/dawnrose/CMakeLists.txt
View File

@ -1,20 +1,17 @@
# Copyright (c) 2022 Dominic Masters # Copyright (c) 2023 Dominic Masters
# #
# This software is released under the MIT License. # This software is released under the MIT License.
# https://opensource.org/licenses/MIT # https://opensource.org/licenses/MIT
# Set up the executable # Build Project
set(DAWN_TARGET_NAME "DawnOS" CACHE INTERNAL ${DAWN_CACHE_TARGET}) add_executable(${DAWN_TARGET_NAME})
# Build Project # Includes
add_executable(${DAWN_TARGET_NAME}) target_include_directories(${DAWN_TARGET_NAME}
PUBLIC
# Includes ${CMAKE_CURRENT_LIST_DIR}
target_include_directories(${DAWN_TARGET_NAME} )
PUBLIC
${CMAKE_CURRENT_LIST_DIR} # Subdirs
) add_subdirectory(game)
add_subdirectory(save)
# Subdirs
add_subdirectory(game)
add_subdirectory(display)

10
src/dawnrose/game/CMakeLists.txt Normal file
View File

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

13
src/dawnrose/game/RoseGame.cpp Normal file
View File

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

19
src/dawnrose/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)

10
src/dawnrose/save/CMakeLists.txt Normal file
View File

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

12
src/dawnrose/save/RoseSave.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;
}

65
src/dawnrose/scenes/HelloWorldScene.hpp 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
#pragma once
#include "scene/Scene.hpp"
#include "prefabs/SimpleSpinningCubePrefab.hpp"
#include "scene/components/ui/UILabel.hpp"
#include "scene/components/ui/UIImage.hpp"
#include "display/font/BitmapFont.hpp"
namespace Dawn {
class HelloWorldScene : public Scene {
protected:
Camera *camera;
SimpleSpinningCubePrefab *cube;
UICanvas *canvas;
UILabel *label;
UIImage *image;
BitmapFont font;
void stage() override {
camera = Camera::create(this);
camera->transform->lookAt(glm::vec3(0, 0, 8), glm::vec3(0, 0, 0));
cube = SimpleSpinningCubePrefab::create(this);
canvas = UICanvas::create(this);
auto imageItem = this->createSceneItem();
image = imageItem->addComponent<UIImage>();
image->color = COLOR_BLACK;
imageItem->transform.setParent(canvas->transform);
auto labelItem = this->createSceneItem();
label = labelItem->addComponent<UILabel>();
labelItem->transform.setParent(canvas->transform);
auto assMan = &this->game->assetManager;
auto texture = assMan->get<TextureAsset>("testbitmap_texture");
auto tileset = assMan->get<TilesetAsset>("testbitmap_tileset");
this->font.texture = &texture->texture;
this->font.tileset = &tileset->tileset;
label->text = "Hello World, how are you today? I hope you are doing well. I really like the fact I can ramble in my text for once.";
label->font = &font;
label->maxWidth = 220;
image->alignment = glm::vec4(0, 0, label->getContentWidth(), label->getContentHeight());
}
std::vector<Asset*> getRequiredAssets() override {
auto assMan = &this->game->assetManager;
std::vector<Asset*> assets;
vectorAppend(&assets, SimpleSpinningCubePrefab::getRequiredAssets(assMan));
assets.push_back(assMan->get<TextureAsset>("testbitmap_texture"));
assets.push_back(assMan->get<TilesetAsset>("testbitmap_tileset"));
return assets;
}
public:
HelloWorldScene(DawnGame *game) : Scene(game) {}
};
}