region.py (73b5b40) - voxels

region.py

from libs import *
import mesh

def smoothstep(x):
    return x ** 2 * (3 - 2 * x)

def interp(ab, t):
    return ab[0] + smoothstep(t) * (ab[1] - ab[0])

class WorldRegion(mesh.SquareMesh):
    def __init__(self, size=16):
        super().__init__()
        self.grid = np.zeros((size, size, size), dtype=VOXEL_TYPE)
        self.r = size

def add_voxel(self, pos, vt=1):
        self.grid[*pos] = vt

def del_voxel(self, ind):
        self.grid[*self.faces[ind][1]] = 0

def remesh(self):
        offset = vec([0.5, 0.0, 0.0])
        self.faces = []
        prev, curr = 0, 0
        vl = []
        for d in range(3):
            offset = np.array([1, 0, 0])
            roll_vec3(offset, d)
            for i in range(self.r):
                for j in range(self.r):
                    for k in range(self.r + 1):
                        p = np.array([k, i, j])
                        roll_vec3(p, d)
                        prev, curr = curr, (self.grid[*p] if k < self.r else 0)
                        bp, bc = bool(prev), bool(curr)
                        if bp ^ bc:
                            sq = vec([
                                [0, 1, 1], [0, -1, 1], [0, 1, -1],
                                [0, -1, -1], [0, 1, -1], [0, -1, 1]
                            ])
                            sq /= 2 * (bp - bc)
                            for v in sq:
                                roll_vec3(v, d)
                            sq += p - offset / 2
                            vl.extend(sq)
                            if bp:
                                p -= offset
                            for _ in range(2):
                                self.faces.append(((bp - bc) * (d + 1), p))
        self.verts = vec(vl)

def prof_min(self):
        self.add_voxel((0, 0, 0))
        self.remesh()

def prof_med(self):
        for i in range(self.r // 2):
            for j in range(self.r // 2):
                for k in range(self.r // 2):
                    self.add_voxel((2 * i, 2 * j, 2 * k))
        self.remesh()

def prof_max(self):
        for i in range(self.r):
            for j in range(self.r):
                for k in range(self.r):
                    if not (i + j + k) % 2:
                        self.add_voxel((i, j, k))
        self.remesh()

def gen_perlin(self, grads):
        corners = np.array([(i, j, k) for i in range(2) for j in range(2) for k in range(2)])
        n = 0
        for i in range(self.r):
            for j in range(self.r):
                for k in range(self.r):
                    w = np.array((i, j, k)) / self.r
                    d = [np.dot(grads[*c], w) for c in corners]
                    d = [interp(d[2 * k:2 * (k + 1)], w[2]) for k in range(4)]
                    d = [interp(d[:2], w[1]), interp(d[2:4], w[1])]
                    p = interp(d, w[0])
                    if p > 2 * w[1] - 0.5:
                        self.add_voxel((i, j, k))
                        n += 1
        return n

voxels

Frantically optimise remesh and improve gen_perlin