voxels

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

 *.swp

 *.log

-venv

+__pycache__/

+venv/

 tags

@@ -22,8 +22,8 @@ class Camera:

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

     def view_mat(self):

-        f = normalize(self.looking())

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

+        f = normalise(self.looking())

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

         u = np.cross(s, f)

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

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

@@ -50,10 +50,13 @@ class Camera:

         else:

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

-    def draw(self, ent, loc_mvp):

+    def draw(self, ent):

+        if not ent.verts.shape[0]:

+            return

         if not ent.vao:

             ent.build_vao()

-        glUniformMatrix4fv(loc_mvp, 1, GL_TRUE, self.mvp(ent))

+        glUniformMatrix4fv(UNIFORMS["MVP"][2], 1, GL_TRUE, self.mvp(ent))

+        glUniform3fv(UNIFORMS["camPos"][2], 1, self.pos)

         glBindVertexArray(ent.vao)

         glDrawArrays(ent.draw_mode, 0, len(ent.verts))

@@ -1,51 +1,48 @@

 from libs import *

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

-

 class Entity:

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

         self.verts = vec(verts)

         self.col = vec(col)

+        self.refls = vec(kwargs.get("refls", [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], [None, 0]]

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

     def col_list(self):

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

-    def update_attr(self, i, l=None):

-        if l is None:

-            l = self.verts if i == 0 else self.col_list()

-        if self.vao:

-            glBindBuffer(GL_ARRAY_BUFFER, self.vbos[i][0])

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

-                glBufferData(GL_ARRAY_BUFFER, l.nbytes, l, GL_DYNAMIC_DRAW)

-                self.vbos[i][1] = l.shape[0]

+    def norm_list(self):

+        l = []

+        if self.draw_mode == GL_TRIANGLE_STRIP:

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

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

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

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

         else:

-                glBufferSubData(GL_ARRAY_BUFFER, 0, l.nbytes, l)

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

-        for (i, l) in enumerate((self.verts, self.col_list())):

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

             self.vbos[i][0] = glGenBuffers(1)

-            self.update_attr(i, l)

+            l = update_attr(self, i)

             glEnableVertexAttribArray(i)

             glVertexAttribPointer(i, l.shape[1], GL_FLOAT, GL_FALSE, 0, None)

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

+from OpenGL.GL import *

+from OpenGL.GLU import *

+from OpenGL.GLUT import *

+import sys

+import time

+

+lf = time.time()

+fc = 0

+

+def reshape(width, height):

+    glViewport(0, 0, width, height)

+    glMatrixMode(GL_PROJECTION)

+    glLoadIdentity()

+    gluPerspective(45, width / float(height or 1), 1, 50)

+    glMatrixMode(GL_MODELVIEW)

+

+def draw_cube():

+    glutWireCube(1)

+

+def display():

+    global lf, fc

+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

+    glLoadIdentity()

+    glTranslatef(0, 0, -5)

+    glRotatef((60 * time.time()) % 360, 2, 1, 0)

+    draw_cube()

+    glutSwapBuffers()

+    fc += 1

+    now = time.time()

+    if now - lf >= 1.0:

+        print(f"{fc} FPS")

+        fc = 0

+        lf = now

+

+def keyboard(key, x, y):

+    if key == b'\x1b':  # ESC

+        glutLeaveMainLoop()

+

+glutInit(sys.argv)

+glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH)

+glutInitWindowSize(500, 500)

+glutInitWindowPosition(100, 100)

+glutCreateWindow("PyOpenGL Cube")

+glEnable(GL_DEPTH_TEST)

+

+glutDisplayFunc(display)

+glutIdleFunc(display)

+glutReshapeFunc(reshape)

+glutKeyboardFunc(keyboard)

+

+glutMainLoop()

@@ -5,6 +5,8 @@ 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]}

 def vec(l):

     return np.array(l, dtype=FLOAT)

@@ -13,7 +15,7 @@ RED = vec([1.0, 0.0, 0.0, 1.0])

 YELLOW = vec([1.0, 1.0, 0.0, 1.0])

 GREEN = vec([0.0, 1.0, 0.0, 1.0])

-def normalize(v):

+def normalise(v):

     norm = np.linalg.norm(v)

     return v / norm if norm > 0 else v

@@ -28,3 +30,46 @@ def axis2offset(a, x=1):

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

     roll_vec3(o, abs(a))

     return o

+

+# 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 update_attr(ent, n, l=None):

+    if isinstance(n, int):

+        i, name = n, VERTEX_ATTRS[n].split()[1]

+    elif isinstance(n, str):

+        # https://stackoverflow.com/a/30197797

+        i, name = next((i for (i, s) in enumerate(VERTEX_ATTRS) if n in s)), n

+    if l is None:

+        match name:

+            case "position":

+                l = ent.verts

+            case "col":

+                l = ent.col_list()

+            case "normal":

+                l = ent.norm_list()

+            case "refls":

+                l = ent.refls_list()

+    if ent.vao:

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

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

+            glBufferData(GL_ARRAY_BUFFER, l.nbytes, l, GL_DYNAMIC_DRAW)

+            ent.vbos[i][1] = l.shape[0]

+        else:

