About to audit code.

CMakeLists.txt

@@ -11,9 +11,6 @@ set(CMAKE_C_STANDARD_REQUIRED ON)
 #Include
 include(FetchContent)
 
-#Vars
-set(DEPS_DIR "${PROJECT_BINARY_DIR}/_deps")
-
 ################################ Setting Degs ##################################
 set(SETTING_PLATFORM_GLFW 1)
 set(SETTING_PLATFORM_SDL 2)
@@ -29,11 +26,11 @@ set(SETTING_GAME_NAME "DawnGame")
 set(SETTING_TARGET_WIN32 1)
 set(SETTING_TARGET_RG351 2)
 
-set(SETTING_TARGET SETTING_TARGET_RG351)
+set(SETTING_TARGET SETTING_TARGET_WIN32)
 
 # Win32
 if(${SETTING_TARGET} EQUAL ${SETTING_TARGET_WIN32})
-  set(SETTING_PLATFORM SETTING_PLATFORM_SDL)
+  set(SETTING_PLATFORM SETTING_PLATFORM_GLFW)
   set(SETTING_PLATFORM_USE_GLAD 1)
 endif()
 
@@ -45,6 +42,7 @@ 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)
@@ -131,8 +129,7 @@ target_link_libraries(${PROJECT_NAME} cglm)
 
 # OpenGL
 find_package(OpenGL REQUIRED)
-# target_link_libraries(${PROJECT_NAME} OpenGL::GL)
+target_link_libraries(${PROJECT_NAME} OpenGL::GL)
-# include_directories(${OPENGL_INCLUDE_DIR} ${OPENGL_INCLUDE_DIRS})
 
 # CMake
 target_link_libraries(${PROJECT_NAME} ${CMAKE_DL_LIBS})

include/dawn/dawn.h

@@ -43,6 +43,7 @@
 #include "game/poker/pokergame.h"
 #include "game/poker/pokerdiscussion.h"
 #include "game/poker/pokergameassets.h"
+#include "game/poker/pokerrender.h"
 #include "game/poker/pokerui.h"
 
 // Player Input

include/dawn/game/poker/pokergame.h

@@ -8,10 +8,11 @@
 #pragma once
 #include "../../libs.h"
 #include "pokergameassets.h"
+#include "pokerrender.h"
+#include "pokerui.h"
 #include "../../poker/poker.h"
 #include "../../vn/vnconversation.h"
 #include "../../vn/vnscene.h"
