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

More Progress

Browse Source
This commit is contained in:
Dominic Masters
2022-10-18 15:23:50 -07:00
parent 0ec2809d88
commit 6f10535962
45 changed files with 7994 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
CMakeLists.txt 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
cmake_minimum_required(VERSION 3.13)
set(CMAKE_C_STANDARD 99)
set(CMAKE_C_STANDARD_REQUIRED ON)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/")
# Initialize Project First.
project(Dawn
VERSION 1.0.0
LANGUAGES C CXX
)
# Set Common Build Variables
set(DAWN_ROOT_DIR "${CMAKE_SOURCE_DIR}")
set(DAWN_BUILD_DIR "${CMAKE_BINARY_DIR}")
set(DAWN_TOOLS_DIR "${DAWN_ROOT_DIR}/tools")
set(DAWN_ASSETS_SOURCE_DIR "${DAWN_ROOT_DIR}/assets")
set(DAWN_ASSETS_BUILD_DIR "${DAWN_BUILD_DIR}/assets")
set(DAWN_TEMP_DIR "${DAWN_BUILD_DIR}/temp")
# Variable Caches
set(DAWN_CACHE_TARGET "Target")
# Add CMake Tools
add_subdirectory(cmake)
# Add Libraries
add_subdirectory(lib)
# Add Project Files
add_subdirectory(src)

19
README.md Normal file
View File

@ -0,0 +1,19 @@
# Dawn Project
Simple in code, complex in structure game engine for creating small, fast and
reusable games.
## Folder Structure
```Markdown
.
├── assets # Game Assets and Files (before optimization)
├── cmake
| ├── modules # Tools to allow CMake to find third-party libraries
| ├── targets # Variable lists to control what will be built
├── lib # Third-Party Submodule Libraries
├── src
| ├── dawn # Game engine, common project tools and utilities
| ├── dawnglfw # Engine files for GLFW Support
| ├── dawnopengl # Engine files for OpenGL Support
| ├── dawnpokergame # Poker Game Project
| ├── dawnwin32 # Engine files for WIN32 Host
```

6
cmake/CMakeLists.txt Normal file
View File

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

45
cmake/modules/FindALUT.cmake Normal file
View File

@ -0,0 +1,45 @@
find_path(ALUT_INCLUDE_DIR AL/alut.h
HINTS
ENV ALUTDIR
PATHS
"/usr"
"/usr/local"
"~/Library/Frameworks"
"/Library/Frameworks"
"/opt"
"$ENV{PROGRAMFILES}/alut"
"$ENV{PROGRAMFILES}/freealut"
PATH_SUFFIXES
include
alut
freealut
)
# Search for the library
FIND_LIBRARY(ALUT_LIBRARY
NAMES
alut freealut
HINTS
ENV ALUTDIR
PATHS
"/usr"
"/usr/local"
"~/Library/Frameworks"
"/Library/Frameworks"
"/opt"
"$ENV{PROGRAMFILES}/alut"
"$ENV{PROGRAMFILES}/freealut"
PATH_SUFFIXES
lib
lib32
lib64
libs
)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(
ALUT
REQUIRED_VARS ALUT_LIBRARY ALUT_INCLUDE_DIR
)
mark_as_advanced(ALUT_LIBRARY ALUT_INCLUDE_DIR)

49
cmake/modules/FindGLFW.cmake Normal file
View File

@ -0,0 +1,49 @@
find_path(GLFW_INCLUDE_DIR GLFW/glfw3.h
HINTS
ENV GLFWDIR
PATHS
"/usr"
"/usr/local"
"~/Library/Frameworks"
"/Library/Frameworks"
"/opt"
"$ENV{PROGRAMFILES}/glfw"
"$ENV{PROGRAMFILES}/glfw3"
PATH_SUFFIXES
include
)
# Search for the library
FIND_LIBRARY(GLFW_LIBRARY
NAMES
glfw glfw3 GLFW GLFW3
HINTS
ENV GLFWDIR
PATHS
"/usr"
"/usr/local"
"~/Library/Frameworks"
"/Library/Frameworks"
"/opt"
"$ENV{PROGRAMFILES}/glfw"
"$ENV{PROGRAMFILES}/glfw3"
PATH_SUFFIXES
lib
lib32
lib64
libs
lib-vc2012
lib-vc2013
lib-vc2015
lib-vc2017
lib-vc2019
lib-vc2022
)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(
GLFW
REQUIRED_VARS GLFW_LIBRARY GLFW_INCLUDE_DIR
)
mark_as_advanced(GLFW_LIBRARY GLFW_INCLUDE_DIR)