+            glBufferSubData(GL_ARRAY_BUFFER, 0, l.nbytes, l)

+        return l

@@ -6,24 +6,29 @@ from mesh import SquareMesh

 from player import Player

 from region import WorldRegion

-VS = """

+VS = f"""

 #version 120

-attribute vec3 position;

-attribute vec4 colIn;

-varying vec4 colOut;

-uniform mat4 MVP;

-void main() {

+{"\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);

-    colOut = colIn;

-}

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

+}}

 """

-FS = """

+FS = f"""

 #version 120

-varying vec4 colOut;

-void main() {

-    gl_FragColor = colOut;

-}

+{"\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);

+}}

 """

 FPS = 60

@@ -41,8 +46,8 @@ def click_mesh(self, button, coords):

             offset = axis2offset(coords[0])

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

     if button % 2 == 1:

-        self.update_attr(0)

-        self.update_attr(1)

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

+            update_attr(self, i)

 def build_scene(mg):

     box = WorldRegion()

@@ -59,10 +64,12 @@ def main():

         shaders.compileShader(VS, GL_VERTEX_SHADER),

         shaders.compileShader(FS, GL_FRAGMENT_SHADER)

     )

-    loc_mvp = glGetUniformLocation(sp, "MVP")

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

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

     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)

     clock = pygame.time.Clock()

@@ -80,9 +87,9 @@ def main():

         cam.update_pos()

         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

         for ent in scene:

-            cam.draw(ent, loc_mvp)

+            cam.draw(ent)

         perf = clock.get_fps() / FPS

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

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

         pygame.display.flip()

         clock.tick(FPS)

@@ -20,8 +20,10 @@ class MapGen:

         dots = []

         for c in corners:

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

-            dots.append(np.dot(fract - c, gt.setdefault(ci, np.random.rand(dim))))

-        return smerp(dots, fract)

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

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

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

+        return 2 * smerp(dots, fract)

     def world_natural(self, wr):

         n = 0

@@ -29,8 +31,9 @@ class MapGen:

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

-                    wr.grid[i, k, j] = 1

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

                     n += 1

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

         return n

     def world_min(self, wr):

@@ -19,7 +19,8 @@ class SquareMesh(entity.Entity):

             [-w, -w, 0], [w, -w, 0], [-w, w, 0]

         ]), abs(axis), 1)

         if axis < 0:

-            sq = np.flip(sq, 0)

+            sq[1:3] = sq[2:0:-1]

+            sq[4:6] = sq[5:3:-1]

         self.verts = np.concatenate((self.verts, sq), dtype=FLOAT)

         for i in range(2):

             self.faces.append((axis, fd))

@@ -48,6 +49,10 @@ class SquareMesh(entity.Entity):

                         return top

                     case -2:

                         return bottom

+            case 3:

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

+            case 4:

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

     def col_list(self):

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

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

             case pygame.WINDOWSIZECHANGED | pygame.WINDOWRESIZED:

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

-    def draw_hud(self, loc_mvp, wr, perf):

+    def draw_hud(self, wr, perf):

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

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

         if c:

@@ -88,6 +88,6 @@ class Player(camera.Camera):

         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

-        self.hud["fps"].update_attr(1)

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

         for ent in self.hud.values():

-            self.draw(ent, loc_mvp)

+            self.draw(ent)

@@ -15,13 +15,15 @@ def intersect_box(ro, rd, c, s):

 class WorldRegion(mesh.SquareMesh):

     def __init__(self, size=16):

-        super().__init__()

+        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 = 0

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

         self.grid[*pos] = vt

+        if vt == 0:

+            self.remesh()

+        else:

             bp = bool(vt)

             for d in range(3):

                 for s in range(2):

@@ -31,12 +33,8 @@ class WorldRegion(mesh.SquareMesh):

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

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

                     if bp ^ bc:

-                    a = (bp - bc) * (d + 1)

+                        a *= bc - bp

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

-        self.dirty += 1

-        if self.dirty > self.r:

-            self.dirty = 0

-            self.remesh()

     def remesh(self):

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

@@ -57,7 +55,10 @@ class WorldRegion(mesh.SquareMesh):

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

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

                             ])

-                            sq /= 2 * (bp - bc)

+                            sq /= 2

+                            if bp:

+                                sq[1:3] = sq[2:0:-1]

+                                sq[4:6] = sq[5:3:-1]

                             for v in sq:

                                 roll_vec3(v, d)

                             sq += p - offset / 2

@@ -68,19 +69,24 @@ class WorldRegion(mesh.SquareMesh):

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

         self.verts = vec(vl)

+    def norm_list(self):

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

         tn, tf = intersect_box(ro, rd, self.pos + vr / 2 - 0.5, vr / 2)

         if tn is not None:

-            if tn < 0:

-                tn = 0

-            ids = [[(d, i) for d in ((np.arange(self.r) + 0.5) * np.sign(rd[i]) - np.mod(ro[i] + tn * rd[i], 1)) / rd[i]] for i in range(3)]

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

+            q, p = None, None

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

-                ts = tn + te

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

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

-                    break

-                elif self.grid[*p]:

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

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

-                    return ts, (sa, p)

+                    return te, (sa, p)

         return None, None