Entity positions.

src/duskgl/display/shader/data/CMakeLists.txt

@@ -7,4 +7,5 @@
 target_sources(${DUSK_TARGET_NAME}
   PRIVATE
     transforms.c
+    entities.c
 )

src/duskgl/display/shader/data/entities.c

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "entities.h"
+#include "overworld/overworld.h"
+#include "assert/assert.h"
+
+shaderbuffer_t ENTITIES_BUFFER;
+entitiesdata_t ENTITIES_DATA;
+
+void entitiesInit() {
+  memset(&ENTITIES_DATA, 0, sizeof(entitiesdata_t));
+  shaderBufferInit(&ENTITIES_BUFFER, sizeof(overworld_t));
+}
+
+void entitiesUpdate() {
+  shaderBufferBind(&ENTITIES_BUFFER);
+  shaderBufferSetData(&ENTITIES_BUFFER, &OVERWORLD);
+
+  for(uint8_t i = 0; i < OVERWORLD.entityCount; i++) {
+    // Pack the entity data into the buffer
+    entity_t *src = &OVERWORLD.entities[i];
+    entitiesdataent_t *dst = &ENTITIES_DATA.entities[i];
+
+    // Copy position data.
+    assertTrue(
+      (&src->subY - &src->x) + sizeof(uint8_t) == sizeof(uint_t),
+      "Entity data is not packed correctly any more."
+    );
+    memcpy(&dst->position, &src->x, sizeof(uint_t));
+  }
+}
+
+void entitiesDispose() {
+  shaderBufferDispose(&ENTITIES_BUFFER);
+}

src/duskgl/display/shader/data/entities.glsl

@@ -0,0 +1,41 @@
+// Copyright (c) 2025 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "../../../../dusk/overworld/overworlddefs.h"
+#include "../fragments/packed.glsl"
+#include "../fragments/quad.glsl"
+
+struct Entity {
+  uint position;
+  uvec3 _padding0;
+};
+
+layout(std140) uniform b_Entities {
+  Entity entities[OVERWORLD_ENTITY_COUNT_MAX];
+};
+
+vec2 entityGetSize() {
+  return vec2(float(OVERWORLD_ENTITY_WIDTH), float(OVERWORLD_ENTITY_HEIGHT));
+}
+
+vec2 entityGetVertice(uint instanceIndex, uint indiceIndex) {
+  // Get base quad vertice
+  vec2 vert = quadGetVertice(indiceIndex);
+
+  uint x = packedGetU8(0u, entities[instanceIndex].position);
+  uint y = packedGetU8(1u, entities[instanceIndex].position);
+  uint subX = packedGetU8(2u, entities[instanceIndex].position);
+  uint subY = packedGetU8(3u, entities[instanceIndex].position);
+
+  vert.x += float(x);
+  vert.y += float(y);
+
+  vert *= entityGetSize();
+
+  vert.x += float(subX);
+  vert.y += float(subY);
+
+  return vert;
+}

src/duskgl/display/shader/data/entities.h

@@ -5,3 +5,35 @@
  * https://opensource.org/licenses/MIT
  */
 
+#pragma once
+#include "display/shader/shaderbuffer.h"
+#include "overworld/overworld.h"
+
+#define ENTITIES_BLOCK_NAME "b_Entities"
+
+typedef struct {
+  uint_t position;
+  uvec3_t _padding0;
+} entitiesdataent_t;
+
+typedef struct {
+  entitiesdataent_t entities[OVERWORLD_ENTITY_COUNT_MAX];
+} entitiesdata_t;
+
+extern shaderbuffer_t ENTITIES_BUFFER;
+extern entitiesdata_t ENTITIES_DATA;
+
+/**
+ * Initializes the entities buffer and data.
+ */
+void entitiesInit();
+
+/**
+ * Updates the entities buffer with the current data.
+ */
+void entitiesUpdate();
+
+/**
+ * Destroys the entities buffer.
+ */
+void entitiesDispose();

src/duskgl/display/shader/data/transforms.c

@@ -29,13 +29,13 @@ void transformsUpdate() {
   glm_perspective(
     glm_rad(45.0f),
     TRANSFORMS_DATA.resolution[0] / TRANSFORMS_DATA.resolution[1],
-    1.0f,
-    100.0f,
+    0.5f,
+    1000.0f,
     TRANSFORMS_DATA.projection
   );
 
   glm_lookat(
-    (vec3){ 3, 3, 3 },
+    (vec3){ 300, 300, 300 },
     (vec3){ 0, 0, 0 },
     (vec3){ 0, 1, 0 },
     TRANSFORMS_DATA.view

src/duskgl/display/shader/data/transforms.glsl

@@ -0,0 +1,32 @@
+// Copyright (c) 2025 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "../../../../dusk/display/displaydefs.h"
+
+struct Transform {
+  mat4 projection;
+  mat4 view;
+  vec2 resolution;
+};
+
+layout(std140) uniform b_Transforms {
+  Transform transforms;
+};
+
+vec2 transformDisplayGetSize() {
+  return vec2(SCREEN_WIDTH, SCREEN_HEIGHT);
+}
+
+float transformDisplayGetAspectRatio() {
+  return (float(SCREEN_WIDTH) / float(SCREEN_HEIGHT));
+}
+
+vec2 transformResolutionGetSize() {
+  return transforms.resolution;
+}
+
+float transformResolutionGetAspectRatio() {
+  return (transforms.resolution.x / transforms.resolution.y);
+}