voxels

@@ -22,9 +22,11 @@ class Camera:

         return self.viewport[0] / self.viewport[1]

     def view_mat(self):

-        f = normalise(self.looking())

-        s = normalise(np.cross(f, self.up()))

-        u = np.cross(s, f)

+        ct, st = np.cos(self.theta), np.sin(self.theta)

+        cp, sp = np.cos(self.phi), np.sin(self.phi)

+        f = vec([cp * st, sp, cp * ct])

+        s = vec([-ct, 0, st])

+        u = vec([-sp * st, cp, -sp * ct])

         m = np.identity(4, dtype=FLOAT)

         m[:3, :3] = [s, u, -f]

         m[:3, 3] = [-np.dot(s, self.pos), -np.dot(u, self.pos), np.dot(f, self.pos)]

@@ -9,7 +9,7 @@ class Entity:

         self.pos = vec(pos)

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

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

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

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

         self.vao = None

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

@@ -59,8 +59,8 @@ class Entity:

             [0, 0, 0, 1]

         ]) @ self.orient

-    def click(self, button, face):

-        self.onclick(self, button, face)

+    def click(self, button, face, hand=1):

+        self.onclick(self, button, face, hand)

     def raycast(self, ro, rd):

         if self.hud or self.draw_mode == GL_LINES:

@@ -73,7 +73,6 @@ def update_attr(ent, n, l=None):

                 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.mat_list()[1]

     if ent.vao:

@@ -39,9 +39,18 @@ def build_scene():

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

     return mg

+def in_view(wr, cam):

+    rwrc = wr.pos + wr.r / 2 - cam.pos

+    close = np.linalg.norm(rwrc) < VIEW_DIST

+    ld = cam.looking()

+    cv = rwrc + 8 * ld

+    frust = np.dot(cv, ld) / np.linalg.norm(cv) > 0.5

+    return close and frust

+

 def main():

     pygame.init()

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

+    pygame.display.set_mode((640, 480), pygame.DOUBLEBUF | pygame.OPENGL | pygame.FULLSCREEN | pygame.SCALED, vsync=1)

