voxels

@@ -29,7 +29,8 @@ class Camera:

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

+        p = self.pos

+        m[:3, 3] = [-s @ p, -u @ p, f @ p]

         return m

     def persp_mat(self):

@@ -45,12 +46,13 @@ class Camera:

         ])

     def mvp(self, ent):

-        if ent.hud:

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

+        vp = np.identity(4, dtype=FLOAT)

+        if ent.hud:

             am[0, 0] = 1 / self.aspect()

-            return ent.translate() @ am @ ent.orient

         else:

-            return self.persp_mat() @ self.view_mat() @ ent.translate() @ ent.orient

+            vp = self.persp_mat() @ self.view_mat()

+        return vp @ ent.translate() @ am @ ent.orient

     def draw(self, ent):

         if not ent.verts.shape[0]:

@@ -0,0 +1,60 @@

+from libs import *

+from OpenGL.GL import shaders

+import os

+

+VS = f"""

+#version 120

+{"\n".join([f"attribute {a};" for a in VERTEX_ATTRS])}

+{"\n".join([f"varying {a}F;" for a in VERTEX_ATTRS])}

+{"\n".join([

+    f"uniform {v[1]} {k};" for (k, v) in UNIFORMS.items() if v[0] == "vert"

+])}

+void main() {{

+    gl_Position = MVP * vec4(position, 1.0);

+{"\n".join([f"    {a.split()[1]}F = {a.split()[1]};" for a in VERTEX_ATTRS])}

+}}

+"""

+

+FS = f"""

+#version 120

+{"\n".join([f"varying {a}F;" for a in VERTEX_ATTRS])}

+{"\n".join([

+    f"uniform {v[1]} {k};" for (k, v) in UNIFORMS.items() if v[0] == "frag"

+])}

+void main() {{

+    float ambient = reflsF.x;

+    vec3 lightDir = normalize(lightPos.xyz - positionF);

+    float diffuse = reflsF.y * lightPos.w *

+        dot(normalF, lightDir) / pow(distance(lightPos.xyz, positionF), 2);

+    float specular = reflsF.z * lightPos.w * pow(max(dot(

+        normalize(camPos - positionF), reflect(-lightDir, normalF)

+    ), 0.0), reflsF.w);

+    gl_FragColor = vec4((ambient + diffuse + specular) * colF.xyz, colF.w);

+}}

+"""

+

+def init_display():

+    pygame.init()

+    full = os.environ.get("FULLSCREEN")

+    pygame.display.set_mode((640, 480),

+        pygame.DOUBLEBUF | pygame.OPENGL |

+        (pygame.FULLSCREEN | pygame.SCALED if full else pygame.RESIZABLE),

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

+        shaders.compileShader(FS, GL_FRAGMENT_SHADER)

+    )

+    for (k, v) in UNIFORMS.items():

+        v[2] = glGetUniformLocation(sp, k)

+    glUseProgram(sp)

+    glEnable(GL_DEPTH_TEST)

+    glEnable(GL_BLEND)

+    glEnable(GL_CULL_FACE)

+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

+    glClearColor(0.1, 0.1, 0.1, 1.0)

@@ -1,15 +1,25 @@

 from libs import *

+from raycast import intersect_tri

+import types

+

+draw_modes = types.SimpleNamespace()

+draw_modes.TRI_STRIP = GL_TRIANGLE_STRIP

+draw_modes.TRI_FAN = GL_TRIANGLE_FAN

+draw_modes.TRIS = GL_TRIANGLES

+draw_modes.LINE_STRIP = GL_LINE_STRIP

+draw_modes.LINES = GL_LINES

 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", [1.0, 0.0, 0.0, 1.0] if self.hud else [0.5, 0.5, 0.0, 32.0]))

+        refl = [1.0, 0.0, 0.0, 1.0] if self.hud else [0.5, 0.5, 0.0, 32.0]

+        self.refls = vec(kwargs.get("refls", refl))

         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, h: print(f"clicked {s}:{n} with button {b}, hand {h}")

+        self.onclick = lambda s, b, n, h: print(f"{h}:{b} on {s}:{n}")

         self.vao = None

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

@@ -18,19 +28,20 @@ class Entity:

     def norm_list(self):

         l = []

