Map stuff some more, about to do more packing stuff

src/dusk/overworld/overworld.c

@@ -17,8 +17,14 @@ void overworldInit() {
   // Test
   OVERWORLD.mapWidth = 16;
   OVERWORLD.mapHeight = 16;
+  OVERWORLD.mapLayerCount = 2;
+
+  memset(&OVERWORLD.tileIds, 0x01, sizeof(OVERWORLD.tileIds));
+
   assertTrue(
-    OVERWORLD.mapWidth * OVERWORLD.mapHeight <= OVERWORLD_TILE_COUNT_MAX,
+    (
+      OVERWORLD.mapWidth * OVERWORLD.mapHeight * OVERWORLD.mapLayerCount
+    ) <= OVERWORLD_TILE_COUNT_MAX,
     "Map size exceeds tile count."
   );
 

src/dusk/overworld/overworld.h

@@ -16,7 +16,7 @@ typedef struct {
 
   tileid_t tileIds[OVERWORLD_TILE_COUNT_MAX];
   tiledata_t tileData[OVERWORLD_TILE_COUNT_MAX];
-  uint8_t mapWidth, mapHeight;
+  uint8_t mapWidth, mapHeight, mapLayerCount;
 } overworld_t;
 
 extern overworld_t OVERWORLD;

src/dusk/overworld/overworlddefs.h

@@ -9,6 +9,8 @@
 #define OVERWORLD_ENTITY_WIDTH 32
 #define OVERWORLD_ENTITY_HEIGHT 32
 
-#define OVERWORLD_TILE_COUNT_MAX 256
+#define OVERWORLD_TILE_LAYER_COUNT_MAX 2
+#define OVERWORLD_TILE_COUNT_PER_LAYER 256
+#define OVERWORLD_TILE_COUNT_MAX (OVERWORLD_TILE_COUNT_PER_LAYER * OVERWORLD_TILE_LAYER_COUNT_MAX)
 #define OVERWORLD_TILE_WIDTH OVERWORLD_ENTITY_WIDTH
 #define OVERWORLD_TILE_HEIGHT OVERWORLD_ENTITY_HEIGHT

src/dusk/overworld/tile.h

@@ -13,3 +13,5 @@ typedef uint8_t tileid_t;
 typedef struct {
   uint32_t nothing;
 } tiledata_t;
+
+#define TILE_ID_NULL 0

src/duskgl/display/render.c

@@ -21,6 +21,12 @@ void renderInit() {
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
   assertNoGLError();
 
+  glEnable(GL_BLEND);
+  assertNoGLError();
+
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+  assertNoGLError();
+
   shaderManagerInit();
   quadInit();
 }

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

@@ -27,7 +27,9 @@ void mapUpdate() {
   memoryCopyRangeSafe(
     &MAP_DATA.tileIds,
     &OVERWORLD.tileIds[0],
-    &OVERWORLD.tileIds[OVERWORLD.mapWidth * OVERWORLD.mapHeight],
+    &OVERWORLD.tileIds[
+      OVERWORLD.mapWidth * OVERWORLD.mapHeight * OVERWORLD.mapLayerCount
+    ],
     sizeof(MAP_DATA.tileIds)
   );
 
@@ -35,7 +37,7 @@ void mapUpdate() {
   memoryCopyRangeSafe(
     &MAP_DATA.mapSize,
     &OVERWORLD.mapWidth,
-    &OVERWORLD.mapHeight + sizeof(uint8_t),
+    &OVERWORLD.mapLayerCount + sizeof(uint8_t),
     sizeof(MAP_DATA.mapSize)
   );
   

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

@@ -22,13 +22,25 @@ vec2 mapGetVertice(uint instanceIndex, uint indiceIndex) {
 
   uint mapWidth = packedGetU8(0u, mapSize);
   uint mapHeight = packedGetU8(1u, mapSize);
+  uint mapLayerCount = packedGetU8(2u, mapSize);
 
-  quad += vec2(
+  // Get x and y within layer
-    float(instanceIndex % mapWidth),
+  uint x = instanceIndex % mapWidth;
-    float(instanceIndex / mapWidth)
+  uint y = (instanceIndex / mapWidth) % mapHeight;
-  );
 
+  // Get quad position, consider layer count
+  quad += vec2(x, y);
   quad *= mapTileGetSize();
 
   return quad;
 }
+
+uint mapGetLayer(uint instanceIndex) {
+  uint mapWidth = packedGetU8(0u, mapSize);
+  uint mapHeight = packedGetU8(1u, mapSize);
+  return instanceIndex / (mapWidth * mapHeight);
+}
+
+uint mapGetTileId(uint instanceIndex) {
+  
+}

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

@@ -15,7 +15,7 @@
 typedef struct {
   uvec4_t tileIds[OVERWORLD_TILE_COUNT_MAX / MAP_TILE_PACK_SIZE];
   uint_t mapSize;
-  uvec3_t _padding0;
+  uvec3_t _p0;
 } mapdata_t;
 
 extern shaderbuffer_t MAP_BUFFER;

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

@@ -35,8 +35,8 @@ void transformsUpdate() {
   );
 
   glm_lookat(
-    (vec3){ 300, 300, 300 },
+    (vec3){ 0, 0, 300 },
-    (vec3){ 0, 0, 0 },
+    (vec3){ 0, 32, 0 },
     (vec3){ 0, 1, 0 },
     TRANSFORMS_DATA.view
   );

src/duskgl/display/shader/mapshader/map_frag.glsl

@@ -4,13 +4,24 @@
 // https://opensource.org/licenses/MIT
 
 #include "../fragments/header.glsl"
+#include "../data/map.glsl"
 
 // Inputs from vertex shader
 in vec2 v_TextureCoord;
+flat in uint v_InstanceIndex;
+flat in uint v_IndiceIndex;
 
 // Frag pixel color
 out vec4 FragColor;
 
 void main() {
-  FragColor = vec4(1, 0, 0, 1);
+  uint layer = mapGetLayer(v_InstanceIndex);
+
+  if(layer == 0u) {
+    FragColor = vec4(1, 0, 0, 0.5);
+  } else {
+    FragColor = vec4(0, 1, 0, 0.5);
+  }
+
+  // FragColor = vec4(1, 0, 0, 1);
 }

src/duskgl/display/shader/mapshader/map_vert.glsl

@@ -9,14 +9,20 @@
 
 // Outputs to fragment shader
 out vec2 v_TextureCoord;
+flat out uint v_InstanceIndex;
+flat out uint v_IndiceIndex;
 
 void main() {
   uint instanceIndex = uint(gl_InstanceID);
   uint indiceIndex = quadGetIndiceIndex(gl_VertexID);
 
+  uint layer = mapGetLayer(instanceIndex);
   vec2 vert = mapGetVertice(instanceIndex, indiceIndex);
   vec2 uv = quadGetTextureCoordinate(indiceIndex);
 
-  gl_Position = transforms.projection * transforms.view * vec4(vert, 0.0, 1.0);
+  gl_Position = transforms.projection * transforms.view * vec4(vert, float(layer) * 64.0, 1.0);
+
   v_TextureCoord = uv;
+  v_InstanceIndex = instanceIndex;
+  v_IndiceIndex = indiceIndex;
 }

src/duskgl/overworld/overworld.c

@@ -12,7 +12,7 @@
 
 void overworldRender() {
   mapShaderUse();
-  quadRender(OVERWORLD.mapWidth * OVERWORLD.mapHeight);
+  quadRender(OVERWORLD.mapWidth*OVERWORLD.mapHeight*OVERWORLD.mapLayerCount);
 
   entityShaderUse();
   quadRender(OVERWORLD.entityCount);