"""10-17 (user: v7 条件,开始编码数据) the v7 condition of every training window -> /data/yuzhewu/datasets/wan_v7/cond7/clip_.pt cond [48,31,30,52] bf16 VAE latent of the v7 condition video (832x480 crop) dep [121,60,104] f16 planar depth (m) at the cell centres for the token coordinates (0 = none: sky / characters) tier [121,60,104] u8 0 sky | 1 unknown | 2 coarse | 3 exact (token tier channel; characters' cells carry nothing via dep = 0) meta dict source, variant (moge / holes / patch), normals Encoding (v7enc.py): R height, B depth (v5), skeleton on top with a black outline (+ the player's shield disc), G = tier, exact G modulated by normals. Sources (tier by where the geometry comes from): ww exact WildWorld 8-bit depth (sigma 5), characters = silhouette_mask, background behind them from other frames bk exact Black Knife raw depth_packed (lossless), characters = capsules of shot.npz, other frames roam exact memroam windows: capture.mkv depth, player capsules (prep_mem), skeleton layer = prep_mem.Skel, R/B built here synth exact ground plane (analytic) + the v5 props; above the horizon: sky (MoGe-2 by direction) / unknown er,ue coarse the BOSSV2V proxy geometry of the v5 condition, black = sky (MoGe-2) / unknown Variants (fixed per window by its key): 30% MoGe-2 first-frame world (coarse; outside it unknown; exact sources: 50% of them get a world-anchored exact patch), 15% time-spanning holes (unknown), normals off for 20%. build_v7.py --rank R --world N [--limit K] [--preview]""" import sys, os, json, gzip, hashlib, argparse, subprocess, time import numpy as np, cv2, torch import torch.nn.functional as F sys.path.insert(0, "/data/yuzhewu/runs/v7demo"); sys.path.insert(0, "/data/yuzhewu/wancond_mem"); sys.path.insert(0, "/data/yuzhewu/wancond") sys.path.insert(0, "/data/yuzhewu/datasets/wildworld"); sys.path.insert(0, "/data/yuzhewu/runs/proxykit") import v7enc as E DS = "/data/yuzhewu/datasets"; OUT = f"{DS}/wan_v7"; CK = "/data/yuzhewu/models/Wan2.2-TI2V-5B"; N = 121; W8, H8, X0 = 853, 480, 10 GV, GU = np.mgrid[0:60, 0:104]; CV, CU = 8 * GV + 4, 8 * GU + 4 + X0 # cell centres in the 853x480 frame NB = (-60, -40, -25, -12, 12, 25, 40, 60) # other frames for the background behind the characters PAR17 = [-1, 0, 1, 2, 3, 2, 5, 6, 2, 8, 9, 0, 11, 12, 0, 14, 15] key_of = lambda v: hashlib.md5(v.encode()).hexdigest()[:16] def u100(key, salt): return int(hashlib.md5((key + salt).encode()).hexdigest(), 16) % 100 def ff(path, start, n, w=None, h=None, fmt="rgb24", scale=None): """frames [start, start+n) of a video -> uint8/uint16 array""" vf = f"select='between(n\\,{start}\\,{start + n - 1})'" + (f",scale={scale[0]}:{scale[1]}:flags=area" if scale else "") if w is None or scale: if scale: w, h = scale else: w, h = map(int, subprocess.run(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height", "-of", "csv=p=0", path], capture_output=True, text=True).stdout.strip().split(",")[:2]) raw = subprocess.run(["ffmpeg", "-v", "error", "-i", path, "-vf", vf, "-vsync", "0", "-f", "rawvideo", "-pix_fmt", fmt, "-"], capture_output=True).stdout dt = np.uint16 if fmt == "rgb48le" else np.uint8; a = np.frombuffer(raw, dt) return a.reshape(-1, h, w, 3)[:n] def r853(x, interp=cv2.INTER_AREA): return cv2.resize(x, (W8, H8), interpolation=interp) def z853(z, ok): """planar depth -> 853x480 by AREA in disparity (nearest aliases into a grid in the normals); 0 where mostly invalid""" d = np.where(ok, 1.0 / np.maximum(z, 1e-3), 0).astype(np.float32); w = ok.astype(np.float32) d = cv2.resize(d, (W8, H8), interpolation=cv2.INTER_AREA); w = cv2.resize(w, (W8, H8), interpolation=cv2.INTER_AREA); good = w > 0.5 return np.where(good, 1.0 / np.maximum(d / np.maximum(w, 1e-6), 1e-6), 0.0), good class Models: def __init__(self): from wanvendor.vae2_2 import Wan2_2_VAE self.vae = Wan2_2_VAE(vae_pth=f"{CK}/Wan2.2_VAE.pth", device="cuda"); self.moge = None def mg(self, im): if self.moge is None: from moge.model.v2 import MoGeModel; self.moge = MoGeModel.from_pretrained("Ruicheng/moge-2-vitl-normal").to("cuda").eval() with torch.no_grad(): o = self.moge.infer(torch.from_numpy(np.ascontiguousarray(im)).permute(2, 0, 1).float().div(255).cuda()) return o["points"].cpu().numpy().astype(np.float64), o["mask"].cpu().numpy().astype(bool) def encode(self, v): # [121,480,832,3] uint8 (numpy or cuda) -> [48,31,30,52] if isinstance(v, np.ndarray): v = torch.from_numpy(np.ascontiguousarray(v)) x = v.cuda().permute(3, 0, 1, 2).float().div(127.5).sub(1.0) with torch.no_grad(): return self.vae.encode([x])[0].to(torch.bfloat16).cpu() # ------------------------------------------------------------------ geometry helpers (853x480, cam = (pos, Rrows right/up/forward, f, cx, cy), y up, metres) def world_pts(cam, z): pos, R, f, cx, cy = cam; v, u = np.mgrid[0:z.shape[0], 0:z.shape[1]] + 0.5 return pos + ((u - cx) / f * z)[..., None] * R[0] - ((v - cy) / f * z)[..., None] * R[1] + z[..., None] * R[2] def capsules(cam, J, rad, shape, par=PAR17): """character mask from joints [n,3] (world): bones as thick lines of radius rad (m) in perspective""" pos, R, f, cx, cy = cam; rel = J - pos; X, Y, Zc = rel @ R[0], rel @ R[1], rel @ R[2]; m = np.zeros(shape, np.uint8) for j, p in enumerate(par): if p is None or not (np.isfinite(J[j]).all() and np.isfinite(J[p]).all()): continue if p < 0 or Zc[j] < 0.2 or Zc[p] < 0.2: continue a = (int(cx + f * X[j] / Zc[j]), int(cy - f * Y[j] / Zc[j])); b = (int(cx + f * X[p] / Zc[p]), int(cy - f * Y[p] / Zc[p])) wpx = max(3, int(round(f * rad / min(Zc[j], Zc[p])))); cv2.line(m, a, b, 1, 2 * wpx); cv2.circle(m, a, wpx, 1, -1) return m.astype(bool) def fill_chars(Z, valid, CH, cams): """depth behind the characters: other frames reprojected (v7enc.temporal_fill), then the smooth fill""" out = [] for t in range(len(Z)): m = CH[t] & valid[t]; z = Z[t] if m.any(): srcs = [(cams[t + d], Z[t + d], valid[t + d] & ~CH[t + d]) for d in NB if 0 <= t + d < len(Z)] z, got = E.temporal_fill(cams[t], np.where(m, 0, z), m, srcs); m = m & ~got z = E.fill_under(z, m, valid[t] | CH[t]) out.append(z) return np.stack(out) def height_fit(V5, Z, valid, cams): """the v5 R = a * (world height) + b on the environment of frame 0 (each source has its own range / origin)""" P = world_pts(cams[0], Z[0]); r = V5[0][..., 0].astype(float) / 255; ok = valid[0] & (r > 0.52) & (r < 0.98) & (V5[0][..., 1] < 20) if ok.sum() < 500: return 0.5 / 56, 0.5 + 0.5 * 8 / 56 A = np.stack([P[..., 1][ok], np.ones(ok.sum())], 1); a, b = np.linalg.lstsq(A, r[ok], rcond=None)[0]; return a, b def rb_from(z, cam, ab): P = world_pts(cam, z); R_ = np.clip(ab[0] * P[..., 1] + ab[1], 0.5, 1.0); B_ = 1 - np.clip((z - 0.1) / 79.9, 0, 1); return R_, B_ # ------------------------------------------------------------------ the shared core def core(key, src, V5, Z, valid, sky, CH, cams, exact_src, sig, rgb0, M, shield=None, ab=None, tier0=None): """V5 [121,480,853,3] (characters drawn), Z planar depth (0 = none), valid geometry, sky, CH characters (excluded from geometry), tier0: optional base tier map (synth). GPU (v7gpu.py). Returns v7 frames (cuda uint8 [121,480,832,3]), dep cells, tier cells, meta.""" import v7gpu as G dev = "cuda"; moge = u100(key, "moge") < 30; holes = u100(key, "holes") < 15; normals = u100(key, "nrm") >= 20; patch = exact_src and moge and u100(key, "patch") < 50 pos = torch.tensor(np.stack([c[0] for c in cams]), dtype=torch.float32, device=dev); R = torch.tensor(np.stack([c[1] for c in cams]), dtype=torch.float32, device=dev) f, cx, cy = float(cams[0][2]), float(cams[0][3]), float(cams[0][4]) Zt = torch.from_numpy(np.ascontiguousarray(Z)).float().to(dev); vt = torch.from_numpy(valid).to(dev); skt = torch.from_numpy(sky).to(dev); cht = torch.from_numpy(CH).to(dev) if exact_src: Zf, miss = G.temporal_fill(Zt, vt, cht, pos, R, f, cx, cy); Zf = G.fill_rest(Zf, miss, vt) else: Zf = Zt if tier0 is not None: tier = torch.from_numpy(tier0).to(dev) else: tier = torch.where(vt, torch.full_like(Zt, 3 if exact_src else 2), torch.where(skt, torch.zeros_like(Zt), torch.ones_like(Zt))).to(torch.uint8) Zc = Zf; RB = None; pm = None if moge: # the inference world: MoGe-2 of the first frame along the true cameras Zf0 = Zf[0].cpu().numpy().astype(np.float64) P, ok = M.mg(rgb0); sel = valid[0] & ok & ~CH[0] s = float(np.median((Z[0][sel] + 1e-6) / (P[..., 2][sel] + 1e-6))) if sel.sum() > 500 else 1.0 chm = cv2.dilate(CH[0].astype(np.uint8), np.ones((15, 15), np.uint8)).astype(bool) near = valid[0] & (s * P[..., 2] < 0.9 * Zf0 - 0.3) # (10-18) nearer than the environment = a character (bodies are wider than skeleton lines) g0 = V5[0][..., 1].astype(int); hull = np.zeros((H8, W8), np.uint8) # and each character's skeleton hull (a boss against the sky has no environment behind it) for slot in np.unique(g0[g0 >= 20] // 32): ys, xs = np.nonzero((g0 >= 20) & (g0 // 32 == slot)) if len(xs) >= 3: cv2.fillConvexPoly(hull, cv2.convexHull(np.stack([xs, ys], 1).astype(np.int32)), 1) near |= cv2.dilate(hull, np.ones((61, 61), np.uint8)).astype(bool) chm |= cv2.dilate(near.astype(np.uint8), np.ones((9, 9), np.uint8)).astype(bool); okm = ok & ~chm & np.isfinite(P).all(-1) fillm = chm & ~char_fill(~ok, chm) # the characters' pixels whose surroundings are ground / walls (not sky): fill those only zM = np.where(okm, s * P[..., 2], 0.0); zM = E.fill_under(zM, fillm, okm | fillm); okm = okm | fillm Pw = world_pts(cams[0], zM); st = 2; Q = Pw[::st, ::st]; mm = okm[::st, ::st]; dd = zM[::st, ::st]; idx = np.arange(mm.size).reshape(mm.shape) a_, b_, c_, d_ = idx[:-1, :-1], idx[:-1, 1:], idx[1:, :-1], idx[1:, 1:]; D4 = np.stack([dd[:-1, :-1], dd[:-1, 1:], dd[1:, :-1], dd[1:, 1:]]) g = mm[:-1, :-1] & mm[:-1, 1:] & mm[1:, :-1] & mm[1:, 1:] & (D4.max(0) < 1.12 * D4.min(0)) F_ = np.concatenate([np.stack([a_[g], b_[g], c_[g]], 1), np.stack([b_[g], d_[g], c_[g]], 1)]); Vm = Q.reshape(-1, 3)[F_].reshape(-1, 3).astype("f4") zc = G.splat_grid(torch.from_numpy(Pw).float().to(dev), torch.from_numpy(okm).to(dev), pos, R, f, cx, cy, H8, W8) # GPU surface splat (EGL in many processes aborts: exit 134) if ab is None: ab = height_fit(V5, Zf.cpu().numpy(), valid, cams) ray = G.rays(N, H8, W8, f, cx, cy, R, dev); Py = (pos[:, None, None] + zc[..., None] * ray)[..., 1] RB = ((ab[0] * Py + ab[1]).clamp(0.5, 1.0), 1 - ((zc - 0.1) / 79.9).clamp(0, 1)); cov = zc > 0 skyd = torch.from_numpy(sky_dirs(cams, char_fill(~ok, cv2.dilate(chm.astype(np.uint8), np.ones((15, 15), np.uint8)).astype(bool)))).to(dev) # what inference knows: sky = directions frame 0 saw as sky skyd &= ~(vt & ~cht) # (10-18) sky only where the truth has no geometry: a big boss's char_fill must not call the ruins behind it sky tier = torch.where(cov, torch.full_like(tier, 2), torch.where(skyd, torch.zeros_like(tier), torch.ones_like(tier))); Zc = torch.where(cov, zc, Zf) if patch: # a world-anchored exact block round a ground point of frame 0 (an agent's object) yy, xx = int(H8 * 0.68), W8 // 2 if valid[0][yy, xx]: Pf = pos[:, None, None] + Zf[..., None] * ray; pc = Pf[0, yy, xx]; half = torch.tensor([2.0, 2.5, 2.0], device=dev) pm = ((Pf - pc).abs() < half).all(-1) & vt; tier[pm] = 3; Zc = torch.where(pm, Zf, Zc) if holes: # 1-3 ellipses, each over a contiguous span of frames rng = np.random.default_rng(int(key, 16) % 2 ** 32); hm = np.zeros((N, H8, W8), bool) for _ in range(int(rng.integers(1, 4))): t0 = int(rng.integers(0, 80)); t1 = int(rng.integers(t0 + 40, N + 1)); cx_, cy_ = int(rng.integers(100, 750)), int(rng.integers(80, 400)) ax_ = (int(rng.integers(60, 220)), int(rng.integers(40, 160))); m = np.zeros((H8, W8), np.uint8); cv2.ellipse(m, (cx_, cy_), ax_, float(rng.uniform(0, 180)), 0, 360, 1, -1) hm[t0:t1] |= m.astype(bool)[None] hm = torch.from_numpy(hm).to(dev); tier = torch.where(hm & (tier != 0), torch.ones_like(tier), tier) if os.environ.get("MEMUNK") == "1": # (10-19 user: 必须看记忆的窗口一定比例给未知) the whole environment unknown in the VIDEO; the cells keep their depth -> tokens keep coordinates tier = torch.where(tier != 0, torch.ones_like(tier), tier); meta_memunk = True if shield is not None: V5 = np.stack([E.draw_shield_853(V5[t], shield[t]) if np.isfinite(shield[t][0]) else V5[t] for t in range(N)]) V5t = torch.from_numpy(np.ascontiguousarray(V5)).to(dev) if RB is not None: # the coarse MoGe world's R / B (the patch and the characters keep theirs) keep = (V5t[..., 1] >= 20) | (pm if pm is not None else torch.zeros_like(vt)) V5t[..., 0] = torch.where(keep, V5t[..., 0], torch.round(RB[0] * 255).to(torch.uint8)); V5t[..., 2] = torch.where(keep, V5t[..., 2], torch.round(RB[1] * 255).to(torch.uint8)) ex = tier == 3 sh = G.shade(torch.where(ex, Zf, Zc), ex, R, f, cx, cy, sig * W8 / 1280) if normals else torch.full_like(Zt, 0.5) out = G.compose(V5t, tier, sh)[:, :, X0:X0 + 832] cvi = torch.from_numpy(CV).to(dev); cui = torch.from_numpy(CU).to(dev) chc = F.max_pool2d(cht[:, None].float(), 9, 1, 4)[:, 0] > 0 zc_ = torch.where(chc | (tier == 0), torch.zeros_like(Zc), Zc) zc_ = torch.where(torch.isfinite(zc_) & (zc_ < 1000), zc_, torch.zeros_like(zc_)) # f16 cells: nothing past 1 km dep = zc_[:, cvi, cui].half().cpu().numpy(); tc = tier[:, cvi, cui].cpu().numpy() return out, dep, tc, dict(src=src, moge=moge, holes=holes, patch=bool(patch and pm is not None), normals=normals) _ctx = {} class egl_lock: """one EGL user per card at a time: many processes rendering on one card stall in the driver's lock (os_acquire_rwlock) and abort (exit 134)""" def __enter__(self): import fcntl; self.f = open(f"/tmp/v7_egl_{os.environ.get('EGL', '0')}.lock", "w"); fcntl.flock(self.f, fcntl.LOCK_EX); return self def __exit__(self, *a): import fcntl; fcntl.flock(self.f, fcntl.LOCK_UN); self.f.close() def render_mesh(Vm, cams): with egl_lock(): return _render_mesh(Vm, cams) def _render_mesh(Vm, cams): import moderngl if True: # a fresh context per call: Skel's renderer can invalidate a cached one ctx = moderngl.create_standalone_context(backend="egl", require=330, device_index=int(os.environ.get("EGL", "0"))); ctx.enable(moderngl.DEPTH_TEST) prog = ctx.program(vertex_shader="""#version 330 uniform vec3 cf, cr, cu, cpos; uniform float foc, ox, oy, hw, hh; in vec3 pos; out float fd; void main(){ vec3 d = pos - cpos; float z = dot(d, cf); fd = z; float n = 0.05, f = 5000.0; gl_Position = vec4((foc * dot(d, cr) + ox * z) / hw, (foc * dot(d, cu) + oy * z) / hh, z * (f + n) / (f - n) - 2.0 * f * n / (f - n), z); }""", fragment_shader="#version 330\nin float fd; out float o; void main(){ o = fd; }") fbo = ctx.framebuffer(color_attachments=[ctx.texture((W8, H8), 1, dtype="f4")], depth_attachment=ctx.depth_renderbuffer((W8, H8))) _ctx.update(ctx=ctx, prog=prog, fbo=fbo) ctx, prog, fbo = _ctx["ctx"], _ctx["prog"], _ctx["fbo"]; buf = ctx.buffer(Vm.tobytes()); vao = ctx.vertex_array(prog, [(buf, "3f", "pos")]); out = [] prog["hw"].value = W8 / 2; prog["hh"].value = H8 / 2 for pos, R, f, cx, cy in cams: for k_, v_ in (("cf", R[2]), ("cr", R[0]), ("cu", R[1]), ("cpos", pos)): prog[k_].value = tuple(map(float, v_)) prog["foc"].value = float(f); prog["ox"].value = float(cx - W8 / 2); prog["oy"].value = float(-(cy - H8 / 2)) fbo.use(); fbo.clear(0.0, 0.0, 0.0, 0.0, depth=1.0); vao.render(); out.append(np.frombuffer(fbo.read(components=1, dtype="f4"), np.float32).reshape(H8, W8)[::-1].astype(np.float64)) vao.release(); buf.release(); fbo.release(); prog.release(); ctx.release(); _ctx.clear(); return np.stack(out) def dir_grid(cam): pos, R, f, cx, cy = cam; v, u = np.mgrid[0:H8, 0:W8] + 0.5 d = ((u - cx) / f)[..., None] * R[0] - ((v - cy) / f)[..., None] * R[1] + R[2]; d /= np.linalg.norm(d, axis=-1, keepdims=True) yaw = ((np.degrees(np.arctan2(d[..., 0], d[..., 2])) + 180) * 2).astype(int) % 720; pit = np.clip(((np.degrees(np.arcsin(np.clip(d[..., 1], -1, 1))) + 90) * 2).astype(int), 0, 359) return pit, yaw def char_fill(sky, char): """(10-18) characters must not decide sky / not sky (a character-shaped unknown hole in the sky = a cut-out trace): inside the character mask take the label of the nearest pixel outside it""" if not char.any() or char.all(): return sky from scipy import ndimage as ndi _, (iy, ix) = ndi.distance_transform_edt(char, return_indices=True); return np.where(char, sky[iy, ix], sky) def sky_dirs(cams, sky0): """sky in every frame = the directions frame 0 saw as sky (0.5 deg grid); directions frame 0 never saw are NOT sky""" sky0 = cv2.morphologyEx(sky0.astype(np.uint8), cv2.MORPH_OPEN, np.ones((7, 7), np.uint8)).astype(bool) # MoGe's invalid specks on grass / edges are not sky p0, y0 = dir_grid(cams[0]); sky0 &= p0 >= 178 # and nothing below the horizon is sky G = np.zeros((360, 720), np.int8); G[p0[sky0], y0[sky0]] = 1 G = cv2.dilate(G.astype(np.uint8), np.ones((3, 3), np.uint8)).astype(bool) return np.stack([G[dir_grid(c)] for c in cams]) def gb_cams(gb): Kg = gb["K"].numpy().astype(float); f = Kg[0] * 8; cx = Kg[2] * 8 + X0; cy = Kg[3] * 8 return [(gb["pos"][t].numpy().astype(float), gb["R"][t].numpy().astype(float), f, cx, cy) for t in range(N)] def sky_mg(M, frames, every=10, CH=None): """MoGe-2 sky (its invalid mask) every `every` frames, nearest for the rest; characters filled from their surroundings""" ks = list(range(0, N, every)) + ([N - 1] if (N - 1) % every else []); S = {k: (char_fill(~M.mg(frames[k])[1], CH[k]) if CH is not None else ~M.mg(frames[k])[1]) for k in ks} return np.stack([S[min(ks, key=lambda k: abs(k - t))] for t in range(N)]) # ------------------------------------------------------------------ sources def rows_of(src): v5 = {json.loads(l)["video"]: json.loads(l) for l in open(f"{OUT}/v5_list.jsonl")} rows = [json.loads(l) for l in open(f"{OUT}/v6_rows.jsonl")] if src == "ww": return [r for r in rows if r["group"] == "ww"] if src == "bk": return [r for r in rows if r["group"] == "bk"] if src == "er": return [r for r in rows if r["group"] == "er"] if src == "ue": return [r for r in rows if r["group"] == "ue"] if src == "synth": return [r for r in rows if r["group"] in ("e1o", "e2o", "e1n", "e2n", "e1x", "turn")] def cond_of(v): d = os.path.dirname(v); b = os.path.basename(v) return f"{d}/" + (b.replace("rgb_", "condition_") if b.startswith("rgb_") else "cond.mp4") def do_coarse(r, M): key = r["key"]; gb = torch.load(f"{OUT}/gbuf2/clip_{key}.pt", weights_only=False); cams = gb_cams(gb) V5 = np.stack([r853(x) for x in ff(cond_of(r["video"]), 0, N)]); rgb = np.stack([r853(x) for x in ff(r["video"], 0, N)]) env = ((V5[..., 0] > 8) | (V5[..., 2] > 8)) & (V5[..., 1] < 20); Z = np.where(env, 0.1 + (1 - V5[..., 2] / 255.0) * 79.9, 0.0) CH = np.stack([cv2.dilate((x[..., 1] >= 20).astype(np.uint8), np.ones((15, 15), np.uint8)) > 0 for x in V5]); valid = env | CH CHw = np.stack([cv2.dilate((x[..., 1] >= 20).astype(np.uint8), np.ones((41, 41), np.uint8)) > 0 for x in V5]) sky = sky_mg(M, rgb, CH=CHw) & ~valid return core(key, r["group"], V5, Z, valid, sky, CH, cams, False, 1.0, rgb[0], M, shield=shield_of(key)) def shield_of(key): p = f"{OUT}/shield/clip_{key}.npy"; return np.load(p) if os.path.exists(p) else None def do_ww(r, M, cache): import ww_to_bossv2v_v2 as WW from proxykit.geometry import Camera, quat_from_matrix wd = os.path.dirname(r["video"]); m = json.load(open(f"{wd}/meta.json")); sd = f"{DS}/wildworld/data_part1/{m['sample']}"; t0 = int(m["t0"]); ts = np.arange(t0, t0 + N) if cache.get("sid") != m["sample"]: st = WW.load_state(f"{sd}/state.csv"); z = np.load(f"{sd}/skeleton.npz"); keys = {k[0]: k for k in z.files}; ents = {} edges = json.load(open(f"{DS}/wildworld/skeleton_edges.json")) for kind, rotcol in (("n", "npc.list.1.rot"), ("m", "monster.list.1.rot")): k = keys[kind]; tid = k.split("_", 1)[1]; ek = "npc" if kind == "n" else f"em_{tid}" parts, parent, size, labels, _ = WW.assign_parts(z[k], edges[ek], st[rotcol], kind); ents[kind] = dict(joints=z[k], parts=parts, parent=parent, size_m=size) cache.clear(); cache.update(sid=m["sample"], st=st, ents=ents) st, ents = cache["st"], cache["ents"]; K = st["camera.K"][ts]; ground = float(m["ground_y_m"]); to_ue = lambda p: WW.S_SWAP(p - np.array([0, ground, 0])) * 100.0 dep = WW.decode_gray(f"{sd}/depth.mkv", t0, N); W_, H_ = 1280, 720 global LUT8 if "LUT8" not in globals(): LUT8 = WW.depth8_to_m(np.arange(256, dtype=np.uint8)) e_ = lambda v: np.array([v[0], v[2], -v[1]], float) V5 = np.stack([r853(x) for x in ff(f"{wd}/cond.mp4", 0, N)]); rgb0 = r853(ff(r["video"], 0, 1)[0]) Z, valid, sky, CH, cams = [], [], [], [], [] for i, t in enumerate(ts): Rgl = WW.q2R(st["camera.rot"][t]); Mx = np.stack([WW.S_SWAP(-Rgl[:, 2]), WW.S_SWAP(Rgl[:, 0]), WW.S_SWAP(Rgl[:, 1])], 1) cam = Camera(to_ue(st["camera.pos"][t]), quat_from_matrix(Mx), float(np.degrees(2 * np.arctan(W_ / 2 / K[i, 0]))), W_, H_) zm = LUT8[dep[i]]; sk = dep[i] >= WW.SKY_DEPTH8 zz, gd = z853(zm, ~sk); Z.append(zz); sky.append(~gd); valid.append(gd) s = 480 / 720; cams.append((e_(cam.position) / 100.0, np.stack([e_(cam.R[:, 1]), e_(cam.R[:, 2]), e_(cam.R[:, 0])]), cam.focal * s, W8 / 2, H8 / 2)) m = np.zeros((H8, W8), bool) # characters: capsules round their bones (radius by body size) for e in ents.values(): Jw = np.stack([e_(to_ue(q)) / 100.0 if np.isfinite(q).all() else np.full(3, np.nan) for q in e["joints"][t]]) par = [int(p) if (p is not None and p >= 0 and e["parts"][j] > 0 and e["parts"][int(p)] > 0) else None for j, p in enumerate(e["parent"])] m |= capsules(cams[-1], Jw, max(0.3, 0.16 * float(e["size_m"])), (H8, W8), par) CH.append(cv2.dilate(m.astype(np.uint8), np.ones((11, 11), np.uint8)) > 0) Z = np.stack(Z).astype(np.float64); return core(r["key"], "ww", V5, Z, np.stack(valid), np.stack(sky), np.stack(CH), cams, True, 5.0, rgb0, M) def do_bk(r, M): import prep_mem as PM v = r["video"]; clip = os.path.dirname(v); k = int(os.path.basename(v)[4:7]); b0 = k * 120 src = clip.replace("/blackknife_121/", "/blackknife_cond/"); meta = json.load(open(f"{src}/meta.json")); raw = meta["attempt"]; sh = np.load(f"{src}/shot.npz") off = int(round(float(meta.get("window", [0.0])[0]) * 30)) # the cond's frame 0 in the raw capture gb = torch.load(f"{OUT}/gbuf2/clip_{r['key']}.pt", weights_only=False); cams = gb_cams(gb) V5 = np.stack([r853(x) for x in ff(cond_of(v), 0, N)]); dp = ff(f"{raw}/depth_packed.mkv", off + b0, N); rgb0 = r853(ff(f"{raw}/rgb.mp4", off + b0, 1)[0]) e_ = lambda p: np.stack([p[..., 0], p[..., 2], -p[..., 1]], -1) / 100.0 Z, valid, CH = [], [], [] for i in range(N): z, ok = PM.depth_m(dp[i]); ok &= z < 2000; zz, gd = z853(z, ok); Z.append(zz); valid.append(gd) m = capsules(cams[i], e_(sh["player_poses"][b0 + i]), 0.30, (H8, W8)) | capsules(cams[i], e_(sh["boss_poses"][b0 + i]), 0.35, (H8, W8)) CH.append(m | (cv2.dilate((V5[i][..., 1] >= 20).astype(np.uint8), np.ones((7, 7), np.uint8)) > 0)) Z = np.stack(Z).astype(np.float64); valid = np.stack(valid); return core(r["key"], "bk", V5, Z, valid, ~valid, np.stack(CH), cams, True, 1.0, rgb0, M, shield=shield_of(r["key"])) def do_synth(r, M): key = r["key"]; gb = torch.load(f"{OUT}/gbuf2/clip_{key}.pt", weights_only=False); cams = gb_cams(gb) V5 = np.stack([r853(x) for x in ff(cond_of(r["video"]), 0, N)]); rgb = np.stack([r853(x) for x in ff(r["video"], 0, N)]) Z, geo, CH, dirs = [], [], [], [] v, u = np.mgrid[0:H8, 0:W8] + 0.5 for t in range(N): pos, R, f, cx, cy = cams[t]; d = ((u - cx) / f)[..., None] * R[0] - ((v - cy) / f)[..., None] * R[1] + R[2] tt = np.where(d[..., 1] < -1e-6, -pos[1] / np.minimum(d[..., 1], -1e-6), 0.0); gnd = (tt > 0) & (tt < 60.0) c5 = V5[t]; env5 = ((c5[..., 0] > 8) | (c5[..., 2] > 8)) & (c5[..., 1] < 20); z5 = 0.1 + (1 - c5[..., 2] / 255.0) * 79.9 prop = env5 & ~(gnd & (np.abs(tt - z5) < 0.05 * tt + 0.3)); Z.append(np.where(prop, z5, np.where(gnd, tt, 0))); geo.append(gnd | env5) CH.append(cv2.dilate((c5[..., 1] >= 20).astype(np.uint8), np.ones((15, 15), np.uint8)) > 0); dirs.append(d / np.linalg.norm(d, axis=-1, keepdims=True)) # sky by DIRECTION (the HDRI is at infinity): MoGe-2 on frames 0 / 60 / 120 votes into a yaw-pitch grid G_ = np.zeros((360, 720, 2), np.int32) for k in (0, 60, 120): skym = char_fill(~M.mg(rgb[k])[1], cv2.dilate(CH[k].astype(np.uint8), np.ones((29, 29), np.uint8)).astype(bool)) & ~geo[k]; dd = dirs[k]; yaw = ((np.degrees(np.arctan2(dd[..., 0], dd[..., 2])) + 180) * 2).astype(int) % 720; pit = np.clip(((np.degrees(np.arcsin(np.clip(dd[..., 1], -1, 1))) + 90) * 2).astype(int), 0, 359) np.add.at(G_, (pit.ravel(), yaw.ravel(), skym.ravel().astype(int)), 1) sky = [] for t in range(N): dd = dirs[t]; yaw = ((np.degrees(np.arctan2(dd[..., 0], dd[..., 2])) + 180) * 2).astype(int) % 720; pit = np.clip(((np.degrees(np.arcsin(np.clip(dd[..., 1], -1, 1))) + 90) * 2).astype(int), 0, 359) c = G_[pit, yaw]; sky.append((c[..., 1] > c[..., 0]) & ~geo[t]) Z = np.stack(Z).astype(np.float64); geo = np.stack(geo); sky = np.stack(sky) tier0 = np.where(geo, 3, np.where(sky, 0, 1)).astype(np.uint8) return core(key, r["group"], V5, Z, geo, sky, np.stack(CH), cams, True, 1.0, rgb[0], M, tier0=tier0) # ------------------------------------------------------------------ roam (memroam windows; whole segments read once) def roam_rows(): """memroam training windows (Leyndell held out); user 10-17: Siofra 1/2, snowfield 1/4, every clip (outfit) keeps >= 1 window""" idx = json.load(open(f"{DS}/wan_memroam/index.json")); by = {} ev = set(json.load(open(f"{OUT}/leyndell_eval.json"))["eval_segments"]) # (user 10-17) Leyndell trains too, only the 4 eval windows' segments stay out for name, v in idx.items(): if v["test"] and v["seg"] in ev: continue by.setdefault(v["seg"], []).append((int(v["f0"]), name[5:-3], v["session"])) out = [] for seg, ws in by.items(): ws.sort(); keep = 2 if "siofra" in ws[0][2] else 4 if "snowfield" in ws[0][2] else 1 out += [dict(seg=seg, f0=f0, key=k, session=s) for i, (f0, k, s) in enumerate(ws) if i % keep == 0] return out def skel_layer(key, M): """memroam stored the skeleton-only layer (prep_mem.Skel, the live engine's actor layer) as a VAE latent: decode it, keep the bone pixels""" z = torch.load(f"{DS}/wan_memroam/clips/clip_{key}.pt", map_location="cpu", weights_only=False)["skel"].float().cuda() with torch.no_grad(): x = M.vae.decode([z])[0] v = ((x.clamp(-1, 1) + 1) * 127.5).round().byte().permute(1, 2, 3, 0).cpu().numpy()[:N] m = v[..., 1] >= 24; return np.where(m[..., None], v, 0).astype(np.uint8) def _weapon_track(rows, M, ground): """(10-18) the roaming player's sword: samples' weapons[0] (start, end), world = local + the row's offset; into the Skel frame (cm, z up, grounded)""" W_ = [] for r in rows: if r["Wp"]: off = np.asarray(r["J"][0], float) - np.asarray(r["Jl"][0], float) W_.append(np.stack([(np.asarray(p, float) - off) @ M.T * 100.0 for p in r["Wp"][0]])) else: W_.append(None) ok = [i for i, w in enumerate(W_) if w is not None] out = np.stack([W_[min(ok, key=lambda j: abs(j - i))] for i in range(len(W_))]); out[..., 2] -= ground; return out _SKW = None def skel_weapon(rows): """(10-18) the player's skeleton layer WITH the sword, drawn by prep_mem.Skel.video itself (same renderer, same codes) with tr.weapon set (memroam's stored layer has tr.weapon = None, so the roaming windows had no sword condition while every boss-fight source draws it)""" global _SKW import prep_mem as PM, inspect, textwrap if _SKW is None: src = textwrap.dedent(inspect.getsource(PM.Skel.video)); assert src.count("tr.weapon = None") == 1 ns = dict(PM.__dict__); ns["_weapon_track"] = _weapon_track; exec(src.replace("tr.weapon = None", "tr.weapon = _weapon_track(rows, M, ground)"), ns) cls = type("SkelW", (PM.Skel,), {"video": ns["video"]}); _SKW = cls(int(os.environ.get("EGL", "0"))) with egl_lock(): return _SKW.video(rows) def do_roam_seg(seg, wins, M, sk): """every window of one recording segment: rgb + packed depth decoded once""" import prep_mem as PM rows = PM.load_states(seg); last = max(w["f0"] for w in wins) + N; need = set(f for w in wins for f in range(w["f0"], w["f0"] + N)) S = [json.loads(l) for l in gzip.open(seg + "/samples.jsonl.gz", "rt")]; FA = [json.loads(l) for l in gzip.open(seg + "/frame_association.jsonl.gz", "rt")] def equip(f): r = FA[f]; s = S[r["raw_sample_index"]] if r["raw_sample_index"] < len(S) else None; return (s or {}).get("equipment") or {} RGB, DP = {}, {} for f, (fr, fd) in enumerate(zip(PM.frames(seg, 0), PM.frames(seg, 1))): if f >= last: break if f in need: RGB[f] = r853(fr); DP[f] = fd.copy() res = [] for w in wins: f0 = w["f0"]; R_ = [rows[f0 + i] for i in range(N)] if any(r is None for r in R_) or (f0 + N - 1) not in DP: continue cams, Z, valid, CH = [], [], [], [] for i, r in enumerate(R_): fx, fy, cx, cy = r["K"]; s = 480 / 540; cams.append((np.asarray(r["pos"], float), np.asarray(r["R"], float), fx * s, cx * s, cy * s)) z, ok = PM.depth_m(DP[f0 + i]); ok &= z < 2000; zz, gd = z853(z, ok); Z.append(zz); valid.append(gd) CH.append(capsules(cams[-1], np.asarray(r["J"], float), 0.35, (H8, W8))) Z = np.stack(Z); valid = np.stack(valid); CH = np.stack(CH) feet = float(np.asarray(R_[0]["J"])[:, 1].min()); ab = (1 / 112.0, 0.5 + (8 - feet) / 112.0) # R = 0.5 + 0.5 clamp((h - feet + 8) / 56) skl = skel_weapon(R_) if os.environ.get("V7_SWORD") and any(r["Wp"] for r in R_) else skel_layer(w["key"], M) # (10-18) sword off: the samples' weapon direction is unreliable (curved / reverse-grip blades point the wrong way) # the player's skeleton layer prep_mem.Skel drew for this window (no EGL here) V5 = np.zeros((N, H8, W8, 3), np.uint8) for t in range(N): Rr, Bb = rb_from(Z[t], cams[t], ab); V5[t][..., 0] = np.where(valid[t], np.round(Rr * 255), 0); V5[t][..., 2] = np.where(valid[t], np.round(Bb * 255), 0) a = skl[t][..., 1] > 0; V5[t][:, X0:X0 + 832][a] = skl[t][a] sh = None # the round shield (left_param_id 30000000..33000000): a disc 6 cm past the left hand, r 0.30 m if 30000000 <= int(equip(f0).get("left_param_id") or 0) < 33000000: sh = [] for t, r in enumerate(R_): J = np.asarray(r["J"], float); pos, Rm, f, cx, cy = cams[t]; p = J[7] + 0.06 * (J[7] - J[6]) / max(np.linalg.norm(J[7] - J[6]), 1e-6) - pos x, y, z = p @ Rm[0], p @ Rm[1], p @ Rm[2] sh.append((cx + f * x / z - X0, cy - f * y / z, f * 0.30 / z) if z > 0.2 else (np.nan,) * 3) sh = np.array(sh) res.append((w, core(w["key"], "roam", V5, Z, valid, ~valid, CH, cams, True, 1.0, RGB[f0], M, shield=sh, ab=ab))) return res MARK = os.environ.get("V7_MARK", "redo_"); C7 = os.environ.get("V7_SUB", "cond7") # (10-19) MEMUNK=1 V7_SUB=cond7_memunk writes the variant beside the normal ones KEYS = set(json.load(open(os.environ["V7_KEYS"]))) if os.environ.get("V7_KEYS") else None # (10-18) re-render these windows (overwrite); a redo_ marker = done def main(): ap = argparse.ArgumentParser(); ap.add_argument("src"); ap.add_argument("--rank", type=int, default=0); ap.add_argument("--world", type=int, default=1) ap.add_argument("--limit", type=int, default=0); ap.add_argument("--preview", action="store_true"); a = ap.parse_args() os.makedirs(f"{OUT}/cond7", exist_ok=True); os.makedirs(f"{OUT}/{C7}", exist_ok=True); os.makedirs(f"{OUT}/preview", exist_ok=True); torch.set_num_threads(4); cv2.setNumThreads(4) if a.src == "roam": import prep_mem as PM W_ = roam_rows(); segs = {} if KEYS is not None: W_ = [w for w in W_ if w["key"] in KEYS] for w in W_: segs.setdefault(w["seg"], []).append(w) mine = sorted(segs)[a.rank::a.world]; M = Models(); sk = None; n = 0; t_ = time.time() # skeleton layer from memroam's latent print(f"rank {a.rank} roam: {len(W_)} windows in {len(segs)} segments, mine {len(mine)}", flush=True) for seg in mine: todo = [w for w in segs[seg] if KEYS is not None and not os.path.exists(f"{OUT}/{C7}/{MARK}{w['key']}") or not os.path.exists(f"{OUT}/{C7}/clip_{w['key']}.pt")] if not todo: continue try: res = do_roam_seg(seg, todo, M, sk) except Exception as ex: import traceback; print("FAIL", seg, repr(ex)[:200], traceback.format_exc().splitlines()[-3:], flush=True); continue for w, (v7, dep, tc, meta) in res: dst = f"{OUT}/{C7}/clip_{w['key']}.pt"; meta["session"] = w["session"] torch.save(dict(cond=M.encode(v7), dep=torch.from_numpy(dep), tier=torch.from_numpy(tc), meta=meta), dst + ".tmp"); os.replace(dst + ".tmp", dst); n += 1 if KEYS is not None: open(f"{OUT}/{C7}/{MARK}{w['key']}", "w").close() if a.preview and n <= 3: cv2.imwrite(f"{OUT}/preview/roam_{w['key']}.jpg", cv2.cvtColor(np.concatenate([v7[i].cpu().numpy() for i in (0, 60, 120)], 1), cv2.COLOR_RGB2BGR)) if a.limit and n >= a.limit: break print(f"rank {a.rank} roam: {n} done, {(time.time() - t_) / max(n, 1):.1f} s/window", flush=True) if a.limit and n >= a.limit: break print(f"rank {a.rank} roam BUILD_V7_DONE {n}", flush=True); return rows = rows_of(a.src) if KEYS is not None: rows = [r for r in rows if r["key"] in KEYS] if a.src == "ww": rows = sorted(rows, key=lambda r: r["video"]) # windows of one sample together (state cache) rows = rows[a.rank::a.world]; M = Models(); cache = {}; n = 0; t_ = time.time() if os.environ.get("REVERSE"): rows = rows[::-1] # a second host works from the other end for r in rows: dst = f"{OUT}/{C7}/clip_{r['key']}.pt" if os.path.exists(dst) and (KEYS is None or os.path.exists(f"{OUT}/{C7}/{MARK}{r['key']}")): continue try: if a.src in ("er", "ue"): v7, dep, tc, meta = do_coarse(r, M) elif a.src == "ww": v7, dep, tc, meta = do_ww(r, M, cache) elif a.src == "bk": v7, dep, tc, meta = do_bk(r, M) elif a.src == "synth": v7, dep, tc, meta = do_synth(r, M) except Exception as ex: import traceback; print("FAIL", r["video"], repr(ex)[:200], traceback.format_exc().splitlines()[-3:], flush=True); continue lat = M.encode(v7); torch.save(dict(cond=lat, dep=torch.from_numpy(dep), tier=torch.from_numpy(tc), meta=meta), dst + ".tmp"); os.replace(dst + ".tmp", dst); n += 1 if KEYS is not None: open(f"{OUT}/{C7}/{MARK}{r['key']}", "w").close() if a.preview and n <= 3: img = np.concatenate([v7[i].cpu().numpy() for i in (0, 60, 120)], 1); cv2.imwrite(f"{OUT}/preview/{a.src}_{r['key']}_{'m' if meta['moge'] else ''}{'h' if meta['holes'] else ''}{'p' if meta['patch'] else ''}.jpg", cv2.cvtColor(img, cv2.COLOR_RGB2BGR)) if n % 20 == 0: print(f"rank {a.rank} {a.src}: {n} done, {(time.time() - t_) / n:.1f} s/window", flush=True) if a.limit and n >= a.limit: break print(f"rank {a.rank} {a.src} BUILD_V7_DONE {n}", flush=True) if __name__ == "__main__": main()