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

Working on doing things properly.

Browse Source
This commit is contained in:
Dominic Masters
2021-09-30 11:09:52 -07:00
parent d47a3707ba
commit fd6b9e5c84
27 changed files with 106439 additions and 890 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -67,7 +67,6 @@ _deps
# Custom
build
.vscode
lib
assets/testworld/tileset.png
oldsrc

16
.gitmodules vendored Normal file
View File

@ -0,0 +1,16 @@
[submodule "lib/Unity"]
path = lib/Unity
url = https://github.com/ThrowTheSwitch/Unity.git
[submodule "lib/stb"]
path = lib/stb
url = https://github.com/nothings/stb
[submodule "lib/cglm"]
path = lib/cglm
url = https://github.com/recp/cglm
[submodule "lib/glfw"]
path = lib/glfw
url = https://github.com/glfw/glfw
[submodule "lib/glad2"]
path = lib/glad2
url = https://github.com/Dav1dde/glad
branch = glad2

142
CMakeLists.txt
View File

@ -8,141 +8,13 @@ cmake_minimum_required(VERSION 3.13)
set(CMAKE_C_STANDARD 99)
set(CMAKE_C_STANDARD_REQUIRED ON)
#Include
include(FetchContent)
################################ Setting Defs ##################################
set(SETTING_PLATFORM_GLFW 1)
set(SETTING_PLATFORM_SDL 2)
# Game Settings
set(SETTING_GAME_POKER 1)
set(SETTING_GAME_DAWN 2)
set(SETTING_GAME_SANDBOX 3)
set(SETTING_GAME SETTING_GAME_DAWN)
set(SETTING_GAME_NAME "DawnGame")
################################## Targets #####################################
set(SETTING_TARGET_WIN32 1)
set(SETTING_TARGET_RG351 2)
set(SETTING_TARGET SETTING_TARGET_WIN32)
# Win32
if(${SETTING_TARGET} EQUAL ${SETTING_TARGET_WIN32})
set(SETTING_PLATFORM SETTING_PLATFORM_GLFW)
set(SETTING_PLATFORM_USE_GLAD 1)
set(SETTING_ASSET_PREFIX "../assets/")
endif()
# RG351
if(${SETTING_TARGET} EQUAL ${SETTING_TARGET_RG351})
set(SETTING_PLATFORM SETTING_PLATFORM_SDL)
set(SETTING_PLATFORM_USE_GLAD 1)
set(SETTING_ASSET_PREFIX "assets/")
endif()
# Configuring
configure_file(config.h.in config.h)
set(DEPS_DIR "${PROJECT_BINARY_DIR}/_deps/${SETTING_TARGET}")
#################################### PROJECT ###################################
project(${SETTING_GAME_NAME} VERSION 1.0)
##################################### SRCS #####################################
file(GLOB_RECURSE SOURCE_FILES ${CMAKE_SOURCE_DIR}/src/*.c)
file(GLOB_RECURSE HEADER_FILES ${CMAKE_SOURCE_DIR}/src/*.h)
# GLFW Sources
if(${SETTING_PLATFORM} EQUAL ${SETTING_PLATFORM_GLFW})
file(GLOB_RECURSE SRC ${CMAKE_SOURCE_DIR}/platform/glfw/*.c)
file(GLOB_RECURSE HDRS ${CMAKE_SOURCE_DIR}/platform/glfw/*.h)
list(APPEND SOURCE_FILES ${SRC})
list(APPEND HEADER_FILES ${HDRS})
endif()
# SDL Sources
if(${SETTING_PLATFORM} EQUAL ${SETTING_PLATFORM_SDL})
file(GLOB_RECURSE SRC ${CMAKE_SOURCE_DIR}/platform/sdl/*.c)
file(GLOB_RECURSE HDRS ${CMAKE_SOURCE_DIR}/platform/sdl/*.h)
list(APPEND SOURCE_FILES ${SRC})
list(APPEND HEADER_FILES ${HDRS})
endif()
#################################### ASSETS ####################################
file(COPY ${CMAKE_CURRENT_LIST_DIR}/assets DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
set(GAME_NAME DawnGame)
set(GAME_VERSION 1.0)
##################################### LIBS #####################################
include_directories(${CMAKE_SOURCE_DIR}/lib/stb)
add_subdirectory(lib)
add_subdirectory(src)
add_subdirectory(client)
# RG351
if(${SETTING_TARGET} EQUAL ${SETTING_TARGET_RG351})
include_directories(${CMAKE_SOURCE_DIR}/include/rg351)
include_directories(${CMAKE_SOURCE_DIR}/include/rg351/SDL2)
endif()
include_directories(${CMAKE_CURRENT_BINARY_DIR})
################################## EXECUTABLE ##################################
add_executable(${PROJECT_NAME} ${HEADER_FILES} ${SOURCE_FILES} ${SCRIPT_FILES})
################################# STATIC LIBS ##################################
# Math
if(NOT WIN32)
target_link_libraries(${PROJECT_NAME} m)
endif()
# GLAD
if(${SETTING_PLATFORM_USE_GLAD} EQUAL 1)
add_subdirectory(${CMAKE_SOURCE_DIR}/lib/glad)
target_link_libraries(${PROJECT_NAME} glad)
endif()
# GLFW
if(${SETTING_PLATFORM} EQUAL ${SETTING_PLATFORM_GLFW})
if(NOT glfw3_FOUND)
FetchContent_Declare(
glfw
GIT_REPOSITORY https://github.com/glfw/glfw
GIT_TAG 3.3.4
)
FetchContent_MakeAvailable(glfw)
endif()
target_link_libraries(${PROJECT_NAME} glfw)
endif()
# SDL
if(${SETTING_PLATFORM} EQUAL ${SETTING_PLATFORM_SDL})
find_package(SDL2 REQUIRED)
include_directories(${SDL2_INCLUDE_DIRS})
target_link_libraries(${PROJECT_NAME} ${SDL2_LIBRARIES})
endif()
# CGLM
if(NOT cglm_FOUND)
FetchContent_Declare(
cglm
GIT_REPOSITORY https://github.com/recp/cglm
GIT_TAG v0.8.3
)
FetchContent_MakeAvailable(cglm)
endif()
target_link_libraries(${PROJECT_NAME} cglm)
# Duktape
add_subdirectory(${CMAKE_SOURCE_DIR}/lib/duktape)
target_link_libraries(${PROJECT_NAME} duktape)
# OpenGL
find_package(OpenGL REQUIRED)
if(${SETTING_TARGET} EQUAL ${SETTING_TARGET_RG351})
target_link_libraries(${PROJECT_NAME} OpenGL::OpenGL)
else()
target_link_libraries(${PROJECT_NAME} OpenGL::GL)
endif()
# CMake
target_link_libraries(${PROJECT_NAME} ${CMAKE_DL_LIBS})
#################################### ASSETS ####################################
file(COPY ${CMAKE_CURRENT_LIST_DIR}/assets DESTINATION ${CMAKE_CURRENT_BINARY_DIR})

6
client/CMakeLists.txt Normal file
View File

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

12
client/glfw/CMakeLists.txt Normal file
View File

@ -0,0 +1,12 @@
# Copyright (c) 2021 Dominic Msters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
project(${GAME_NAME} VERSION ${GAME_VERSION})
file(GLOB_RECURSE SOURCES ${CMAKE_SOURCE_DIR}/*.c)
file(GLOB_RECURSE HEADERS ${CMAKE_SOURCE_DIR}/*.h)
add_executable(${PROJECT_NAME} ${HEADERS} ${SOURCES})
target_link_libraries(${PROJECT_NAME} src glfw)

2
platform/glfw/glwfwplatform.c → client/glfw/glwfwplatform.c
View File

@ -69,7 +69,7 @@ int32_t main() {
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
// Update the window title.
glfwSetWindowTitle(window, SETTING_GAME_NAME);
glfwSetWindowTitle(window, game->engine.name);
double time = 0;

8
platform/glfw/glwfwplatform.h → client/glfw/glwfwplatform.h
View File

@ -4,10 +4,10 @@
// https://opensource.org/licenses/MIT
#pragma once
#include "../../src/libs.h"
#include "../../src/display/render.h"
#include "../../src/game/game.h"
#include "../../src/input/input.h"
#include <src/libs.h>
#include "src/display/render.h"
#include "src/game/game.h"
#include "src/input/input.h"
#define WINDOW_WIDTH_DEFAULT 1280
#define WINDOW_HEIGHT_DEFAULT WINDOW_WIDTH_DEFAULT/16*9

4
config.h.in
View File

@ -7,18 +7,14 @@
// Target Settings
#cmakedefine SETTING_TARGET_WIN32 @SETTING_TARGET_WIN32@
#cmakedefine SETTING_TARGET_RG351 @SETTING_TARGET_RG351@
#cmakedefine SETTING_TARGET @SETTING_TARGET@
// Platform Settings
#cmakedefine SETTING_PLATFORM_GLFW @SETTING_PLATFORM_GLFW@
#cmakedefine SETTING_PLATFORM_SDL @SETTING_PLATFORM_SDL@
#cmakedefine SETTING_PLATFORM @SETTING_PLATFORM@
#cmakedefine SETTING_PLATFORM_USE_GLAD @SETTING_PLATFORM_USE_GLAD@
// Additional settings
#cmakedefine SETTING_ASSET_PREFIX "@SETTING_ASSET_PREFIX@"

18
lib/CMakeLists.txt Normal file
View File

@ -0,0 +1,18 @@
# Copyright (c) 2021 Dominic Msters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
add_subdirectory(Unity)
add_subdirectory(cglm)
add_subdirectory(glfw)
add_subdirectory(duktape)
# STB
add_library(stb STATIC stb/stb_image.h)
set_target_properties(stb PROPERTIES LINKER_LANGUAGE C)
target_include_directories(stb PUBLIC stb/)
# GLAD
add_subdirectory(glad2/cmake)
glad_add_library(glad_gl_core_33 SHARED API gl:core=3.3)

1
lib/Unity Submodule

Submodule lib/Unity added at b19370cc2b

1
lib/cglm Submodule

Submodule lib/cglm added at 0631598d08

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

@ -0,0 +1,12 @@
# Copyright (c) 2021 Dominic Msters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
cmake_minimum_required(VERSION 3.11)
project(duktape)
set(CMAKE_C_STANDARD 99)
set(CMAKE_C_STANDARD_REQUIRED ON)
add_library(${PROJECT_NAME} STATIC duktape.c)
target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

3198
lib/duktape/duk_config.h Normal file
View File

File diff suppressed because it is too large Load Diff

1911
lib/duktape/duk_source_meta.json Normal file
View File

File diff suppressed because it is too large Load Diff

99762
lib/duktape/duktape.c Normal file
View File

File diff suppressed because it is too large Load Diff

1450
lib/duktape/duktape.h Normal file
View File

File diff suppressed because it is too large Load Diff

1
lib/glad2 Submodule

Submodule lib/glad2 added at 369fba4abb

1
lib/glfw Submodule

Submodule lib/glfw added at 6ed5294223

446
platform/gbm/gbm.c
View File

@ -1,446 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "gbm.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
#include <gbm.h>
#define GL_GLEXT_PROTOTYPES 1
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <assert.h>
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
static struct {
EGLDisplay display;
EGLConfig config;
EGLContext context;
EGLSurface surface;
GLuint program;
GLint modelviewmatrix, modelviewprojectionmatrix, normalmatrix;
GLuint vbo;
GLuint positionsoffset, colorsoffset, normalsoffset;
} gl;
static struct {
struct gbm_device *dev;
struct gbm_surface *surface;
} gbm;
static struct {
int fd;
drmModeModeInfo *mode;
uint32_t crtc_id;
uint32_t connector_id;
} drm;
struct drm_fb {
struct gbm_bo *bo;
uint32_t fb_id;
};
static uint32_t find_crtc_for_encoder(
const drmModeRes *resources, const drmModeEncoder *encoder
) {
int i;
for (i = 0; i < resources->count_crtcs; i++) {
/* possible_crtcs is a bitmask as described here:
* https://dvdhrm.wordpress.com/2012/09/13/linux-drm-mode-setting-api
*/
const uint32_t crtc_mask = 1 << i;
const uint32_t crtc_id = resources->crtcs[i];
if(encoder->possible_crtcs & crtc_mask) {
return crtc_id;
}
}
/* no match found */
return -1;
}
static uint32_t find_crtc_for_connector(
const drmModeRes *resources, const drmModeConnector *connector
) {
int i;
for (i = 0; i < connector->count_encoders; i++) {
const uint32_t encoder_id = connector->encoders[i];
drmModeEncoder *encoder = drmModeGetEncoder(drm.fd, encoder_id);
if(encoder) {
const uint32_t crtc_id = find_crtc_for_encoder(resources, encoder);
drmModeFreeEncoder(encoder);
if(crtc_id != 0) {
return crtc_id;
}
}
}
/* no match found */
return -1;
}
static void drm_fb_destroy_callback(struct gbm_bo *bo, void *data) {
struct drm_fb *fb = data;
struct gbm_device *gbm = gbm_bo_get_device(bo);
if(fb->fb_id) drmModeRmFB(drm.fd, fb->fb_id);
free(fb);
}
static struct drm_fb * drm_fb_get_from_bo(struct gbm_bo *bo) {
struct drm_fb *fb = gbm_bo_get_user_data(bo);
uint32_t width, height, stride, handle;
int ret;
if(fb)
return fb;
fb = calloc(1, sizeof *fb);
fb->bo = bo;
width = gbm_bo_get_width(bo);
height = gbm_bo_get_height(bo);
stride = gbm_bo_get_stride(bo);
handle = gbm_bo_get_handle(bo).u32;
ret = drmModeAddFB(drm.fd, width, height, 24, 32, stride, handle, &fb->fb_id);
if(ret) {
printf("failed to create fb: %s\n", strerror(errno));
free(fb);
return NULL;
}
gbm_bo_set_user_data(bo, fb, drm_fb_destroy_callback);
return fb;
}
static void page_flip_handler(
int fd, unsigned int frame, unsigned int sec, unsigned int usec, void *data
) {
int *waiting_for_flip = data;
*waiting_for_flip = 0;
}
static int32_t drmInit(void) {
drmModeRes *resources;
drmModeConnector *connector = NULL;
drmModeEncoder *encoder = NULL;
int i, area;
drm.fd = open("/dev/dri/card0", O_RDWR);
if(drm.fd < 0) {
printf("could not open drm device\n");
return -1;
}
resources = drmModeGetResources(drm.fd);
if(!resources) {
printf("drmModeGetResources failed: %s\n", strerror(errno));
return -1;
}
// Find an existing connected connector.
for (i = 0; i < resources->count_connectors; i++) {
connector = drmModeGetConnector(drm.fd, resources->connectors[i]);
if(connector->connection == DRM_MODE_CONNECTED) break;
drmModeFreeConnector(connector);
connector = NULL;
}
// Did we find a connector?
if(!connector) {
printf("No connected connector!\n");
return -1;
}
// Now get the mode to use, based on resolution.
for (i = 0, area = 0; i < connector->count_modes; i++) {
drmModeModeInfo *current_mode = &connector->modes[i];
if(current_mode->type & DRM_MODE_TYPE_PREFERRED) drm.mode = current_mode;
int current_area = current_mode->hdisplay * current_mode->vdisplay;
if(current_area > area) {
drm.mode = current_mode;
area = current_area;
}
}
// Did we find the best mode?
if(!drm.mode) {
printf("could not find mode!\n");
return -1;
}
// Now find a display encoder
for (i = 0; i < resources->count_encoders; i++) {
encoder = drmModeGetEncoder(drm.fd, resources->encoders[i]);
if(encoder->encoder_id == connector->encoder_id) break;
drmModeFreeEncoder(encoder);
encoder = NULL;
}
// Is there an encoder?
if(encoder) {
drm.crtc_id = encoder->crtc_id;
} else {
// No, use a CRTC
uint32_t crtc_id = find_crtc_for_connector(resources, connector);
if(crtc_id == 0) {
printf("no crtc found!\n");
return -1;
}
drm.crtc_id = crtc_id;
}
// Update the DRM with the new connector ID.
drm.connector_id = connector->connector_id;
return 0;
}
static int32_t gbmInit(void) {
gbm.dev = gbm_create_device(drm.fd);
gbm.surface = gbm_surface_create(
gbm.dev,
drm.mode->hdisplay, drm.mode->vdisplay,
GBM_FORMAT_XRGB8888,
GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING
);
if(!gbm.surface) {
printf("failed to create gbm surface\n");
return -1;
}
return 0;
}
static int32_t glInit(void) {
EGLint major, minor, n;
GLuint vertex_shader, fragment_shader;
GLint ret;
// Set up the attributes for the EGL
static const EGLint context_attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
static const EGLint config_attribs[] = {
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RED_SIZE, 1,
EGL_GREEN_SIZE, 1,
EGL_BLUE_SIZE, 1,
EGL_ALPHA_SIZE, 0,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
// Get the "display getter".
PFNEGLGETPLATFORMDISPLAYEXTPROC getDisplay = NULL;
getDisplay = (void *)eglGetProcAddress("eglGetPlatformDisplayEXT");
if(getDisplay == NULL) {
printf("Failed to get GBM-EGL Display.\n");
return -1;
}
// Now get the display with that getter.
gl.display = getDisplay(EGL_PLATFORM_GBM_KHR, gbm.dev, NULL);
// Initialize EGL
if(!eglInitialize(gl.display, &major, &minor)) {
printf("failed to initialize\n");
return -1;
}
// Bind OpenGL API
if(!eglBindAPI(EGL_OPENGL_ES_API)) {
printf("Failed to bind api\n");
return -1;
}
if(!eglChooseConfig(gl.display, config_attribs, &gl.config, 1, &n) || n != 1) {
printf("failed to choose config: %d\n", n);
return -1;
}
// Create a new EGL Context.
gl.context = eglCreateContext(
gl.display, gl.config, EGL_NO_CONTEXT, context_attribs
);
if(gl.context == NULL) {
printf("failed to create context\n");
return -1;
}
// Create the EGL Surface to render to.
gl.surface = eglCreateWindowSurface(gl.display, gl.config, gbm.surface, NULL);
if(gl.surface == EGL_NO_SURFACE) {
printf("failed to create egl surface\n");
return -1;
}
// Update the current EGL Context
eglMakeCurrent(gl.display, gl.surface, gl.surface, gl.context);
printf("GL Extensions: \"%s\"\n", glGetString(GL_EXTENSIONS));
return 0;
}
void gbmUpdateResolution(game_t *game) {
// Get the surface dimensions
EGLint width;
EGLint height;
eglQuerySurface(gl.display, gl.surface, EGL_WIDTH,&width);
eglQuerySurface(gl.display, gl.surface, EGL_HEIGHT,&height);
bool needsUpdating = (
(width != game->engine.render.width) ||
(height != game->engine.render.height
);
if(!needsUpdating) return;
renderSetResolution(&game->engine.render, (int32_t)width, (int32_t)height);
}
int32_t main(int argc, char *argv[]) {
fd_set fds;
drmEventContext evctx = {
.version = DRM_EVENT_CONTEXT_VERSION,
.page_flip_handler = page_flip_handler,
};
struct gbm_bo *bo;
struct drm_fb *fb;
int32_t ret;
// Init the DRM
ret = drmInit();
if(ret) {
printf("failed to initialize DRM\n");
return ret;
}
// ???
FD_ZERO(&fds);
FD_SET(0, &fds);
FD_SET(drm.fd, &fds);
// Init the GBM
ret = gbmInit();
if(ret) {
printf("failed to initialize GBM\n");
return ret;
}
// Now Initialize OpenGL/OpenGL ES
ret = glInit();
if(ret) {
printf("failed to initialize EGL\n");
return ret;
}
// Do a once clear of the color buffer
eglSwapBuffers(gl.display, gl.surface);
// Now uh?
bo = gbm_surface_lock_front_buffer(gbm.surface);
fb = drm_fb_get_from_bo(bo);
// ?
ret = drmModeSetCrtc(
drm.fd, drm.crtc_id, fb->fb_id, 0, 0, &drm.connector_id, 1, drm.mode
);
if(ret) {
printf("failed to set mode: %s\n", strerror(errno));
return ret;
}
// Init Game
game_t *game = malloc(sizeof(game_t));
printf("Game is %zu bytes.\n", sizeof(game_t));
gbmUpdateResolution(game);
// Get the surface dimensions
if(!gameInit(game)) {
printf("Game Init Error\n");
return 1;
}
while (1) {
struct gbm_bo *next_bo;
int waiting_for_flip = 1;
// Draw
float fDelta = 0.016f;
gbmUpdateResolution(game);
if(!gameUpdate(game, fDelta)) break;
// Drawn
// Swap the EGL Buffers
eglSwapBuffers(gl.display, gl.surface);
// Now do a back buffer flip
next_bo = gbm_surface_lock_front_buffer(gbm.surface);
fb = drm_fb_get_from_bo(next_bo);
// ?
ret = drmModePageFlip(drm.fd, drm.crtc_id, fb->fb_id,
DRM_MODE_PAGE_FLIP_EVENT, &waiting_for_flip
);
if(ret) {
printf("Failed to queue page flip: %s\n", strerror(errno));
return -1;
}
// ?
while(waiting_for_flip) {
ret = select(drm.fd + 1, &fds, NULL, NULL, NULL);
if(ret < 0) {
printf("select err: %s\n", strerror(errno));
return ret;
} else if(ret == 0) {
printf("select timeout!\n");
return -1;
} else if(FD_ISSET(0, &fds)) {
printf("user interrupted!\n");
break;
}
drmHandleEvent(drm.fd, &evctx);
}
// ?
gbm_surface_release_buffer(gbm.surface, bo);
bo = next_bo;
}
// Game has finished running, cleanup.
gameDispose(game);
free(game);
return ret;
}

34
platform/gbm/gbm.h
View File

@ -1,34 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
#include <gbm.h>
#define GL_GLEXT_PROTOTYPES 1
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <assert.h>
#include <dawn/dawn.h>
#include "../../src/display/render.h"
#include "../../src/game/game.h"
#include "../../src/input/input.h"
int32_t main(int32_t argc, char *argv[]);

153
platform/sdl/sdl.c
View File

@ -1,153 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "sdl.h"
game_t *GAME_STATE;
int32_t main(int32_t argc, char *argv[]) {
game_t *game;
input_t *input;
SDL_GLContext context;
SDL_Window* displayWindow;
SDL_Event event;
SDL_Renderer* renderer;
bool running;
uint32_t currentTime;
uint32_t lastTime;
float timeDelta;
// Init SEDL
if(SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("No init SDL\n");
return 1;
}
// Setup GL Information.
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, OPENGL_MAJOR_VERSION);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, OPENGL_MINOR_VERSION);
// Create a window
displayWindow = SDL_CreateWindow("test",
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
SCREEN_WIDTH, SCREEN_HEIGHT,
SDL_WINDOW_OPENGL | SDL_RENDERER_ACCELERATED
// SDL_WINDOW_OPENGL | SDL_RENDERER_ACCELERATED | SDL_WINDOW_FULLSCREEN
);
if(displayWindow == NULL) {
printf("No make window %s\n", SDL_GetError());
return 1;
}
// Create Renderer
renderer = SDL_CreateRenderer(displayWindow, -1, SDL_RENDERER_ACCELERATED);
if(renderer == NULL) {
printf("SDL2 Renderer couldn't be created. Error: %s\n", SDL_GetError());
return 1;
}
// Create a GL Context
context = SDL_GL_CreateContext(displayWindow);
if(context == NULL) {
printf("No make context\n");
return 1;
}
#if SETTING_PLATFORM_USE_GLAD == 1
// Load glad
if (!gladLoadGLLoader((GLADloadproc) SDL_GL_GetProcAddress)) {
printf("Failed to initialize the OpenGL context.\n");
return 1;
}
#endif
// Bind the GL Context
SDL_GL_MakeCurrent(displayWindow, context);
// SDL Time management init
currentTime = SDL_GetTicks();
lastTime = currentTime - EPOCH_FIXED_STEP;
// Initialize the game
game = malloc(sizeof(game_t));
GAME_STATE = game;
printf("Game is %zu bytes.\n", sizeof(game_t));
renderSetResolution(&game->engine.render, SCREEN_WIDTH, SCREEN_HEIGHT);
if(gameInit(game)) {
input = &game->engine.input;
// Bind initial keys
inputBind(input, INPUT_NULL, (inputsource_t)SDLK_ESCAPE);
inputBind(input, INPUT_DEBUG_UP, (inputsource_t)SDLK_w);
inputBind(input, INPUT_DEBUG_DOWN, (inputsource_t)SDLK_s);
inputBind(input, INPUT_DEBUG_LEFT, (inputsource_t)SDLK_a);
inputBind(input, INPUT_DEBUG_RIGHT, (inputsource_t)SDLK_d);
inputBind(input, INPUT_UP, (inputsource_t)SDLK_UP);
inputBind(input, INPUT_DOWN, (inputsource_t)SDLK_DOWN);
inputBind(input, INPUT_LEFT, (inputsource_t)SDLK_LEFT);
inputBind(input, INPUT_RIGHT, (inputsource_t)SDLK_RIGHT);
inputBind(input, INPUT_UP, (inputsource_t)SDLK_w);
inputBind(input, INPUT_DOWN, (inputsource_t)SDLK_s);
inputBind(input, INPUT_LEFT, (inputsource_t)SDLK_a);
inputBind(input, INPUT_RIGHT, (inputsource_t)SDLK_d);
inputBind(input, INPUT_ACCEPT, (inputsource_t)SDLK_e);
inputBind(input, INPUT_ACCEPT, (inputsource_t)SDLK_RETURN);
inputBind(input, INPUT_ACCEPT, (inputsource_t)SDLK_SPACE);
// Update window title.
SDL_SetWindowTitle(displayWindow, SETTING_GAME_NAME);
running = true;
while(running) {
// Poll for SDL Events
while(SDL_PollEvent(&event)) {
switch(event.type) {
case SDL_QUIT:
running = false;
break;
case SDL_KEYDOWN:
input->buffer[(inputsource_t)event.key.keysym.sym] = true;
break;
case SDL_KEYUP:
input->buffer[(inputsource_t)event.key.keysym.sym] = false;
break;
default:
break;
}
}
if(!running) break;
// Calc time delta
lastTime = currentTime;
currentTime = SDL_GetTicks();
timeDelta = (currentTime - lastTime) / 1000.0f;
// Tick Game
if(!gameUpdate(game, timeDelta)) break;
// Swap buffers
SDL_GL_SwapWindow(displayWindow);
}
// Game has finished running, cleanup.
gameDispose(game);
}
free(game);
// Cleanup SDL
SDL_GL_DeleteContext(context);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(displayWindow);
SDL_Quit();
return 0;
}

