voxels

@@ -3,18 +3,18 @@ from libs import *

 class Entity:

     def __init__(self, verts, col, pos, **kwargs):

         self.verts = vec(verts)

+        self.hud = kwargs.get("hud", False)

         self.col = vec(col)

-        self.refls = vec(kwargs.get("refls", [0.5, 0.5, 0.0, 32.0]))

+        self.refls = vec(kwargs.get("refls", [1.0, 0.0, 0.0, 1.0] if self.hud else [0.5, 0.5, 0.0, 32.0]))

         self.pos = vec(pos)

         self.draw_mode = kwargs.get("mode", GL_TRIANGLE_STRIP)

-        self.hud = kwargs.get("hud", False)

         self.orient = np.identity(4, dtype=FLOAT)

         self.onclick = lambda s, b, n: print(f"clicked {s}:{n} with button {b}")

         self.vao = None

         self.vbos = [[None, 0] for _ in VERTEX_ATTRS]

-    def col_list(self):

-        return np.repeat(vec([self.col]), len(self.verts), 0)

+    def mat_list(self):

+        return np.repeat(vec([[self.col], [self.refls]]), len(self.verts), 1)

     def norm_list(self):

         l = []

@@ -34,9 +34,6 @@ class Entity:

             raise NotImplementedError

         return (self.orient[:3, :3] @ vec(l).T).T

-    def refls_list(self):

-        return np.repeat(vec([self.refls]), len(self.verts), 0)

-

     def build_vao(self):

         self.vao = glGenVertexArrays(1)

         glBindVertexArray(self.vao)

@@ -60,11 +60,12 @@ def update_attr(ent, n, l=None):

             case "position":

                 l = ent.verts

             case "col":

-                l = ent.col_list()

+                l = ent.mat_list()[0]

             case "normal":

                 l = ent.norm_list()

+                assert all([abs(np.linalg.norm(v) - 1) < 1e-3 for v in l])

             case "refls":

-                l = ent.refls_list()

+                l = ent.mat_list()[1]

     if ent.vao:

         glBindBuffer(GL_ARRAY_BUFFER, ent.vbos[i][0])

         if l.shape[0] != ent.vbos[i][1]:

@@ -33,10 +33,10 @@ void main() {{

 FPS = 60

-def debug_mode(scene, cam):

+def debug_mode(mg, cam):

     pass

-def click_mesh(self, button, coords):

+def click_mesh(self, button, coords, mg):

     match button:

         case 1:

             self.set_voxel(coords[1])

@@ -44,22 +44,24 @@ def click_mesh(self, button, coords):

             print(f"coords {coords}")

         case 3:

             offset = axis2offset(coords[0])

-            self.set_voxel(coords[1] + offset, 2)

+            p = self.set_voxel(coords[1] + offset, 1)

+            if p is not None:

+                rc = self.pos + p // self.r * self.r

+                awr = mg.fetch(tuple(int(x) for x in rc), click_mesh)

+                print(f"placed out-of-bounds at {p}")

     if button % 2 == 1:

         for i in range(len(VERTEX_ATTRS)):

             update_attr(self, i)

-def build_scene(mg):

-    box = WorldRegion()

-    print(f"map generated with {mg.world_natural(box)} voxels")

-    box.remesh()

-    box.onclick = click_mesh

-    return [box]

+def build_scene():

+    mg = MapGen()

+    mg.fetch((0, 0, 0), click_mesh)

+    return mg

 def main():

     pygame.init()

     pygame.display.set_mode((640, 480), pygame.DOUBLEBUF | pygame.OPENGL | pygame.RESIZABLE)

-    pygame.display.set_caption("OpenGL")

+    pygame.display.set_caption("Voxels")

     sp = shaders.compileProgram(

         shaders.compileShader(VS, GL_VERTEX_SHADER),

         shaders.compileShader(FS, GL_FRAGMENT_SHADER)

@@ -69,27 +71,27 @@ def main():

     glUseProgram(sp)

     glEnable(GL_DEPTH_TEST)

     glClearColor(0.1, 0.1, 0.1, 1.0)

-    glUniform4fv(UNIFORMS["lightPos"][2], 1, vec([5, 10, 10, 10]))

-    mg = MapGen()

-    scene = build_scene(mg)

+    glUniform4fv(UNIFORMS["lightPos"][2], 1, vec([5, 30, 10, 100]))

+    mg = build_scene()

     clock = pygame.time.Clock()

     cam = Player(speed=10/FPS)

     cam.pos = [8, 16, 8]

     cam.set_focus(True)

     while True:

+        scene = list(mg.regions.values())

         for ev in pygame.event.get():

             if ev.type == pygame.QUIT or ev.type == pygame.KEYUP and ev.unicode == "q":

                 pygame.quit()

                 return

             elif ev.type == pygame.KEYUP and ev.unicode == "d":

-                debug_mode(scene, cam)

+                debug_mode(mg, cam)

             cam.handle_event(ev, scene)

         cam.update_pos()

         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

         for ent in scene:

             cam.draw(ent)

         perf = clock.get_fps() / FPS

-        cam.draw_hud(scene[0], perf)

+        cam.draw_hud(scene, perf)

         pygame.display.flip()

         clock.tick(FPS)

@@ -1,4 +1,5 @@

 from libs import *

+import region

 def smerp(ab, w):

     assert all([abs(x) < 2 for x in ab])

@@ -9,6 +10,20 @@ def smerp(ab, w):

 class MapGen:

     def __init__(self):

         self.grads = [{} for _ in range(4)]

+        self.regions = {}

+

+    def fetch(self, pos, onclick=None):

+        if pos in self.regions:

+            return self.regions[pos]

+        else:

+            wr = region.WorldRegion()

+            wr.pos = vec(pos)

+            self.world_natural(wr)

+            wr.remesh()

+            if onclick:

+                wr.onclick = lambda s, b, c: onclick(s, b, c, self)

+            self.regions[pos] = wr

+            return wr

     def perlin(self, name, pos, period):

         dim = pos.shape[0]

@@ -29,15 +44,16 @@ class MapGen:

         n = 0

         for i in range(wr.r):

             for j in range(wr.r):

-                h = 8 + 4 * self.perlin("height", np.add(wr.pos[[0, 2]], (i, j)), np.array([10, 5]))

-                for k in range(int(h)):

+                h = 4 + 4 * self.perlin("height", np.add(wr.pos[[0, 2]], (i, j)), np.array([10, 5])) - wr.pos[1]

+                for k in range(min(int(h), wr.r)):

                     wr.grid[i, k, j] = 3

                     n += 1

+                if h > 0 and h < wr.r:

                     wr.grid[i, int(h), j] = 4

         return n

     def world_min(self, wr):

-        wr.add_voxel((0, 0, 0))

+        wr.set_voxel((0, 0, 0), 1)

         return 1

     def world_grid(self, wr):

@@ -29,35 +29,42 @@ class SquareMesh(entity.Entity):

         self.verts = np.delete(self.verts, np.s_[3 * ind:3 * (ind + 2)], 0)

         del self.faces[ind:ind + 2]

-    def cube_col(self, fd, axis, corner):

+    def cube_mat(self, fd, axis, corner):

         if not isinstance(fd, int):

             fd = self.grid[*fd]

         match fd:

             case 0:

-                return vec([0.0, 0.0, 0.0, 0.0])

+                return (vec([0.0, 0.0, 0.0, 0.0]), vec([1.0, 0.0, 0.0, 1.0]))

             case 1:

-                return vec([*np.add(0.5, axis2offset(axis, 0.5)), 1.0])

+                return (vec([*np.add(0.5, axis2offset(axis, 0.5)), 1.0]), vec([1.0, 0.0, 0.1, 128.0]))

             case 2:

-                top = vec([0.5, 0.5, 1.0, 1.0])

-                bottom = vec([0.0, 0.0, 0.5, 1.0])

+                top = (vec([0.5, 0.5, 1.0, 1.0]), vec([1.0, 0.0, 0.0, 1.0]))

+                bottom = (vec([0.0, 0.0, 0.5, 1.0]), vec([1.0, 0.0, 0.0, 1.0]))

                 match axis:

-                    case 3 | -3:

-                        return top if corner < 2 else bottom

-                    case 1 | -1:

-                        return top if not corner % 2 else bottom

                     case 2:

                         return top

                     case -2:

                         return bottom

+                    case a:

+                        return bottom if corner & (1 << ((a % 4) // 2)) else top

             case 3:

-                return vec([0.7, 0.7, 0.8, 1.0])

+                return (vec([0.7, 0.7, 0.8, 1.0]), vec([0.5, 0.5, 0.01, 2.0]))

             case 4:

-                return vec([0.5, 0.2, 0.0, 1.0])

+                top = (vec([0.2, 0.6, 0.2, 1.0]), vec([0.6, 0.4, 0.0, 1.0]))

+                bottom = (vec([0.5, 0.2, 0.0, 1.0]), vec([0.8, 0.2, 0.0, 1.0]))

+                match axis:

+                    case 2:

+                        return top

+                    case -2:

+                        return bottom

+                    case a:

+                        return bottom if corner & (2 >> ((a % 4) // 2)) else top

+                return 

-    def col_list(self):

-        cl = np.empty((3 * len(self.faces), 4), dtype=FLOAT)

+    def mat_list(self):

+        cl = np.empty((2, 3 * len(self.faces), 4), dtype=FLOAT)

         for s in range(len(self.faces) // 2):

             axis, fd = self.faces[2 * s]

-            for (t, c) in enumerate([0, 1, 2, 3, 2, 1] if axis > 0 else [1, 2, 3, 2, 1, 0]):

-                cl[6 * s + t] = self.cube_col(fd, axis, c)

+            for (t, c) in enumerate([0, 1, 2, 3, 2, 1] if (True or axis > 0) else [1, 2, 3, 2, 1, 0]):

+                cl[0][6 * s + t], cl[1][6 * s + t] = self.cube_mat(fd, axis, c)

         return cl

@@ -25,13 +25,13 @@ class Player(camera.Camera):

             "fps": entity.Entity(

                 [[0.0, 0.0, 0.0], [0.1, 0.0, 0.0], [0.0, -0.1, 0.0], [0.1, -0.1, 0.0]],

                 YELLOW, [-1.0, 1.0, 0.0], mode=GL_TRIANGLE_STRIP, hud=True

-            ),

+            )

         }

-        offset = [0, 0, 20]

+        offset = [0, 0, 30]

         for d in range(3):

             roll_vec3(offset, 1)

             for s in range(2):

-                self.hud["skybox"].add_sq((d + 1) * (-1) ** s, 40, (-1) ** s * vec(offset), 2)

+                self.hud["skybox"].add_sq((d + 1) * (-1) ** s, 60, (-1) ** s * vec(offset), 2)

         self.hud["shl"].draw_mode = GL_LINE_STRIP

         self.hud["shl"].add_sq(2, 0.96, [0, 0, 0], 2)

         self.hud["shl"].verts[:] = self.hud["shl"].verts[[0, 1, 3, 2, 0, 3]]

@@ -79,11 +79,11 @@ class Player(camera.Camera):

             case pygame.WINDOWSIZECHANGED | pygame.WINDOWRESIZED:

                 self.viewport = reshape(ev.x, ev.y)

-    def draw_hud(self, wr, perf):

+    def draw_hud(self, wrs, perf):

         self.hud["skybox"].pos = self.pos

-        c, ap = self.target([wr])

+        c, ap = self.target(wrs)

         if c:

-            self.hud["shl"].pos = ap[1] + axis2offset(ap[0], 0.52)

+            self.hud["shl"].pos = c.pos + ap[1] + axis2offset(ap[0], 0.52)

             self.hud["shl"].orient[:3, :3] = np.sign(ap[0]) * np.roll(np.identity(3), abs(ap[0]) + 1, 0)

         else:

             self.hud["shl"].pos = vec([0, 0, 0])

@@ -14,12 +14,14 @@ def intersect_box(ro, rd, c, s):

         return None, None

 class WorldRegion(mesh.SquareMesh):

-    def __init__(self, size=16):

+    def __init__(self, size=8):

         super().__init__(refls=[0.5, 0.5, 0.5, 32.0])

         self.grid = np.zeros((size, size, size), dtype=VOXEL_TYPE)

         self.r = size

     def set_voxel(self, pos, vt=0):

+        if any(pos < 0) or any(pos >= self.r):

+            return pos

         self.grid[*pos] = vt

         if vt == 0:

             self.remesh()

@@ -33,7 +35,7 @@ class WorldRegion(mesh.SquareMesh):

                     o = np.array(axis2offset(a), dtype=np.int64)

                     bc = bool(self.grid[*(pos + o)])

                     if bp ^ bc:

-                        a *= bc - bp

+                        a *= bp - bc

                         self.add_sq(a, 1, pos + o / 2, pos + (0 if bp else o))

     def remesh(self):

@@ -79,12 +81,12 @@ class WorldRegion(mesh.SquareMesh):

             ids = []

             for i in range(3):

                 k = np.arange(self.r + 1) if rd[i] >= 0 else np.arange(self.r + 1, 0, -1)

-                ids.append([(d, i) for d in (k - 0.5 - ro[i]) / rd[i]])

+                ids.append([(d, i) for d in (self.pos[i] + k - 0.5 - ro[i]) / rd[i]])

             q, p = None, None

             for (te, i) in heapq.merge(*ids):

                 if te < 0 or te < tn or te > tf - 1e-3:

                     continue

-                q, p = p, np.astype(np.round(ro + (te + 1e-8) * rd - self.pos), np.int16)

+                q, p = p, np.astype(np.round(ro + (te + 1e-4) * rd - self.pos), np.int16)

                 assert q is None or abs(np.sum(p - q)) == 1

                 if self.grid[*p]:

                     sa = np.astype((i + 1) * -np.sign(rd[i]), np.int8)