+    pygame.event.set_allowed([pygame.KEYDOWN, pygame.KEYUP, pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP, pygame.MOUSEMOTION, pygame.QUIT, pygame.WINDOWRESIZED, pygame.WINDOWSIZECHANGED])

     pygame.display.set_caption("Voxels")

     sp = shaders.compileProgram(

         shaders.compileShader(VS, GL_VERTEX_SHADER),

@@ -51,6 +60,8 @@ def main():

         v[2] = glGetUniformLocation(sp, k)

     glUseProgram(sp)

     glEnable(GL_DEPTH_TEST)

+    glEnable(GL_BLEND)

+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

     glClearColor(0.1, 0.1, 0.1, 1.0)

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

     mg = build_scene()

@@ -59,7 +70,10 @@ def main():

     cam.pos = [4, 8, 4]

     cam.set_focus(True)

     while True:

-        scene = list(filter(lambda wr: np.linalg.norm(wr.pos - cam.pos) < VIEW_DIST, mg.regions.values()))

+        scene = list(filter(lambda wr: in_view(wr, cam), mg.regions.values()))

+        for wr in scene:

+            if wr.dirty:

+                wr.remesh()

         for ev in pygame.event.get():

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

                 pygame.quit()

@@ -1,51 +1,16 @@

 from libs import *

-import region

+from collections import defaultdict

+import world

-class MapGen:

+class MapGen(world.WorldHolder):

     def __init__(self):

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

-        self.regions = {}

-

-    def fetch(self, pos):

-        if pos in self.regions:

-            return self.regions[pos]

-        else:

-            wr = region.WorldRegion()

-            wr.pos = vec(pos)

-            self.world_natural(wr)

-            wr.remesh()

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

+        super().__init__()

+        self.grads = [defaultdict(lambda dim=d: defaultdict(lambda: normalise(np.random.normal(size=dim)))) for d in range(4)]

+        self.poissons = {}

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

         dim = pos.shape[0]

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

+        gt = self.grads[dim][name]

         corner, fract = np.divmod(pos, period)

         fract /= period

         # https://stackoverflow.com/a/58827205

@@ -53,25 +18,40 @@ class MapGen:

         dots = []

         for c in corners:

             ci = tuple(np.add(c, corner, dtype=int, casting="unsafe"))

-            cg = gt.setdefault(ci, normalise(np.random.normal(size=dim)))

+            cg = gt[ci]

             assert abs(np.linalg.norm(cg) - 1) < 1e-3

             dots.append(np.dot(fract - c, cg))

         return 2 * smerp(dots, fract)

+    def poisson(self, name, pos, r, period):

+        dim = pos.shape[0]

+        if name in self.poissons:

+            gt = self.poissons[name]

+        else:

+            gt = defaultdict(lambda: np.random.poisson(1 / np.prod(period), np.repeat(r, dim)))

+            self.poissons[name] = gt

+        return gt[tuple((x // r) * r for x in pos)]

+

     def world_natural(self, wr):

         n = 0

         for i in range(wr.r):

             for j in range(wr.r):

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

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

+                if h > 0:

+                    wr.grid[i, :min(int(h), wr.r), j] = 3

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

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

+                    if 2 <= i < wr.r - 2 and 2 <= j < wr.r - 2 and self.poisson("trees", wr.pos[[0, 2]], wr.r, (6, 6))[i, j] >= 1:

+                        for u in range(1, 6):

+                            self.voxel_at(wr.pos + [0, h + u, 0], 5)

+                        for u in range(5, 7):

+                            for v in range(-7 + u, 8 - u):

+                                for w in range(-7 + u + abs(v), 8 - u - abs(v)):

+                                    self.voxel_at(wr.pos + [v, h + u, w], 6)

         return n

     def world_min(self, wr):

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

+        wr.grid[0, 0, 0] = 1

         return 1

     def world_grid(self, wr):

@@ -60,6 +60,16 @@ class SquareMesh(entity.Entity):

                     case a:

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

                 return 

+            case 5:

+                core = (vec([1.0, 1.0, 0.8, 1.0]), vec([0.4, 1.6, 0.0, 1.0]))

+                bark = (vec([0.4, 0.3, 0.0, 1.0]), vec([0.5, 0.5, 0.0, 1.0]))

+                match axis:

+                    case 2 | -2:

+                        return core

+                    case _:

+                        return bark

+            case 6:

+                return (vec([0.0, 0.4, 0.0, 0.5]), vec([0.6, 0.4, 0.01, 4.0]))

     def mat_list(self):

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

@@ -20,9 +20,12 @@ class Player(interactive.InteractiveCamera):

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

+        self.hand = 1

+        self.collides = True

     def update_motion(self, pk, mg):

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

+        if self.collides:

             for i in range(len(netv)):

                 for s in range(2):

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

@@ -36,12 +39,16 @@ class Player(interactive.InteractiveCamera):

             case pygame.KEYUP:

                 if ev.unicode == "\x1b":

                     self.set_focus(False)

+                elif "1" <= ev.unicode <= "9":

+                    self.hand = int(ev.unicode)

+                elif ev.unicode == "n":

+                    self.collides = not self.collides

             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)

+                    t.click(ev.button, n, self.hand)

     def draw_hud(self, wrs, perf):

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

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

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

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

         self.r = size

+        self.dirty = False

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

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

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

                             for _ in range(2):

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

         self.verts = vec(vl)

+        self.dirty = False

     def norm_list(self):

         return np.astype(np.repeat([axis2offset(a) for (a, _) in self.faces], 3, 0), FLOAT)

@@ -84,12 +86,10 @@ class WorldRegion(mesh.SquareMesh):

             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 (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-4) * rd - self.pos), np.int16)

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

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

                 if self.grid[*p]:

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

                     return te, (sa, p)

@@ -0,0 +1,51 @@

+from libs import *

+from collections import defaultdict

+import region

+

+class WorldHolder():

+    def __init__(self):

+        self.regions = {}

+

+    def fetch(self, pos):

+        if pos in self.regions:

+            return self.regions[pos]

+        else:

+            wr = region.WorldRegion()

+            wr.pos = vec(pos)

+            self.regions[pos] = wr

+            self.world_natural(wr)

+            wr.remesh()

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

+            return wr

+

+    def voxel_at(self, pos, vt=None):

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

+        it = tuple(int(c) for c in pf)

+        if vt is None:

+            return wr.grid[*it]

+        else:

+            old = wr.grid[*it]

+            wr.grid[*it] = vt

+            wr.dirty = True

+            return old

+

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

+        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, hand)

+                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, hand)

+        if button % 2 == 1:

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

+                update_attr(wr, i)