49
cmake/modules/FindOpenAL.cmake Normal file
View File

@ -0,0 +1,49 @@
find_path(OPENAL_INCLUDE_DIR al.h
HINTS
ENV OPENALDIR
PATHS
"/usr"
"/usr/local"
"~/Library/Frameworks"
"/Library/Frameworks"
"/opt"
"$ENV{PROGRAMFILES}/openal"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Creative\ Labs\\OpenAL\ 1.1\ Software\ Development\ Kit\\1.00.0000;InstallDir]"
PATH_SUFFIXES
include/AL
AL/AL
include/OpenAL
include
AL
OpenAL
)
# Search for the library
FIND_LIBRARY(OPENAL_LIBRARY
NAMES
OpenAL al openal OpenAL32
HINTS
ENV OPENALDIR
PATHS
"/usr"
"/usr/local"
"~/Library/Frameworks"
"/Library/Frameworks"
"/opt"
"$ENV{PROGRAMFILES}/openal"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Creative\ Labs\\OpenAL\ 1.1\ Software\ Development\ Kit\\1.00.0000;InstallDir]"
PATH_SUFFIXES
lib
lib32
lib64
libs
${_OpenAL_ARCH_DIR}
)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(
OpenAL
REQUIRED_VARS OPENAL_LIBRARY OPENAL_INCLUDE_DIR
)
mark_as_advanced(OPENAL_LIBRARY OPENAL_INCLUDE_DIR)

19
cmake/targets/CMakeLists.txt Normal file
View File

@ -0,0 +1,19 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Check for build target, or default
if(NOT DEFINED DAWN_BUILD_TARGET)
if(WIN32)
set(DAWN_BUILD_TARGET "target-pokergame-win32-glfw")
endif()
endif()
# Now validate we have a build target for real
if(NOT DEFINED DAWN_BUILD_TARGET)
message(FATAL_ERROR "You need to define a DAWN_BUILD_TARGET")
endif()
# Include the build target
add_subdirectory(${DAWN_BUILD_TARGET})

7
cmake/targets/target-pokergame-win32-glfw/CMakeLists.txt Normal file
View File

@ -0,0 +1,7 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
set(DAWN_TARGET_WIN32 true CACHE INTERNAL ${DAWN_CACHE_TARGET})
set(DAWN_TARGET_GLFW true CACHE INTERNAL ${DAWN_CACHE_TARGET})

13
lib/CMakeLists.txt Normal file
View File

@ -0,0 +1,13 @@
# Copyright (c) 2021 Dominic Msters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# GLAD
add_subdirectory(glad)
# GLFW
add_subdirectory(glfw)
# GLM
add_subdirectory(glm)

12
lib/glad/CMakeLists.txt Normal file
View File

@ -0,0 +1,12 @@
cmake_minimum_required(VERSION 3.11)
project(glad)
set(CMAKE_C_STANDARD 99)
set(CMAKE_C_STANDARD_REQUIRED ON)
add_library(${PROJECT_NAME}
src/glad.c
)
target_include_directories(${PROJECT_NAME}
PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}/include
)

290
lib/glad/include/KHR/khrplatform.h Normal file
View File

