voxels

@@ -0,0 +1,58 @@

+from libs import *

+import camera

+import entity

+

+def reshape(w, h):

+    glViewport(0, 0, w, h)

+    return (w, h)

+

+class InteractiveCamera(camera.Camera):

+    def __init__(self, **kwargs):

+        super().__init__(**kwargs)

+        self.sensitivity = kwargs.get("sensitivity", 0.005)

+        self.rv = vec([0, 0, 0])

+        self.speed = kwargs.get("speed", 0.05)

+        self.hud = {

+            "crosshair": entity.Entity(

+                [[-0.03, 0.0, 0.0], [0.03, 0.0, 0.0], [0.0, -0.03, 0.0], [0.0, 0.03, 0.0]],

+                [1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0], mode=GL_LINES, hud=True

+            )

+        }

+

+    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):

+        return not pygame.mouse.get_visible()

+

+    def mouse_move(self, dx, dy):

+        self.theta = (self.theta - self.sensitivity * dx) % (2 * np.pi)

+        self.phi = min(np.pi / 2, max(-np.pi / 2, self.phi + self.sensitivity * dy))

+                

+    def update_motion(self, pk):

+        self.rv = vec([pk[a] - pk[b] for (a, b) in zip(ARROWS[::2], ARROWS[1::2])])

+

+    def vdof(self):

+        l = self.looking()

+        l[1] = 0

+        u = self.up()

+        return vec([normalise(np.cross(l, u)), u, normalise(l)])

+

+    def update_pos(self):

+        self.pos += self.speed * self.vdof() @ self.rv.T

+

+    def handle_event(self, ev, mg):

+        match ev.type:

+            case pygame.KEYUP | pygame.KEYDOWN if ev.key in ARROWS:

+                self.update_motion(pygame.key.get_pressed(), mg)

+            case pygame.MOUSEMOTION if self.get_focus():

+                self.mouse_move(ev.rel[0], -ev.rel[1])

+            case pygame.WINDOWSIZECHANGED | pygame.WINDOWRESIZED:

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

+

+    def draw_hud(self, wrs, perf):

+        for ent in self.hud.values():

+            self.draw(ent)

@@ -8,6 +8,10 @@ VOXEL_TYPE = np.uint8

 VERTEX_ATTRS = ["vec3 position", "vec4 col", "vec3 normal", "vec4 refls"]

 UNIFORMS = {"MVP": ["vert", "mat4", None], "lightPos": ["frag", "vec4", None], "camPos": ["frag", "vec3", None]}

+VIEW_DIST = 30

+FPS = 60

+ARROWS = [pygame.K_RIGHT, pygame.K_LEFT, pygame.K_SPACE, pygame.K_LSHIFT, pygame.K_UP, pygame.K_DOWN]

+

 def vec(l):

     return np.array(l, dtype=FLOAT)

@@ -31,6 +35,12 @@ def axis2offset(a, x=1):

     roll_vec3(o, abs(a))

     return o

+def smerp(ab, w):

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

+    for i in range(w.shape[0]):

+        ab = [a + w[i] ** 2 * (3 - 2 * w[i]) * (b - a) for (a, b) in zip(ab[::2], ab[1::2])]

+    return ab[0]

+

 # https://iquilezles.org/articles/intersectors/

 def intersect_tri(ro, rd, tv):

     e1 = tv[1] - tv[0]

