load tilemap from file

7 files changed, 130 insertions, 59 deletions

diff --git a/Makefile b/Makefile
deleted file mode 100644
index 2a5ece6..0000000
--- a/Makefile
+++ /dev/null
@@ -1,15 +0,0 @@
-PROG=tiled
-CC=gcc
-FLAGS=-lm -lraylib
-
-.DEFAULT_GOAL := build
-
-install: ${PROG}
-	cp ${PROG} ${PREFIX}/bin/
-
-build: ${PROG}.c
-	${CC} ${PROG}.c -o ${PROG} ${FLAGS}
-
-clean: ${PROG}
-	rm ${PROG}
-
diff --git a/createmap.py b/createmap.py
new file mode 100755
index 0000000..59fb315
--- /dev/null
+++ b/createmap.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+import sys
+
+outfile = "map.tiles"
+
+WIDTH = 500
+HEIGHT = 100
+# number of bytes each tile needs to represent
+TILEBYTES = 25
+
+HEADER = "TILEFILEv1"
+
+with open(outfile, "wb") as file:
+    file.write(bytes(HEADER, "ascii"))
+    file.write(WIDTH.to_bytes(4, 'big'));
+    file.write(HEIGHT.to_bytes(4, 'big'));
+    file.write(TILEBYTES.to_bytes(4, 'big'));
+
+    for y in range(HEIGHT):
+        for x in range(WIDTH):
+            index = (x + y) % 5
+            file.write(index.to_bytes(TILEBYTES, 'big'));
+
diff --git a/makefile b/makefile
new file mode 100644
index 0000000..4c0072f
--- /dev/null
+++ b/makefile
@@ -0,0 +1,14 @@
+CC=gcc
+FLAGS=-lm -lraylib
+
+.DEFAULT_GOAL := build
+
+install: tiled
+	cp tiled ${PREFIX}/bin/
+
+build: tiled.c tiledfile.c tiledfile.h
+	${CC} tiled.c tiledfile.c -o tiled ${FLAGS} 
+
+clean: tiled
+	rm tiled
+
diff --git a/tiled.c b/tiled.c
index 220043d..715a91d 100644
--- a/tiled.c
+++ b/tiled.c
@@ -1,66 +1,35 @@
 #include <raylib.h>
-#include <stdlib.h>
 #include <stdio.h>
-#include <wctype.h>
+
+#include "tiledfile.h"
 
 #define SCREEN_W 1280
 #define SCREEN_H 720
 
-#define MAP_W 16
-#define MAP_H 4
-
-const int tilemap[MAP_H * MAP_W] = {
-   0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0,
-   0, 3, 3, 0, 0, 3, 1, 1, 1, 3, 0, 0, 0, 0, 0, 0,
-   3, 1, 1, 3, 3, 1, 2, 2, 2, 1, 3, 3, 3, 0, 0, 3,
-   1, 2, 2, 1, 1, 2, 4, 4, 4, 2, 1, 1, 1, 3, 3, 1
-};                          
-
 const int atlasSize[2] = {2, 2};
 