@ -0,0 +1,290 @@
#ifndef __khrplatform_h_
#define __khrplatform_h_
/*
** Copyright (c) 2008-2018 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
/* Khronos platform-specific types and definitions.
*
* The master copy of khrplatform.h is maintained in the Khronos EGL
* Registry repository at https://github.com/KhronosGroup/EGL-Registry
* The last semantic modification to khrplatform.h was at commit ID:
* 67a3e0864c2d75ea5287b9f3d2eb74a745936692
*
* Adopters may modify this file to suit their platform. Adopters are
* encouraged to submit platform specific modifications to the Khronos
* group so that they can be included in future versions of this file.
* Please submit changes by filing pull requests or issues on
* the EGL Registry repository linked above.
*
*
* See the Implementer's Guidelines for information about where this file
* should be located on your system and for more details of its use:
* http://www.khronos.org/registry/implementers_guide.pdf
*
* This file should be included as
* #include <KHR/khrplatform.h>
* by Khronos client API header files that use its types and defines.
*
* The types in khrplatform.h should only be used to define API-specific types.
*
* Types defined in khrplatform.h:
* khronos_int8_t signed 8 bit
* khronos_uint8_t unsigned 8 bit
* khronos_int16_t signed 16 bit
* khronos_uint16_t unsigned 16 bit
* khronos_int32_t signed 32 bit
* khronos_uint32_t unsigned 32 bit
* khronos_int64_t signed 64 bit
* khronos_uint64_t unsigned 64 bit
* khronos_intptr_t signed same number of bits as a pointer
* khronos_uintptr_t unsigned same number of bits as a pointer
* khronos_ssize_t signed size
* khronos_usize_t unsigned size
* khronos_float_t signed 32 bit floating point
* khronos_time_ns_t unsigned 64 bit time in nanoseconds
* khronos_utime_nanoseconds_t unsigned time interval or absolute time in
* nanoseconds
* khronos_stime_nanoseconds_t signed time interval in nanoseconds
* khronos_boolean_enum_t enumerated boolean type. This should
* only be used as a base type when a client API's boolean type is
* an enum. Client APIs which use an integer or other type for
* booleans cannot use this as the base type for their boolean.
*
* Tokens defined in khrplatform.h:
*
* KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
*
* KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
* KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
*
* Calling convention macros defined in this file:
* KHRONOS_APICALL
* KHRONOS_APIENTRY
* KHRONOS_APIATTRIBUTES
*
* These may be used in function prototypes as:
*
* KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
* int arg1,
* int arg2) KHRONOS_APIATTRIBUTES;
*/
#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
# define KHRONOS_STATIC 1
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APICALL
*-------------------------------------------------------------------------
* This precedes the return type of the function in the function prototype.
*/
#if defined(KHRONOS_STATIC)
/* If the preprocessor constant KHRONOS_STATIC is defined, make the
* header compatible with static linking. */
# define KHRONOS_APICALL
#elif defined(_WIN32)
# define KHRONOS_APICALL __declspec(dllimport)
#elif defined (__SYMBIAN32__)
# define KHRONOS_APICALL IMPORT_C
#elif defined(__ANDROID__)
# define KHRONOS_APICALL __attribute__((visibility("default")))
#else
# define KHRONOS_APICALL
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIENTRY
*-------------------------------------------------------------------------
* This follows the return type of the function and precedes the function
* name in the function prototype.
*/
#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
/* Win32 but not WinCE */
# define KHRONOS_APIENTRY __stdcall
#else
# define KHRONOS_APIENTRY
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIATTRIBUTES
*-------------------------------------------------------------------------
* This follows the closing parenthesis of the function prototype arguments.
*/
#if defined (__ARMCC_2__)
#define KHRONOS_APIATTRIBUTES __softfp
#else
#define KHRONOS_APIATTRIBUTES
#endif
/*-------------------------------------------------------------------------
* basic type definitions
*-----------------------------------------------------------------------*/
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
/*
* Using <stdint.h>
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__VMS ) || defined(__sgi)
/*
* Using <inttypes.h>
*/
#include <inttypes.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
/*
* Win32
*/
typedef __int32 khronos_int32_t;
typedef unsigned __int32 khronos_uint32_t;
typedef __int64 khronos_int64_t;
typedef unsigned __int64 khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__sun__) || defined(__digital__)
/*
* Sun or Digital
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#if defined(__arch64__) || defined(_LP64)
typedef long int khronos_int64_t;
typedef unsigned long int khronos_uint64_t;
#else
typedef long long int khronos_int64_t;
typedef unsigned long long int khronos_uint64_t;
#endif /* __arch64__ */
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif 0
/*
* Hypothetical platform with no float or int64 support
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#define KHRONOS_SUPPORT_INT64 0
#define KHRONOS_SUPPORT_FLOAT 0
#else
/*
* Generic fallback
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#endif
/*
* Types that are (so far) the same on all platforms
*/
typedef signed char khronos_int8_t;
typedef unsigned char khronos_uint8_t;
typedef signed short int khronos_int16_t;
typedef unsigned short int khronos_uint16_t;
/*
* Types that differ between LLP64 and LP64 architectures - in LLP64,
* pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
* to be the only LLP64 architecture in current use.
*/
#ifdef _WIN64
typedef signed long long int khronos_intptr_t;
typedef unsigned long long int khronos_uintptr_t;
typedef signed long long int khronos_ssize_t;
typedef unsigned long long int khronos_usize_t;
#else
typedef signed long int khronos_intptr_t;
typedef unsigned long int khronos_uintptr_t;
typedef signed long int khronos_ssize_t;
typedef unsigned long int khronos_usize_t;
#endif
#if KHRONOS_SUPPORT_FLOAT
/*
* Float type
*/
typedef float khronos_float_t;
#endif
#if KHRONOS_SUPPORT_INT64
/* Time types
*
* These types can be used to represent a time interval in nanoseconds or
* an absolute Unadjusted System Time. Unadjusted System Time is the number
* of nanoseconds since some arbitrary system event (e.g. since the last
* time the system booted). The Unadjusted System Time is an unsigned
* 64 bit value that wraps back to 0 every 584 years. Time intervals
* may be either signed or unsigned.
*/
typedef khronos_uint64_t khronos_utime_nanoseconds_t;
typedef khronos_int64_t khronos_stime_nanoseconds_t;
#endif
/*
* Dummy value used to pad enum types to 32 bits.
*/
#ifndef KHRONOS_MAX_ENUM
#define KHRONOS_MAX_ENUM 0x7FFFFFFF
#endif
/*
* Enumerated boolean type
*
* Values other than zero should be considered to be true. Therefore
* comparisons should not be made against KHRONOS_TRUE.
*/
typedef enum {
KHRONOS_FALSE = 0,
KHRONOS_TRUE = 1,
KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
} khronos_boolean_enum_t;
#endif /* __khrplatform_h_ */