-        if self.draw_mode == GL_TRIANGLE_STRIP or self.draw_mode == GL_TRIANGLE_FAN:

+        match self.draw_mode:

+            case draw_modes.TRI_STRIP | draw_modes.TRI_FAN:

                 l.append(norm_tri(self.verts[:3]))

                 for i in range(1, len(self.verts) - 1):

                     l.append(norm_tri(self.verts[i - 1:i + 2]))

                 l.append(norm_tri(self.verts[-3:]))

-        elif self.draw_mode == GL_TRIANGLES:

+            case draw_modes.TRIS:

                 for i in range(0, len(self.verts), 3):

                     for _ in range(3):

                         l.append(norm_tri(self.verts[i:i + 3]))

-        elif self.draw_mode == GL_LINE_STRIP or self.draw_mode == GL_LINES:

+            case draw_modes.LINE_STRIP | draw_modes.LINES:

                 for _ in range(len(self.verts)):

                     l.append([1, 0, 0])

-        else:

+            case _:

                 raise NotImplementedError

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

@@ -66,14 +77,17 @@ class Entity:

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

             return

         elif self.draw_mode == GL_TRIANGLE_STRIP:

-            tl = ((i, self.verts[i:i + 3]) for i in range(len(self.verts) - 2))

+            ir = range(len(self.verts) - 2)

+            tl = ((i, self.verts[i:i + 3]) for i in ir)

         elif self.draw_mode == GL_TRIANGLES:

-            tl = ((i, self.verts[3 * i:3 * (i + 1)]) for i in range(len(self.verts) // 3))

+            ir = range(len(self.verts) // 3)

+            tl = ((i, self.verts[3 * i:3 * (i + 1)]) for i in ir)

         else:

             raise NotImplementedError

         d, n = None, None

         for (i, t) in tl:

-            r = intersect_tri(ro, rd, np.dot(t, self.orient[:3, :3].T) + self.pos)

+            t = np.dot(t, self.orient[:3, :3].T) + self.pos

+            r = intersect_tri(ro, rd, t)

             if r and (d is None or r < d):

                 d, n = r, i

         return d, n

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

+from libs import *

+import entity

+import mesh

+

+def crosshair():

+    return entity.Entity(

+        [[-0.03, 0, 0], [0.03, 0, 0], [0, -0.03, 0], [0, 0.03, 0]],

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

+    )

+

+def fps():

+    return entity.Entity(

+        [[0, 0, 0], [0, -0.1, 0], [0.1, 0, 0], [0.1, -0.1, 0]],

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

+    )

+

+def hand():

+    h = mesh.SquareMesh(hud=True)

+    h.add_sq(1, 1, [0.5, 0, 0], 1)

+    h.add_sq(2, 1, [0, 0.5, 0], 1)

+    h.add_sq(3, 1, [0, 0, 0.5], 1)

+    h.pos = [0.8, -0.8, 0.0]

+    h.rotate(-1, [0, 1, 0])

+    h.rotate(0.1, [1, 0, 0])

+    h.orient[:3, :3] *= 0.2

+    return h

+

+def selection():

+    s = mesh.SquareMesh()

+    s.draw_mode = GL_LINE_STRIP

+    s.add_sq(-2, 0.96, [0, 0, 0], 2)

+    s.verts[:] = s.verts[[0, 1, 3, 2, 0, 3]]

+    return s

+

+def skybox():

+    sb = mesh.SquareMesh()

+    offset = [0, 0, VIEW_DIST]

+    for d in range(3):

+        roll_vec3(offset, 1)

+        for s in range(2):

+            sf = (-1) ** s

+            sb.add_sq((d + 1) * sf, 2 * VIEW_DIST, sf * vec(offset), 2)

+            i = 6 * (2 * d + s) + 1

+            for t in range(2):

+                vp = np.s_[i + 3 * t:i + 3 * t + 2]

+                sb.verts[vp] = sb.verts[vp][::-1]

+    return sb

+

+def sun():

+    s = entity.Entity(

+        [[0.0, 0.0, 0.0]], [1.0, 1.0, 0.9, 1.0],

+        normalise(LIGHT_POS) * VIEW_DIST, mode=GL_TRIANGLE_FAN

+    )

+    cv = []

+    for k in np.arange(0, 1.01, 0.05):

+        cv.append([np.cos(2 * np.pi * k), 0, np.sin(2 * np.pi * k)])

+    s.verts = np.concatenate((s.verts, np.multiply(3, cv)), dtype=FLOAT)

+    return s

@@ -1,6 +1,6 @@

 from libs import *

 import camera

-import entity

+import huds

 def reshape(w, h):

     glViewport(0, 0, w, h)

@@ -10,39 +10,40 @@ 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.vaa_vel = 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

-            )

+            "crosshair": huds.crosshair()

         }

-    def set_focus(self, f): 

-        pygame.event.set_grab(f)

-        pygame.mouse.set_visible(not f)

+    def set_focus(self, focus): 

+        pygame.event.set_grab(focus)

+        pygame.mouse.set_visible(not focus)

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

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

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

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

+        self.phi += self.sensitivity * dy

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

-    def update_motion(self, pk):

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

+    def update_motion(self, pressed, mg=None):

+        diffs = [0, 0, 0]

+        for i in range(3):

+            diffs[i] = pressed[ARROWS[2 * i]] - pressed[ARROWS[2 * i + 1]]

+        self.vaa_vel = vec(diffs)

-    def vdof(self):

+    def vaa_mat(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

+        self.pos += self.speed * self.vaa_mat() @ self.vaa_vel.T

     def handle_event(self, ev, mg):

         match ev.type:

@@ -53,6 +54,6 @@ class InteractiveCamera(camera.Camera):

             case pygame.WINDOWSIZECHANGED | pygame.WINDOWRESIZED:

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

-    def draw_hud(self, wrs, perf):

+    def draw_hud(self, regions, perf):

         for ent in self.hud.values():

             self.draw(ent)

@@ -6,13 +6,23 @@ import pygame

 FLOAT = np.float32

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

+UNIFORMS = {

+    "MVP": ["vert", "mat4", None],

+    "lightPos": ["frag", "vec4", None],

+    "camPos": ["frag", "vec3", None]

+}

 LIGHT_POS = [5, 30, 10]

+REGION_SIZE = 8

 GRAVITY = 1

 VIEW_DIST = 30

 FPS = 60

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

+ARROWS = [

+    ["RIGHT", "e", "d"], ["LEFT", "a"],

+    ["SPACE"], ["LSHIFT"],

+    ["UP", "COMMA", "w"], ["DOWN", "o", "s"],

+]

+ARROWS = [[getattr(pygame, f"K_{n}") for n in opts] for opts in ARROWS]

 def vec(l):

     return np.array(l, dtype=FLOAT)

@@ -32,34 +42,21 @@ def roll_vec3(l, k):

         case 2:

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

-def axis2offset(a, x=1):

-    o = [0, 0, x * np.sign(a)]

+def axis2offset(a, mag=1):

+    o = [0, 0, mag * np.sign(a)]

     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]

+def smerp(corners, weights):

+    for w in weights:

+        t = w ** 2 * (3 - 2 * w)

+        pairs = zip(corners[::2], corners[1::2])

+        corners = [a + t * (b - a) for (a, b) in pairs]

+    return corners[0]

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

-def intersect_tri(ro, rd, tv):

-    e1 = tv[1] - tv[0]

-    e2 = tv[2] - tv[0]

-    to = ro - tv[0]

-    n = np.cross(e1, e2)

-    q = np.cross(to, rd)

-    d = 1.0 / np.dot(rd, n)

-    u = d * np.dot(-q, e2)

-    v = d * np.dot(q, e1)

-    t = d * np.dot(-n, to)

-    if u > 0.0 and v > 0.0 and u + v < 1.0 and t > 1e-3:

-        return t

-

-def norm_tri(tv):

-    assert tv.shape[0] == 3

-    return normalise(np.cross(tv[2] - tv[0], tv[1] - tv[0]))

+def norm_tri(verts):

+    assert verts.shape[0] == 3

+    return normalise(np.cross(verts[2] - verts[0], verts[1] - verts[0]))

 def update_attr(ent, n, l=None):

     if isinstance(n, int):

@@ -1,45 +1,14 @@

-from OpenGL.GL import shaders

 from libs import *

+from display import init_display

 from entity import Entity

 from mapgen import MapGen

 from mesh import SquareMesh

 from player import Player

 from region import WorldRegion

-import os

-

-VS = f"""

-#version 120

-{"\n".join([f"attribute {a};" for a in VERTEX_ATTRS])}

-{"\n".join([f"varying {a}F;" for a in VERTEX_ATTRS])}

-{"\n".join([f"uniform {v[1]} {k};" for (k, v) in UNIFORMS.items() if v[0] == "vert"])}

-void main() {{

-    gl_Position = MVP * vec4(position, 1.0);

-{"\n".join([f"    {a.split()[1]}F = {a.split()[1]};" for a in VERTEX_ATTRS])}

-}}

-"""

-

-FS = f"""

-#version 120

-{"\n".join([f"varying {a}F;" for a in VERTEX_ATTRS])}

-{"\n".join([f"uniform {v[1]} {k};" for (k, v) in UNIFORMS.items() if v[0] == "frag"])}

-void main() {{

-    float ambient = reflsF.x;

-    vec3 lightDir = normalize(lightPos.xyz - positionF);

-    float lambert = dot(normalF, lightDir);

-    float diffuse = reflsF.y * lightPos.w * lambert / pow(distance(lightPos.xyz, positionF), 2);

-    float specular = reflsF.z * lightPos.w * pow(max(dot(normalize(camPos - positionF), reflect(-lightDir, normalF)), 0.0), reflsF.w);

-    gl_FragColor = vec4((ambient + diffuse + specular) * colF.xyz, colF.w);

-}}

-"""

 def debug_mode(mg, cam):

     pass

-def build_scene():

-    mg = MapGen()

-    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

@@ -49,23 +18,9 @@ def in_view(wr, cam):

     return close and frust

 def main():

-    pygame.init()

-    pygame.display.set_mode((640, 480), pygame.DOUBLEBUF | pygame.OPENGL | (pygame.FULLSCREEN | pygame.SCALED if os.environ.get("FULLSCREEN") else pygame.RESIZABLE), 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),

-        shaders.compileShader(FS, GL_FRAGMENT_SHADER)

-    )