20
platform/sdl/sdl.h
View File

@ -1,20 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include <dawn/dawn.h>
#include "../../src/display/render.h"
#include "../../src/game/game.h"
#include "../../src/input/input.h"
#define SCREEN_WIDTH 480
#define SCREEN_HEIGHT 320
#define OPENGL_MAJOR_VERSION 2
#define OPENGL_MINOR_VERSION 1
int32_t main(int32_t argc, char *argv[]);

70
scripts/bundle.js
View File

@ -1,70 +0,0 @@
const path = require('path');
const fs = require('fs');
const DIR_BUILT_SCRIPTS = path.join('build', 'scripts');
const DIR_OUT = path.join('build', 'assets', 'scripts');
const FILE_MAIN = 'main.js';
let doneFiles = [];
let full = `
var exports = {};
function __extends(d,b) {
d.prototype = b.prototype;
}
`;
const CRUMMY_EXTENDS = /var __extends =([\S\s]*?)\}\)\(\)\;/gm;
const ES5_DEFINED = /Object\.defineProperty\(exports, \"__esModule\", \{ value\: true \}\)\;/gm
const outputFix = (output, dir) => {
let out = output
.replace(CRUMMY_EXTENDS, '')
.replace(/exports\.\_\_esModule\ =\ true\;/gm, '')
;
// Replace requires with exports.
const reg = /var\ (.*?)\ \= require\("(.*?)"\)\;/gm;
const matches = out.matchAll(reg);
let match;
while(!(match = matches.next()).done) {
const exp = new RegExp(`${match.value[1]}\.`, 'gm');
const filePath = path.join(dir, match.value[2]);
scanFile(filePath, path.dirname(filePath));
out = out.replace(match.value[0], '').replace(exp, 'exports.');
}
out = out
.replace(CRUMMY_EXTENDS, '')
.replace(ES5_DEFINED, '')
.replace(/exports\.(.*?) \= void 0\;/gm, '')
.replace(/\ \ \ \ /gm, ' ')
;
return out;
}
const scanFile = (file, dir) => {
if(!file.endsWith('.js')) file += '.js';
if(doneFiles.indexOf(file) !== -1) return;
doneFiles.push(file);
const contents = fs.readFileSync(file, 'utf-8');
const f = outputFix(contents, dir);
full = full + `\n//${file}\n` + f;
}
const scanDir = dir => fs.readdirSync(dir).forEach(file => {
if(!file.endsWith('.js')) return;
const joint = path.join(DIR_BUILT_SCRIPTS, file);
const stat = fs.statSync(joint);
if(stat.isDirectory()) {
scanDir(joint);
} else {
scanFile(joint, dir);
}
});
scanFile(path.join(DIR_BUILT_SCRIPTS, FILE_MAIN), DIR_BUILT_SCRIPTS);
if(!fs.existsSync(DIR_OUT)) fs.mkdirSync(DIR_OUT);
fs.writeFileSync(path.join(DIR_OUT, FILE_MAIN), full);

30
src/CMakeLists.txt Normal file
View File

@ -0,0 +1,30 @@
# Copyright (c) 2021 Dominic Msters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Add Sources
file(GLOB_RECURSE SOURCES *.c)
add_library(src STATIC ${SOURCES})
target_include_directories(src PUBLIC ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(src PUBLIC
glfw
cglm
stb
cglm
duktape
glad_gl_core_33
)
# Set up flags
target_compile_definitions(src PRIVATE
SETTING_PLATFORM_GLFW=1
SETTING_PLATFORM=1
SETTING_PLATFORM_USE_GLAD=1
SETTING_ASSET_PREFIX="../assets/"
SETTING_GAME_NAME="DawnGame"
SETTING_GAME_POKER=1
SETTING_GAME_DAWN=2
SETTING_GAME_SANDBOX=3
SETTING_GAME=1
)

0
src/config.h Normal file
View File

3
src/engine/engine.h
View File

@ -13,6 +13,9 @@
#include "../display/render.h"
typedef struct {
/** Name of the game */
char *name;
/** Time Manager for the game */
epoch_t time;

27
src/libs.h
View File

@ -5,33 +5,15 @@
#pragma once
// Settings
#include "config.h"
// Static Libs
#include <cglm/cglm.h>
#include <glad/gl.h>
#include <GLFW/glfw3.h>
#include <duktape.h>
#if SETTING_PLATFORM_USE_GLAD == 1
#include <glad/glad.h>
#else
#include <GL/gl.h>
#endif
#if SETTING_PLATFORM == SETTING_PLATFORM_GLFW
#include <GLFW/glfw3.h>
#elif SETTING_PLATFORM == SETTING_PLATFORM_SDL
#include "SDL.h"
#include "SDL_opengl.h"
#elif SETTING_PLATFORM == SETTING_PLATFORM_GBM
#include <xf86drm.h>
#include <xf86drmMode.h>
#include <gbm.h>
#endif
#include <cglm/cglm.h>
#include <stb_image.h>
#include <stb_truetype.h>
// Standard Libs
#include <stdio.h>
#include <stdint.h>
@ -51,5 +33,6 @@
# define sleep(n) _sleep(n)
#endif
#else
// Unix Fixes
#include <unistd.h>
#endif