4068
lib/glad/include/glad/glad.h Normal file
View File

File diff suppressed because it is too large Load Diff

2522
lib/glad/src/glad.c Normal file
View File

File diff suppressed because it is too large Load Diff

28
src/CMakeLists.txt Normal file
View File

@ -0,0 +1,28 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Change what we are building
add_subdirectory(dawnpokergame)
# Check the game project includes the target name
if(NOT DEFINED DAWN_TARGET_NAME)
message(FATAL_ERROR "You need to define a DAWN_TARGET_NAME")
endif()
# Add in base library
add_subdirectory(dawn)
# Compile entry targets
if(DAWN_TARGET_WIN32)
add_subdirectory(dawnwin32)
else()
message(FATAL_ERROR "You need to define an entry target")
endif()
# Compile support targets
if(DAWN_TARGET_GLFW)
add_subdirectory(dawnglfw)
add_subdirectory(dawnopengl)
endif()

19
src/dawn/CMakeLists.txt Normal file
View File

@ -0,0 +1,19 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Libraries
target_link_libraries(${DAWN_TARGET_NAME}
PUBLIC
glm
)
# Includes
target_include_directories(${DAWN_TARGET_NAME}
PUBLIC
${CMAKE_CURRENT_LIST_DIR}
)
# Subdirs
add_subdirectory(scene)

43
src/dawn/dawnlibs.hpp Normal file
View File