-    for (k, v) in UNIFORMS.items():

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

+    init_display()

     glUniform4fv(UNIFORMS["lightPos"][2], 1, vec([*LIGHT_POS, 100]))

-    mg = build_scene()

+    mg = MapGen()

     clock = pygame.time.Clock()

     cam = Player(speed=6/FPS)

     cam.pos = [4, 8, 4]

@@ -76,10 +31,16 @@ def main():

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

+            match ev.type:

+                case pygame.QUIT:

+                    pygame.quit()

+                    return

+                case pygame.KEYUP:

+                    match ev.unicode:

+                        case "q":

                             pygame.quit()

                             return

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

+                        case "d":

                             debug_mode(mg, cam)

             cam.handle_event(ev, mg, scene)

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

@@ -5,7 +5,11 @@ import world

 class MapGen(world.WorldHolder):

     def __init__(self):

         super().__init__()

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

+        self.grads = []

+        for d in range(4):

+            self.grads.append(defaultdict(lambda dim=d:

+                defaultdict(lambda: normalise(np.random.normal(size=dim)))

+            ))

         self.poissons = {}

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

@@ -18,9 +22,7 @@ class MapGen(world.WorldHolder):

         dots = []

         for c in corners:

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

-            cg = gt[ci]

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

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

+            dots.append(np.dot(fract - c, gt[ci]))

         return 2 * smerp(dots, fract)

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

@@ -28,7 +30,9 @@ class MapGen(world.WorldHolder):

         if name in self.poissons:

             gt = self.poissons[name]

         else:

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

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

@@ -36,17 +40,24 @@ class MapGen(world.WorldHolder):

         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, 20])) - wr.pos[1]

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

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

+                                b = 7 - u - abs(v)

+                                for w in range(-b, b + 1):

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

         return n

@@ -29,14 +29,18 @@ 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_mat(self, fd, axis, corner):

-        if not isinstance(fd, int):

-            fd = self.grid[*fd]

-        match fd:

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

+        if not isinstance(face_desc, int):

