voxels

@@ -0,0 +1,11 @@

+PROF=profile.log

+

+run:

+	python main.py

+

+dbg:

+	python -m pdb -c 'break debug_mode' main.py

+

+prof:

+	python -m cProfile main.py >$(PROF)

+	$(PAGER) $(PROF)

@@ -16,3 +16,10 @@ GREEN = vec([0.0, 1.0, 0.0, 1.0])

 def normalize(v):

     norm = np.linalg.norm(v)

     return v / norm if norm > 0 else v

+

+def roll_vec3(l, k):

+    match k:

+        case 1:

+            l[:] = [l[2], l[0], l[1]]

+        case 2:

+            l[:] = [l[1], l[2], l[0]]

@@ -26,6 +26,9 @@ void main() {

 FPS = 240

+def debug_mode():

+    pass

+

 def click_mesh(self, button, ind):

     a, p = self.faces[ind]

     match button:

@@ -42,7 +45,7 @@ def click_mesh(self, button, ind):

 def build_scene():

     box = WorldRegion()

-    box.gen_perlin(np.random.rand(2, 2, 2, 3))

+    print(f"map generated with {box.gen_perlin(np.random.rand(2, 2, 2, 3))} voxels")

     box.remesh()

     box.onclick = click_mesh

     return [box]

@@ -69,6 +72,8 @@ def main():

             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()

             cam.handle_event(ev, scene)

         cam.update_pos()

         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

@@ -24,10 +24,12 @@ class Player(camera.Camera):

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

             ),

         }

+        self.viewport = (640, 480)

     def set_focus(self, f): 

         pygame.event.set_grab(f)

         pygame.mouse.set_visible(not f)

+        pygame.mouse.set_pos([self.viewport[0] / 2, self.viewport[1] / 2])

         self.hud["crosshair"].pos[0] = 2 * (not f)

     def get_focus(self):

@@ -73,3 +75,4 @@ class Player(camera.Camera):

                         t.click(ev.button, n)

             case pygame.WINDOWSIZECHANGED | pygame.WINDOWRESIZED:

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

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

@@ -11,6 +11,7 @@ class WorldRegion(mesh.SquareMesh):

     def __init__(self, size=16):

         super().__init__()

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

+        self.r = size

     def add_voxel(self, pos, vt=1):

         self.grid[*pos] = vt

@@ -20,30 +21,66 @@ class WorldRegion(mesh.SquareMesh):

     def remesh(self):

         offset = vec([0.5, 0.0, 0.0])

-        r = self.grid.shape[0]

-        self.verts = np.empty((0, 3), dtype=FLOAT)

         self.faces = []

-        for i in range(r):

-            for j in range(r):

-                for k in range(r):

-                    p = [i, j, k]

-                    if self.grid[*p]:

+        prev, curr = 0, 0

+        vl = []

         for d in range(3):

-                            for s in range(2):

-                                ts = (-1) ** s

-                                if p[d] == [r - 1, 0][s] or not self.grid[*(p + np.roll([ts, 0, 0], d))]:

-                                    self.add_sq(ts * (d + 1), 1, p + ts * np.roll(offset, d), p)

+            offset = np.array([1, 0, 0])

+            roll_vec3(offset, d)

+            for i in range(self.r):

+                for j in range(self.r):

+                    for k in range(self.r + 1):

+                        p = np.array([k, i, j])

+                        roll_vec3(p, d)

+                        prev, curr = curr, (self.grid[*p] if k < self.r else 0)

+                        bp, bc = bool(prev), bool(curr)

+                        if bp ^ bc:

+                            sq = vec([

+                                [0, 1, 1], [0, -1, 1], [0, 1, -1],

+                                [0, -1, -1], [0, 1, -1], [0, -1, 1]

+                            ])

+                            sq /= 2 * (bp - bc)

+                            for v in sq:

+                                roll_vec3(v, d)

+                            sq += p - offset / 2

+                            vl.extend(sq)

+                            if bp:

+                                p -= offset

+                            for _ in range(2):

+                                self.faces.append(((bp - bc) * (d + 1), p))

+        self.verts = vec(vl)

+

+    def prof_min(self):

+        self.add_voxel((0, 0, 0))

+        self.remesh()

+

+    def prof_med(self):

+        for i in range(self.r // 2):

+            for j in range(self.r // 2):

+                for k in range(self.r // 2):

+                    self.add_voxel((2 * i, 2 * j, 2 * k))

+        self.remesh()

+

+    def prof_max(self):

+        for i in range(self.r):

+            for j in range(self.r):

+                for k in range(self.r):

+                    if not (i + j + k) % 2:

+                        self.add_voxel((i, j, k))

+        self.remesh()

     def gen_perlin(self, grads):

-        r = self.grid.shape[0]

         corners = np.array([(i, j, k) for i in range(2) for j in range(2) for k in range(2)])

-        for i in range(r):

-            for j in range(r):

-                for k in range(r):

-                    w = np.array((i, j, k)) / r

+        n = 0

+        for i in range(self.r):

+            for j in range(self.r):

+                for k in range(self.r):

+                    w = np.array((i, j, k)) / self.r

                     d = [np.dot(grads[*c], w) for c in corners]

                     d = [interp(d[2 * k:2 * (k + 1)], w[2]) for k in range(4)]

                     d = [interp(d[:2], w[1]), interp(d[2:4], w[1])]

                     p = interp(d, w[0])

-                    if p < 0.6:

+                    if p > 2 * w[1] - 0.5:

                         self.add_voxel((i, j, k))

+                        n += 1

+        return n