fog

const.h

@@ -15,8 +15,8 @@ typedef struct Vertex2 {
 } Vertex2;
 
 #define CHUNK_LENGTH 16
-#define CHUNK_RADIUS_H 5 // 8
+#define CHUNK_RADIUS_H 4 // 8
-#define CHUNK_RADIUS_V 5 // 4
+#define CHUNK_RADIUS_V 4 // 4
 
 #define TEXT_GAP_H 1 / 3.0
 #define TEXT_GAP_V 1 / 1.0
@@ -26,7 +26,7 @@ typedef struct Vertex2 {
 #define CHUNK_ALL CHUNK_DIAMETER_H *CHUNK_DIAMETER_H *CHUNK_DIAMETER_V
 #define BLOCK_ALL CHUNK_LENGTH *CHUNK_LENGTH *CHUNK_LENGTH
 #define CBLOCK_ALL BLOCK_ALL *CHUNK_ALL
-#define CBUF_ALL 25
+#define CBUF_ALL 2
 
 #define CTRI_ALL CBLOCK_ALL * 18 * sizeof(Vertex)
 

cubes.c

@@ -14,6 +14,9 @@ struct args {
   int a3;
 };
 
+Chunk *chunk_old = NULL;
+int read_order = 0;
+
 void gen_face(Vertex *cube, int i, int x, int y, int z, int x2, int y2, int z2,
               int *j, int is_text, Chunk dat, int ci, int a3) {
   VertexI a = {{x, y, z}};
@@ -22,8 +25,8 @@ void gen_face(Vertex *cube, int i, int x, int y, int z, int x2, int y2, int z2,
   if (is_text) {
     a.pos[i]--;
     int exists = 0;
-    exists = (cube_exists(x, y, z, dat, ci) !=
+    exists = (cube_exists(x, y, z, dat, ci, read_order) !=
-              cube_exists(a.pos[0], a.pos[1], a.pos[2], dat, ci));
+              cube_exists(a.pos[0], a.pos[1], a.pos[2], dat, ci, read_order));
 
     a2.pos[0] = exists ? TEXT_GAP_H * i : -1.0;
     a2.pos[1] = exists ? TEXT_GAP_V * i : -1.0;
@@ -38,6 +41,7 @@ void gen_face(Vertex *cube, int i, int x, int y, int z, int x2, int y2, int z2,
   Vertex c = a2;
   Vertex d = a2;
 
+
   if (is_text) {
     b.pos[0] += TEXT_GAP_H;
     c.pos[1] += TEXT_GAP_V;
@@ -74,8 +78,15 @@ void *gen_chunk(void *args) {
   Vertex *text = args2.text;
   // int is_text = args2.is_text;
 
+  int the_j = (((z2 / CHUNK_LENGTH)%a3) + ((x2 / CHUNK_LENGTH)%a3) * CHUNK_DIAMETER_H +
+               ((y2 / CHUNK_LENGTH)%a3) * CHUNK_DIAMETER_H * CHUNK_DIAMETER_H) %
+              CHUNK_ALL;
   Chunk chunk =
-      fetch_chunk(x2 / CHUNK_LENGTH, y2 / CHUNK_LENGTH, z2 / CHUNK_LENGTH, a);
+      fetch_chunk(x2 / CHUNK_LENGTH, y2 / CHUNK_LENGTH, z2 / CHUNK_LENGTH, a,
+                  chunk_old[the_j > 0 ? the_j : 0].exists, read_order);
+
+  if (chunk.exists != 0 && the_j > 0)
+    chunk_old[the_j] = chunk;
 
   printf("Loading world... (%i / %i)\n", a2, CHUNK_ALL);
 
@@ -103,7 +114,8 @@ void *gen_chunk(void *args) {
   return (void *)i;
 }
 
-int gen_cubes(Vertex *cube, Vertex *text, int x, int y, int z, int r, int is_purge) {
+int gen_cubes(Vertex *cube, Vertex *text, int x, int y, int z, int r,
+              int is_purge) {
   Vertex noth = {{-1, -1, -1}};
   for (int i = 0; i < CBLOCK_ALL * 18; i++) {
     cube[i] = noth;
@@ -115,13 +127,24 @@ int gen_cubes(Vertex *cube, Vertex *text, int x, int y, int z, int r, int is_pur
   y *= CHUNK_LENGTH;
   z *= CHUNK_LENGTH;
   int a3 = CHUNK_DIAMETER_H + (r * 2);
-  int a = 0; //(z % CHUNK_DIAMETER_H) + (x % CHUNK_DIAMETER_H) * CHUNK_DIAMETER_H  + (y % CHUNK_DIAMETER_V) * CHUNK_DIAMETER_H * CHUNK_DIAMETER_H;
+  int a =
-  //a = a % a3;
+      0; //(z % CHUNK_DIAMETER_H) + (x % CHUNK_DIAMETER_H) * CHUNK_DIAMETER_H  +
-  //if (a < 0) a = -a;
+         //(y % CHUNK_DIAMETER_V) * CHUNK_DIAMETER_H * CHUNK_DIAMETER_H;
+  // a = a % a3;
+  // if (a < 0) a = -a;
 
   struct args args[a3];
   int thread_return[a3];
+  if (is_purge) {
+    for (int k = 0; k < a3; k++) {
+      purge_chunks(k);
+    }
+  }
 
+  if (!chunk_old) {
+    chunk_old = calloc(CHUNK_ALL, sizeof(struct Chunk));
+  }
+  read_order = !read_order;
   pthread_t thread_id[a3];
   for (int y2 = y - (CHUNK_RADIUS_V + r) * CHUNK_LENGTH;
        y2 <= y + (CHUNK_RADIUS_V + r) * CHUNK_LENGTH; y2 += CHUNK_LENGTH) {
@@ -132,7 +155,14 @@ int gen_cubes(Vertex *cube, Vertex *text, int x, int y, int z, int r, int is_pur
       for (int z2 = z - (CHUNK_RADIUS_H + r) * CHUNK_LENGTH;
            z2 <= z + (CHUNK_RADIUS_H + r) * CHUNK_LENGTH; z2 += CHUNK_LENGTH) {
 
-        VertexI pos = {{x2, y2, z2}};
+        VertexI pos = {
+            {x + (((x2 / CHUNK_LENGTH) % (CHUNK_DIAMETER_H + r * 2))) *
+                     CHUNK_LENGTH,
+             y + (((y2 / CHUNK_LENGTH) % (CHUNK_DIAMETER_V + r * 2))) *
+                     CHUNK_LENGTH,
+             z + (((z2 / CHUNK_LENGTH) % (CHUNK_DIAMETER_H + r * 2))) *
+                     CHUNK_LENGTH}};
+
         int a2 = a % a3;
         args[a2].cube = cube;
         args[a2].text = text;
@@ -144,7 +174,6 @@ int gen_cubes(Vertex *cube, Vertex *text, int x, int y, int z, int r, int is_pur
 
         /*gen_chunk((void *)&args); */
 
-        if (is_purge) purge_chunks(a2);
         pthread_create(&(thread_id[a2]), NULL, gen_chunk, (void *)&(args[a2]));
 
         i += 6;
@@ -155,7 +184,6 @@ int gen_cubes(Vertex *cube, Vertex *text, int x, int y, int z, int r, int is_pur
       for (int k = 0; k < a3; k++) {
         pthread_join((thread_id[k]), (void **)&thread_return[k]);
       }
-
       int max = 0;
       int min = 0xFFFFFFF;
 

gen.c

@@ -7,7 +7,7 @@
 Chunk *chunks = NULL;
 int lastI = 0;
 int seed = 69420;
-
+int prevExists = 0;
 double interpolate(double a0, double a1, double w) {
   return (a1 - a0) * (3.0 - w * 2.0) * w * w + a0;
 }
@@ -58,23 +58,44 @@ double perlin_calc(double x, double y, double s) {
   return value;
 }
 
-Chunk fetch_chunk(int x, int y, int z, int ci) {
+Chunk fetch_chunk(int x, int y, int z, int ci, int h, int r_order) {
-  Chunk *chunks2 = &chunks[CBUF_ALL * ci];
+
+  Chunk *chunks2 = chunks; // &chunks[CBUF_ALL * ci];
 
   Chunk chunk;
 
-  int i, j;
+  if (x < 0 || y < 0 || z < 0) {
-  for (j = 0; j < CBUF_ALL; j++) {
+    chunk.exists = 0;
-    i = j;
-    chunk = chunks2[i];
-    if (chunk.x == x && chunk.y == y && chunk.z == z && chunk.exists) {
-      // lastI = i;
     return chunk;
   }
 
-    if (!chunk.exists)
+  int cbuf2 = CHUNK_ALL; // CBUF_ALL * (CHUNK_DIAMETER_H + (MAX_R * 2));
+
+  int i, j;
+  int r = (h == 0);
+
+  h = h * 16;
+
+  for (j = 0; j < (r ? 16 : 1) && h; j++) {
+    i = (j + h + cbuf2) % cbuf2;
+    chunk = chunks2[i];
+    if (chunk.x == x && chunk.y == y && chunk.z == z && chunk.exists != 0) {
+
+      chunk.exists = i / 16;
+      if (chunk.exists == 0)
+        chunk.exists = 1;
+      return chunk;
+    }
+  }
+
+  // printf("fail\n");
+  for (j = 0; j < cbuf2; j += 16) {
+    i = (j + h + cbuf2) % cbuf2;
+    chunk = chunks2[i];
+    if (chunk.exists == 0) {
       break;
     }
+  }
 
   char fname[1024];
   snprintf(fname, 1023, "./db/chunk_%i_%i_%i.dat", x, y, z);
@@ -84,17 +105,22 @@ Chunk fetch_chunk(int x, int y, int z, int ci) {
   int code = (fp) ? fread(&chunk, sizeof(Chunk), 1, fp) : 0;
   if (code != 0) {
     fclose(fp);
+    fp = 0;
+    if (chunk.exists != 0) {
+      chunk.exists = i / 16;
+      if (chunk.exists == 0)
+        chunk.exists = 1;
       return chunk;
     }
+  }
   if (!fp) {
     fp = fopen(fname, "wb");
   }
 
   lastI = i;
 
-  if (i > CBUF_ALL - 1)
+  chunk.exists = i / 16;
-    i = CBUF_ALL - 1;
+  if (chunk.exists == 0)
-
     chunk.exists = 1;
   chunk.x = x;
   chunk.y = y;
@@ -137,21 +163,24 @@ void purge_chunks(int ci) {
   chunks = calloc(CBUF_ALL, sizeof(Chunk));
   */
   if (chunks == NULL) {
-    chunks = calloc(CBUF_ALL * (CHUNK_DIAMETER_H + (MAX_R * 2)), sizeof(Chunk));
+    chunks = calloc(CHUNK_ALL, sizeof(Chunk));
   }
-  memset(&chunks[CBUF_ALL * ci], 0, sizeof(Chunk) * CBUF_ALL);
+  // memset(chunks, 0, sizeof(Chunk) *CHUNK_ALL);
 }
 
-int cube_exists(int x, int y, int z, Chunk dat, int ci) {
+int cube_exists(int x, int y, int z, Chunk dat, int ci, int r_order) {
   if (x < 0 || y < 0 || z < 0)
     return 0;
 
   if (dat.exists == 0 || dat.x != (x / CHUNK_LENGTH) ||
-      dat.y != (y / CHUNK_LENGTH) || dat.z != (z / CHUNK_LENGTH))
+      dat.y != (y / CHUNK_LENGTH) || dat.z != (z / CHUNK_LENGTH)) {
     dat = fetch_chunk((x / CHUNK_LENGTH), (y / CHUNK_LENGTH),
-                      (z / CHUNK_LENGTH), ci);
+                      (z / CHUNK_LENGTH), ci, dat.exists, r_order);
+    prevExists = dat.exists;
+  }
+
   int h = dat.blocks[(y % CHUNK_LENGTH) + (z % CHUNK_LENGTH) * CHUNK_LENGTH +
                      (x % CHUNK_LENGTH) * CHUNK_LENGTH * CHUNK_LENGTH];
 
-  return h;
+  return !!h;
 }

gen.h

@@ -1,5 +1,5 @@
 #include "const.h"
 
-int cube_exists(int x, int y, int z, Chunk dat, int ci);
+int cube_exists(int x, int y, int z, Chunk dat, int ci, int r_order);
-Chunk fetch_chunk(int x, int y, int z, int ci);
+Chunk fetch_chunk(int x, int y, int z, int ci, int h, int r_order);
 void purge_chunks(int ci);

main.c

@@ -15,28 +15,37 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include "gen.h"
+
 static const char *vertex_shader_text =
     "#version 330\n"
     "layout (location = 0) in vec3 v_pos;"
     "layout (location = 1) in vec3 v_off;"
     "uniform mat4 mvp;\n"
     "out vec2 v_tex;\n"
+    "out vec3 v_pos_out;\n"
     "void main()\n"
     "{\n"
     "    gl_Position = mvp * vec4(v_pos, 1.0);\n"
     "    v_tex=vec2(v_off);\n"
+    "    v_pos_out=v_pos;\n"
     "}\n";
 
 static const char *fragment_shader_text =
     "#version 330\n"
     "out vec4 color;\n"
     "in vec2 v_tex;\n"
+    "in vec3 v_pos_out;\n"
     "uniform sampler2D sampler_tex;\n"
+    "uniform vec3 center;\n"
+    "float dist;\n"
     "void main()\n"
     "{\n"
     //"    color=vec4(v_tex.rg,0.5,0.5);\n"
     "    if (v_tex.x < 0.0 || v_tex.y < 0.0) { discard; }\n"
-    "    color=vec4(texture(sampler_tex, v_tex).rgb,0.5);\n"
+    "    dist = distance(v_pos_out, center)/65;\n"
+    "    if (dist > 1.0) { dist = 1.0; }\n"
+    "    color=vec4(texture(sampler_tex, v_tex).rgb,1.0)*(1.0-(dist*dist)) + vec4(0.2,0.5,0.7,1.0)*(dist*dist);\n"
     "}\n";
 
 int isCursor = 0;
@@ -117,8 +126,8 @@ int main(void) {
   Vertex *cube = malloc(CTRI_ALL);
   Vertex *text = malloc(CTRI_ALL);
 
-  int cube_count = gen_cubes(cube, text, 1024 / CHUNK_LENGTH, 64 / CHUNK_LENGTH,
+  int cube_count = gen_cubes(cube, text, 10240 / CHUNK_LENGTH, 64 / CHUNK_LENGTH,
-                             1024 / CHUNK_LENGTH, 0, 1);
+                             10240 / CHUNK_LENGTH, 0, 1);
   GLuint vertex_buffer[2];
 
   GLuint vertex_array;
@@ -152,6 +161,7 @@ int main(void) {
 
   GLint tex_location = glGetUniformLocation(program, "sampler_tex");
   GLint mvp_location = glGetUniformLocation(program, "mvp");
+  GLint center_location = glGetUniformLocation(program, "center");
 
   unsigned char *pixels;
 
@@ -165,7 +175,16 @@ int main(void) {
   glfwSetKeyCallback(window, key_callback);
   glfwSetCursorPosCallback(window, cursor_position_callback);
 
-  vec3 pos = {1024, 64, 1024};
+  vec3 pos = {10240, 48, 10240};
+  vec3 oldPos = {0,0,0};
+  Chunk ch7;
+  ch7.exists = 0;
+  int state = cube_exists(pos[0], pos[1], pos[2], ch7, 0, 0);
+
+  while (1) {
+    if (state != cube_exists(pos[0], pos[1], pos[2], ch7, 0, 0)) break;
+    pos[1] += (state ? 1 : -1);
+  }
 
   // int x = 0, y = 25, z = 0;
   glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
@@ -175,7 +194,6 @@ int main(void) {
   int is_render = 1;
 
   int last_render = 0;
-  vec3 oldPos = {pos[0], pos[1], pos[2]};
 
   while (!glfwWindowShouldClose(window)) {
 
@@ -220,6 +238,7 @@ int main(void) {
     mat4x4_mul(mvp, mvp, m);
 
     glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat *)&mvp);
+    glUniform3fv(center_location, 1, (const GLfloat *)(&(oldPos[0])));
 
     int ax = (int)(oldPos[0] / CHUNK_LENGTH) - (int)(pos[0] / CHUNK_LENGTH);
     int ay = (int)(oldPos[1] / CHUNK_LENGTH) - (int)(pos[1] / CHUNK_LENGTH);