RacesOfValheim/scripts/paint_nexus.py
kanym 778451bed8 fix: the Ljoskjarne's seam is painted into a glow map, the plates look forged
The cyan bars stood on the faces and lost part of their length to the face
on one side of the world, lit or unlit. The seam is now a line in the faces'
own glow map, with a shallow channel in a new normal map. The plates take
grain and blotches from the black metal and iron beam textures, and shine
less.
2026-10-30 19:46:55 +01:00

126 lines
7.7 KiB
Python

"""Paint the Ljoskjarne's pyramid face (Alfar Nexus) and render a preview.
Usage: py -3.14 -I paint_nexus.py <pylib> <scripts dir> <work dir>
<work dir> must hold runes/RuneTile_e.png (Valheim's glyphs, the Ashlands rune tile's glow mask),
metal/blackmetal_d.png and metal/Ironbeam_d.png, all from bundle c4210710. Writes
AlfarNexus_face.png (one face, u 0..1 along the base, v 1 at the apex), AlfarNexus_glow.png (its glow
map: the cyan seam down the middle), AlfarNexus_n.png (its normal map), AlfarNexus_icon.png and
prev_nexus.png; copy the face, glow, normal map and icon to
JotunnModStub/Assets/AlfarNexus/."""
import sys, os, math
sys.path.insert(0, sys.argv[1]); sys.path.insert(0, sys.argv[2])
import numpy as np
from PIL import Image, ImageFilter, ImageChops
from render_obj import render
d = sys.argv[3]
S = 512
# --- the glyphs: every blob of the rune tile's glow mask, cut out with its bounding box
mask = np.asarray(Image.open(os.path.join(d,"runes","RuneTile_e.png")).convert("L"), dtype=np.float32)/255
grown = np.asarray(Image.fromarray((mask>0.15).astype(np.uint8)*255).filter(ImageFilter.MaxFilter(15)))>0
seen = np.zeros_like(grown); blobs = []
H, W = grown.shape
for y in range(H):
for x in range(W):
if grown[y,x] and not seen[y,x]:
stack=[(y,x)]; seen[y,x]=True; ys=[];xs=[]
while stack:
cy,cx=stack.pop(); ys.append(cy); xs.append(cx)
for ny,nx in ((cy+1,cx),(cy-1,cx),(cy,cx+1),(cy,cx-1)):
if 0<=ny<H and 0<=nx<W and grown[ny,nx] and not seen[ny,nx]: seen[ny,nx]=True; stack.append((ny,nx))
y0,y1,x0,x1=min(ys)+7,max(ys)-7,min(xs)+7,max(xs)-7
if (y1-y0)*(x1-x0) > 150: blobs.append((x0,y0,x1+1,y1+1))
tall = [b for b in blobs if (b[3]-b[1]) > 2.5*(b[2]-b[0])]
wide = [b for b in blobs if b not in tall and (b[2]-b[0]) < 200]
glyph = lambda b: Image.fromarray((mask[b[1]:b[3], b[0]:b[2]]*255).astype(np.uint8))
print("glyphs: tall", len(tall), "short", len(wide))
# --- the plate: forged steel. Fine grain from the black metal bar's texture, tiled every 37 cm, and
# broad blotches from the iron beam's metal, stretched over the whole face.
def norm(a): return (a - a.mean())/(a.std() + 1e-6)
tile = Image.open(os.path.join(d,"metal","blackmetal_d.png")).convert("L").resize((96,96), Image.BICUBIC)
grain = norm(np.tile(np.asarray(tile, dtype=np.float32), (6,6))[:S,:S])
iron = Image.open(os.path.join(d,"metal","Ironbeam_d.png")).convert("L").crop((176,90,256,250))
mottle = norm(np.asarray(iron.resize((S,S), Image.BICUBIC).filter(ImageFilter.GaussianBlur(6)), dtype=np.float32))
tone = 0.27 + 0.035*grain + 0.05*mottle
stone = tone[...,None]*np.array([0.95,1.0,1.08])
# --- lay the glyphs out inside the face's triangle (in image space the apex is at the top middle)
ink = Image.new("L", (S,S), 0)
inside = lambda x, y: abs(x - S/2) < (y/S)*S/2 - 14 # y measured from the apex
GAP = 26 # half-width kept clear for the seam
# the tall columns flank the seam
for i, b in enumerate(tall[:3]):
g = glyph(b); h = int(S*0.28); w = max(1, int(g.width*h/g.height))
g = g.resize((w,h), Image.LANCZOS)
for side in (-1, 1):
x = int(S/2 + side*(GAP + 8 + i*(w+10)) - (w if side < 0 else 0)); y = int(S*0.34)
if inside(x, y) and inside(x+w, y): ink.paste(g, (x,y), g)
# short clusters in rows toward the base
k = 0
for row, y in enumerate(range(int(S*0.66), S-40, 48)):
half = (y/S)*S/2 - 22
x = S/2 - half
while x < S/2 + half:
g = glyph(wide[k % len(wide)]); k += 1
h = 34; w = max(1, int(g.width*h/g.height)); w = min(w, 80)
g = g.resize((w,h), Image.LANCZOS)
if abs(x + w/2 - S/2) < GAP + w/2: x = S/2 + GAP; continue
if inside(x, y) and inside(x+w, y+h): ink.paste(g, (int(x), int(y)), g)
x += w + 14
ink = ink.filter(ImageFilter.MaxFilter(3)) # thicker strokes: they are read from metres away
inkf = np.clip(np.asarray(ink, dtype=np.float32)/255*1.4, 0, 1)
# carved: a dark rim just below each line, the line itself light grey
shadow = np.asarray(ink.filter(ImageFilter.GaussianBlur(2)).transform((S,S), Image.AFFINE, (1,0,-1,0,1,-2)), dtype=np.float32)/255
face = stone*(1 - 0.45*shadow[...,None])
face = face*(1 - inkf[...,None]) + np.array([0.72,0.73,0.76])*inkf[...,None]
out = Image.fromarray((np.clip(face,0,1)*255).astype(np.uint8)) # top row is v = 1, the apex, as Unity reads a PNG
out.save(os.path.join(d,"AlfarNexus_face.png"))
# --- the glow map: one line down the middle. u runs 0.5 per metre at every height, so a band of
# constant width in u is 9 cm wide on the pyramid from base to tip.
SEAM_HALF = 11 # pixels; GAP keeps the runes clear of it
xs = np.abs(np.arange(S) - (S-1)/2)
line = np.clip((SEAM_HALF + 1 - xs)/2, 0, 1) # two pixels of soft edge
glow = np.tile(line, (S,1))
Image.fromarray((glow*255).astype(np.uint8)).convert("RGB").save(os.path.join(d,"AlfarNexus_glow.png"))
# --- the normal map, from a height field: the grain and blotches raised a little, runes and the
# seam's channel cut in. DXT5nm, as Valheim packs it: X in alpha, Y in green and blue, red 255.
height = 0.35*grain + 0.9*mottle - 2.2*np.asarray(ink.filter(ImageFilter.GaussianBlur(1)), dtype=np.float32)/255 \
- 1.5*np.clip((SEAM_HALF + 4 - xs)/3, 0, 1)[None,:]
gx = np.zeros_like(height); gy = np.zeros_like(height)
gx[:,1:-1] = height[:,2:] - height[:,:-2]; gy[1:-1,:] = height[2:,:] - height[:-2,:]
K = 0.35
nm = np.stack([-gx*K, gy*K, np.ones_like(height)], -1) # image y runs down, texture v up
nm /= np.linalg.norm(nm, axis=-1, keepdims=True)
packed = np.zeros((S,S,4), np.float32)
packed[...,0] = 1; packed[...,1] = packed[...,2] = nm[...,1]*0.5 + 0.5; packed[...,3] = nm[...,0]*0.5 + 0.5
Image.fromarray((packed*255).astype(np.uint8), "RGBA").save(os.path.join(d,"AlfarNexus_n.png"))
# a lit check of the normal map, light from the upper left
shade = np.clip(nm @ np.array([-0.5,0.5,0.7])/np.linalg.norm([-0.5,0.5,0.7]), 0, 1)
Image.fromarray((np.clip(face*shade[...,None]*1.6,0,1)*255).astype(np.uint8)).save(os.path.join(d,"prev_nexus_bump.png"))
# --- preview: the pyramid as AlfarNexus builds it
HGT, B, LIFT = 2.0, 1.0, 0.5 # AlfarNexusLook: 2 m tall, 2 m base, floating 0.5 m up
apex = np.array([0, LIFT+HGT, 0]); c = [np.array(p) for p in [(-B,LIFT,-B),(B,LIFT,-B),(B,LIFT,B),(-B,LIFT,B)]]
lit = np.asarray(out, dtype=np.float32)/255
lit = lit*(1-glow[...,None]) + np.array([0.35,0.75,1.0])*glow[...,None]
shown = Image.fromarray((lit*255).astype(np.uint8))
L = []; vi = 1
for i in range(4):
a, b = c[i], c[(i+1)%4]
for p in (a, b, apex): L.append("v %f %f %f" % (-p[0], p[1], p[2]))
L += ["vt 0 0", "vt 1 0", "vt 0.5 1", f"f {vi}/{vi} {vi+1}/{vi+1} {vi+2}/{vi+2}"]; vi += 3
for p in c: L.append("v %f %f %f" % (-p[0], p[1], p[2]))
L += ["vt 0 0", f"f {vi}/{3*4+1} {vi+3}/{3*4+1} {vi+2}/{3*4+1} {vi+1}/{3*4+1}"]
open(os.path.join(d,"pyramid.obj"),"w").write("\n".join(L)+"\n")
open(os.path.join(d,"ground.obj"),"w").write("v -2 0 -2\nv 2 0 -2\nv 2 0 2\nv -2 0 2\nvt 0 0\nf 1/1 2/1 3/1 4/1\n")
sh = B*0.85
open(os.path.join(d,"shadow.obj"),"w").write(
f"v {-sh} 0.005 {-sh}\nv {sh} 0.005 {-sh}\nv {sh} 0.005 {sh}\nv {-sh} 0.005 {sh}\nvt 0 0\nf 1/1 2/1 3/1 4/1\n")
parts = [{'obj':os.path.join(d,'pyramid.obj'),'tex':shown},
{'obj':os.path.join(d,'ground.obj'),'color':(0.33,0.36,0.3)},
{'obj':os.path.join(d,'shadow.obj'),'color':(0.18,0.2,0.17)}]
render(parts, os.path.join(d,'prev_nexus.png'), size=640, yaw=25, pitch=-12, light=(0.4,0.8,0.6), fit=(np.array([0,1.4,0]), 2.5))
# the hammer icon: the pyramid alone, nearly side-on so two faces show
render(parts[:1], os.path.join(d,'AlfarNexus_icon.png'), size=128, yaw=35, pitch=-12, bg=(0,0,0,0), light=(0.3,0.8,0.7))