@ -0,0 +1,43 @@
/**
* Copyright (c) 2022 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
// Static Libs
extern "C" {
// Standard Libs
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <malloc.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <assert.h>
typedef bool bool_t;
typedef float float_t;
}
#include <vector>
#include <iostream>
#include <thread>
#include <map>
// #include <iterator>
// #include <algorithm>
// #include <string>
// #include <sstream>
#include <glm/glm.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
#include <glm/ext/matrix_transform.hpp>
#include <glm/ext/matrix_clip_space.hpp>
#include <glm/ext/scalar_constants.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtx/matrix_decompose.hpp>

23
src/dawn/display/RenderManager.hpp Normal file
View File

@ -0,0 +1,23 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "dawnlibs.hpp"
namespace Dawn {
class DawnGame;
class RenderManager {
public:
std::weak_ptr<DawnGame> game;
RenderManager(std::weak_ptr<DawnGame>);
void init();
void update();
~RenderManager();
};
}

35
src/dawn/game/DawnGame.hpp Normal file
View File

@ -0,0 +1,35 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "dawnlibs.hpp"
#include "scene/Scene.hpp"
#include "display/RenderManager.hpp"
#define DAWN_GAME_INIT_RESULT_SUCCESS 0
#define DAWN_GAME_UPDATE_RESULT_SUCCESS 0
#define DAWN_GAME_UPDATE_RESULT_EXIT 1
namespace Dawn {
class DawnHost;
class DawnGame :
public std::enable_shared_from_this<DawnGame>
{
private:
std::shared_ptr<Scene> scene;
std::weak_ptr<DawnHost> host;
public:
RenderManager renderManager;
DawnGame(std::weak_ptr<DawnHost> host);
int32_t init();
int32_t update(float_t delta);
~DawnGame();
};
}

89
src/dawn/host/DawnHost.hpp Normal file
View File

@ -0,0 +1,89 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "dawnlibs.hpp"
#include "game/DawnGame.hpp"
/** Implies the host initialized successfully */
#define DAWN_HOST_INIT_RESULT_SUCCESS 0
/** Implies that the update was successful, and the loop should continue */
#define DAWN_HOST_UPDATE_RESULT_SUCCESS 0
/** Implies that the update was successful, but the loop should not continue */
#define DAWN_HOST_UPDATE_RESULT_EXIT 1
/** Implies that the host started successfully */
#define DAWN_HOST_START_RESULT_SUCCESS 0
/** Implies that the host started successfully, and then finished everything */
#define DAWN_HOST_START_RESULT_EXIT_SUCCESS 1
namespace Dawn {
/**
* DawnHostData is a custom forwarder that allows any host to define what it
* will need access to, data-wise. For example, GLFW+GLAD uses this to hold
* the window handle during the hosts' session, so that it can destroy it
* safely when the host is unloaded.
*/
class DawnHostData;
class DawnHost {
public:
std::unique_ptr<DawnHostData> data;
/**
* Construct a new DawnHost. Hosts are set by the various dawn platform
* libraries to be handled in different ways depending on the exact
* system. For example, Windows can support both GLFW+GLAD or SDL and may
* opt to invoke a DawnHost for either of these scenarios.
*/
DawnHost();
/**
* Request to initialize the host. Hosts can initialize themselves pretty
* much however they want, but they must return a status code, in cases
* where some hosts may not be responsible for their own invokation.
*
* @param game Game instance that this host is running for.
* @return A status code, where DAWN_HOST_INIT_RESULT_SUCCESS is success.
*/
int32_t init(std::weak_ptr<DawnGame> game);
/**
* Request to start the main loop. This method may not exist and may not
* need to exist depending on the host. For that reason this is marked as
* virtual and is up to the main caller to know how this start method
* needs to be called. Start should request update() to be invoked if it
* does begin the main thread.
*
* @param game Game instance that this host is running for.
* @return A status code, refer to DAWN_HOST_START_RESULT_{} definitions.
*/
virtual int32_t start(std::weak_ptr<DawnGame> game);
/**
* Requests the host to perform a main-thread update.
*
* @param game Game instance that this host is running for.
* @param delta How much time has passed (in seconds) since the last tick.
* @return A status code, refer to DAWN_HOST_UPDATE_RESULT_{} definitions.
*/
int32_t update(std::weak_ptr<DawnGame> game, float_t delta);
/**
* Request the host to be unloaded. This is a bit different from dispose
* as we are likely to unload the host just after the game is unloaded,
* but before the parent program has requested memory freeing.
*
* @param game Game instance that this host is running for.
*/
void unload(std::weak_ptr<DawnGame> game);
/**
* Destroy (and unload) all of the DawnHost data from memory.
*/
~DawnHost();
};
}

15
src/dawn/scene/CMakeLists.txt Normal file
View File

@ -0,0 +1,15 @@
# 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
Scene.cpp
SceneItem.cpp
SceneItemComponent.cpp
)
# Subdirs
add_subdirectory(components)

44
src/dawn/scene/Scene.cpp Normal file
View File

@ -0,0 +1,44 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "Scene.hpp"
#include "game/DawnGame.hpp"
using namespace Dawn;
Scene::Scene(std::weak_ptr<DawnGame> game) {
this->game = game;
this->nextId = 0;
}
void Scene::update() {
// Finsh adding scene items that were trying to add from the last frame.
auto it = this->itemsNotInitialized.begin();
while(it != this->itemsNotInitialized.end()) {
this->items[it->first] = it->second;
it++;
it->second->init();
}
this->itemsNotInitialized.clear();
// TODO: Cleanup old scene items
// TODO: Tick scene items(?)
}
std::shared_ptr<SceneItem> Scene::createSceneItem() {
sceneitemid_t id = this->nextId++;
auto item = std::make_shared<SceneItem>(weak_from_this(), id);
this->itemsNotInitialized[id] = item;
return item;
}
void Scene::removeSceneItem(SceneItem *item) {
}
Scene::~Scene() {
}