-Texture2D processTilemapTexture(const int * tilemap, int width, int height) {
-    Color *pixels = (Color*) malloc(width * height * sizeof(Color));
-
-    for (int y = 0; y < height; y++) {
-        for (int x = 0; x < width; x++) {
-            int tile = tilemap[y*width + x];
-            pixels[y*width + x] = (Color){
-                (int) tile, 0, 0, 0
-            };
-        }
-    }
-
-    Image checkedIm = {
-        .data = pixels,
-        .width = width,
-        .height = height,
-        .format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
-        .mipmaps = 1
-    };
-
-    Texture2D checked = LoadTextureFromImage(checkedIm);
-    UnloadImage(checkedIm);
-
-    return checked;
-}
-
 int main() {
     InitWindow(SCREEN_W, SCREEN_H, "tiled");
 
     Shader shader = LoadShader(0, "tiled.glsl");
 
-    Texture2D processedTilemap = processTilemapTexture(tilemap, MAP_W, MAP_H);
+    Texture2D tilemap = loadTileMap("map.tiles");
+
     Texture atlas = LoadTexture("tiled.png");
     RenderTexture2D target = LoadRenderTexture(SCREEN_W, SCREEN_H);
 
     float resolution[2] = {SCREEN_W, SCREEN_H};
     float offset[2] = {0, 0};
     float zoom = 16.0f;
+    int mapSize[2] = {tilemap.width, tilemap.height};
+
 
     int resolutionLoc = GetShaderLocation(shader, "resolution");
     int locationLoc = GetShaderLocation(shader, "offset");
     int zoomLoc = GetShaderLocation(shader, "zoom");
+
     int atlasSizeLoc = GetShaderLocation(shader, "atlasSize");
+    int mapSizeLoc = GetShaderLocation(shader, "mapSize");
 
     int textureLoc = GetShaderLocation(shader, "texture1");
     int tilemapLoc = GetShaderLocation(shader, "texture2");
@@ -77,7 +46,9 @@ int main() {
         SetShaderValue(shader, resolutionLoc, resolution, SHADER_UNIFORM_VEC2);
         SetShaderValue(shader, locationLoc, &offset, SHADER_UNIFORM_VEC2);
         SetShaderValue(shader, zoomLoc, &zoom, SHADER_UNIFORM_FLOAT);
+
         SetShaderValue(shader, atlasSizeLoc, &atlasSize, SHADER_UNIFORM_IVEC2);
+        SetShaderValue(shader, mapSizeLoc, &tilemap.width, SHADER_UNIFORM_IVEC2);
 
         BeginDrawing();
 
@@ -89,12 +60,11 @@ int main() {
 
         BeginShaderMode(shader);
             SetShaderValueTexture(shader, textureLoc, atlas);
-            SetShaderValueTexture(shader, tilemapLoc, processedTilemap);
+            SetShaderValueTexture(shader, tilemapLoc, tilemap);
 
             // draw the base image to texture0
             DrawTexture(target.texture, 0, 0, WHITE);
         EndShaderMode();
-            DrawTexture(processedTilemap, 0, 0, WHITE);
 
             DrawText(TextFormat("FPS: %d", GetFPS()), 12, 12, 24, DARKGRAY);
 
diff --git a/tiled.glsl b/tiled.glsl
index 3ec1c66..8580f52 100644
--- a/tiled.glsl
+++ b/tiled.glsl
@@ -1,7 +1,5 @@
 #version 430
 
-#define MAP_H 4
-#define MAP_W 16
 precision highp float;
 
 in vec3 vertexPos;
@@ -16,6 +14,7 @@ uniform vec2 resolution;
 uniform vec2 offset;
 uniform float zoom;
 uniform ivec2 atlasSize;
+uniform ivec2 mapSize;
 
 out vec4 finalColor;
 
@@ -61,7 +60,7 @@ void main() {
     // get position in tiled world wow
     ivec2 tilemapPos = ivec2(floor(uv));
 
-    if (inBounds(uv, vec2(MAP_W, MAP_H))) {
+    if (inBounds(uv, mapSize)) {
         finalColor = none;
     } else {
         vec2 position = mod(uv, 1);
diff --git a/tiledfile.c b/tiledfile.c
new file mode 100644
index 0000000..8cb8dfa
--- /dev/null
+++ b/tiledfile.c
@@ -0,0 +1,77 @@
+#include <raylib.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+const int i = 1;
+#define is_bigendian() ( (*(char*)&i) == 0 )
+
+Texture2D processTilemapTexture(int * tilelayout, int width, int height) {
+    Color *pixels = (Color*) malloc(width * height * sizeof(Color));
+
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            int tile = tilelayout[y*width + x];
+            pixels[y*width + x] = (Color){
+                (int) tile, 0, 0, 0
+            };
+        }
+    }
+
+    Image checkedIm = {
+        .data = pixels,
+        .width = width,
+        .height = height,
+        .format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
+        .mipmaps = 1
+    };
+
+    Texture2D checked = LoadTextureFromImage(checkedIm);
+    UnloadImage(checkedIm);
+
+    return checked;
+}
+
+// read a big endian bytes from file
+int readb(char *out, size_t noBytes, FILE *file) {
+    int s = fread(out, (size_t)1, (size_t) noBytes, file);
+    
+    if (!is_bigendian()) {
+        int tmp;
+        // reverse byte order
+        for(int i = 0; i < noBytes/2; i++) {
+            tmp = out[i];
+            out[i] = out[noBytes-i-1];
+            out[noBytes-i-1] = tmp;
+        }
+    }
+    return s;
+}
+
+
+Texture2D loadTileMap(char *filename) {
+    int width, height, tilebytes;
+    int *tilelayout;
+
+    FILE *file;
+
+    file = fopen(filename, "rb");
+    // skip header 
+    fseek(file, 10, SEEK_CUR);
+    // 4 bytes for int width
+    readb((char *)&width, 4, file);
+    // 4 bytes for int height
+    readb((char *)&height, 4, file);
+    // 1 byte saying how big each tile is
+    readb((char *)&tilebytes, 4, file);
+    printf("tilebytes: %d\n", tilebytes);
+
+    tilelayout = malloc(width*height*tilebytes);
+    int tile;
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            readb((char *)&tile, tilebytes, file);
+            tilelayout[y*width + x] = tile;
+        }
+    }
+    return processTilemapTexture(tilelayout, width, height);
+}
diff --git a/tiledfile.h b/tiledfile.h
new file mode 100644
index 0000000..cf2980b
--- /dev/null
+++ b/tiledfile.h
@@ -0,0 +1,3 @@
+#include <raylib.h>
+
+Texture2D loadTileMap(char *filename);