About to audit code.

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
   );