33
src/dawn/scene/Scene.hpp Normal file
View File

@ -0,0 +1,33 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "SceneItem.hpp"
namespace Dawn {
class DawnGame;
class Scene :
public std::enable_shared_from_this<Scene>
{
private:
sceneitemid_t nextId;
std::map<sceneitemid_t,std::shared_ptr<SceneItem>> items;
std::map<sceneitemid_t,std::shared_ptr<SceneItem>> itemsNotInitialized;
public:
std::weak_ptr<DawnGame> game;
Scene(std::weak_ptr<DawnGame> game);
void update();
std::shared_ptr<SceneItem> createSceneItem();
void removeSceneItem(SceneItem *item);
~Scene();
};
}

22
src/dawn/scene/SceneItem.cpp Normal file
View File

@ -0,0 +1,22 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "SceneItem.hpp"
#include "Scene.hpp"
using namespace Dawn;
SceneItem::SceneItem(std::weak_ptr<Scene>, sceneitemid_t id) {
this->scene = scene;
this->id = id;
}
void SceneItem::init() {
}
SceneItem::~SceneItem() {
}

47
src/dawn/scene/SceneItem.hpp Normal file
View File

@ -0,0 +1,47 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "SceneItemComponent.hpp"
namespace Dawn {
typedef int32_t sceneitemid_t;
class Scene;
class SceneItem {
private:
std::vector<std::shared_ptr<SceneItemComponent>> components;
public:
std::weak_ptr<Scene> scene;
sceneitemid_t id;
SceneItem(std::weak_ptr<Scene> scene, sceneitemid_t id);
void init();
template<class T>
std::shared_ptr<T> addComponent() {
auto component = std::make_unique<T>(this);
this->components.push_back(component);
return component;
}
template<class T>
std::shared_ptr<T> getComponent() {
auto it = this->components.begin();
while(it != this->components.end()) {
std::shared_ptr<T> castedAs = dynamic_cast<std::shared_ptr<T>>(*it);
if(castedAs != nullptr) return castedAs;
it++;
continue;
}
return nullptr;
}
~SceneItem();
};
}

17
src/dawn/scene/SceneItemComponent.cpp Normal file
View File

@ -0,0 +1,17 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "SceneItemComponent.hpp"
#include "SceneItem.hpp"
using namespace Dawn;
SceneItemComponent::SceneItemComponent(std::weak_ptr<SceneItem> item) {
this->item = item;
}
SceneItemComponent::~SceneItemComponent() {
}

22
src/dawn/scene/SceneItemComponent.hpp Normal file
View File

@ -0,0 +1,22 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "dawnlibs.hpp"
namespace Dawn {
class SceneItem;
class SceneItemComponent {
public:
std::weak_ptr<SceneItem> item;
SceneItemComponent(std::weak_ptr<SceneItem> item);
virtual void start() = 0;
virtual ~SceneItemComponent();
};
}

10
src/dawn/scene/components/CMakeLists.txt Normal file
View File

@ -0,0 +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
DummyComponent.cpp
)

12
src/dawn/scene/components/DummyComponent.cpp Normal file
View File

@ -0,0 +1,12 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "DummyComponent.hpp"
using namespace Dawn;
void DummyComponent::start() {
std::cout << "Dummy Component Start" << std::endl;
}

18
src/dawn/scene/components/DummyComponent.hpp Normal file
View File

@ -0,0 +1,18 @@
// 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 DummyComponent : public SceneItemComponent {
public:
DummyComponent(std::weak_ptr<SceneItem> item) : SceneItemComponent(item) {
std::cout << "Dummy Component Initialized" << std::endl;
};
void start() override;
};
}

20
src/dawnglfw/CMakeLists.txt Normal file
View File

