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

Added AABB Point

Browse Source
This commit is contained in:
Dominic Masters
2021-08-17 08:25:20 -07:00
parent e426ca69f0
commit 1b90e20187
20 changed files with 310 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
CMakeLists.txt
View File

@ -24,9 +24,9 @@ set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/modules)
set(SETTING_PLATFORM_GLFW 1)
set(SETTING_PLATFORM_SDL 2)
set(SETTING_PLATFORM_GBM 3)
set(SETTING_PLATFORM SETTING_PLATFORM_GBM)
set(SETTING_PLATFORM SETTING_PLATFORM_GLFW)
set(SETTING_USE_GLAD 0)
set(SETTING_USE_GLAD 1)
# Game Settings
set(SETTING_GAME_POKER 1)
@ -86,7 +86,6 @@ add_executable(${PROJECT_NAME} ${HEADER_FILES} ${SOURCE_FILES})
# Math
if(NOT WIN32)
target_link_libraries(${PROJECT_NAME} m)
target_link_libraries(${PROJECT_NAME} ${CMAKE_DL_LIBS})
endif()
# GLAD
@ -126,15 +125,14 @@ endif()
# CGLM
add_subdirectory(${CMAKE_SOURCE_DIR}/lib/cglm)
# if(NOT cglm_FOUND)
# FetchContent_Declare(
# cglm
# GIT_REPOSITORY https://github.com/recp/cglm
# GIT_TAG v0.8.3
# )
# FetchContent_MakeAvailable(cglm)
# endif()
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)
# OpenGL

3
include/dawn/dawn.h
View File

@ -51,6 +51,9 @@
// Locales
#include "locale/language.h"
// Physics
#include "physics/aabb.h"
// Poker Game Logic
#include "poker/turn.h"
#include "poker/bet.h"

9
include/dawn/input/input.h
View File