-#include "pokerui.h"
 
 typedef struct {
   /** Poker Game State */
@@ -20,9 +21,12 @@ typedef struct {
   /** Visual Novel Engine */
   vnscene_t scene;
 
-  /** Assets for the game. */
+  /** Assets (Files) for the game. */
   pokergameassets_t assets;
 
+  /** Rendering Engine for the game. */
+  pokerrender_t render;
+
   /** UI For the Game */
   pokerui_t ui;
 } pokergame_t;

include/dawn/game/poker/pokergameassets.h

@@ -15,4 +15,6 @@ typedef struct {
   shader_t shader;
   language_t language;
   texture_t testTexture;
+
+  texture_t roomTexture;
 } pokergameassets_t;

include/dawn/game/poker/pokerrender.h

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../../libs.h"
+#include "../../display/primitive.h"
+
+typedef struct {
+  primitive_t skywall;
+} pokerrender_t;

src/display/primitives/skywall.c

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "skywall.h"
+
+void skywallInit(primitive_t *primitive) {
+  primitiveInit(primitive, SKYWALL_VERTICE_COUNT, SKYWALL_INDICE_COUNT);
+  
+  vertice_t vertices[SKYWALL_VERTICE_COUNT];
+  indice_t indices[SKYWALL_INDICE_COUNT];
+  int32_t n, i, j;
+  float x, z, p, r;
+  int32_t slices;
+
+  // For each slice. We iterate slices+1 to do the wrapping mentioned below.
+  for(i = 0; i < SKYWALL_SLICE_COUNT+1; i++) {
+    // Get the "percentage" of the current slice, slice 0 is 0, slice n is 1
+    p = (float)i/(float)SKYWALL_SLICE_COUNT;
+
+    // Because we we are to "seal the cylinder" we wrap around back to 0 on the
+    // last slice to have the last vertice meet the first.
+    if(SKYWALL_SLICE_COUNT == i) {
+      r = 0;
+    } else {
+      r = p * (float)M_PI * 2;// Convert % to radians
+    }
+
+    // Determine the X/Z for the given radian
+    x = SKYWALL_SIZE * (float)cos(r);
+    z = SKYWALL_SIZE * (float)sin(r);
+
+    // Get the start index for the ertices
+    n = i * SKYWALL_VERTICES_PER_SLICE;
+    vertices[n].x = x, vertices[n].y = -SKYWALL_SIZE, vertices[n].z = z;
+    vertices[n].u = p, vertices[n].v = 1;
+    vertices[n+1].x = x, vertices[n+1].y = SKYWALL_SIZE, vertices[n+1].z = z;
+    vertices[n+1].u = p, vertices[n+1].v = 0;
+
+    if(i == SKYWALL_SLICE_COUNT) continue;
+    j = i * SKYWALL_INDICES_PER_SLICE;
+    indices[j] = (indice_t)n;
+    indices[j+1] = (indice_t)n+1;
+    indices[j+2] = (indice_t)n+2;
+
+    indices[j+3] = (indice_t)n+3;
+    indices[j+4] = (indice_t)n+2;
+    indices[j+5] = (indice_t)n+1;
+  }
+
+  primitiveBufferVertices(primitive, 0, SKYWALL_VERTICE_COUNT, vertices);
+  primitiveBufferIndices(primitive, 0, SKYWALL_INDICE_COUNT, indices);
+}

src/display/primitives/skywall.h

@@ -0,0 +1,28 @@
+// 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 "../primitive.h"
+
+/** How many slices in each cylinder. */
+#define SKYWALL_SLICE_COUNT 20
+
+/** How many vertices per slice */
+#define SKYWALL_VERTICES_PER_SLICE 2
+
+/** How many indices per slice */
+#define SKYWALL_INDICES_PER_SLICE 6
+
+/** How many vertices in the cylinder, +1 to have the cylinder "wrap" */
+#define SKYWALL_VERTICE_COUNT (SKYWALL_SLICE_COUNT+1)*SKYWALL_VERTICES_PER_SLICE
+
+/** How many indices in the cylinder */
+#define SKYWALL_INDICE_COUNT SKYWALL_INDICES_PER_SLICE*SKYWALL_SLICE_COUNT
+
+/** How big the skywall cylinder is */
+#define SKYWALL_SIZE 100
+
+void skywallInit(primitive_t *primitive);

src/game/poker/pokergame.c

@@ -13,6 +13,9 @@ bool pokerGameInit(game_t *game) {
   // Load the Assets
   pokerGameAssetsInit(&pokerGame->assets);
 
+  // Initialize the world
+  pokerRenderInit(&pokerGame->render);
+
   // Initialize the UI.
   pokerUiInit(pokerGame);
   
@@ -35,13 +38,19 @@ void pokerGameUpdate(game_t *game) {
   shaderUse(&pokerGame->assets.shader);
 
   // Render the visual novel scene
-  vnSceneRenderWorld(&pokerGame->scene, &game->engine, &pokerGame->assets.shader);
+  vnSceneRenderWorld(&pokerGame->scene,&game->engine,&pokerGame->assets.shader);
+
+  // Render the world
+  pokerRenderRender(&pokerGame->render, &game->engine, &pokerGame->assets);
+
+  // Render the UI
   vnSceneRenderGui(&pokerGame->scene, &game->engine, &pokerGame->assets.shader);
   pokerUiRender(pokerGame);
 }
 
 void pokerGameDispose(game_t *game) {
   pokerUiDispose(&game->pokerGame);
+  pokerRenderDispose(&game->pokerGame.render);
   vnSceneDispose(&game->pokerGame.scene);
   pokerGameAssetsDispose(&game->pokerGame.assets);
 }

src/game/poker/pokergame.h

@@ -13,6 +13,7 @@
 #include "../../vn/vnscene.h"
 #include "actions/start.h"
 #include "pokerui.h"
+#include "pokerrender.h"
 
 #include "../../ui/frame.h"
 #include "../../physics/aabb.h"

src/game/poker/pokergameassets.c

@@ -13,6 +13,8 @@ bool pokerGameAssetsInit(pokergameassets_t *assets) {
   );
   languageInit(&assets->language, "locale/language/en-US.csv");
   assetTextureLoad(&assets->testTexture, "test_texture.png");
+
+  assetTextureLoad(&assets->roomTexture, "room.png");
   return true;
 }
 

src/game/poker/pokerrender.c

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "pokerrender.h"
+
+void pokerRenderInit(pokerrender_t *render) {
+  skywallInit(&render->skywall);
+}
+
+void pokerRenderRender(
+  pokerrender_t *render, engine_t *engine, pokergameassets_t *assets
+) {
+  // Render the wall
+  shaderUseTexture(&assets->shader, &assets->roomTexture);
+  shaderUsePosition(&assets->shader, 0, 0, 0, 0,0,0);
+  primitiveDraw(&render->skywall, 0, -1);
+}
+
+void pokerRenderDispose(pokerrender_t *render) {
+  primitiveDispose(&render->skywall);
+}

src/game/poker/pokerrender.h

@@ -0,0 +1,36 @@
+/**
+ * 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 "../../display/shader.h"
+#include "../../display/primitive.h"
+#include "../../display/primitives/skywall.h"
+#include "../../vn/vnscene.h"
+
+/**
+ * Initialize the poker renderer.
+ * 
+ * @param render Render to initialize.
+ */
+void pokerRenderInit(pokerrender_t *render);
+
+/**
+ * Render the poker game.
+ * @param render Renderer to use.
+ * @param engine Engine for rendering.
+ * @param assets Poker game assets.
+ */
+void pokerRenderRender(
+  pokerrender_t *render, engine_t *engine, pokergameassets_t *assets
+);
+
+/**
+ * Cleanup the poker renderer.
+ * @param render Render to dispose.
+ */
+void pokerRenderDispose(pokerrender_t *render);

src/vn/vnscene.c

@@ -42,7 +42,7 @@ void vnSceneRenderWorld(vnscene_t *scene, engine_t *engine, shader_t *shader) {
   );
 
   // Set Camera Perspective
-  cameraPerspective(&scene->camera, 75,
+  cameraPerspective(&scene->camera, 35,
     engine->render.width/engine->render.height,
     0.01, 1000.0
   );