@ -0,0 +1,20 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Libs
target_link_libraries(${DAWN_TARGET_NAME}
PUBLIC
glfw
glad
)
# Includes
target_include_directories(${DAWN_TARGET_NAME}
PUBLIC
${CMAKE_CURRENT_LIST_DIR}
)
# Subdirs
add_subdirectory(host)

7
src/dawnglfw/dawnopengl.hpp Normal file
View File

@ -0,0 +1,7 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include <glad/glad.h>

10
src/dawnglfw/host/CMakeLists.txt Normal file
View File

@ -0,0 +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
DawnGLFWHost.cpp
)

104
src/dawnglfw/host/DawnGLFWHost.cpp Normal file
View File

@ -0,0 +1,104 @@
/**
* Copyright (c) 2022 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "DawnGLFWHost.hpp"
#include "game/DawnGame.hpp"
using namespace Dawn;
// Host
DawnHost::DawnHost() {
this->data = std::make_unique<DawnHostData>();
this->data->window = nullptr;
}
int32_t DawnHost::init(std::weak_ptr<DawnGame> game) {
// Init GLFW
if(!glfwInit()) return DAWN_GLFW_INIT_RESULT_INIT_FAILED;
// Create Window
this->data->window = glfwCreateWindow(
DAWN_GLFW_WINDOW_WIDTH_DEFAULT,
DAWN_GLFW_WINDOW_HEIGHT_DEFAULT,
"Dawn", NULL, NULL
);
if(this->data->window == nullptr) {
glfwTerminate();
return DAWN_GLFW_INIT_RESULT_WINDOW_CREATE_FAILED;
}
// Load GLAD
glfwMakeContextCurrent(this->data->window);
// glfwSwapInterval(0); // "Vsync" disabled if uncommented
gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
return DAWN_HOST_INIT_RESULT_SUCCESS;
}
int32_t DawnHost::start(std::weak_ptr<DawnGame> game) {
double_t time, newTime;
float_t fDelta;
int32_t updateResult;
// Main Render Loop
time = 0.0f;
while(true) {
// Determine the delta.
newTime = glfwGetTime();
fDelta = (float_t)(newTime - time);
time = newTime;
// Perform update
updateResult = this->update(game, fDelta);
// Did the update complete successfully?
if(updateResult == DAWN_HOST_UPDATE_RESULT_EXIT) {
break;
} else if(updateResult != DAWN_HOST_UPDATE_RESULT_SUCCESS) {
return DAWN_GLFW_START_RESULT_UPDATE_FAILED;
}
// Tick the engine.
glfwSwapBuffers(this->data->window);
// Update events
glfwPollEvents();
// Was the window requested to close?
if(glfwWindowShouldClose(this->data->window)) {
break;
}
}
return DAWN_HOST_START_RESULT_EXIT_SUCCESS;
}
int32_t DawnHost::update(std::weak_ptr<DawnGame> game, float_t delta) {
if(auto g = game.lock()) {
auto ret = g->update(delta);
switch(ret) {
case DAWN_GAME_UPDATE_RESULT_SUCCESS:
return DAWN_HOST_UPDATE_RESULT_SUCCESS;
case DAWN_GAME_UPDATE_RESULT_EXIT:
return DAWN_HOST_UPDATE_RESULT_EXIT;
default:
return ret;
}
}
}
void DawnHost::unload(std::weak_ptr<DawnGame> game) {
glfwDestroyWindow(this->data->window);
this->data->window = nullptr;
glfwTerminate();
}
DawnHost::~DawnHost() {
}

25
src/dawnglfw/host/DawnGLFWHost.hpp Normal file
View File

@ -0,0 +1,25 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include "host/DawnHost.hpp"
#define DAWN_GLFW_WINDOW_WIDTH_DEFAULT 1280
#define DAWN_GLFW_WINDOW_HEIGHT_DEFAULT 720
#define DAWN_GLFW_INIT_RESULT_INIT_FAILED -1
#define DAWN_GLFW_INIT_RESULT_WINDOW_CREATE_FAILED -2
#define DAWN_GLFW_START_RESULT_UPDATE_FAILED -1
namespace Dawn {
class DawnHostData {
public:
GLFWwindow *window;
};
}

26
src/dawnopengl/CMakeLists.txt Normal file
View File

@ -0,0 +1,26 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Libraries
find_package(OpenGL REQUIRED)
target_include_directories(${DAWN_TARGET_NAME}
PUBLIC
${OPENGL_INCLUDE_DIR}
)
target_link_libraries(${DAWN_TARGET_NAME}
PUBLIC
${OPENGL_LIBRARIES}
)
# Includes
target_include_directories(${DAWN_TARGET_NAME}
PUBLIC
${CMAKE_CURRENT_LIST_DIR}
)
# Subdirs
add_subdirectory(display)

10
src/dawnopengl/display/CMakeLists.txt Normal file
View File

@ -0,0 +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
RenderManager.cpp
)

34
src/dawnopengl/display/RenderManager.cpp Normal file
View File

@ -0,0 +1,34 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "dawnopengl.hpp"
#include "game/DawnGame.hpp"
#include "display/RenderManager.hpp"
using namespace Dawn;
RenderManager::RenderManager(std::weak_ptr<DawnGame> game) {
this->game = game;
}
void RenderManager::init() {
glClearColor(
0.39215686274f,
0.58431372549f,
0.9294117647f,
1.0f
);
glViewport(0, 0, 500, 500);
}
void RenderManager::update() {
printf("Rendering\n");
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
RenderManager::~RenderManager() {
}

13
src/dawnpokergame/CMakeLists.txt Normal file
View File

@ -0,0 +1,13 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Set up the executable
set(DAWN_TARGET_NAME "PokerGame" CACHE INTERNAL ${DAWN_CACHE_TARGET})
# Build Project
add_executable(${DAWN_TARGET_NAME})
# Subdirs
add_subdirectory(game)

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

@ -0,0 +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
DawnPokerGame.cpp
)

32
src/dawnpokergame/game/DawnPokerGame.cpp Normal file
View File

@ -0,0 +1,32 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "DawnPokerGame.hpp"
using namespace Dawn;
DawnGame::DawnGame(std::weak_ptr<DawnHost> host) :
renderManager(weak_from_this())
{
this->host = host;
}
int32_t DawnGame::init() {
this->renderManager.init();
this->scene = std::make_unique<Scene>(weak_from_this());
return DAWN_GAME_INIT_RESULT_SUCCESS;
}
int32_t DawnGame::update(float_t delta) {
this->renderManager.update();
return DAWN_GAME_UPDATE_RESULT_SUCCESS;
}
DawnGame::~DawnGame() {
}

7
src/dawnpokergame/game/DawnPokerGame.hpp Normal file
View File

@ -0,0 +1,7 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "game/DawnGame.hpp"

13
src/dawnwin32/CMakeLists.txt Normal file
View File

@ -0,0 +1,13 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Includes
target_include_directories(${DAWN_TARGET_NAME}
PUBLIC
${CMAKE_CURRENT_LIST_DIR}
)
# Subdirs
add_subdirectory(host)

10
src/dawnwin32/host/CMakeLists.txt Normal file
View File

@ -0,0 +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
DawnHostWin32.cpp
)

42
src/dawnwin32/host/DawnHostWin32.cpp Normal file
View File

@ -0,0 +1,42 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "DawnHostWin32.hpp"
using namespace Dawn;
int32_t main(int32_t argc, char **args) {
int32_t result;
// Create the host
auto host = std::make_shared<DawnHost>();
auto game = std::make_shared<DawnGame>(host);
// Initialize the host and error check
result = host->init(std::weak_ptr<DawnGame>(game));
switch(result) {
case DAWN_HOST_INIT_RESULT_SUCCESS:
break;
default:
return result;
}
// Request the main loop to start running.
result = host->start(std::weak_ptr<DawnGame>(game));
switch(result) {
case DAWN_HOST_START_RESULT_SUCCESS:
break;
case DAWN_HOST_START_RESULT_EXIT_SUCCESS:
break;
default:
return result;
}
// Main loop finished without errors, cleanup
host->unload(std::weak_ptr<DawnGame>(game));
// Success
return 0;
}

18
src/dawnwin32/host/DawnHostWin32.hpp Normal file
View File

@ -0,0 +1,18 @@
// Copyright (c) 2022 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "dawnlibs.hpp"
#include "host/DawnHost.hpp"
#include "game/DawnGame.hpp"
/**
* Main entry function received by parent Win32 Operating System.
*
* @param argc Count of arguments passed to the program.
* @param args Array of strings provided to the program.
* @return 0 for success, else for any issue/error.
*/
int32_t main(int32_t argc, char **args);