@@ -31,31 +31,12 @@ void main() {{

 }}

 """

-FPS = 60

-

 def debug_mode(mg, cam):

     pass

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

-    match button:

-        case 1:

-            self.set_voxel(coords[1])

-        case 2:

-            print(f"coords {coords}")

-        case 3:

-            offset = axis2offset(coords[0])

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

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

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

     return mg

 def main():

@@ -74,18 +55,19 @@ def main():

     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 = Player(speed=6/FPS)

+    cam.pos = [4, 8, 4]

     cam.set_focus(True)

     while True:

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

+        scene = list(filter(lambda wr: np.linalg.norm(wr.pos - cam.pos) < VIEW_DIST, 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(mg, cam)

-            cam.handle_event(ev, scene)

+            cam.handle_event(ev, mg, scene)

+        cam.update_motion(pygame.key.get_pressed(), mg)

         cam.update_pos()

         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

         for ent in scene:

@@ -1,18 +1,12 @@

 from libs import *

 import region

-def smerp(ab, w):

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

-    for i in range(w.shape[0]):

-        ab = [a + w[i] ** 2 * (3 - 2 * w[i]) * (b - a) for (a, b) in zip(ab[::2], ab[1::2])]

-    return ab[0]

-

 class MapGen:

     def __init__(self):

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

         self.regions = {}

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

+    def fetch(self, pos):

         if pos in self.regions:

             return self.regions[pos]

         else:

@@ -20,11 +14,35 @@ class MapGen:

             wr.pos = vec(pos)

             self.world_natural(wr)

             wr.remesh()

-            if onclick:

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

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

             self.regions[pos] = wr

             return wr

+    def voxel_at(self, pos):

+        r = next(iter(self.regions.values())).r

+        pr, pf = np.divmod(pos + 0.5, r)

+        wr = self.fetch(tuple(int(r * c) for c in pr))

+        return wr.grid[*tuple(int(c) for c in pf)]

+

+    def click_region(self, wr, button, coords):

+        match button:

+            case 1:

+                wr.set_voxel(coords[1])

+            case 2:

+                print(f"coords {coords}")

+            case 3:

+                offset = axis2offset(coords[0])

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

+                if p is not None:

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

+                    awr = self.fetch(tuple(int(x) for x in rc))

+                    p = p % wr.r

+                    if not awr.grid[*p]:

+                        awr.set_voxel(p, 1)

+        if button % 2 == 1:

+            for i in range(len(VERTEX_ATTRS)):

+                update_attr(wr, i)

+

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

         dim = pos.shape[0]

         gt = self.grads[dim].setdefault(name, {})

@@ -1,83 +1,47 @@

 from libs import *

-import camera

+import interactive

 import entity

 import mesh

-ARROWS = [pygame.K_RIGHT, pygame.K_LEFT, pygame.K_SPACE, pygame.K_LSHIFT, pygame.K_UP, pygame.K_DOWN]

-

-def reshape(w, h):

-    glViewport(0, 0, w, h)

-    return (w, h)

-

-class Player(camera.Camera):

+class Player(interactive.InteractiveCamera):

     def __init__(self, **kwargs):

         super().__init__(**kwargs)

-        self.sensitivity = kwargs.get("sensitivity", 0.005)

-        self.rv = vec([0, 0, 0])

-        self.speed = kwargs.get("speed", 0.05)

-        self.hud = {

-            "skybox": mesh.SquareMesh(),

-            "shl": mesh.SquareMesh(),

-            "crosshair": entity.Entity(

-                [[-0.03, 0.0, 0.0], [0.03, 0.0, 0.0], [0.0, -0.03, 0.0], [0.0, 0.03, 0.0]],

-                [1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0], mode=GL_LINES, hud=True

-            ),

-            "fps": entity.Entity(

+        self.hud["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, 30]

+        self.hud["skybox"] = mesh.SquareMesh()

+        offset = [0, 0, VIEW_DIST]

         for d in range(3):

             roll_vec3(offset, 1)

             for s in range(2):

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

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

+        self.hud["shl"] = mesh.SquareMesh()

         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]]

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

-        return not pygame.mouse.get_visible()

-

-    def mouse_move(self, dx, dy):

-        self.theta = (self.theta - self.sensitivity * dx) % (2 * np.pi)

-        self.phi = min(np.pi / 2, max(-np.pi / 2, self.phi + self.sensitivity * dy))

-                

-    def update_motion(self, pk):

-        self.rv = vec([pk[a] - pk[b] for (a, b) in zip(ARROWS[::2], ARROWS[1::2])])

-

-    def vdof(self):

-        l = self.looking()

-        l[1] = 0

-        u = self.up()

-        return vec([np.cross(l, u), u, l])

-

-    def update_pos(self):

-        self.pos += self.speed * self.vdof() @ self.rv.T

+    def update_motion(self, pk, mg):

+        netv = [pk[a] - pk[b] for (a, b) in zip(ARROWS[::2], ARROWS[1::2])]

+        for i in range(len(netv)):

+            for s in range(2):

+                o = (-1) ** s * self.vdof()[i]

+                if mg.voxel_at(self.pos + o):

+                    netv[i] = (max if s else min)(netv[i], 0)

+        self.rv = vec(netv)

-    def handle_event(self, ev, scene):

+    def handle_event(self, ev, mg, scene):

+        super().handle_event(ev, mg)

         match ev.type:

-            case pygame.KEYUP | pygame.KEYDOWN:

-                if ev.unicode == "\x1b" and ev.type == pygame.KEYUP:

+            case pygame.KEYUP:

+                if ev.unicode == "\x1b":

                     self.set_focus(False)

-                elif ev.key in ARROWS:

-                    self.update_motion(pygame.key.get_pressed())

-            case pygame.MOUSEMOTION if self.get_focus():

-                self.mouse_move(ev.rel[0], -ev.rel[1])

             case pygame.MOUSEBUTTONUP if ev.button == 1:

                 self.set_focus(True)

             case pygame.MOUSEBUTTONDOWN if self.get_focus():

                 t, n = self.target(scene)

                 if t:

                     t.click(ev.button, n)

-            case pygame.WINDOWSIZECHANGED | pygame.WINDOWRESIZED:

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

     def draw_hud(self, wrs, perf):

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

@@ -39,6 +39,8 @@ class WorldRegion(mesh.SquareMesh):

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

     def remesh(self):

+        if not np.sum(self.grid):

+            return

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

         self.faces = []

         prev, curr = 0, 0

@@ -87,7 +89,7 @@ class WorldRegion(mesh.SquareMesh):

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

                     continue

                 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

+                assert q is None or np.sum(abs(p - q)) <= 2

                 if self.grid[*p]:

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

                     return te, (sa, p)