@ -19,6 +19,10 @@
#define INPUT_DEBUG_PLUS (inputbind_t)0x08
#define INPUT_DEBUG_MINUS (inputbind_t)0x09
/** Reserved Inputs (Starts at 64) */
#define INPUT_MOUSE_X (inputbind_t)0x40
#define INPUT_MOUSE_Y (inputbind_t)0x41
/** Real Inputs (Starts at 128/0x80) */
#define INPUT_UP (inputbind_t)0x80
#define INPUT_DOWN (inputbind_t)0x81
@ -26,9 +30,8 @@
#define INPUT_RIGHT (inputbind_t)0x83
#define INPUT_ACCEPT (inputbind_t)0x84
#define INPUT_BIND_COUNT 0xFF
#define INPUT_SOURCE_COUNT 0xFF
#define INPUT_SOURCE_COUNT 1024
/**
* Input Bind, a specific action bind reference for the game engine to use.
@ -41,7 +44,7 @@ typedef uint8_t inputbind_t;
* hell this number refers to. For most platforms it will be an input, such as a
* keyboard scancode or a (pad number * button count) + button.
*/
typedef uint8_t inputsource_t;
typedef uint16_t inputsource_t;
/**
* Value that represents the state of an input. Defined as 0-1 where 0 is set

3
include/dawn/libs.h
View File

@ -16,6 +16,7 @@
#endif
#if SETTING_PLATFORM == SETTING_PLATFORM_GLFW
#include <GLFW/glfw3.h>
#elif SETTING_PLATFORM == SETTING_PLATFORM_SDL
#include <SDL2/SDL.h>
#include <SDL2/SDL_opengl.h>
@ -41,6 +42,7 @@
#include <stdbool.h>
#include <malloc.h>
#include <string.h>
#include <math.h>
#if defined(_WIN32) || defined(_WIN64)
// Windows Fixes
@ -48,5 +50,4 @@
# define sleep(n) _sleep(n)
#else
#include <unistd.h>
#include <math.h>
#endif

16
include/dawn/physics/aabb.h Normal file
View File

@ -0,0 +1,16 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
typedef struct {
float hitX;
float hitY;
float normalX;
float normalY;
} aabbpointhit_t;

3
include/dawn/util/math.h
View File

@ -15,4 +15,5 @@
#define mathMin(a,b) (a>b?b:a)
#define mathAbs(n) (n<0?-n:n)
#define mathDeg2Rad(n) (n * M_PI / 180.0)
#define mathRad2Deg(n) (n * 180 / M_PI)
#define mathRad2Deg(n) (n * 180 / M_PI)
#define mathSign(n) (n>=0 ? 1 : -1)

59
platform/glfw/glwfwplatform.c
View File

@ -17,8 +17,8 @@ int32_t main() {
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, false);
// Create Window
window = glfwCreateWindow(WINDOW_WIDTH_DEFAULT, WINDOW_HEIGHT_DEFAULT,
"", NULL, NULL
window = glfwCreateWindow(
WINDOW_WIDTH_DEFAULT, WINDOW_HEIGHT_DEFAULT, "", NULL, NULL
);
if(!window) {
glfwTerminate();
@ -33,8 +33,8 @@ int32_t main() {
// Setup window listeners
glfwSetWindowSizeCallback(window, &glfwOnResize);
glfwSetKeyCallback(window, &glfwOnKey);
glfwSetErrorCallback(&glfwOnError);
glfwSetCursorPosCallback(window, &glfwOnCursor);
// Prepare the game
game_t *game = malloc(sizeof(game_t));
@ -51,28 +51,33 @@ int32_t main() {
// Init the game
if(gameInit(game)) {
// Bind initial keys
inputBind(input, INPUT_NULL, (inputsource_t)GLFW_KEY_ESCAPE);
inputBind(input, INPUT_DEBUG_UP, (inputsource_t)GLFW_KEY_W);
inputBind(input, INPUT_DEBUG_DOWN, (inputsource_t)GLFW_KEY_S);
inputBind(input, INPUT_DEBUG_LEFT, (inputsource_t)GLFW_KEY_A);
inputBind(input, INPUT_DEBUG_RIGHT, (inputsource_t)GLFW_KEY_D);
inputBind(input, INPUT_DEBUG_RAISE, (inputsource_t)GLFW_KEY_Q);
inputBind(input, INPUT_DEBUG_LOWER, (inputsource_t)GLFW_KEY_E);
inputBind(input, INPUT_DEBUG_FINE, (inputsource_t)GLFW_KEY_LEFT_CONTROL);
inputBind(input, INPUT_DEBUG_PLUS, (inputsource_t)GLFW_KEY_EQUAL);
inputBind(input, INPUT_DEBUG_MINUS, (inputsource_t)GLFW_KEY_MINUS);
inputBind(input, INPUT_NULL, (inputsource_t)GLFW_KEY_ESCAPE);
inputBind(input, INPUT_DEBUG_UP, (inputsource_t)GLFW_KEY_W);
inputBind(input, INPUT_DEBUG_DOWN, (inputsource_t)GLFW_KEY_S);
inputBind(input, INPUT_DEBUG_LEFT, (inputsource_t)GLFW_KEY_A);
inputBind(input, INPUT_DEBUG_RIGHT, (inputsource_t)GLFW_KEY_D);
inputBind(input, INPUT_DEBUG_RAISE, (inputsource_t)GLFW_KEY_Q);
inputBind(input, INPUT_DEBUG_LOWER, (inputsource_t)GLFW_KEY_E);
inputBind(input, INPUT_DEBUG_FINE, (inputsource_t)GLFW_KEY_LEFT_CONTROL);
inputBind(input, INPUT_DEBUG_PLUS, (inputsource_t)GLFW_KEY_EQUAL);
inputBind(input, INPUT_DEBUG_MINUS, (inputsource_t)GLFW_KEY_MINUS);
inputBind(input, INPUT_UP, (inputsource_t)GLFW_KEY_UP);
inputBind(input, INPUT_DOWN, (inputsource_t)GLFW_KEY_DOWN);
inputBind(input, INPUT_LEFT, (inputsource_t)GLFW_KEY_LEFT);
inputBind(input, INPUT_RIGHT, (inputsource_t)GLFW_KEY_RIGHT);
inputBind(input, INPUT_UP, (inputsource_t)GLFW_KEY_W);
inputBind(input, INPUT_DOWN, (inputsource_t)GLFW_KEY_S);
inputBind(input, INPUT_LEFT, (inputsource_t)GLFW_KEY_A);
inputBind(input, INPUT_RIGHT, (inputsource_t)GLFW_KEY_D);
inputBind(input, INPUT_ACCEPT, (inputsource_t)GLFW_KEY_E);
inputBind(input, INPUT_ACCEPT, (inputsource_t)GLFW_KEY_ENTER);
inputBind(input, INPUT_ACCEPT, (inputsource_t)GLFW_KEY_SPACE);
inputBind(input, INPUT_UP, (inputsource_t)GLFW_KEY_UP);
inputBind(input, INPUT_DOWN, (inputsource_t)GLFW_KEY_DOWN);
inputBind(input, INPUT_LEFT, (inputsource_t)GLFW_KEY_LEFT);
inputBind(input, INPUT_RIGHT, (inputsource_t)GLFW_KEY_RIGHT);
inputBind(input, INPUT_UP, (inputsource_t)GLFW_KEY_W);
inputBind(input, INPUT_DOWN, (inputsource_t)GLFW_KEY_S);
inputBind(input, INPUT_LEFT, (inputsource_t)GLFW_KEY_A);
inputBind(input, INPUT_RIGHT, (inputsource_t)GLFW_KEY_D);
inputBind(input, INPUT_ACCEPT, (inputsource_t)GLFW_KEY_E);
inputBind(input, INPUT_ACCEPT, (inputsource_t)GLFW_KEY_ENTER);
inputBind(input, INPUT_ACCEPT, (inputsource_t)GLFW_KEY_SPACE);
// Bind the fake inputs
inputBind(input, INPUT_MOUSE_X, (inputsource_t)INPUT_MOUSE_X);
inputBind(input, INPUT_MOUSE_Y, (inputsource_t)INPUT_MOUSE_Y);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
// Update the window title.
glfwSetWindowTitle(window, SETTING_GAME_NAME);
@ -123,4 +128,10 @@ void glfwOnKey(GLFWwindow *window,
void glfwOnError(int error, const char* description) {
fputs(description, stderr);
}
void glfwOnCursor(GLFWwindow *window, double x, double y) {
input_t *input = &GAME_STATE->engine.input;
input->buffer[INPUT_MOUSE_X] = x;
input->buffer[INPUT_MOUSE_Y] = y;
}

8
platform/glfw/glwfwplatform.h
View File

@ -5,11 +5,6 @@
#pragma once
// I load GLAD and GLFW Here because they need to be included in specific orders
#if SETTING_USE_GLAD == 1
#include <glad/glad.h>
#endif
#include <GLFW/glfw3.h>
#include <dawn/dawn.h>
#include "../../src/display/render.h"
#include "../../src/game/game.h"
@ -49,4 +44,5 @@ void glfwOnKey(GLFWwindow *window,
);
void glfwOnError(int error, const char* description);
void glfwOnError(int error, const char* description);
void glfwOnCursor(GLFWwindow *window, double x, double y);

8
src/display/framebuffer.c
View File

@ -25,11 +25,11 @@ void frameBufferInit(framebuffer_t *fb, int32_t w, int32_t h) {
// Render Buffer
glGenRenderbuffers(1, &fb->rboId);
glBindRenderbuffer(GL_RENDERBUFFER, fb->rboId);
// glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, w, h);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, w, h);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
// glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
// GL_RENDERBUFFER, fb->rboId
// );
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
GL_RENDERBUFFER, fb->rboId
);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
uint32_t error;

2
src/display/render.c
View File

@ -18,7 +18,7 @@ void renderInit() {
glDepthMask(GL_TRUE);
glDepthFunc(GL_LEQUAL);
glClearColor(1.0, 0, 0, 1.0);
glClearColor(0,0,0, 1.0);
}
void renderFrameStart(render_t *render) {

5
src/game/game.c
View File

@ -7,6 +7,11 @@
#include "game.h"
#include "../physics/vector.h"
primitive_t primitive;
texture_t texture;
bool gameInit(game_t *game) {
// Init the engine and the rendering pipeline
engineInit(&game->engine, game);

32
src/game/poker/pokergame.c
View File

@ -7,6 +7,10 @@
#include "pokergame.h"
primitive_t primitive;
primitive_t dot;
float x, y;
bool pokerGameInit(game_t *game) {
pokergame_t *pokerGame = &game->pokerGame;
@ -21,6 +25,11 @@ bool pokerGameInit(game_t *game) {
pokerGameActionStartAdd(pokerGame);
queueNext(&pokerGame->scene.conversation.actionQueue);
//
quadInit(&primitive, 0, 0,0,0,0, 64,64,1,1);
quadInit(&dot, 0, 0,0,0,0, 2,2,1,1);
x = 0, y = 0;
return true;
}
@ -29,7 +38,7 @@ void pokerGameUpdate(game_t *game) {
pokerGame = &game->pokerGame;
// Update the scene
vnSceneUpdate(&pokerGame->scene, &game->engine);
// vnSceneUpdate(&pokerGame->scene, &game->engine);
// Bind the shader.
shaderUse(&pokerGame->assets.shader);
@ -38,7 +47,26 @@ void pokerGameUpdate(game_t *game) {
// Render the visual novel scene
// vnSceneRenderWorld(&pokerGame->scene, &game->engine, &pokerGame->assets.shader);
vnSceneRenderGui(&pokerGame->scene, &game->engine, &pokerGame->assets.shader);
pokerUiRender(pokerGame);
shaderUseTexture(&pokerGame->assets.shader, &pokerGame->assets.testTexture);
x = inputGetAxis(&game->engine.input, INPUT_MOUSE_X);
y = inputGetAxis(&game->engine.input, INPUT_MOUSE_Y);
aabbpointhit_t hitting;
bool hit = aabbPoint2D(x, y, 64,64, 64,64, &hitting);
shaderUsePosition(&pokerGame->assets.shader, 64,64,0, 0,0,0);
primitiveDraw(&primitive, 0, -1);
if(hit) {
shaderUsePosition(&pokerGame->assets.shader, hitting.hitX,hitting.hitY,0, 0,0,0);
} else {
shaderUsePosition(&pokerGame->assets.shader, x,y,0, 0,0,0);
}
primitiveDraw(&dot, 0, -1);
// pokerUiRender(pokerGame);
}
void pokerGameDispose(game_t *game) {

2
src/game/poker/pokergame.h
View File

@ -15,6 +15,8 @@
#include "pokerui.h"
#include "../../ui/frame.h"
#include "../../physics/aabb.h"
#include "../../input/input.h"
/**
* Initializes the game state for the poker game.

57
src/physics/aabb.c Normal file
View File

@ -0,0 +1,57 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "aabb.h"
bool aabbPoint2D(
float pointX, float pointY,
float x, float y, float width, float height,
aabbpointhit_t *hit
) {
float dx, px, sx, halfWidth;
float dy, py, sy, halfHeight;
if(hit == NULL) {
// Check X Axis, are we outside the box
if(pointX < x || pointY < y) return false;
if(pointX > x+width || pointY > y+height) return false;
return true;
}
halfWidth = width / 2;
halfHeight = height / 2;
x += halfWidth;
y += halfHeight;
dx = pointX - x;
px = halfWidth - mathAbs(dx);
if(px <= 0) return false;
dy = pointY - y;
py = halfHeight - mathAbs(dy);
if(py <= 0) return false;
if(px < py) {
sx = mathSign(dx);
// float deltaX = px *sx;
hit->normalX = sx;
hit->normalY = 0;
hit->hitX = x + (halfWidth * sx);
hit->hitY = pointY;
} else {
sy = mathSign(dy);
// float deltaY = py * sy;
hit->normalX = 0;
hit->normalY = sy;
hit->hitX = pointX;
hit->hitY = x + (halfHeight * sy);
}
return true;
}

17
src/physics/aabb.h Normal file
View File

@ -0,0 +1,17 @@
/**
* 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 "sphere.h"
#include "../input/input.h"
bool aabbPoint2D(
float pointX, float pointY,
float x, float y, float width, float height,
aabbpointhit_t *hit
);

20
src/physics/sphere.c Normal file
View File

@ -0,0 +1,20 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "sphere.h"
bool sphereDistance2D(float x0, float y0, float x1, float y1, float radius) {
x0 = vectorDistance2D(x0, y0, x1, y1);
return x0 <= radius;
}
bool sphereDistance3D(
float x0, float y0, float z0, float x1, float y1, float z1, float radius
) {
x0 = vectorDistance3D(x0, y0, z0, x1, y1, z1);
return x0 <= radius;
}

38
src/physics/sphere.h Normal file
View File

@ -0,0 +1,38 @@
/**
* 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 "vector.h"
/**
* Checks whether a point is colliding with a circle.
*
* @param x0 X Position of the vector.
* @param y0 Y position of the vector.
* @param x1 Center point of the circle. X Coordinate.
* @param y1 Center point of the circle. Y Coordinate.
* @param radius Radius of the circle
* @return True if the point is colliding, otherwise false.
*/
bool sphereDistance2D(float x0, float y0, float x1, float y1, float radius);
/**
* Checks whether a point is colliding with a sphere.
*
* @param x0 X Position of the vector.
* @param y0 Y Position of the vector.
* @param z0 Z Position of the vector.
* @param x1 Center point of the circle, X Coordinate.
* @param y1 Center point of the circle, Y Coordinate.
* @param z1 Center point of the circle, Z Coordinate.
* @param radius Radius of the sphere.
* @return True if the point is colliding with the sphere.
*/
bool sphereDistance3D(
float x0, float y0, float z0, float x1, float y1, float z1, float radius
);

