ww_index: window list, captions, lags and scripts to rebuild the WildWorld windows from upstream
a54e6a7 verified Download ww_index/scripts/proxykit36/proxykit/render.py from yuzhewu207/wizard-precoded: direct link, hf CLI and curl.
- Browser
- Download file 10.9 kB
-
https://huggingface.co/datasets/yuzhewu207/wizard-precoded/resolve/main/ww_index/scripts/proxykit36/proxykit/render.py
- Command line
-
hf download hf://datasets/yuzhewu207/wizard-precoded/ww_index/scripts/proxykit36/proxykit/render.py
-
curl -L -o render.py https://huggingface.co/datasets/yuzhewu207/wizard-precoded/resolve/main/ww_index/scripts/proxykit36/proxykit/render.py
10.9 kB
| """Condition renderer for arbitrary skeleton topologies, encoding identical to BOSSV2V capture_720p30_v1. | |
| The fragment shader is the dataset's analytic ray caster (entity_geometry_gpu.py) with larger uniform arrays | |
| (256 capsules, 128 boxes) so non-humanoid monsters fit. Per pixel, nearest surface among: sea plane (id 5), finite | |
| platform disc (id 1), yaw-rotated boxes (ids 2-4), capsules/spheres (id = slot * 32 + part_id). | |
| R = environment: 0.5 + 0.5 * h ; actors: 0.2 * h h = clamp((world_z_m - hmin) / (hmax - hmin)) | |
| G = actor id / 255 (environment 0) | |
| B = 1 - clamp((camera_forward_depth_m - near) / (far - near)) | |
| Output rgb16 (H, W, 3) uint16, bottom-up flipped to image order. | |
| """ | |
| import math, shutil, subprocess | |
| import numpy as np | |
| import moderngl | |
| MAX_CAPSULES, MAX_BOXES = 256, 128 | |
| HEIGHT_RANGE_M, DEPTH_RANGE_M = (-8.0, 32.0), (0.1, 80.0) | |
| VERTEX = '''#version 330 | |
| void main(){vec2 p=vec2((gl_VertexID<<1)&2,gl_VertexID&2);gl_Position=vec4(p*2.-1.,0.,1.);}''' | |
| FRAGMENT = '''#version 330 | |
| uniform vec2 resolution;uniform vec3 origin,forward,right,up;uniform float hfov; | |
| uniform vec2 heightRange,depthRange; | |
| uniform int sceneCount;uniform vec4 boxCenter[%(B)d],boxSize[%(B)d];uniform vec3 platform; | |
| uniform int count;uniform vec4 aa[%(C)d],bb[%(C)d];layout(location=0) out uvec4 outData; | |
| float sphere(vec3 rd,vec3 center,float r){vec3 q=-center;float b=dot(q,rd),c=dot(q,q)-r*r,h=b*b-c;if(h<0.)return 1e20;float t=-b-sqrt(h);if(t<=1.)t=-b+sqrt(h);return t>1.?t:1e20;} | |
| float capsule(vec3 rd,vec3 a,vec3 b,float radius){ | |
| vec3 ba=b-a,oa=-a;float baba=dot(ba,ba),result=min(sphere(rd,a,radius),sphere(rd,b,radius)); | |
| if(baba<1e-8)return result; | |
| float bard=dot(ba,rd),baoa=dot(ba,oa),rdoa=dot(rd,oa); | |
| float A=baba-bard*bard,B=baba*rdoa-baoa*bard,C=baba*dot(oa,oa)-baoa*baoa-radius*radius*baba; | |
| float h=B*B-A*C;if(h>=0.&&abs(A)>1e-8){float root=sqrt(h); | |
| float t=(-B-root)/A,y=baoa+t*bard;if(t>1.&&y>=0.&&y<=baba)result=min(result,t); | |
| t=(-B+root)/A;y=baoa+t*bard;if(t>1.&&y>=0.&&y<=baba)result=min(result,t);} | |
| return result; | |
| } | |
| float boxHit(vec3 rd,vec4 center,vec3 halfSize){ | |
| vec3 q=origin-center.xyz;float c=cos(center.w),s=sin(center.w); | |
| vec3 ro=vec3(c*q.x+s*q.y,-s*q.x+c*q.y,q.z);rd=vec3(c*rd.x+s*rd.y,-s*rd.x+c*rd.y,rd.z); | |
| float nearT=-1e20,farT=1e20; | |
| for(int k=0;k<3;k++){if(abs(rd[k])<1e-8){if(abs(ro[k])>halfSize[k])return 1e20;} | |
| else{float a=(-halfSize[k]-ro[k])/rd[k],b=(halfSize[k]-ro[k])/rd[k];nearT=max(nearT,min(a,b));farT=min(farT,max(a,b));}} | |
| if(farT<nearT)return 1e20;float t=nearT>1.?nearT:farT;return t>1.?t:1e20; | |
| } | |
| void main(){ | |
| vec2 xy=(gl_FragCoord.xy-resolution*.5)/(resolution.x*.5/tan(hfov*.5)); | |
| vec3 localRay=normalize(vec3(1.,xy.x,xy.y));vec3 ray=forward*localRay.x+right*localRay.y+up*localRay.z; | |
| float t=1e20;uint id=0u; | |
| if(abs(ray.z)>1e-7){float d=(platform.z-origin.z)/ray.z;if(d>1.&&d<100000.){t=d;id=5u;} | |
| d=(platform.y-origin.z)/ray.z;vec2 p=origin.xy+ray.xy*d;if(d>1.&&d<t&&d<100000.&&dot(p,p)<=platform.x*platform.x){t=d;id=1u;}} | |
| for(int i=0;i<%(B)d;i++){if(i>=sceneCount)break;float d=boxHit(ray,boxCenter[i],boxSize[i].xyz);if(d<t){t=d;id=uint(boxSize[i].w);}} | |
| for(int i=0;i<%(C)d;i++){if(i>=count)break;float d=capsule(localRay,aa[i].xyz,bb[i].xyz,aa[i].w);if(d<t){t=d;id=uint(bb[i].w);}} | |
| if(id==0u){outData=uvec4(0);return;} | |
| bool environment=id<=5u;float height=(origin.z+t*ray.z)*.01,depth=t*localRay.x*.01; | |
| float h=clamp((height-heightRange.x)/(heightRange.y-heightRange.x),0.,1.); | |
| float red=environment?.5+.5*h:.2*h; | |
| float blue=1.-clamp((depth-depthRange.x)/(depthRange.y-depthRange.x),0.,1.); | |
| uint flags=8u;if(height<heightRange.x||height>heightRange.y)flags|=1u; | |
| if(depth<depthRange.x||depth>depthRange.y)flags|=environment?4u:2u; | |
| outData=uvec4(uint(round(red*65535.)),environment?0u:id*257u,uint(round(blue*65535.)),flags); | |
| }''' % {"B": MAX_BOXES, "C": MAX_CAPSULES} | |
| class Renderer: | |
| """scene: dict(platform=dict(radius_cm, z_cm), sea_z_cm, boxes=[dict(center_cm, size_cm, yaw_degrees, label)]).""" | |
| def __init__(self, scene, width=1280, height=720, device_index=None): | |
| kw = dict(backend="egl", require=330) | |
| if device_index is not None: | |
| kw["device_index"] = int(device_index) | |
| self.ctx = moderngl.create_standalone_context(**kw) | |
| self.w, self.h = width, height | |
| self.program = self.ctx.program(vertex_shader=VERTEX, fragment_shader=FRAGMENT) | |
| self.vao = self.ctx.vertex_array(self.program, []) | |
| self.texture = self.ctx.texture((width, height), 4, dtype="u2") | |
| self.fbo = self.ctx.framebuffer(color_attachments=[self.texture]) | |
| self.program["resolution"].value = (width, height) | |
| self.program["heightRange"].value = HEIGHT_RANGE_M | |
| self.program["depthRange"].value = DEPTH_RANGE_M | |
| self.set_scene(scene) | |
| def set_scene(self, scene): | |
| boxes = scene.get("boxes", []) | |
| assert len(boxes) <= MAX_BOXES, f"{len(boxes)} boxes > {MAX_BOXES}" | |
| self.program["platform"].value = (scene["platform"]["radius_cm"], scene["platform"]["z_cm"], scene["sea_z_cm"]) | |
| centers = np.zeros((MAX_BOXES, 4), np.float32); sizes = np.zeros_like(centers) | |
| for i, b in enumerate(boxes): | |
| assert b["label"] in (2, 3, 4) | |
| centers[i] = [*b["center_cm"], math.radians(b["yaw_degrees"])] | |
| sizes[i] = [*[v * 0.5 for v in b["size_cm"]], b["label"]] | |
| self.program["boxCenter"].write(centers.tobytes()); self.program["boxSize"].write(sizes.tobytes()) | |
| self.program["sceneCount"].value = len(boxes) | |
| def render(self, camera, capsules): | |
| """camera: geometry.Camera; capsules: iterable of (a_cm, b_cm, radius_cm, label). Returns rgb16 and clip stats.""" | |
| rot = camera.R; origin = np.asarray(camera.position, float) | |
| for i, key in enumerate(["forward", "right", "up"]): | |
| self.program[key].value = tuple(rot[:, i]) | |
| self.program["origin"].value = tuple(origin) | |
| self.program["hfov"].value = math.radians(camera.fov) | |
| aa = np.zeros((MAX_CAPSULES, 4), np.float32); bb = np.zeros_like(aa); n = 0 | |
| for a, b, radius, label in capsules: | |
| assert n < MAX_CAPSULES, "too many capsules" | |
| assert 0 < int(label) < 256 and int(label) > 5, f"actor label {label} collides with environment ids" | |
| aa[n] = [*((np.asarray(a, float) - origin) @ rot), radius] | |
| bb[n] = [*((np.asarray(b, float) - origin) @ rot), label] | |
| n += 1 | |
| self.program["aa"].write(aa.tobytes()); self.program["bb"].write(bb.tobytes()); self.program["count"].value = n | |
| self.fbo.use(); self.ctx.viewport = (0, 0, self.w, self.h); self.vao.render(vertices=3) | |
| rgba = np.frombuffer(self.fbo.read(components=4, dtype="u2", alignment=1), dtype="<u2").reshape(self.h, self.w, 4)[::-1] | |
| return np.ascontiguousarray(rgba[:, :, :3]), { | |
| "height_clipped": int(np.count_nonzero(rgba[:, :, 3] & 1)), | |
| "actor_depth_clipped": int(np.count_nonzero(rgba[:, :, 3] & 2))} | |
| def close(self): | |
| self.vao.release(); self.fbo.release(); self.texture.release(); self.program.release(); self.ctx.release() | |
| class VideoWriter: | |
| """rgb16 frames -> 10-bit 4:4:4 full-range BT.709 CRF12 MP4 (dataset settings); optional 1024x576 training scale.""" | |
| def __init__(self, path, width=1280, height=720, fps=30, scale_to=None): | |
| vf = "scale=in_range=full:out_range=full:out_color_matrix=bt709" | |
| if scale_to: | |
| vf = f"scale={scale_to[0]}:{scale_to[1]}:flags=area:in_range=full:out_range=full:out_color_matrix=bt709" | |
| cmd = [shutil.which("ffmpeg"), "-threads", "2", "-filter_threads", "1", "-v", "error", "-y", "-f", "rawvideo", "-pix_fmt", "rgb48le", "-s", f"{width}x{height}", | |
| "-r", str(fps), "-i", "-", "-an", "-vf", vf, "-threads", "2", "-c:v", "libx264", "-crf", "12", "-preset", "fast", | |
| "-pix_fmt", "yuv444p10le", "-profile:v", "high444", "-color_range", "pc", "-colorspace", "bt709", | |
| "-color_primaries", "bt709", "-color_trc", "bt709", "-movflags", "+faststart", str(path)] | |
| self.proc = subprocess.Popen(cmd, stdin=subprocess.PIPE) | |
| def write(self, rgb16): | |
| self.proc.stdin.write(np.ascontiguousarray(rgb16, dtype="<u2").tobytes()) | |
| def close(self): | |
| self.proc.stdin.close() | |
| assert self.proc.wait(timeout=300) == 0, "ffmpeg failed" | |
| def preview_rgb8(rgb16): | |
| return (rgb16 // 257).astype(np.uint8) | |
| _SLOT_HUES = {1: (60, 200, 255), 2: (255, 120, 40), 3: (120, 255, 120), 4: (230, 90, 255), 5: (255, 230, 80), 6: (255, 90, 150), 7: (180, 180, 255)} | |
| def _actor_lut(): | |
| """G value (slot*32 + part) -> RGB8 for the human-readable view: hue by slot, shade by part (head bright, left | |
| limbs light, right limbs dark, tail/wings mid), weapon bright yellow.""" | |
| lut = np.zeros((256, 3), np.float32) | |
| for g in range(33, 256): | |
| slot, part = divmod(g, 32) | |
| if slot not in _SLOT_HUES or part == 0: | |
| continue | |
| base = np.array(_SLOT_HUES[slot], np.float32) | |
| if part == 18: | |
| lut[g] = (255, 255, 90) | |
| continue | |
| if part == 5: | |
| k = 1.25 | |
| elif part in (6, 7, 8, 12, 13, 14, 23, 24, 25, 29): | |
| k = 1.1 | |
| elif part in (9, 10, 11, 15, 16, 17, 26, 27, 28, 30): | |
| k = 0.7 | |
| else: | |
| k = 0.9 | |
| lut[g] = np.clip(base * k + (40 if part == 5 else 0), 0, 255) | |
| return lut.astype(np.uint8) | |
| ACTOR_LUT = _actor_lut() | |
| def readable_rgb8(rgb16): | |
| """Human-readable frame from an exact (pre-encoding) condition frame: environment in grey shaded by nearness, | |
| sky dark blue, actors coloured by identity slot and body part.""" | |
| g = (rgb16[..., 1] // 257).astype(np.int32) | |
| r = rgb16[..., 0].astype(np.float32) / 65535 | |
| b = rgb16[..., 2].astype(np.float32) / 65535 | |
| out = np.empty(rgb16.shape, np.uint8) | |
| out[:] = (18, 22, 38) | |
| env = (g == 0) & (r > 0) | |
| shade = np.clip(60 + 150 * b + 60 * (r - 0.5), 0, 255) | |
| out[env] = shade[env][:, None].astype(np.uint8) | |
| actor = g > 0 | |
| out[actor] = ACTOR_LUT[g[actor]] | |
| return out | |
| class ReadableWriter: | |
| """RGB8 frames -> H.264 yuv420p CRF18 MP4 for viewing.""" | |
| def __init__(self, path, width=1280, height=720, fps=30): | |
| cmd = [shutil.which("ffmpeg"), "-threads", "2", "-filter_threads", "1", "-v", "error", "-y", "-f", "rawvideo", "-pix_fmt", "rgb24", "-s", f"{width}x{height}", | |
| "-r", str(fps), "-i", "-", "-an", "-threads", "2", "-c:v", "libx264", "-crf", "18", "-preset", "fast", "-pix_fmt", "yuv420p", | |
| "-movflags", "+faststart", str(path)] | |
| self.proc = subprocess.Popen(cmd, stdin=subprocess.PIPE) | |
| def write(self, rgb8): | |
| self.proc.stdin.write(np.ascontiguousarray(rgb8, dtype=np.uint8).tobytes()) | |
| def close(self): | |
| self.proc.stdin.close() | |
| assert self.proc.wait(timeout=300) == 0, "ffmpeg failed" | |