+            face_desc = self.grid[*face_desc]

+        face_orient = ((axis % 4) // 2)

+        match face_desc:

             case 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]), vec([1.0, 0.0, 0.1, 128.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.2, 0.2, 1.0, 1.0]), vec([1.0, 0.0, 0.0, 1.0]))

                 bottom = (vec([0.0, 0.0, 0.2, 1.0]), vec([1.0, 0.0, 0.0, 1.0]))

@@ -46,7 +50,7 @@ class SquareMesh(entity.Entity):

                     case -2:

                         return bottom

                     case a:

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

+                        return bottom if corner & (2 >> face_orient) else top

             case 3:

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

             case 4:

@@ -58,7 +62,7 @@ class SquareMesh(entity.Entity):

                     case -2:

                         return bottom

                     case a:

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

+                        return bottom if corner & (1 << face_orient) else top

                 return 

             case 5:

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

@@ -75,6 +79,7 @@ class SquareMesh(entity.Entity):

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

+            for (t, c) in enumerate([0, 1, 2, 3, 2, 1]):

+                i = 6 * s + t

+                cl[0][i], cl[1][i] = self.cube_mat(fd, axis, c)

         return cl

@@ -1,61 +1,39 @@

 from libs import *

 import interactive

-import entity

-import mesh

+import huds

 class Player(interactive.InteractiveCamera):

     def __init__(self, **kwargs):

         super().__init__(**kwargs)

-        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

-        )

-        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, 2 * VIEW_DIST, (-1) ** s * vec(offset), 2)

-        self.hud["sun"] = entity.Entity(

-            [[0.0, 0.0, 0.0], *[[2 * np.cos(2 * np.pi * k), 0, 2 * np.sin(2 * np.pi * k)] for k in np.arange(0, 1.01, 0.05)]],

-            [1.0, 1.0, 0.8, 1.0], normalise(LIGHT_POS) * VIEW_DIST, mode=GL_TRIANGLE_FAN

-        )

-        h = mesh.SquareMesh(hud=True)

-        self.hud["hand"] = h

-        h.add_sq(1, 1, [0.5, 0, 0], 1)

-        h.add_sq(2, 1, [0, 0.5, 0], 1)

-        h.add_sq(3, 1, [0, 0, 0.5], 1)

-        h.pos = [0.8, -0.8, 0.5]

-        h.rotate(2, [0, 1, 0])

-        h.rotate(-0.1, [1, 0, 0])

-        h.orient[:3, :3] *= 0.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]]

+        self.hud["fps"] = huds.fps()

+        self.hud["skybox"] = huds.skybox()

+        self.hud["sun"] = huds.sun()

+        self.hud["hand"] = huds.hand()

+        self.hud["shl"] = huds.selection()

         self.hand = 1

         self.collides = True

         self.falls = 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)):

+    def update_motion(self, pressed, mg):

+        netv = [0, 0, 0]

+        for i in range(3):

             for s in range(2):

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

-                    va = mg.voxel_at(self.pos + o)

-                    if va:

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

+                sf = (-1) ** s

+                cp = self.pos + sf * self.vaa_mat()[i]

+                if self.collides and mg.voxel_at(cp):

+                    pass

                 elif self.falls and i == 1 and s == 1:

-                        netv[i] = self.rv[i] - GRAVITY / FPS

-        self.rv = vec(netv)

+                    netv[i] = self.vaa_vel[i] - GRAVITY / FPS

+                else:

+                    netv[i] += sf * any(pressed[j] for j in ARROWS[2 * i + s])

+        self.vaa_vel = vec(netv)

-    def set_hand(self, nh):

-        nh = int(nh)

-        self.hand = nh

-        self.hud["hand"].faces = [(a, self.hand) for (a, _) in self.hud["hand"].faces]

+    def set_hand(self, new_hand):

+        self.hand = int(new_hand)

+        hg = self.hud["hand"]

+        hg.faces = [(a, self.hand) for (a, _) in hg.faces]

         for i in range(1, 4, 2):

-            update_attr(self.hud["hand"], i)

+            update_attr(hg, i)

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

         super().handle_event(ev, mg)

