voxels

@@ -33,18 +33,13 @@ void main() {{

     vec3 c = colF.xyz;

 {"\n".join([

     f"if (abs(j - {i}.0) < 1e-3)" +

-        f"c = texture2D(tex[{i}], texcF.xy).xyz;" for i in range(TEX_COUNT)

+        f"c *= texture2D(tex[{i}], texcF.xy).xyz;" for i in range(TEX_COUNT)

 ])}

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

 }}

 """

 def load_texture(i, img_data):

-    if isinstance(img_data, str):

-        pli = pygame.image.load(img_data).convert()

-        (tw, th) = pli.get_size()

-        img_data = np.array(list(pygame.image.tobytes(pli, "RGB")), np.uint8)

-    elif isinstance(img_data, np.ndarray):

     (tw, th) = img_data.shape[:2]

     tex = glGenTextures(1)

     glActiveTexture(GL_TEXTURE0 + i)

@@ -57,10 +52,9 @@ def load_texture(i, img_data):

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

+        pygame.DOUBLEBUF | pygame.OPENGL | (pygame.FULLSCREEN | pygame.SCALED

+            if conf["maximised"] else pygame.RESIZABLE),

     vsync=1)

     pygame.event.set_allowed([

         pygame.KEYDOWN, pygame.KEYUP,

@@ -68,8 +62,6 @@ def init_display():

         pygame.QUIT, pygame.WINDOWRESIZED, pygame.WINDOWSIZECHANGED

     ])

     pygame.display.set_caption("Voxels")

-    load_texture(0, "favicon.png")

-    load_texture(1, "container.jpg")

     sp = shaders.compileProgram(

         shaders.compileShader(VS, GL_VERTEX_SHADER),

         shaders.compileShader(FS, GL_FRAGMENT_SHADER)

@@ -34,12 +34,12 @@ def selection():

 def skybox():

     sb = mesh.SquareMesh()

-    offset = [0, 0, VIEW_DIST]

+    offset = [0, 0, conf["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)

+            sb.add_sq((d + 1) * sf, 2 * conf["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]

@@ -48,7 +48,7 @@ def skybox():

 def sun():

     s = attributes.AttributedEntity(

-        [[0.0, 0.0, 0.0]], normalise(LIGHT_POS) * VIEW_DIST,

+        [[0.0, 0.0, 0.0]], normalise(LIGHT_POS) * conf["view-dist"],

         [1.0, 1.0, 0.9, 1.0], texi=-1, mode=GL_TRIANGLE_FAN

     )

     cv = []

@@ -4,12 +4,7 @@ import numpy as np

 import pygame

 TEX_COUNT = 7

-TEX_RES = 64

 LIGHT_POS = [5, 30, 10]

-REGION_SIZE = 8

-GRAVITY = 1

-VIEW_DIST = 30

-FPS = 60

 ARROWS = [

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

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

@@ -17,8 +12,16 @@ ARROWS = [

 ]

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

+conf = {

+    "fps": 60,

+    "gravity": 1.0,

+    "maximised": False,

+    "region": 8,

+    "tex-res": 32,

+    "view-dist": 30.0,

+}

+

 FLOAT = np.float32

-VOXEL_TYPE = np.uint8

 VERTEX_ATTRS = [

     "vec3 position", "vec4 col", "vec3 normal", "vec4 refls", "vec3 texc"

 ]

@@ -60,7 +63,6 @@ def smerp(corners, weights):

     return corners[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):

@@ -1,35 +1,47 @@

 from libs import *

+import argparse

 import display

 from mapgen import MapGen

 from player import Player

+TEX_PARAMS = [

+    ("debug", 0.1, (0.5, 0.5)), ("sky", 0.15, (0.15, 0.1)),

+    ("stone", 0.1, (0.2, 0.3)), ("grass", 0.15, (0.15, 0.12)),

+    ("bark", 0.2, (0.04, 0.25)), ("leaves", 0.4, (0.2, 0.3)),

+]

+

 def debug_mode(mg, cam):

     pass

-def build_texture(i, mg, name, mid, offset, period):

-    display.load_texture(i, mg.make_texture(

-        name, (TEX_RES, TEX_RES), mid, offset, period

-    ))

-

 def in_view(wr, cam):

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

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

+    close = np.linalg.norm(rwrc) < conf["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():

+    parser = argparse.ArgumentParser()

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

+        parser.add_argument(f"-{k[0]}", f"--{k}", type=type(v))

+    args = parser.parse_args()

+    for k in conf:

+        v = getattr(args, k.replace("-", "_"))

+        if v is not None:

+            conf[k] = v

     display.init_display()

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

     mg = MapGen()

-    build_texture(2, mg, "sky", [0.5, 0.5, 0.8], [0.4, 0.4, 0.1], (20, 8))

-    build_texture(3, mg, "stone", [0.7, 0.7, 0.8], [0.1, 0.1, 0.1], (12, 15))

-    build_texture(4, mg, "grass", [0.3, 0.6, 0.3], [0.2, 0.1, 0.2], (3, 5))

-    build_texture(5, mg, "bark", [0.2, 0.1, 0.0], [0.1, 0.1, 0.0], (2, 8))

-    build_texture(6, mg, "leaves", [0.2, 0.5, 0.2], [0.2, 0.4, 0.2], (10, 14))

+    tr = conf["tex-res"]

+    for (i, p) in enumerate(TEX_PARAMS):

+        v = [0.2, 0.2, 0.0] if i == 0 else [p[1]] * 3

+        m = [1 - 1.5 * p[1]] * 3

+        display.load_texture(i + 1, mg.make_texture(

+            p[0], (tr, tr), m, v, np.multiply(tr, p[2])

+        ))

     clock = pygame.time.Clock()

-    cam = Player(speed=6/FPS)

+    cam = Player(speed=6/conf["fps"])

     cam.pos = [4, 8, 4]

     cam.set_focus(True)

     while True:

@@ -57,9 +69,9 @@ def main():

         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

         for ent in scene:

             cam.draw(ent)

-        perf = clock.get_fps() / FPS

+        perf = clock.get_fps() / conf["fps"]

         cam.draw_hud(scene, perf)

         pygame.display.flip()

-        clock.tick(FPS)

+        clock.tick(conf["fps"])

 main()

@@ -49,7 +49,8 @@ class MapGen(world.WorldHolder):

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

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

                     wr.grid[i, h, j] = 4

-                    if 2 <= i < wr.r - 2 and 2 <= j < wr.r - 2 and self.poisson(

+                    inner = 2 <= i < wr.r - 2 and 2 <= j < wr.r - 2

+                    if inner and self.poisson(

                             "trees", wr.pos[[0, 2]], wr.r, (6, 6)

                         )[i, j] >= 1:

                         for u in range(1, 6):

@@ -58,32 +59,15 @@ class MapGen(world.WorldHolder):

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

                                 b = 7 - u - abs(v)

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

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

-        return n

-

-    def world_min(self, wr):

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

-        return 1

-

-    def world_grid(self, wr):

-        n = 0

-        for i in range(0, wr.r, 2):

-            for j in range(0, wr.r, 2):

-                for k in range(0, wr.r, 2):

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

-                    n += 1

-        return n

-

-    def world_checker(self, wr):

-        n = 0

-        for i in range(wr.r):

-            for j in range(wr.r):

-                for k in range(wr.r):

-                    if not (i + j + k) % 2:

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

-                        n += 1

+                                    self.voxel_at(

+                                        wr.pos + [i + v, h + u, j + w], 6

+                                    )

         return n

     def make_texture(self, name, dims, mid, offset, period):

-        mid, offset = vec(mid), vec(offset)

-        return np.multiply(256, [[mid + offset * self.perlin(name, vec((i, j)), period) for j in range(dims[1])] for i in range(dims[0])], dtype=FLOAT)

+        m, o = vec(mid), vec(offset)

+        ta = np.empty(dims + (3,))

+        for i in range(dims[1]):

+            for j in range(dims[0]):

+                ta[i, j] = m + o * self.perlin(name, vec((i, j)), period)

+        return np.multiply(255, ta, dtype=FLOAT)

@@ -38,11 +38,11 @@ class SquareMesh(attributes.AttributedEntity):

                 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([*np.add(0.5, axis2offset(axis, 0.4)), 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]))

+                top = (vec([0.8, 0.8, 1.5, 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]))

                 match axis:

                     case 2:

@@ -52,7 +52,7 @@ class SquareMesh(attributes.AttributedEntity):

                     case a:

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

+                return (vec([0.5, 0.5, 0.6, 1.0]), vec([0.5, 0.5, 0.01, 16.0]))

             case 4:

                 top = (vec([0.2, 0.6, 0.2, 1.0]), vec([0.6, 0.4, 0.0, 1.0]))

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

@@ -73,7 +73,7 @@ class SquareMesh(attributes.AttributedEntity):

                     case _:

                         return bark

             case 6:

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

+                return (vec([0.2, 0.6, 0.2, 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)

@@ -22,7 +22,7 @@ class Player(interactive.InteractiveCamera):

                 cd = 0.3 * sf * self.vaa_mat()[i]

                 hit = self.collides and mg.voxel_at(self.pos + cd)

                 if i == 1 and sf == -1 and self.falls and not hit:

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

+                    netv[i] = self.vaa_vel[i] - conf["gravity"] / conf["fps"]

                 if i != 1 or not self.falls or mg.voxel_at(self.pos - cd):

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

                 if hit:

@@ -4,9 +4,10 @@ import heapq

 import mesh

 class WorldRegion(mesh.SquareMesh):

-    def __init__(self, size=REGION_SIZE):

+    def __init__(self, size=0):

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

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

+        size = size or conf["region"]

+        self.grid = np.zeros((size, size, size), dtype=np.uint8)

         self.r = size

         self.dirty = False

@@ -22,7 +22,7 @@ class WorldHolder():

         try:

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

         except StopIteration:

-            r = REGION_SIZE

+            r = conf["region"]

         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)