24
src/physics/vector.c Normal file
View File

@ -0,0 +1,24 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "vector.h"
float vectorDistance2D(float x0, float y0, float x1, float y1) {
x0 = x1 - x0;
y0 = y1 - y0;
return sqrt(x0*x0 + y0*y0);
}
float vectorDistance3D(
float x0, float y0, float z0, float x1, float y1, float z1
) {
x0 = x1 - x0;
y0 = y1 - y0;
z0 = z1 - z0;
return sqrt(x0*x0 + y0*y0 + z0*z0);
}

35
src/physics/vector.h Normal file
View File

@ -0,0 +1,35 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include <dawn/dawn.h>
/**
* Calculate the distance between two points in 2D space.
*
* @param x0 First Position X Coordinate.
* @param y0 First Position Y Coordinate.
* @param x1 Second Position X Coordinate.
* @param y1 Second Position Y Coordinate.
* @return The distance measurement.
*/
float vectorDistance2D(float x0, float y0, float x1, float y1);
/**
* Calculate the distance between two points in 3D space.
*
* @param x0 First Position X Coordinate.
* @param y0 First Position Y Coordinate.
* @param z0 First Position Z Coordinate.
* @param x1 Second Position X Coordinate.
* @param y1 Second Position Y Coordinate.
* @param z1 Second Position Z Coordinate.
* @return The distance measurement.
*/
float vectorDistance3D(
float x0, float y0, float z0, float x1, float y1, float z1
);

2
src/vn/vnscene.c
View File

@ -80,5 +80,5 @@ void vnSceneRenderGui(vnscene_t *scene, engine_t *engine, shader_t *shader) {
shaderUseCamera(shader, &scene->camera);
// Render Conversation Element
vnConversationRender(&scene->conversation, shader);
// vnConversationRender(&scene->conversation, shader);
}