@@ -83,10 +61,18 @@ class Player(interactive.InteractiveCamera):

         c, ap = self.target(wrs)

         if c:

             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)

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

-        self.hud["fps"].col = GREEN if 0.9 < perf < 1.1 else YELLOW if perf > 0.5 else RED

+        if 0.9 < perf < 1.1:

+            perf_col = GREEN

+        elif perf > 0.5:

+            perf_col = YELLOW

+        else:

+            perf_col = RED

+        self.hud["fps"].col = perf_col

         update_attr(self.hud["fps"], "col")

         for ent in self.hud.values():

             self.draw(ent)

@@ -0,0 +1,26 @@

+from libs import *

+

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

+def intersect_tri(ro, rd, verts):

+    e1 = verts[1] - verts[0]

+    e2 = verts[2] - verts[0]

+    to = ro - verts[0]

+    n = np.cross(e1, e2)

+    q = np.cross(to, rd)

+    d = 1.0 / np.dot(rd, n)

+    u = d * np.dot(-q, e2)

+    v = d * np.dot(q, e1)

+    t = d * np.dot(-n, to)

+    if u > 0.0 and v > 0.0 and u + v < 1.0 and t > 1e-3:

+        return t

+

+def intersect_box(ro, rd, c, s):

+    m = 1 / rd

+    n = m * (ro - c)

+    k = np.abs(m) * s

+    tn = np.max(-n - k)

+    tf = np.min(-n + k)

+    if tf > tn and tf > 0:

+        return tn, tf

+    else:

+        return None, None

@@ -1,36 +1,28 @@

 from libs import *

+from raycast import intersect_box

 import heapq

 import mesh

-def intersect_box(ro, rd, c, s):

-    m = 1 / rd

-    n = m * (ro - c)

-    k = np.abs(m) * s

-    tn = np.max(-n - k)

-    tf = np.min(-n + k)

-    if tf > tn and tf > 0:

-        return tn, tf

-    else:

-        return None, None

-

 class WorldRegion(mesh.SquareMesh):

-    def __init__(self, size=8):

+    def __init__(self, size=REGION_SIZE):

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

+    def set_voxel(self, pos, voxel_type=0):

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

             return pos

-        self.grid[*pos] = vt

-        if vt == 0:

+        self.grid[*pos] = voxel_type

+        if voxel_type == 0:

             self.remesh()

         else:

-            bp = bool(vt)

+            bp = bool(voxel_type)

             for d in range(3):

                 for s in range(2):

-                    if pos[d] == self.r - 1 and s == 0 or pos[d] == 0 and s == 1:

+                    oob = pos[d] == self.r - 1 and s == 0

+                    oob |= s == 0 or pos[d] == 0 and s == 1

+                    if oob:

                         continue

                     a = (d + 1) * (-1) ** s

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

@@ -76,7 +68,9 @@ class WorldRegion(mesh.SquareMesh):

         self.dirty = False

     def norm_list(self):

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

+        return np.astype(np.repeat([

+            axis2offset(a) for (a, _) in self.faces

+        ], 3, 0), FLOAT)

     def raycast(self, ro, rd):

         vr = np.repeat(self.r, 3)

@@ -84,12 +78,17 @@ class WorldRegion(mesh.SquareMesh):

         if tn is not None:

             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 (self.pos[i] + k - 0.5 - ro[i]) / rd[i]])

+                if rd[i] >= 0:

+                    k = np.arange(self.r + 1)

+                else:

+                    k = np.arange(self.r + 1, 0, -1)

+                dists = (self.pos[i] + k - 0.5 - ro[i]) / rd[i]

+                ids.append([(d, i) for d in dists])

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

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

                     continue

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

+                p = ro + (te + 1e-4) * rd - self.pos

+                p = np.astype(np.round(p), np.int16)

                 if self.grid[*p]:

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

                     return te, (sa, p)

@@ -18,16 +18,19 @@ class WorldHolder():

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

             return wr

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

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

+        try:

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

+        except StopIteration:

+            r = REGION_SIZE

         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:

+        if voxel_type is None:

             return wr.grid[*it]

         else:

             old = wr.grid[*it]

-            wr.grid[*it] = vt

+            wr.grid[*it] = voxel_type

             wr.dirty = True

             return old