voxels

@@ -65,16 +65,16 @@ class Camera:

     def target(self, scene):

         l = self.looking()

-        d, c = None, None

+        d, c, n = None, None, None

         for ent in scene:

             if ent.draw_mode == GL_TRIANGLE_STRIP:

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

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

             elif ent.draw_mode == GL_TRIANGLES:

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

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

             else:

                 raise NotImplementedError

-            for t in tl:

+            for (i, t) in tl:

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

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

-                    d, c = r, ent

-        return c

+                    d, c, n = r, ent, i

+        return c, n

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

         self.pos = vec(pos)

         self.draw_mode = mode

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

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

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

         self.vao = None

         self.vbos = [[None, 0], [None, 0]]

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

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

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

             else:

@@ -50,5 +50,5 @@ class Entity:

             [0, 0, 0, 1]

         ]) @ self.orient

-    def click(self, button):

-        self.onclick(self, button)

+    def click(self, button, face):

+        self.onclick(self, button, face)

@@ -24,9 +24,45 @@ void main() {

 }

 """

+WORLD_SIZE = 8

+

+world = np.zeros((WORLD_SIZE, WORLD_SIZE, WORLD_SIZE), dtype=np.uint8)

+for i in range(2):

+    for j in range(2):

+        for k in range(2):

+            world[-i % WORLD_SIZE, -j % WORLD_SIZE, -k % WORLD_SIZE] = 1

+cubes = []

+

+def place_voxel(mesh, ind):

+    a = mesh.faces[ind][0]

+    p = cubes[ind // 12] + np.sign(a) * np.roll([0, 0, 1], abs(a))

+    world[p] = 1

+    mesh.add_cube(1, p)

+    cubes.append(p)

+    mesh.update_attr(0)

+    mesh.update_attr(1)

+

+def break_voxel(mesh, ind):

+    p = cubes[ind // 12]

+    world[p] = 0

+    mesh.del_cube((ind // 12) * 12)

+    del cubes[ind // 12]

+

+def click_mesh(self, button, ind):

+    if button == 1:

+        break_voxel(self, ind)

+    elif button == 3:

+        place_voxel(self, ind)

+

 def build_scene():

     box = SquareMesh()

-    box.add_cube(2, [0, 0, 0])

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

+        for j in range(world.shape[1]):

+            for k in range(world.shape[2]):

+                if world[i, j, k] == 1:

+                    box.add_cube(1, [i, j, k])

+                    cubes.append(np.array((i, j, k), dtype=np.uint8))

+    box.onclick = click_mesh

     return [box]

 def main():

@@ -0,0 +1,49 @@

+from libs import *

+import entity

+

+def cube_col(axis):

+    return vec([

+        [0.0, 0.0, 0.0, 1.0],

+        [1.0, 0.0, 0.0, 1.0],

+        [0.0, 1.0, 0.0, 1.0],

+        [0.0, 0.0, 1.0, 1.0]

+    ][abs(axis)]) + 0.4 * np.sign(axis, dtype=FLOAT)

+

+class SquareMesh(entity.Entity):

+    def __init__(self):

+        super().__init__(

+            np.empty((0, 3), dtype=FLOAT),

+            [0.0, 1.0, 0.0, 1.0],

+            [0.0, 0.0, 0.0],

+            GL_TRIANGLES

+        )

+        self.faces = []

+

+    def add_sq(self, axis, width, pos):

+        w = width / 2

+        sq = pos + np.roll(vec([

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

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

+        ]), abs(axis), 1)

+        if axis < 0:

+            sq = np.flip(sq, 0)

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

+        for i in range(2):

+            self.faces.append((axis, 1))

+

+    def add_cube(self, width, pos):

+        offset = vec([width / 2, 0, 0])

+        for a in range(1, 4):

+            self.add_sq(a, width, pos + offset)

+            self.add_sq(-a, width, pos - offset)

+            offset = np.roll(offset, 1, 0)

+        return len(self.faces) - 12

+

+    def del_cube(self, ind):

+        self.verts = np.delete(self.verts, np.s_[3 * ind:3 * (ind + 12)], 0)

+        del self.faces[ind:ind + 12]

+        self.update_attr(0)

+        self.update_attr(1)

+

+    def col_list(self):

+        return np.repeat([cube_col(x[0]) for x in self.faces], 3, 0)

@@ -55,8 +55,9 @@ class Player(camera.Camera):

                 if ev.button == 1:

                     self.set_focus(True)

             case pygame.MOUSEBUTTONDOWN:

-                t = self.target(scene)

+                if self.get_focus():

+                    t, n = self.target(scene)

                     if t:

-                    t.click(ev.button)

+                        t.click(ev.button, n)

             case pygame.WINDOWSIZECHANGED | pygame.WINDOWRESIZED:

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