238cd9c6c3
- Authoritative 30 Hz server (ENet, SQLite): accounts, characters, wild AI, tall grass / water / wandering spawns, fishing, captures, follower chains, clock + weather, LAN beacon - Client: title / join / character creator / play screens, prediction + reconciliation, interpolated players and parties, HD-2D UI (dialogue with Professor Henry, HUD, collection) - Shared deterministic zone generator, movement, protocol, roster, appearance - Paper-doll character art pipeline (PixelLab base walk + per-item animation edits) - Brandling roster from the company list (logo colors, jev types), Blender safari props - Headless test bot
1100 lines
48 KiB
Python
1100 lines
48 KiB
Python
"""Builds the Brandling Safari 3D props (fences, entrance gate, signpost, lamp,
|
|
fishing dock, research tent, crates, barrels, benches, hay bales)
|
|
procedurally in Blender and exports them as one assets/models/safari.glb.
|
|
|
|
python3 tools/safari_textures.py # paint assets/models/src/*.png first
|
|
blender -b -P tools/blender_safari.py # headless build + export
|
|
blender -b -P tools/blender_safari.py -- --preview /tmp/safari_props.png [--reference <engine>/assets/models/scenery.glb]
|
|
# or, inside a running Blender (e.g. via the Blender MCP):
|
|
exec(compile(open(p).read(), p, "exec"), {"__name__": "__main__", "__file__": p})
|
|
|
|
Follows the Vibe-HD-2D model conventions (engine tools/blender_scenery.py,
|
|
docs/ASSET_GUIDE.md):
|
|
* one root node per model, named after the model; origin at the ground
|
|
contact point, +Z up in Blender (+Y up in the glTF), long objects along +X,
|
|
fronts (sign faces, tent door) facing -Y in Blender (+Z in the glTF)
|
|
* COLOR_0.rgb = tint / baked ambient occlusion, COLOR_0.a = wind weight
|
|
* emissive materials (lantern glass) glow; child empties are named sockets
|
|
* everything is single-sided and CCW seen from outside; canvas that is seen
|
|
from both sides is emitted twice with opposite winding
|
|
Only the "Safari_Props" collection is touched.
|
|
"""
|
|
import math
|
|
import os
|
|
import random
|
|
import sys
|
|
|
|
import bmesh
|
|
import bpy
|
|
import mathutils
|
|
from mathutils import Euler, Matrix, Vector
|
|
|
|
REPO = os.environ.get("SAFARI_REPO") or os.path.dirname(os.path.dirname(os.path.abspath(
|
|
__file__ if "__file__" in globals() else "/home/gabe/Documents/safari_zone/Brandling-Safari/tools/x")))
|
|
SRC = os.path.join(REPO, "assets", "models", "src")
|
|
OUT = os.path.join(REPO, "assets", "models")
|
|
ARGS = sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else []
|
|
|
|
|
|
def arg(name, default=None):
|
|
return ARGS[ARGS.index(name) + 1] if name in ARGS and ARGS.index(name) + 1 < len(ARGS) else default
|
|
|
|
|
|
# ----------------------------------------------------------------- builder --
|
|
class MeshBuilder:
|
|
"""Accumulates faces with per-corner uv / color / normal; materials by name."""
|
|
|
|
def __init__(self):
|
|
self.verts, self.faces, self.uvs, self.cols, self.nrms, self.mats = [], [], [], [], [], []
|
|
self.mat_names = []
|
|
|
|
def face(self, pts, uvs, cols, nrms, mat):
|
|
if mat not in self.mat_names:
|
|
self.mat_names.append(mat)
|
|
base = len(self.verts)
|
|
self.verts.extend(pts)
|
|
self.faces.append(list(range(base, base + len(pts))))
|
|
self.uvs.extend(uvs)
|
|
self.cols.extend(cols)
|
|
self.nrms.extend(nrms)
|
|
self.mats.append(self.mat_names.index(mat))
|
|
|
|
def build(self, name):
|
|
me = bpy.data.meshes.new(name)
|
|
me.from_pydata([tuple(v) for v in self.verts], [], self.faces)
|
|
for m in self.mat_names:
|
|
me.materials.append(MAT[m])
|
|
me.polygons.foreach_set("material_index", self.mats)
|
|
me.polygons.foreach_set("use_smooth", [True] * len(self.faces))
|
|
uv = me.uv_layers.new(name="UVMap")
|
|
col = me.color_attributes.new("Col", "FLOAT_COLOR", "CORNER")
|
|
for li in range(len(me.loops)): # from_pydata keeps corner order
|
|
uv.data[li].uv = self.uvs[li]
|
|
col.data[li].color = self.cols[li]
|
|
me.color_attributes.active_color = col
|
|
me.validate()
|
|
me.normals_split_custom_set([tuple(n) for n in self.nrms])
|
|
ob = bpy.data.objects.new(name, me)
|
|
COLLECTION.objects.link(ob)
|
|
return ob
|
|
|
|
|
|
def material(name, image, alpha=False, emission=0.0, roughness=0.85):
|
|
"""Principled material the glTF exporter understands (texture x vertex color)."""
|
|
mat = bpy.data.materials.get(name) or bpy.data.materials.new(name)
|
|
mat.use_nodes = True
|
|
nt = mat.node_tree
|
|
nt.nodes.clear()
|
|
out = nt.nodes.new("ShaderNodeOutputMaterial")
|
|
bsdf = nt.nodes.new("ShaderNodeBsdfPrincipled")
|
|
bsdf.inputs["Roughness"].default_value = roughness
|
|
tex = nt.nodes.new("ShaderNodeTexImage")
|
|
tex.image = bpy.data.images.load(os.path.join(SRC, image), check_existing=True)
|
|
vc = nt.nodes.new("ShaderNodeVertexColor")
|
|
vc.layer_name = "Col"
|
|
mul = nt.nodes.new("ShaderNodeMix")
|
|
mul.data_type = "RGBA"
|
|
mul.blend_type = "MULTIPLY"
|
|
mul.inputs["Factor"].default_value = 1.0
|
|
nt.links.new(tex.outputs["Color"], mul.inputs["A"])
|
|
nt.links.new(vc.outputs["Color"], mul.inputs["B"])
|
|
nt.links.new(mul.outputs["Result"], bsdf.inputs["Base Color"])
|
|
if alpha:
|
|
cut = nt.nodes.new("ShaderNodeMath") # Round -> exported as alphaMode MASK
|
|
cut.operation = "ROUND"
|
|
nt.links.new(tex.outputs["Alpha"], cut.inputs[0])
|
|
nt.links.new(cut.outputs[0], bsdf.inputs["Alpha"])
|
|
mat.surface_render_method = "DITHERED"
|
|
if emission > 0.0: # exported as emissiveTexture + KHR_materials_emissive_strength
|
|
nt.links.new(tex.outputs["Color"], bsdf.inputs["Emission Color"])
|
|
bsdf.inputs["Emission Strength"].default_value = emission
|
|
mat.use_backface_culling = not alpha # exported as glTF doubleSided
|
|
nt.links.new(bsdf.outputs["BSDF"], out.inputs["Surface"])
|
|
return mat
|
|
|
|
|
|
# Texture tile size in metres (u, v) per material: grain/fibres run along v.
|
|
TEXEL = {
|
|
"wood": (0.55, 1.1), "planks": (0.9, 0.9), "staves": (0.45, 0.9), "painted_wood": (0.9, 0.9),
|
|
"log_bark": (0.8, 1.6), "end_grain": (1.0, 1.0), "canvas": (3.0, 3.0), "canvas_green": (2.0, 2.0),
|
|
"canvas_stripes": (3.0, 3.0), "rope": (0.1, 0.25), "hay": (0.9, 0.9), "iron": (0.4, 0.4),
|
|
"stone": (1.0, 1.0), "lantern_glass": (1.0, 1.0),
|
|
}
|
|
|
|
|
|
# ------------------------------------------------------------ vertex color --
|
|
def smooth01(a, b, x):
|
|
t = max(0.0, min(1.0, (x - a) / (b - a)))
|
|
return t * t * (3 - 2 * t)
|
|
|
|
|
|
def ao_ground(p, n):
|
|
"""Contact darkening near the ground, darker undersides."""
|
|
k = 0.6 + 0.4 * smooth01(-0.05, 0.75, p.z)
|
|
if n.z < -0.5:
|
|
k *= 0.72
|
|
return (k, k, k)
|
|
|
|
|
|
def ao_dock(p, n):
|
|
"""Dock: bright deck, dim underside, damp greenish posts towards the water."""
|
|
k = 0.5 + 0.5 * smooth01(-1.3, -0.05, p.z)
|
|
if n.z > 0.5 and p.z > -0.03:
|
|
k = 1.0
|
|
if n.z < -0.5:
|
|
k *= 0.7
|
|
wet = 1.0 - smooth01(-1.1, -0.6, p.z)
|
|
return (k * (1 - 0.25 * wet), k * (1 - 0.1 * wet), k * (1 - 0.35 * wet))
|
|
|
|
|
|
def ao_inside(p, n):
|
|
k = 0.42 + 0.22 * smooth01(0.0, 2.2, p.z)
|
|
return (k, k * 0.98, k * 0.94)
|
|
|
|
|
|
def ao_flat(k):
|
|
return lambda p, n: (k, k, k)
|
|
|
|
|
|
AO = [ao_ground] # current model's default
|
|
|
|
|
|
# --------------------------------------------------------------------- uvs --
|
|
def uv_box(grain=2, off=(0.0, 0.0)):
|
|
"""Box projection in the part's local frame; the grain axis maps to v."""
|
|
def f(face, tu, tv):
|
|
n = face.normal
|
|
ax = max(range(3), key=lambda i: abs(n[i]))
|
|
others = [i for i in range(3) if i != ax]
|
|
if grain in others:
|
|
va = grain
|
|
ua = others[0] if others[1] == grain else others[1]
|
|
else:
|
|
ua, va = others
|
|
return [(l.vert.co[ua] / tu + off[0], l.vert.co[va] / tv + off[1]) for l in face.loops]
|
|
return f
|
|
|
|
|
|
def uv_cyl(radius, off=(0.0, 0.0)):
|
|
"""Cylindrical mapping around local Z with a whole number of tiles around."""
|
|
def f(face, tu, tv):
|
|
rep = max(1, round(math.tau * radius / tu))
|
|
us = [(math.atan2(l.vert.co.y, l.vert.co.x) / math.tau) % 1.0 * rep for l in face.loops]
|
|
if max(us) - min(us) > rep / 2: # face straddles the seam
|
|
us = [u + rep if u < rep / 2 else u for u in us]
|
|
return [(u + off[0], l.vert.co.z / tv + off[1]) for u, l in zip(us, face.loops)]
|
|
return f
|
|
|
|
|
|
def uv_cap(radius, off=(0.0, 0.0)):
|
|
"""Planar end-grain mapping: the texture's circle fits the cap radius."""
|
|
def f(face, tu, tv):
|
|
return [(l.vert.co.x / (2 * radius) + 0.5 + off[0], l.vert.co.y / (2 * radius) + 0.5 + off[1])
|
|
for l in face.loops]
|
|
return f
|
|
|
|
|
|
def uv_torus(R, r):
|
|
def f(face, tu, tv):
|
|
out = []
|
|
for l in face.loops:
|
|
p = l.vert.co
|
|
phi = math.atan2(p.y, p.x) % math.tau
|
|
th = math.atan2(p.z, math.hypot(p.x, p.y) - R) % math.tau
|
|
out.append((th / math.tau * max(1, round(math.tau * r / tu)), phi * R / tv))
|
|
for k in (0, 1): # unwrap seams
|
|
vals = [uv[k] for uv in out]
|
|
span = max(1, round(math.tau * r / tu)) if k == 0 else math.tau * R / tv
|
|
if max(vals) - min(vals) > span / 2:
|
|
out = [tuple(c + span if (i == k and c < span / 2) else c for i, c in enumerate(uv)) for uv in out]
|
|
return out
|
|
return f
|
|
|
|
|
|
def uv_by_mat(table):
|
|
return lambda face, tu, tv: table[face.material_index](face, tu, tv)
|
|
|
|
|
|
# ------------------------------------------------------------------- emit --
|
|
def emit(mb, bm, mats, M, uvf, ao=None, tint=(1.0, 1.0, 1.0), wind=0.0, flip=False):
|
|
"""Appends a local-space bmesh, transformed by M (rotation + translation),
|
|
to the builder. Normals are area-weighted vertex normals, so bevelled
|
|
chamfers shade softly while big faces stay flat (a 'harden normals' look)."""
|
|
ao = ao or AO[0]
|
|
if isinstance(tint, (int, float)):
|
|
tint = (tint, tint, tint)
|
|
bm.normal_update()
|
|
bm.verts.index_update()
|
|
vn = []
|
|
for v in bm.verts:
|
|
n = Vector()
|
|
for f in v.link_faces:
|
|
n += f.normal * f.calc_area()
|
|
vn.append(n.normalized() if n.length > 1e-12 else v.normal.copy())
|
|
R = M.to_3x3()
|
|
s = -1.0 if flip else 1.0
|
|
for f in bm.faces:
|
|
mat = mats[f.material_index]
|
|
uvs = uvf(f, *TEXEL[mat])
|
|
pts = [M @ l.vert.co for l in f.loops]
|
|
nrm = [(R @ (vn[l.vert.index] * s)).normalized() for l in f.loops]
|
|
cols = []
|
|
for p, n in zip(pts, nrm):
|
|
k = ao(p, n)
|
|
cols.append((k[0] * tint[0], k[1] * tint[1], k[2] * tint[2], wind))
|
|
if flip:
|
|
pts, uvs, cols, nrm = pts[::-1], uvs[::-1], cols[::-1], nrm[::-1]
|
|
mb.face(pts, uvs, cols, nrm, mat)
|
|
bm.free()
|
|
|
|
|
|
# -------------------------------------------------------------- primitives --
|
|
def bevel_sharp(bm, width, segments=1, angle=0.6):
|
|
if width <= 0:
|
|
return
|
|
bm.normal_update()
|
|
edges = [e for e in bm.edges if e.is_manifold and e.calc_face_angle(0.0) > angle]
|
|
verts = list({v for e in edges for v in e.verts})
|
|
bmesh.ops.bevel(bm, geom=edges + verts, offset=width, segments=segments, profile=0.5, affect="EDGES",
|
|
clamp_overlap=True, material=-1)
|
|
|
|
|
|
def bm_box(sx, sy, sz, bevel=0.02, segments=1, base=False, subdiv=0):
|
|
"""Box centred on the origin (base=True: spans z 0..sz)."""
|
|
bm = bmesh.new()
|
|
bmesh.ops.create_cube(bm, size=1.0)
|
|
if subdiv:
|
|
bmesh.ops.subdivide_edges(bm, edges=bm.edges[:], cuts=subdiv, use_grid_fill=True)
|
|
for v in bm.verts:
|
|
v.co = Vector((v.co.x * sx, v.co.y * sy, v.co.z * sz + (sz / 2 if base else 0.0)))
|
|
bevel_sharp(bm, min(bevel, sx * 0.45, sy * 0.45, sz * 0.45), segments)
|
|
return bm
|
|
|
|
|
|
def bm_lathe(profile, sides=12, caps=(True, True), phase=0.0, bevel=0.0, noise=0.0, seed=0, noise_scale=1.4):
|
|
"""Surface of revolution around local +Z from (radius, z) pairs (bottom to
|
|
top); cap faces get material index 1. noise > 0 makes it a lumpy log."""
|
|
bm = bmesh.new()
|
|
off = Vector((seed * 7.31, seed * 3.17, seed * 1.93))
|
|
rings = []
|
|
for r, z in profile:
|
|
ring = []
|
|
for j in range(sides):
|
|
a = phase + j / sides * math.tau
|
|
k = 1.0
|
|
if noise:
|
|
q = Vector((math.cos(a) * noise_scale, math.sin(a) * noise_scale, z * noise_scale * 1.2)) + off
|
|
k += noise * mathutils.noise.noise(q)
|
|
ring.append(bm.verts.new((math.cos(a) * r * k, math.sin(a) * r * k, z)))
|
|
rings.append(ring)
|
|
for i in range(len(rings) - 1):
|
|
for j in range(sides):
|
|
bm.faces.new((rings[i][j], rings[i][(j + 1) % sides], rings[i + 1][(j + 1) % sides], rings[i + 1][j]))
|
|
if caps[0]:
|
|
bm.faces.new(rings[0][::-1]).material_index = 1
|
|
if caps[1]:
|
|
bm.faces.new(rings[-1]).material_index = 1
|
|
bevel_sharp(bm, bevel)
|
|
return bm
|
|
|
|
|
|
def bm_prism(outline, depth, bevel=0.0, segments=1):
|
|
"""CCW outline in local XY extruded along Z (-depth/2..depth/2); the two
|
|
outline faces get material index 1."""
|
|
bm = bmesh.new()
|
|
bot = [bm.verts.new((x, y, -depth / 2)) for x, y in outline]
|
|
top = [bm.verts.new((x, y, depth / 2)) for x, y in outline]
|
|
n = len(outline)
|
|
for i in range(n):
|
|
bm.faces.new((bot[i], bot[(i + 1) % n], top[(i + 1) % n], top[i]))
|
|
bm.faces.new(bot[::-1]).material_index = 1
|
|
bm.faces.new(top).material_index = 1
|
|
bevel_sharp(bm, bevel, segments)
|
|
return bm
|
|
|
|
|
|
def bm_torus(R, r, n_major=16, n_minor=6):
|
|
bm = bmesh.new()
|
|
vs = [[bm.verts.new(((R + r * math.cos(t)) * math.cos(p), (R + r * math.cos(t)) * math.sin(p), r * math.sin(t)))
|
|
for t in (j / n_minor * math.tau for j in range(n_minor))]
|
|
for p in (i / n_major * math.tau for i in range(n_major))]
|
|
for i in range(n_major):
|
|
for j in range(n_minor):
|
|
i1, j1 = (i + 1) % n_major, (j + 1) % n_minor
|
|
bm.faces.new((vs[i][j], vs[i1][j], vs[i1][j1], vs[i][j1]))
|
|
return bm
|
|
|
|
|
|
def bm_grid(fn, nu, nv):
|
|
"""Open surface from fn(u, v) -> Vector over [0,1]^2 (normal = du x dv)."""
|
|
bm = bmesh.new()
|
|
vs = [[bm.verts.new(fn(i / nu, j / nv)) for j in range(nv + 1)] for i in range(nu + 1)]
|
|
for i in range(nu):
|
|
for j in range(nv):
|
|
bm.faces.new((vs[i][j], vs[i + 1][j], vs[i + 1][j + 1], vs[i][j + 1]))
|
|
return bm
|
|
|
|
|
|
def ico(subdiv):
|
|
"""Unit icosphere vertices + triangles (as in the engine's blender_scenery.py)."""
|
|
t = (1 + 5 ** 0.5) / 2
|
|
v = [Vector(x).normalized() for x in [(-1, t, 0), (1, t, 0), (-1, -t, 0), (1, -t, 0), (0, -1, t), (0, 1, t),
|
|
(0, -1, -t), (0, 1, -t), (t, 0, -1), (t, 0, 1), (-t, 0, -1), (-t, 0, 1)]]
|
|
f = [(0, 11, 5), (0, 5, 1), (0, 1, 7), (0, 7, 10), (0, 10, 11), (1, 5, 9), (5, 11, 4), (11, 10, 2), (10, 7, 6),
|
|
(7, 1, 8), (3, 9, 4), (3, 4, 2), (3, 2, 6), (3, 6, 8), (3, 8, 9), (4, 9, 5), (2, 4, 11), (6, 2, 10),
|
|
(8, 6, 7), (9, 8, 1)]
|
|
for _ in range(subdiv):
|
|
cache, nf = {}, []
|
|
|
|
def mid(a, b):
|
|
key = (min(a, b), max(a, b))
|
|
if key not in cache:
|
|
cache[key] = len(v)
|
|
v.append(((v[a] + v[b]) / 2).normalized())
|
|
return cache[key]
|
|
|
|
for a, b, c in f:
|
|
ab, bc, ca = mid(a, b), mid(b, c), mid(c, a)
|
|
nf += [(a, ab, ca), (b, bc, ab), (c, ca, bc), (ab, bc, ca)]
|
|
f = nf
|
|
return v, f
|
|
|
|
|
|
# ---------------------------------------------------------------- frames --
|
|
def T(x=0.0, y=0.0, z=0.0, rx=0.0, ry=0.0, rz=0.0):
|
|
return Matrix.Translation((x, y, z)) @ Euler((rx, ry, rz), "XYZ").to_matrix().to_4x4()
|
|
|
|
|
|
def along(a, b, roll=0.0):
|
|
"""Frame at a whose local +Z points to b, local X kept horizontal."""
|
|
a, b = Vector(a), Vector(b)
|
|
d = (b - a).normalized()
|
|
x = d.cross(Vector((0, 0, 1)))
|
|
x = Vector((1, 0, 0)) if x.length < 1e-4 else x.normalized()
|
|
y = d.cross(x)
|
|
m = Matrix((x, y, d)).transposed().to_4x4()
|
|
m.translation = a
|
|
return m @ Matrix.Rotation(roll, 4, "Z")
|
|
|
|
|
|
def rnd_off(rng):
|
|
return (rng.random(), rng.random())
|
|
|
|
|
|
# ------------------------------------------------------------ part helpers --
|
|
def box(mb, M, size, mat, rng, bevel=0.02, grain=2, base=False, segments=1, **kw):
|
|
emit(mb, bm_box(*size, bevel=bevel, base=base, segments=segments), [mat], M, uv_box(grain, rnd_off(rng)), **kw)
|
|
|
|
|
|
def beam(mb, a, b, w, h, mat, rng, bevel=0.02, roll=0.0, **kw):
|
|
"""Squared timber from a to b (w across, h the other way), grain along it."""
|
|
L = (Vector(b) - Vector(a)).length
|
|
box(mb, along(a, b, roll), (w, h, L), mat, rng, bevel=bevel, grain=2, base=True, **kw)
|
|
|
|
|
|
def log(mb, a, b, r0, r1, rng, mat="log_bark", cap="end_grain", sides=12, bevel=0.025, noise=0.05, caps=(True, True), **kw):
|
|
"""Round log from a to b, bark on the sides and end grain on the caps."""
|
|
L = (Vector(b) - Vector(a)).length
|
|
bm = bm_lathe([(r0, 0.0), ((r0 + r1) / 2, L / 2), (r1, L)], sides, caps=caps, bevel=bevel,
|
|
noise=noise, seed=rng.randint(0, 999))
|
|
uvf = uv_by_mat({0: uv_cyl((r0 + r1) / 2, rnd_off(rng)), 1: uv_cap(max(r0, r1) * (1 + noise), rnd_off(rng))})
|
|
emit(mb, bm, [mat, cap], along(a, b), uvf, **kw)
|
|
|
|
|
|
def rope(mb, a, b, r=0.016, rng=None, **kw):
|
|
L = (Vector(b) - Vector(a)).length
|
|
bm = bm_lathe([(r, 0.0), (r, L)], 6, caps=(False, False))
|
|
emit(mb, bm, ["rope", "rope"], along(a, b), uv_cyl(r), **kw)
|
|
|
|
|
|
def torus(mb, M, R, r, mat="rope", n_major=16, n_minor=6, **kw):
|
|
emit(mb, bm_torus(R, r, n_major, n_minor), [mat], M, uv_torus(R, r), **kw)
|
|
|
|
|
|
def lashing(mb, centre, radius, turns=3, r=0.022, pitch=0.045, axis=None, **kw):
|
|
"""A few rope wraps around a log (rings stacked along the log axis)."""
|
|
for i in range(turns):
|
|
dz = (i - (turns - 1) / 2) * pitch
|
|
M = (axis or Matrix.Identity(4)) @ T(0, 0, dz)
|
|
M.translation = Vector(centre) + (axis.to_3x3() @ Vector((0, 0, dz)) if axis else Vector((0, 0, dz)))
|
|
torus(mb, M, radius + r * 0.6, r, n_major=18, **kw)
|
|
|
|
|
|
def pyramid_cap(mb, x, y, z, half, rng, mat="wood", h=None):
|
|
"""Four-sided pointed cap for square posts."""
|
|
r = half * 1.12 / math.cos(math.pi / 4)
|
|
bm = bm_lathe([(r, 0.0), (r, half * 0.25), (r * 0.12, half * 0.25 + (h or half * 0.85))], 4,
|
|
caps=(True, True), phase=math.pi / 4, bevel=0.008)
|
|
emit(mb, bm, [mat, mat], T(x, y, z), uv_box(2, rnd_off(rng)))
|
|
|
|
|
|
def square_post(mb, x, y, h, w, rng, mat="wood", cap=True, tint=1.0, tilt=(0.0, 0.0)):
|
|
M = T(x, y, -0.06, tilt[0], tilt[1], 0.0)
|
|
box(mb, M, (w, w, h + 0.06), mat, rng, bevel=0.022, base=True, tint=tint)
|
|
if cap:
|
|
top = M @ Vector((0, 0, h + 0.06))
|
|
pyramid_cap(mb, top.x, top.y, top.z, w / 2, rng, mat)
|
|
|
|
|
|
def socket(ob, name, p):
|
|
s = bpy.data.objects.new(name, None)
|
|
s.empty_display_size = 0.15
|
|
s.location = p
|
|
COLLECTION.objects.link(s)
|
|
s.parent = ob
|
|
return s
|
|
|
|
|
|
# --------------------------------------------------------------- lantern --
|
|
def lantern(mb, top, rng, s=1.0):
|
|
"""Hanging iron lantern with glowing glass; returns the flame position."""
|
|
x, y, z = top
|
|
ring_r = 0.03 * s
|
|
torus(mb, T(x, y, z - ring_r, rx=math.pi / 2), ring_r, 0.008 * s, mat="iron", n_major=10, n_minor=5)
|
|
z -= 2 * ring_r
|
|
hcap = 0.08 * s
|
|
bm = bm_lathe([(0.12 * s, 0.0), (0.035 * s, hcap), (0.02 * s, hcap + 0.015 * s)], 4, phase=math.pi / 4,
|
|
bevel=0.005 * s)
|
|
emit(mb, bm, ["iron", "iron"], T(x, y, z - hcap - 0.015 * s), uv_box(2))
|
|
z -= hcap + 0.015 * s
|
|
box(mb, T(x, y, z - 0.015 * s), (0.2 * s, 0.2 * s, 0.03 * s), "iron", rng, bevel=0.006 * s, ao=ao_flat(0.9))
|
|
z -= 0.03 * s
|
|
gh, g = 0.19 * s, 0.075 * s
|
|
for cx, cy in ((-1, -1), (1, -1), (1, 1), (-1, 1)):
|
|
box(mb, T(x + cx * 0.08 * s, y + cy * 0.08 * s, z - gh / 2), (0.024 * s, 0.024 * s, gh), "iron", rng,
|
|
bevel=0.004 * s, ao=ao_flat(0.85))
|
|
z0, z1 = z - gh, z
|
|
white = (1.0, 1.0, 1.0, 0.0)
|
|
for n in (Vector((1, 0, 0)), Vector((0, 1, 0)), Vector((-1, 0, 0)), Vector((0, -1, 0))):
|
|
t = Vector((-n.y, n.x, 0)) # CCW seen from outside
|
|
c = Vector((x, y, 0)) + n * g
|
|
pts = [c - t * g + Vector((0, 0, z0)), c + t * g + Vector((0, 0, z0)),
|
|
c + t * g + Vector((0, 0, z1)), c - t * g + Vector((0, 0, z1))]
|
|
mb.face(pts, [(0, 0), (1, 0), (1, 1), (0, 1)], [white] * 4, [n] * 4, "lantern_glass")
|
|
flame = Vector((x, y, (z0 + z1) / 2))
|
|
z = z0
|
|
box(mb, T(x, y, z - 0.018 * s), (0.2 * s, 0.2 * s, 0.036 * s), "iron", rng, bevel=0.007 * s, ao=ao_flat(0.8))
|
|
bm = bm_lathe([(0.05 * s, 0.0), (0.01 * s, -0.035 * s)], 4, phase=math.pi / 4, caps=(True, False))
|
|
emit(mb, bm, ["iron", "iron"], T(x, y, z - 0.036 * s), uv_box(2), ao=ao_flat(0.7))
|
|
return flame
|
|
|
|
|
|
def chain(mb, top, bottom_z, link=0.045):
|
|
x, y, z = top
|
|
n = max(1, int(round((z - bottom_z) / link)))
|
|
for i in range(n):
|
|
zc = z - (i + 0.5) * (z - bottom_z) / n
|
|
rz = 0.0 if i % 2 == 0 else math.pi / 2
|
|
bm = bm_torus(0.02, 0.006, 8, 4)
|
|
for v in bm.verts:
|
|
v.co.y *= 1.6 # oval link, long axis vertical after the rotation below
|
|
emit(mb, bm, ["iron"], T(x, y, zc, rx=math.pi / 2, rz=rz) @ T(rz=0.0), uv_torus(0.02, 0.006),
|
|
ao=ao_flat(0.85))
|
|
|
|
|
|
# ------------------------------------------------------------------ models --
|
|
FENCE_H, POST_W = 0.92, 0.15
|
|
|
|
|
|
def fence_post_parts(mb, x, rng):
|
|
# Deterministic (no jitter) so chained fence segments' shared posts coincide exactly.
|
|
square_post(mb, x, 0.0, FENCE_H - 0.06, POST_W, random.Random(7))
|
|
|
|
|
|
def make_fence(name, seed):
|
|
rng = random.Random(seed)
|
|
mb = MeshBuilder()
|
|
for x in (-1.0, 1.0):
|
|
fence_post_parts(mb, x, rng)
|
|
for z in (0.34, 0.68): # rails slightly askew, ends buried in the posts
|
|
a = Vector((-0.98, rng.uniform(-0.008, 0.008), z + rng.uniform(-0.015, 0.015)))
|
|
b = Vector((0.98, rng.uniform(-0.008, 0.008), z + rng.uniform(-0.015, 0.015)))
|
|
beam(mb, a, b, 0.065, 0.13, "wood", rng, bevel=0.02, tint=rng.uniform(0.92, 1.06))
|
|
return mb.build(name)
|
|
|
|
|
|
def make_fence_post(name, seed):
|
|
mb = MeshBuilder()
|
|
fence_post_parts(mb, 0.0, random.Random(seed))
|
|
return mb.build(name)
|
|
|
|
|
|
def rock(mb, c, scale, rng, sink=0.1):
|
|
v, f = ico(2)
|
|
off = Vector((rng.random() * 100, rng.random() * 100, rng.random() * 100))
|
|
pos = []
|
|
for p in v:
|
|
k = 1 + 0.3 * mathutils.noise.noise(p * 1.3 + off) + 0.08 * mathutils.noise.noise(p * 3.5 + off)
|
|
q = Vector((p.x * scale[0], p.y * scale[1], p.z * scale[2])) * k
|
|
q.z = max(q.z, -sink)
|
|
pos.append(q)
|
|
bm = bmesh.new()
|
|
vs = [bm.verts.new(p) for p in pos]
|
|
for tri in f:
|
|
bm.faces.new([vs[i] for i in tri])
|
|
|
|
def col(p, n):
|
|
moss = smooth01(0.45, 0.85, n.z) * (0.6 + 0.4 * mathutils.noise.noise(p * 3 + off))
|
|
k = 0.55 + 0.45 * smooth01(0.0, scale[2] * 0.9, p.z)
|
|
t = Vector((1, 1, 1)).lerp(Vector((0.6, 1.0, 0.4)), max(0.0, min(1.0, moss)))
|
|
return (t.x * k, t.y * k, t.z * k)
|
|
emit(mb, bm, ["stone"], T(*c, rz=rng.random() * math.tau), uv_box(2, rnd_off(rng)), ao=col)
|
|
|
|
|
|
def make_gate(name, seed):
|
|
"""Safari Zone entrance: two log pillars, a log lintel over a squared tie
|
|
beam, a hanging blank plank sign and two hanging lanterns (light_0/1)."""
|
|
rng = random.Random(seed)
|
|
mb = MeshBuilder()
|
|
PX, TOP = 1.7, 3.12
|
|
for s in (-1, 1):
|
|
x = s * PX
|
|
bm = bm_lathe([(0.5, -0.06), (0.46, 0.08), (0.41, 0.3), (0.395, 1.2), (0.38, 2.4), (0.37, TOP)], 14,
|
|
caps=(False, True), bevel=0.03, noise=0.05, seed=rng.randint(0, 99))
|
|
emit(mb, bm, ["log_bark", "end_grain"], T(x, 0, 0, rz=rng.random() * math.tau),
|
|
uv_by_mat({0: uv_cyl(0.4, rnd_off(rng)), 1: uv_cap(0.39)}))
|
|
lashing(mb, (x, 0, 2.52), 0.405, turns=3)
|
|
lashing(mb, (x, 0, 0.62), 0.43, turns=2)
|
|
for k in range(3): # boulders at the foot
|
|
a = (s * 0.9 + k * 0.7 + rng.uniform(-0.2, 0.2)) * math.pi
|
|
d = rng.uniform(0.5, 0.62)
|
|
sc = rng.uniform(0.17, 0.26)
|
|
rock(mb, (x + math.cos(a) * d, math.sin(a) * d, 0.0), (sc * 1.2, sc, sc * 0.8), rng)
|
|
# Lintel log resting on the pillars, overhanging both sides.
|
|
log(mb, (-2.45, 0, TOP + 0.2), (2.45, 0, TOP + 0.2), 0.23, 0.21, rng, sides=14, noise=0.04)
|
|
# Squared tie beam through the pillars just below it.
|
|
beam(mb, (-2.32, 0, 2.86), (2.32, 0, 2.86), 0.24, 0.22, "wood", rng, bevel=0.03)
|
|
# Pegs locking the tie beam outside the pillars.
|
|
for s in (-1, 1):
|
|
log(mb, (s * 2.2, 0, 2.7), (s * 2.2, 0, 3.03), 0.035, 0.035, rng, mat="wood", sides=8,
|
|
bevel=0.008, noise=0.0)
|
|
beam_bottom = 2.86 - 0.11
|
|
# Hanging sign: painted plank board in a dark frame on two ropes.
|
|
sw, sh, sz = 1.7, 0.52, 2.42
|
|
box(mb, T(0, 0, sz), (sw, 0.06, sh), "painted_wood", rng, bevel=0.015, grain=0)
|
|
for z in (sz - sh / 2 - 0.02, sz + sh / 2 + 0.02):
|
|
box(mb, T(0, 0, z), (sw + 0.12, 0.1, 0.07), "wood", rng, bevel=0.018, grain=0, tint=0.72)
|
|
for x in (-sw / 2 - 0.03, sw / 2 + 0.03):
|
|
box(mb, T(x, 0, sz), (0.07, 0.1, sh), "wood", rng, bevel=0.018, grain=2, tint=0.72)
|
|
for x in (-0.62, 0.62):
|
|
top = sz + sh / 2 + 0.055
|
|
torus(mb, T(x, 0, top + 0.03, rx=math.pi / 2), 0.03, 0.008, mat="iron", n_major=10, n_minor=5)
|
|
rope(mb, (x, 0, top + 0.055), (x, 0, beam_bottom - 0.035))
|
|
torus(mb, T(x, 0, beam_bottom - 0.025, rx=math.pi / 2), 0.03, 0.008, mat="iron", n_major=10, n_minor=5)
|
|
# Lanterns hanging from the tie beam, inside the pillars.
|
|
flames = []
|
|
for s in (-1, 1):
|
|
x = s * 1.08
|
|
box(mb, T(x, 0, beam_bottom - 0.01), (0.07, 0.07, 0.04), "iron", rng, bevel=0.006)
|
|
chain(mb, (x, 0, beam_bottom - 0.03), beam_bottom - 0.2)
|
|
flames.append(lantern(mb, (x, 0, beam_bottom - 0.2), rng, s=1.05))
|
|
ob = mb.build(name)
|
|
for i, p in enumerate(flames):
|
|
socket(ob, f"light_{i}", p)
|
|
return ob
|
|
|
|
|
|
def make_signpost(name, seed):
|
|
rng = random.Random(seed)
|
|
mb = MeshBuilder()
|
|
square_post(mb, 0.0, 0.0, 1.32, 0.13, rng, tilt=(0.0, 0.02))
|
|
arrow = [(-0.5, -0.13), (0.36, -0.13), (0.52, 0.0), (0.36, 0.13), (-0.5, 0.13)]
|
|
boards = [(1.08, 0.18, 1, 0.03), (0.78, -0.16, -1, -0.06)]
|
|
for z, x, d, roll in boards:
|
|
pts = [(px * d, py) for px, py in arrow]
|
|
if d < 0:
|
|
pts = pts[::-1] # keep CCW after mirroring
|
|
bm = bm_prism(pts, 0.05, bevel=0.012)
|
|
M = T(x, -0.095, z, rx=math.pi / 2, ry=roll) # local Y -> up, local Z -> -Y (faces the camera)
|
|
emit(mb, bm, ["wood", "painted_wood"], M, uv_box(0, rnd_off(rng)))
|
|
for k in (-0.08, 0.08): # nails into the post
|
|
nail = T(0.0, -0.125, z + k, rx=math.pi / 2)
|
|
emit(mb, bm_lathe([(0.012, 0.0), (0.012, 0.01)], 6), ["iron", "iron"], nail, uv_box(2))
|
|
return mb.build(name)
|
|
|
|
|
|
def make_lamp(name, seed):
|
|
"""Wooden lamp post with an iron hook arm and a hanging lantern (socket 'light')."""
|
|
rng = random.Random(seed)
|
|
mb = MeshBuilder()
|
|
box(mb, T(0, 0, -0.04), (0.32, 0.32, 0.2), "wood", rng, bevel=0.04, base=True, tint=0.85)
|
|
square_post(mb, 0.0, 0.0, 2.08, 0.16, rng)
|
|
arm_z = 1.98
|
|
beam(mb, (-0.06, 0, arm_z), (0.62, 0, arm_z), 0.07, 0.09, "wood", rng, bevel=0.015)
|
|
beam(mb, (0.06, 0, 1.6), (0.38, 0, arm_z - 0.03), 0.06, 0.06, "wood", rng, bevel=0.012) # knee brace
|
|
box(mb, T(0.0, 0, arm_z), (0.18, 0.18, 0.05), "iron", rng, bevel=0.008) # iron collar
|
|
hx = 0.5
|
|
torus(mb, T(hx, 0, arm_z - 0.06, rx=math.pi / 2), 0.035, 0.009, mat="iron", n_major=10, n_minor=5)
|
|
chain(mb, (hx, 0, arm_z - 0.09), arm_z - 0.17)
|
|
flame = lantern(mb, (hx, 0, arm_z - 0.17), rng, s=1.3)
|
|
ob = mb.build(name)
|
|
socket(ob, "light", flame)
|
|
return ob
|
|
|
|
|
|
DOCK_LEN, DOCK_W, DECK_T = 2.0, 1.6, 0.07
|
|
|
|
|
|
def dock_parts(mb, rng, end=False):
|
|
AO[0] = ao_dock
|
|
n = 10
|
|
pitch = DOCK_LEN / n
|
|
for i in range(n):
|
|
x = -DOCK_LEN / 2 + (i + 0.5) * pitch
|
|
dz = -rng.uniform(0.0, 0.008)
|
|
box(mb, T(x, rng.uniform(-0.02, 0.02), -DECK_T / 2 + dz, rz=rng.uniform(-0.012, 0.012)),
|
|
(pitch - 0.016, DOCK_W, DECK_T), "wood", rng, bevel=0.012, grain=1, tint=rng.uniform(0.88, 1.08))
|
|
for s in (-1, 1):
|
|
beam(mb, (-DOCK_LEN / 2, s * 0.55, -0.15), (DOCK_LEN / 2, s * 0.55, -0.15), 0.11, 0.16, "wood", rng,
|
|
bevel=0.015, tint=0.8) # stringers
|
|
beam(mb, (-DOCK_LEN / 2, s * 0.82, -0.09), (DOCK_LEN / 2, s * 0.82, -0.09), 0.045, 0.13, "wood", rng,
|
|
bevel=0.01, tint=0.9) # fascia
|
|
xs = [-0.5, 0.5] + ([0.94] if end else [])
|
|
for x in xs:
|
|
for s in (-1, 1):
|
|
log(mb, (x, s * 0.88, -1.55), (x, s * 0.88, 0.16), 0.085, 0.08, rng, mat="wood", sides=10, noise=0.03,
|
|
bevel=0.02, tint=0.95)
|
|
beam(mb, (x, -0.95, -0.3), (x, 0.95, -0.3), 0.12, 0.12, "wood", rng, bevel=0.015, tint=0.75) # cap beam
|
|
beam(mb, (x + 0.07, -0.86, -0.36), (x + 0.07, 0.86, -1.25), 0.05, 0.11, "wood", rng, bevel=0.01,
|
|
tint=0.7) # diagonal brace
|
|
if end:
|
|
beam(mb, (DOCK_LEN / 2 + 0.025, -0.84, -0.09), (DOCK_LEN / 2 + 0.025, 0.84, -0.09), 0.045, 0.13, "wood",
|
|
rng, bevel=0.01, tint=0.9) # end fascia
|
|
# Mooring bollard with rope wraps and a coil of rope on the deck.
|
|
bx, by = 0.72, 0.6
|
|
log(mb, (bx, by, -1.6), (bx, by, 0.5), 0.13, 0.12, rng, sides=12, noise=0.05, bevel=0.03)
|
|
AO[0] = ao_ground
|
|
lashing(mb, (bx, by, 0.28), 0.125, turns=3, r=0.024, pitch=0.05)
|
|
path = [Vector((bx - 0.1, by - 0.06, 0.24)), Vector((0.58, 0.32, 0.1)), Vector((0.5, 0.05, 0.03)),
|
|
Vector((0.42, -0.2, 0.025))] # droops from the bollard down onto the deck
|
|
for a, b in zip(path[:-1], path[1:]):
|
|
rope(mb, a - (b - a).normalized() * 0.01, b, r=0.022)
|
|
for i in range(3):
|
|
torus(mb, T(0.3, -0.35, 0.022 + i * 0.04), 0.17 - i * 0.03, 0.022, n_major=20)
|
|
AO[0] = ao_ground
|
|
|
|
|
|
def make_dock(name, seed):
|
|
mb = MeshBuilder()
|
|
dock_parts(mb, random.Random(seed))
|
|
return mb.build(name)
|
|
|
|
|
|
def make_dock_end(name, seed):
|
|
mb = MeshBuilder()
|
|
dock_parts(mb, random.Random(seed), end=True)
|
|
return mb.build(name)
|
|
|
|
|
|
def crate_parts(mb, M, size, rng):
|
|
h = size / 2
|
|
t = size * 0.13
|
|
box(mb, M, (size - 0.02, size - 0.02, size - 0.02), "planks", rng, bevel=0.01, grain=2, tint=rng.uniform(0.9, 1.05))
|
|
for cx, cy in ((-1, -1), (1, -1), (1, 1), (-1, 1)): # corner posts
|
|
box(mb, M @ T(cx * (h - t / 2), cy * (h - t / 2), 0), (t, t, size), "wood", rng, bevel=0.012, tint=0.8)
|
|
for z in (-1, 1): # top and bottom battens between the corner posts
|
|
for ax in (0, 1):
|
|
for s in (-1, 1):
|
|
p = [0.0, 0.0, z * (h - t / 2)]
|
|
p[1 - ax] = s * (h - t * 0.45)
|
|
dims = [size - 2 * t, t * 0.9, t] if ax == 0 else [t * 0.9, size - 2 * t, t]
|
|
box(mb, M @ T(*p), dims, "wood", rng, bevel=0.01, grain=ax, tint=0.85)
|
|
L = math.hypot(size - 2 * t, size - 2 * t)
|
|
for s in (-1, 1): # diagonal braces on the front and back
|
|
box(mb, M @ T(0, s * (h - t * 0.4), 0, ry=math.pi / 4 * s), (t * 0.85, t * 0.7, L - t * 0.4), "wood", rng,
|
|
bevel=0.01, grain=2, tint=0.88)
|
|
|
|
|
|
def make_crate(name, seed):
|
|
rng = random.Random(seed)
|
|
mb = MeshBuilder()
|
|
s = 0.72
|
|
crate_parts(mb, T(0, 0, s / 2, rz=0.0), s, rng)
|
|
return mb.build(name)
|
|
|
|
|
|
def make_barrel(name, seed):
|
|
rng = random.Random(seed)
|
|
mb = MeshBuilder()
|
|
H, re, rm = 0.88, 0.25, 0.3
|
|
|
|
def r_at(z):
|
|
return re + (rm - re) * math.sin(math.pi * max(0.0, min(1.0, z / H)))
|
|
prof = [(r_at(z), z) for z in (H * i / 10 for i in range(11))]
|
|
prof += [(re - 0.005, H + 0.012), (re - 0.03, H + 0.012), (re - 0.03, H - 0.02)]
|
|
bm = bm_lathe(prof, 18, caps=(True, True), bevel=0.0)
|
|
off = rnd_off(rng)
|
|
emit(mb, bm, ["staves", "planks"], T(rz=rng.random() * math.tau),
|
|
uv_by_mat({0: uv_cyl(0.28, off), 1: uv_box(1, off)}))
|
|
for z0 in (0.07, 0.25, H - 0.31, H - 0.13):
|
|
z1 = z0 + 0.06
|
|
a, b = r_at(z0) + 0.006, r_at(z1) + 0.006
|
|
bm = bm_lathe([(a - 0.006, z0), (a + 0.006, z0 + 0.008), (b + 0.006, z1 - 0.008), (b - 0.006, z1)], 18,
|
|
caps=(False, False))
|
|
emit(mb, bm, ["iron"], T(), uv_cyl(0.3))
|
|
return mb.build(name)
|
|
|
|
|
|
def make_log_bench(name, seed):
|
|
rng = random.Random(seed)
|
|
mb = MeshBuilder()
|
|
r, L, seat = 0.2, 1.5, 0.45
|
|
half = [(r * math.cos(a), r * math.sin(a)) for a in (math.pi + i / 8 * math.pi for i in range(9))]
|
|
bm = bm_prism(half, L, bevel=0.02)
|
|
bm.normal_update()
|
|
for f in bm.faces: # the sawn top face gets the plain-wood material
|
|
if f.material_index == 0 and f.normal.y > 0.9:
|
|
f.material_index = 2
|
|
# local x -> world Y, local y -> world Z (flat top up), local z -> world X (length)
|
|
M = Matrix((Vector((0, 1, 0)), Vector((0, 0, 1)), Vector((1, 0, 0)))).transposed().to_4x4()
|
|
M.translation = Vector((0, 0, seat))
|
|
emit(mb, bm, ["log_bark", "end_grain", "wood"], M,
|
|
uv_by_mat({0: uv_cyl(r, rnd_off(rng)), 1: uv_cap(r), 2: uv_box(2, rnd_off(rng))}))
|
|
for x in (-0.5, 0.5):
|
|
log(mb, (x, 0, -0.04), (x, 0, seat - r + 0.03), 0.17, 0.16, rng, sides=12, noise=0.05)
|
|
return mb.build(name)
|
|
|
|
|
|
def make_hay_bale(name, seed):
|
|
rng = random.Random(seed)
|
|
mb = MeshBuilder()
|
|
sx, sy, sz = 1.0, 0.56, 0.48
|
|
bm = bm_box(sx, sy, sz, bevel=0.07, segments=3, base=False, subdiv=4)
|
|
off = Vector((rng.random() * 50, rng.random() * 50, 0))
|
|
bm.normal_update()
|
|
for v in bm.verts:
|
|
v.co += v.normal * 0.018 * mathutils.noise.noise(v.co * 4.0 + off)
|
|
emit(mb, bm, ["hay"], T(0, 0, sz / 2 - 0.02), uv_box(1, rnd_off(rng)))
|
|
for x in (-0.26, 0.26): # twine bands
|
|
ring = [(-sy / 2 - 0.012, -sz / 2 + 0.05), (sy / 2 + 0.012, -sz / 2 + 0.05), (sy / 2 + 0.012, sz / 2 - 0.05),
|
|
(sy / 2 - 0.05, sz / 2 + 0.012), (-sy / 2 + 0.05, sz / 2 + 0.012), (-sy / 2 - 0.012, sz / 2 - 0.05)]
|
|
for i in range(len(ring)):
|
|
(ya, za), (yb, zb) = ring[i], ring[(i + 1) % len(ring)]
|
|
rope(mb, (x, ya, za + sz / 2 - 0.02), (x, yb, zb + sz / 2 - 0.02), r=0.012)
|
|
return mb.build(name)
|
|
|
|
|
|
# ------------------------------------------------------------------- tent --
|
|
TW, TD, EAVE, RIDGE, OVX, OVY = 1.5, 1.4, 1.15, 2.36, 0.16, 0.12
|
|
DOOR_W, DOOR_H = 0.56, 1.72
|
|
|
|
|
|
def roof_z(x):
|
|
return RIDGE - (RIDGE - EAVE) * abs(x) / TW
|
|
|
|
|
|
def both_sides(mb, make_bm, mats, uvf, ao_out, ao_in=ao_inside, M=None, **kw):
|
|
"""Canvas seen from both sides: outer and inner (reversed) copies."""
|
|
emit(mb, make_bm(), mats, M or T(), uvf, ao=ao_out, **kw)
|
|
emit(mb, make_bm(), mats, M or T(), uvf, ao=ao_in, flip=True, **kw)
|
|
|
|
|
|
def roof_sag(x, y):
|
|
"""Canvas sags between the ridge and the eaves, most between the rafters."""
|
|
u = min(1.0, abs(x) / (TW + OVX) * 1.05)
|
|
sy = math.sin(math.pi * abs(y) / (TD + OVY)) ** 2 # zero at the gable ends and the middle rafter
|
|
return 0.06 * math.sin(math.pi * u) * (0.35 + 0.65 * sy)
|
|
|
|
|
|
def make_tent(name, seed):
|
|
"""Research tent / ranger station: cream canvas wall tent with a striped
|
|
roof, open door (flap rolled up) facing -Y, guy ropes, ridge pole, pennant."""
|
|
rng = random.Random(seed)
|
|
mb = MeshBuilder()
|
|
Dy = TD + OVY
|
|
for s in (-1, 1): # roof slopes
|
|
def roof(u, v, s=s):
|
|
x = s * u * (TW + OVX)
|
|
y = -Dy + 2 * Dy * v
|
|
z = roof_z(x) - roof_sag(x, y)
|
|
return Vector((x, y, z))
|
|
mk = (lambda roof=roof, s=s: bm_grid(roof, 6, 10) if s > 0 else _flip_grid(bm_grid(roof, 6, 10)))
|
|
both_sides(mb, mk, ["canvas_stripes"],
|
|
lambda f, tu, tv: [(l.vert.co.y / tu, abs(l.vert.co.x) * 1.25 / tv) for l in f.loops],
|
|
ao_out=lambda p, n: (0.82 + 0.18 * smooth01(1.0, 2.3, p.z),) * 3)
|
|
|
|
def wall_side(s):
|
|
def fn(u, v):
|
|
y = -TD + 2 * TD * u
|
|
z = v * (EAVE - 0.03)
|
|
bulge = 0.05 * math.sin(math.pi * u) * math.sin(math.pi * v)
|
|
return Vector((s * (TW - bulge + 0.03 * (1 - v)), y, z))
|
|
bm = bm_grid(fn, 8, 3)
|
|
return bm if s > 0 else _flip_grid(bm)
|
|
|
|
canvas_uv = lambda f, tu, tv: [((l.vert.co.y if abs(f.normal.x) > 0.5 else l.vert.co.x) / tu, l.vert.co.z / tv)
|
|
for l in f.loops]
|
|
for s in (-1, 1):
|
|
both_sides(mb, lambda s=s: wall_side(s), ["canvas"], canvas_uv, ao_out=ao_ground)
|
|
|
|
def gable(front):
|
|
"""Gable wall at y=-TD (front, with the door) or +TD; vertices shared so
|
|
clamped rows collapse into triangles under the roof line."""
|
|
bm = bmesh.new()
|
|
xs = [-TW, -1.05, -DOOR_W, -DOOR_W / 2, 0.0, DOOR_W / 2, DOOR_W, 1.05, TW]
|
|
rows = [0.0, 0.6, EAVE, DOOR_H, 9.0]
|
|
y = -TD if front else TD
|
|
cache = {}
|
|
|
|
def vert(i, z):
|
|
x = xs[i]
|
|
z = min(z, roof_z(x) - roof_sag(x, y) - 0.025)
|
|
key = (i, round(z, 5))
|
|
if key not in cache:
|
|
bulge = 0.03 * math.sin(math.pi * (x + TW) / (2 * TW)) * math.sin(math.pi * z / RIDGE)
|
|
cache[key] = bm.verts.new((x, y + (bulge if front else -bulge), z))
|
|
return cache[key]
|
|
for i in range(len(xs) - 1):
|
|
for j in range(len(rows) - 1):
|
|
xc = (xs[i] + xs[i + 1]) / 2
|
|
zc = (rows[j] + rows[j + 1]) / 2
|
|
if front and abs(xc) < DOOR_W and zc < DOOR_H:
|
|
continue # doorway
|
|
quad = [vert(i, rows[j]), vert(i + 1, rows[j]), vert(i + 1, rows[j + 1]), vert(i, rows[j + 1])]
|
|
uniq = []
|
|
for q in quad:
|
|
if q not in uniq:
|
|
uniq.append(q)
|
|
if len(uniq) >= 3:
|
|
f = bm.faces.new(uniq if front else uniq[::-1]) # outward: -Y for the front
|
|
return bm
|
|
for front in (True, False):
|
|
both_sides(mb, lambda front=front: gable(front), ["canvas"], canvas_uv, ao_out=ao_ground)
|
|
|
|
# Valance strips under the eaves and along the gable edges (green trim).
|
|
def valance_side(s):
|
|
def fn(u, v):
|
|
y = -Dy + 2 * Dy * u
|
|
x = s * (TW + OVX)
|
|
ztop = roof_z(x)
|
|
scallop = 0.05 * abs(math.sin(u * math.pi * 9))
|
|
return Vector((x + s * 0.005, y, ztop - (0.17 - scallop) * (1 - v)))
|
|
bm = bm_grid(fn, 36, 1)
|
|
return bm if s > 0 else _flip_grid(bm)
|
|
|
|
def valance_gable(front, s):
|
|
y = -Dy if front else Dy
|
|
|
|
def fn(u, v):
|
|
x = s * u * (TW + OVX)
|
|
scallop = 0.04 * abs(math.sin(u * math.pi * 6))
|
|
return Vector((x, y - (0.005 if front else -0.005), roof_z(x) - 0.01 - (0.14 - scallop) * (1 - v)))
|
|
bm = bm_grid(fn, 24, 1)
|
|
flip = (s > 0) != front
|
|
return _flip_grid(bm) if flip else bm
|
|
green_uv = lambda f, tu, tv: [((l.vert.co.x + l.vert.co.y) / tu, l.vert.co.z / tv) for l in f.loops]
|
|
for s in (-1, 1):
|
|
both_sides(mb, lambda s=s: valance_side(s), ["canvas_green"], green_uv, ao_out=ao_flat(0.95),
|
|
ao_in=ao_flat(0.6))
|
|
for front in (True, False):
|
|
both_sides(mb, lambda s=s, front=front: valance_gable(front, s), ["canvas_green"], green_uv,
|
|
ao_out=ao_flat(0.95), ao_in=ao_flat(0.6))
|
|
|
|
# Door: green trim around the opening and the flap rolled up above it.
|
|
yd = -TD - 0.012
|
|
for s in (-1, 1):
|
|
box(mb, T(s * (DOOR_W + 0.03), yd, DOOR_H / 2), (0.07, 0.03, DOOR_H + 0.07), "canvas_green", rng, bevel=0.01)
|
|
box(mb, T(0, yd, DOOR_H + 0.01), (2 * DOOR_W + 0.13, 0.03, 0.07), "canvas_green", rng, bevel=0.01, grain=0)
|
|
roll = along((-DOOR_W - 0.08, yd - 0.07, DOOR_H + 0.1), (DOOR_W + 0.08, yd - 0.07, DOOR_H + 0.1))
|
|
bm = bm_lathe([(0.075, 0.0), (0.085, 0.3), (0.08, 2 * DOOR_W - 0.1), (0.075, 2 * DOOR_W + 0.16)], 12, bevel=0.02)
|
|
emit(mb, bm, ["canvas_green", "canvas_green"], roll, uv_cyl(0.08), ao=ao_flat(0.9))
|
|
for s in (-1, 1):
|
|
x = s * (DOOR_W - 0.12)
|
|
torus(mb, T(x, yd - 0.07, DOOR_H + 0.1, ry=math.pi / 2), 0.088, 0.012, n_major=14)
|
|
# Floor cloth inside.
|
|
floor = lambda: bm_grid(lambda u, v: Vector((-TW + 2 * TW * u, -TD + 2 * TD * v, 0.012)), 1, 1)
|
|
emit(mb, floor(), ["canvas_green"], T(), green_uv, ao=ao_flat(0.45))
|
|
# Something to look at inside: a supply crate and a lantern-lit corner.
|
|
crate_parts(mb, T(-0.85, 0.75, 0.3, rz=0.2), 0.6, rng)
|
|
AO[0] = ao_ground
|
|
# Ridge pole poking out of both gables, with a pennant on the front end.
|
|
log(mb, (0, -Dy - 0.14, RIDGE + 0.02), (0, Dy + 0.14, RIDGE + 0.02), 0.045, 0.045, rng, mat="wood", sides=8,
|
|
noise=0.0, bevel=0.01)
|
|
py = -Dy - 0.06
|
|
log(mb, (0, py, RIDGE), (0, py, RIDGE + 0.4), 0.02, 0.018, rng, mat="wood", sides=6, noise=0.0, bevel=0.006)
|
|
torus(mb, T(0, py, RIDGE + 0.42), 0.026, 0.01, mat="wood", n_major=8, n_minor=4)
|
|
for sgn in (1, -1): # pennant: two-sided triangle, fluttering tip
|
|
base0, base1 = Vector((0.02, py, RIDGE + 0.39)), Vector((0.02, py, RIDGE + 0.22))
|
|
tip = Vector((0.36, py, RIDGE + 0.31))
|
|
pts = [base1, tip, base0] if sgn > 0 else [base0, tip, base1]
|
|
n = Vector((0, -sgn, 0))
|
|
mb.face(pts, [(0, 0), (1, 0.5), (0, 1)] if sgn > 0 else [(0, 1), (1, 0.5), (0, 0)],
|
|
[(1.0, 1.0, 1.0, 0.0), (1.0, 1.0, 1.0, 0.8), (1.0, 1.0, 1.0, 0.0)], [n] * 3, "canvas_green")
|
|
# Guy ropes from the eaves to pegs.
|
|
for s in (-1, 1):
|
|
for y in (-0.85, 0.85):
|
|
a = Vector((s * (TW + OVX - 0.03), y, roof_z(TW + OVX) - 0.02))
|
|
peg = Vector((s * (TW + 0.62), y, 0.08))
|
|
rope(mb, a, peg, r=0.012)
|
|
beam(mb, (peg.x - s * 0.03, y, -0.06), (peg.x + s * 0.03, y, 0.14), 0.045, 0.045, "wood", rng, bevel=0.01)
|
|
return mb.build(name)
|
|
|
|
|
|
def _flip_grid(bm):
|
|
bmesh.ops.reverse_faces(bm, faces=bm.faces[:])
|
|
return bm
|
|
|
|
|
|
# ------------------------------------------------------------------- main --
|
|
def export(objects, path):
|
|
"""One .glb with every model as a named root node, so textures are stored once.
|
|
Child empties are exported too: the engine reads them as named sockets."""
|
|
bpy.ops.object.select_all(action="DESELECT")
|
|
for ob in objects:
|
|
ob.select_set(True)
|
|
for child in ob.children:
|
|
child.select_set(True)
|
|
bpy.context.view_layer.objects.active = objects[0]
|
|
bpy.ops.export_scene.gltf(filepath=path, export_format="GLB", use_selection=True, export_yup=True,
|
|
export_apply=True, export_normals=True, export_texcoords=True,
|
|
export_vertex_color="ACTIVE", export_image_format="AUTO", export_materials="EXPORT")
|
|
|
|
|
|
def gltf(v):
|
|
"""Blender Z-up -> glTF Y-up."""
|
|
return (v[0], v[2], -v[1])
|
|
|
|
|
|
def report(ob):
|
|
pts = [gltf(v.co) for v in ob.data.vertices]
|
|
lo = [min(p[i] for p in pts) for i in range(3)]
|
|
hi = [max(p[i] for p in pts) for i in range(3)]
|
|
print(f" {ob.name:<11} {len(ob.data.polygons):5d} faces min ({lo[0]:+.3f}, {lo[1]:+.3f}, {lo[2]:+.3f})"
|
|
f" max ({hi[0]:+.3f}, {hi[1]:+.3f}, {hi[2]:+.3f})")
|
|
for c in ob.children:
|
|
p = gltf(c.location)
|
|
print(f" socket {c.name:<8} ({p[0]:+.3f}, {p[1]:+.3f}, {p[2]:+.3f})")
|
|
|
|
|
|
MODELS = [
|
|
("fence", make_fence, 1), ("fence_post", make_fence_post, 2), ("gate", make_gate, 3),
|
|
("signpost", make_signpost, 4), ("lamp", make_lamp, 5), ("dock", make_dock, 6), ("dock_end", make_dock_end, 7),
|
|
("tent", make_tent, 8), ("crate", make_crate, 9), ("barrel", make_barrel, 10),
|
|
("log_bench", make_log_bench, 11), ("hay_bale", make_hay_bale, 12),
|
|
]
|
|
|
|
# Everything lives in its own collection; nothing else in the open file is touched.
|
|
COLLECTION = bpy.data.collections.get("Safari_Props")
|
|
if COLLECTION is None:
|
|
COLLECTION = bpy.data.collections.new("Safari_Props")
|
|
bpy.context.scene.collection.children.link(COLLECTION)
|
|
for ob in list(COLLECTION.objects):
|
|
data = ob.data
|
|
bpy.data.objects.remove(ob, do_unlink=True)
|
|
if isinstance(data, bpy.types.Mesh) and data.users == 0:
|
|
bpy.data.meshes.remove(data)
|
|
|
|
MAT = {n: material(n, n + ".png") for n in TEXEL if n != "lantern_glass"}
|
|
MAT["lantern_glass"] = material("lantern_glass", "lantern_glass.png", emission=3.0, roughness=0.3)
|
|
|
|
os.makedirs(OUT, exist_ok=True)
|
|
objects = []
|
|
for name, fn, seed in MODELS:
|
|
AO[0] = ao_ground
|
|
objects.append(fn(name, seed))
|
|
glb = os.path.join(OUT, "safari.glb")
|
|
export(objects, glb) # all at the origin: the engine looks models up by node name
|
|
print("wrote", glb)
|
|
for ob in objects:
|
|
report(ob)
|
|
|
|
# ---------------------------------------------------------------- preview --
|
|
LAYOUT = { # Blender (x, y, z) for the side-by-side lineup; docks stand in the preview water
|
|
"gate": (-5.4, 3.6, 0), "tent": (-0.6, 3.8, 0), "lamp": (2.6, 3.2, 0), "signpost": (3.9, 3.0, 0),
|
|
"dock": (-6.4, -0.6, 1.3), "dock_end": (-4.4, -0.6, 1.3), "fence": (-1.9, -0.5, 0), "fence_post": (-0.3, -0.5, 0),
|
|
"crate": (0.8, -0.5, 0), "barrel": (1.9, -0.5, 0), "log_bench": (3.3, -0.6, 0), "hay_bale": (5.0, -0.5, 0),
|
|
}
|
|
REF_LAYOUT = {"oak_a": (6.8, 3.6, 0), "rock_a": (6.5, -0.5, 0), "bush_a": (7.6, -0.4, 0)}
|
|
|
|
|
|
def preview(path, reference=None):
|
|
"""Renders the lineup in a throwaway scene that only contains Safari_Props,
|
|
so nothing else in the open file shows up (or is modified)."""
|
|
old = bpy.data.scenes.get("Safari_Preview")
|
|
if old:
|
|
bpy.data.scenes.remove(old)
|
|
scene = bpy.data.scenes.new("Safari_Preview")
|
|
scene.collection.children.link(COLLECTION)
|
|
for ob in objects:
|
|
ob.location = LAYOUT.get(ob.name, (0, 0, 0))
|
|
if reference: # engine scenery for a side-by-side style check
|
|
before = set(bpy.data.objects)
|
|
bpy.ops.import_scene.gltf(filepath=reference)
|
|
for ob in set(bpy.data.objects) - before:
|
|
for c in ob.users_collection:
|
|
c.objects.unlink(ob)
|
|
COLLECTION.objects.link(ob)
|
|
if ob.parent is None and ob.name in REF_LAYOUT:
|
|
ob.location = REF_LAYOUT[ob.name]
|
|
elif ob.parent is None:
|
|
ob.hide_render = True
|
|
ground = bpy.data.meshes.new("preview_ground")
|
|
ground.from_pydata([(-30, -30, 0), (30, -30, 0), (30, 30, 0), (-30, 30, 0)], [], [(0, 1, 2, 3)])
|
|
gob = bpy.data.objects.new("preview_ground", ground)
|
|
gm = bpy.data.materials.get("preview_ground") or bpy.data.materials.new("preview_ground")
|
|
gm.use_nodes = True
|
|
next(n for n in gm.node_tree.nodes if n.type == "BSDF_PRINCIPLED").inputs["Base Color"].default_value = \
|
|
(0.2, 0.32, 0.13, 1)
|
|
ground.materials.append(gm)
|
|
COLLECTION.objects.link(gob)
|
|
# Water box under the docks so their legs read as standing in water.
|
|
water = bpy.data.meshes.new("preview_water")
|
|
water.from_pydata([(-7.6, -1.9, 0.45), (-3.2, -1.9, 0.45), (-3.2, 0.7, 0.45), (-7.6, 0.7, 0.45)], [],
|
|
[(0, 1, 2, 3)])
|
|
wob = bpy.data.objects.new("preview_water", water)
|
|
wm = bpy.data.materials.get("preview_water") or bpy.data.materials.new("preview_water")
|
|
wm.use_nodes = True
|
|
bsdf = next(n for n in wm.node_tree.nodes if n.type == "BSDF_PRINCIPLED")
|
|
bsdf.inputs["Base Color"].default_value = (0.1, 0.3, 0.38, 1)
|
|
bsdf.inputs["Roughness"].default_value = 0.15
|
|
water.materials.append(wm)
|
|
COLLECTION.objects.link(wob)
|
|
|
|
cam = bpy.data.objects.new("preview_cam", bpy.data.cameras.new("preview_cam"))
|
|
focus = arg("--focus")
|
|
if focus: # close-up of one model
|
|
ob = bpy.data.objects[focus]
|
|
lo = Vector([min(c[i] for c in ob.bound_box) for i in range(3)])
|
|
hi = Vector([max(c[i] for c in ob.bound_box) for i in range(3)])
|
|
target = ob.location + (lo + hi) / 2
|
|
dist = max((hi - lo).length * 1.6, 2.2)
|
|
cam.data.lens = 50
|
|
pitch = math.radians(float(arg("--pitch", 58)))
|
|
yaw = math.radians(float(arg("--yaw", 0)))
|
|
else: # HD-2D-ish three-quarter view of the whole lineup
|
|
target, dist, pitch, yaw = Vector((0.3, 1.5, 0.8)), 17.5, math.radians(52), 0.0
|
|
cam.data.lens = 35
|
|
cam.location = target + Vector((math.sin(yaw) * math.sin(pitch), -math.cos(yaw) * math.sin(pitch),
|
|
math.cos(pitch))) * dist
|
|
cam.rotation_euler = (pitch, 0, yaw)
|
|
COLLECTION.objects.link(cam)
|
|
sun = bpy.data.objects.new("preview_sun", bpy.data.lights.new("preview_sun", "SUN"))
|
|
sun.data.energy = 3.5
|
|
sun.data.angle = math.radians(8)
|
|
sun.rotation_euler = (math.radians(45), math.radians(-20), math.radians(-30))
|
|
COLLECTION.objects.link(sun)
|
|
world = bpy.data.worlds.get("preview_world") or bpy.data.worlds.new("preview_world")
|
|
world.use_nodes = True
|
|
bg = next(n for n in world.node_tree.nodes if n.type == "BACKGROUND")
|
|
bg.inputs["Color"].default_value = (0.55, 0.62, 0.7, 1)
|
|
bg.inputs["Strength"].default_value = 0.9
|
|
scene.world = world
|
|
scene.camera = cam
|
|
try:
|
|
scene.render.engine = "BLENDER_EEVEE"
|
|
except TypeError:
|
|
scene.render.engine = "BLENDER_WORKBENCH"
|
|
scene.render.resolution_x, scene.render.resolution_y = int(arg("--width", 1800)), int(arg("--height", 1000))
|
|
scene.render.resolution_percentage = 100
|
|
scene.render.filepath = path
|
|
bpy.ops.render.render(write_still=True, scene=scene.name)
|
|
bpy.data.scenes.remove(scene)
|
|
print("preview", path)
|
|
|
|
|
|
if arg("--preview"):
|
|
preview(arg("--preview"), arg("--reference"))
|
|
else:
|
|
for ob in objects: # lay out side by side for inspection in a live session
|
|
ob.location = LAYOUT.get(ob.name, (0, 0, 0))
|