voxels

@@ -56,11 +56,10 @@ class Camera:

     def mvp(self, ent):

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

-    def draw(self, ent, loc_mvp, loc_col):

+    def draw(self, ent, loc_mvp):

         if not ent.vao:

             ent.build_vao()

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

-        glUniform4fv(loc_col, 1, ent.col)

         glBindVertexArray(ent.vao)

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

@@ -75,7 +74,7 @@ class Camera:

             else:

                 raise NotImplementedError

             for t in tl:

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

+                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

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

         self.pos = vec(pos)

         self.draw_mode = mode

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

-        self.vao = None

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

+        self.vao = None

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

+

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

+            else:

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

     def build_vao(self):

         self.vao = glGenVertexArrays(1)

         glBindVertexArray(self.vao)

-        vbo = glGenBuffers(1)

-        glBindBuffer(GL_ARRAY_BUFFER, vbo)

-        glBufferData(GL_ARRAY_BUFFER, self.verts.nbytes, self.verts, GL_STATIC_DRAW)

-        glEnableVertexAttribArray(0)

-        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)

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

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

+            self.update_attr(i, l)

+            glEnableVertexAttribArray(i)

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

     def translate(self):

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

@@ -2,53 +2,37 @@ from OpenGL.GL import shaders

 from libs import *

 from player import Player

 from entity import Entity

+from mesh import SquareMesh

 VS = """

 #version 120

 attribute vec3 position;

+attribute vec4 colIn;

+varying vec4 colOut;

 uniform mat4 MVP;

 void main() {

     gl_Position = MVP * vec4(position, 1.0);

+    colOut = colIn;

 }

 """

 FS = """

 #version 120

-uniform vec4 matCol;

+varying vec4 colOut;

 void main() {

-    gl_FragColor = matCol;

+    gl_FragColor = colOut;

 }

 """

-def weaken(self, button):

-    if button == 1:

-        self.col *= 0.9

-

-def toggle_spin(self, button):

-    if button == 3:

-        self.spin = not self.spin

-

 def build_scene():

-    ot = Entity(

-        [[-0.5, -0.5, 0.0], [0.5, -0.5, 0.0], [0.0, 0.5, 0.0]],

-        [1.0, 0.5, 0.2, 1.0],

-        [0.0, 0.0, 3.0]

-    )

-    ot.spin = True

-    ot.onclick = toggle_spin

-    cr = Entity(

-        [[-0.8, -0.4, 0.0], [-0.8, 0.4, 0.0], [0.8, -0.4, 0.0], [0.8, 0.4, 0.0]],

-        [0.2, 0.5, 1.0, 1.0],

-        [3.0, -0.5, 0.0]

-    )

-    cr.rotate(np.radians(90), [0.0, 1.0, 0.0])

-    cr.onclick = weaken

-    return [ot, cr]

+    box = SquareMesh()

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

+    return [box]

 def main():

     pygame.init()

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

-    pygame.display.set_caption("OpenGL!")

+    pygame.display.set_caption("OpenGL")

     sp = shaders.compileProgram(

         shaders.compileShader(VS, GL_VERTEX_SHADER),

         shaders.compileShader(FS, GL_FRAGMENT_SHADER)

@@ -56,25 +40,26 @@ def main():

     glUseProgram(sp)

     glEnable(GL_DEPTH_TEST)

     loc_mvp = glGetUniformLocation(sp, "MVP")

-    loc_matcol = glGetUniformLocation(sp, "matCol")

     glClearColor(0.1, 0.1, 0.1, 1.0)

     scene = build_scene()

     clock = pygame.time.Clock()

     cam = Player()

     cam.set_focus(True)

+    n = 0

     while True:

         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

         for ent in scene:

-            cam.draw(ent, loc_mvp, loc_matcol)

+            cam.draw(ent, loc_mvp)

         for ev in pygame.event.get():

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

                 pygame.quit()

                 return

             cam.handle_event(ev, scene)

         cam.update_pos()

-        if scene[0].spin:

-            scene[0].rotate(0.03 / np.linalg.norm(scene[0].pos - cam.pos) ** 2, [0.0, 1.0, 0.0])

         pygame.display.flip()

-        clock.tick(60)

+        clock.tick(240)

+        n += 1

+        if n % 120 == 0:

+            pygame.display.set_caption(f"fps {round(clock.get_fps())}")

 main()

@@ -1,7 +1,7 @@

 from libs import *

 import camera

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

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

 def reshape(w, h):

     glViewport(0, 0, w, h)

@@ -26,8 +26,11 @@ class Player(camera.Camera):

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

     def update_motion(self, pk):

-        self.rv[0] = pk[pygame.K_RIGHT] - pk[pygame.K_LEFT]

-        self.rv[2] = pk[pygame.K_UP] - pk[pygame.K_DOWN]

+        self.rv = vec([

+            pk[pygame.K_RIGHT] - pk[pygame.K_LEFT],

+            pk[pygame.K_SPACE] - pk[pygame.K_LSHIFT],

+            pk[pygame.K_UP] - pk[pygame.K_DOWN]

+        ])

     def vdof(self):

         l = self.looking()

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

             case pygame.MOUSEBUTTONDOWN:

                 t = self.target(scene)

                 if t:

-                    t.onclick(ev.button)

+                    t.click(ev.button)

             case pygame.WINDOWSIZECHANGED | pygame.WINDOWRESIZED:

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