reze-engine 0.10.1 → 0.11.0

package/src/folder-upload.ts

@@ -0,0 +1,59 @@
+import { normalizeAssetPath } from "./asset-reader"
+
+/**
+ * Call on `<input type="file" webkitdirectory>` `change` **before** `input.value = ""`.
+ * `FileList` is live — clearing the input empties it; this copies to a stable `File[]`.
+ */
+function prepareLocalFolderFiles(fileList: FileList | null | undefined): {
+  files: File[]
+  pmxRelativePaths: string[]
+} {
+  const files = fileList?.length ? Array.from(fileList) : []
+  const pmxRelativePaths: string[] = []
+  for (const f of files) {
+    const wr = (f as File & { webkitRelativePath?: string }).webkitRelativePath
+    if (!wr || !wr.toLowerCase().endsWith(".pmx")) continue
+    pmxRelativePaths.push(normalizeAssetPath(wr))
+  }
+  pmxRelativePaths.sort((a, b) => a.localeCompare(b))
+  return { files, pmxRelativePaths }
+}
+
+function isDirectoryUpload(files: File[]): boolean {
+  return files.length > 0 && files.every((f) => !!(f as File & { webkitRelativePath?: string }).webkitRelativePath)
+}
+
+/** After choosing a path from `multiple`, get the `File` for `loadModel(..., { files, pmxFile })`. */
+export function pmxFileAtRelativePath(files: File[], relativePath: string): File | undefined {
+  const norm = normalizeAssetPath(relativePath)
+  for (const f of files) {
+    const wr = (f as File & { webkitRelativePath?: string }).webkitRelativePath
+    if (wr && normalizeAssetPath(wr) === norm) return f
+  }
+  return undefined
+}
+
+/** Result of reading a folder input — switch on `status` in your UI. */
+export type PmxFolderInputResult =
+  | { status: "empty" }
+  | { status: "not_directory" }
+  | { status: "no_pmx" }
+  | { status: "single"; files: File[]; pmxFile: File }
+  | { status: "multiple"; files: File[]; pmxRelativePaths: string[] }
+
+/**
+ * One call from `onChange`: snapshots files, validates folder pick, resolves a single PMX or asks you to pick among several.
+ * Reset the input after: `e.target.value = ""`.
+ */
+export function parsePmxFolderInput(fileList: FileList | null | undefined): PmxFolderInputResult {
+  const { files, pmxRelativePaths } = prepareLocalFolderFiles(fileList)
+  if (files.length === 0) return { status: "empty" }
+  if (!isDirectoryUpload(files)) return { status: "not_directory" }
+  if (pmxRelativePaths.length === 0) return { status: "no_pmx" }
+  if (pmxRelativePaths.length === 1) {
+    const pmxFile = pmxFileAtRelativePath(files, pmxRelativePaths[0]!)
+    if (!pmxFile) return { status: "no_pmx" }
+    return { status: "single", files, pmxFile }
+  }
+  return { status: "multiple", files, pmxRelativePaths }
+}

package/src/index.ts

@@ -1,4 +1,14 @@
-export { Engine, type EngineStats } from "./engine"
+export {
+  Engine,
+  DEFAULT_BLOOM_OPTIONS,
+  DEFAULT_VIEW_TRANSFORM,
+  type EngineStats,
+  type EngineOptions,
+  type BloomOptions,
+  type ViewTransformOptions,
+  type LoadModelFromFilesOptions,
+} from "./engine"
+export { parsePmxFolderInput, pmxFileAtRelativePath, type PmxFolderInputResult } from "./folder-upload"
 export { Model } from "./model"
 export { Vec3, Quat, Mat4 } from "./math"
 export type {
@@ -12,4 +22,4 @@ export type {
 } from "./animation"
 export { FPS } from "./animation"
 export { Physics, type PhysicsOptions } from "./physics"
-export { VMDWriter } from "./vmd-writer"
+export type { MaterialPreset, MaterialPresetMap } from "./shaders/classify"

package/src/model.ts

@@ -1,5 +1,6 @@
 import { Mat4, Quat, Vec3 } from "./math"
 import { Engine } from "./engine"
+import { joinAssetPath, type AssetReader } from "./asset-reader"
 import { Rigidbody, Joint } from "./physics"
 import { IKSolverSystem } from "./ik-solver"
 import { VMDLoader, type VMDKeyFrame } from "./vmd-loader"
@@ -206,6 +207,14 @@ export class Model {
   private morphTrackIndices: Map<string, number> = new Map()
   private lastAppliedClip: AnimationClip | null = null
 
+  private assetReader: AssetReader | null = null
+  private assetBasePath = ""
+
+  /** Called by Engine when registering the model; enables loadVmd to resolve relative paths for folder uploads. */
+  setAssetContext(reader: AssetReader, basePath: string): void {
+    this.assetReader = reader
+    this.assetBasePath = basePath
+  }
 
   constructor(
     vertexData: Float32Array<ArrayBuffer>,
@@ -857,8 +866,31 @@ export class Model {
     return { boneTracks, morphTracks, frameCount: maxFrame }
   }
 
-  loadVmd(name: string, url: string): Promise<void> {
-    return VMDLoader.load(url).then((vmdKeyFrames) => {
+  loadVmd(name: string, urlOrRelative: string): Promise<void> {
+    const loadBuffer = (): Promise<ArrayBuffer> => {
+      const u = urlOrRelative.trim()
+      const useSiteFetch =
+        u.startsWith("http://") ||
+        u.startsWith("https://") ||
+        u.startsWith("/") ||
+        u.startsWith("blob:") ||
+        u.startsWith("data:")
+      if (useSiteFetch) {
+        return fetch(u).then((r) => {
+          if (!r.ok) throw new Error(`Failed to fetch VMD ${u}: ${r.status}`)
+          return r.arrayBuffer()
+        })
+      }
+      if (this.assetReader) {
+        return this.assetReader.readBinary(joinAssetPath(this.assetBasePath, u))
+      }
+      return fetch(u).then((r) => {
+        if (!r.ok) throw new Error(`Failed to fetch VMD ${u}: ${r.status}`)
+        return r.arrayBuffer()
+      })
+    }
+    return loadBuffer().then((buf) => {
+      const vmdKeyFrames = VMDLoader.loadFromBuffer(buf)
       const clip = this.buildClipFromVmdKeyFrames(vmdKeyFrames)
       this.animationState.loadAnimation(name, clip)
     })

package/src/pmx-loader.ts

@@ -13,6 +13,7 @@ import {
 } from "./model"
 import { Mat4, Vec3 } from "./math"
 import { Rigidbody, Joint, RigidbodyShape, RigidbodyType } from "./physics"
+import { createFetchAssetReader, type AssetReader } from "./asset-reader"
 
 export class PmxLoader {
   private view: DataView
@@ -42,8 +43,16 @@ export class PmxLoader {
   }
 
   static async load(url: string): Promise<Model> {
-    const loader = new PmxLoader(await fetch(url).then((r) => r.arrayBuffer()))
-    return loader.parse()
+    return PmxLoader.loadFromReader(createFetchAssetReader(), url)
+  }
+
+  static loadFromBuffer(buffer: ArrayBuffer): Model {
+    return new PmxLoader(buffer).parse()
+  }
+
+  static async loadFromReader(reader: AssetReader, pmxLogicalPath: string): Promise<Model> {
+    const buffer = await reader.readBinary(pmxLogicalPath)
+    return PmxLoader.loadFromBuffer(buffer)
   }
 
   private parse(): Model {

package/src/shaders/body.ts

@@ -0,0 +1,211 @@
+// M_Body — 仿深空之眼渲染预设v1.0_by_小绿毛猫_material_graph_dump.json "M_Body"; VALTORGB / math ops from m_graphs where dump omits them.
+
+import { NODES_WGSL } from "./nodes"
+
+export const BODY_SHADER_WGSL = /* wgsl */ `
+
+${NODES_WGSL}
+
+struct CameraUniforms {
+  view: mat4x4f,
+  projection: mat4x4f,
+  viewPos: vec3f,
+  _padding: f32,
+};
+
+struct Light {
+  direction: vec4f,
+  color: vec4f,
+};
+
+struct LightUniforms {
+  ambientColor: vec4f,
+  lights: array<Light, 4>,
+};
+
+struct MaterialUniforms {
+  diffuseColor: vec3f,
+  alpha: f32,
+};
+
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) normal: vec3f,
+  @location(1) uv: vec2f,
+  @location(2) worldPos: vec3f,
+};
+
+struct LightVP { viewProj: mat4x4f, };
+
+@group(0) @binding(0) var<uniform> camera: CameraUniforms;
+@group(0) @binding(1) var<uniform> light: LightUniforms;
+@group(0) @binding(2) var diffuseSampler: sampler;
+@group(0) @binding(3) var shadowMap: texture_depth_2d;
+@group(0) @binding(4) var shadowSampler: sampler_comparison;
+@group(0) @binding(5) var<uniform> lightVP: LightVP;
+@group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
+@group(2) @binding(0) var diffuseTexture: texture_2d<f32>;
+@group(2) @binding(1) var<uniform> material: MaterialUniforms;
+
+fn sampleShadow(worldPos: vec3f, n: vec3f) -> f32 {
+  let biasedPos = worldPos + n * 0.08;
+  let lclip = lightVP.viewProj * vec4f(biasedPos, 1.0);
+  let ndc = lclip.xyz / max(lclip.w, 1e-6);
+  let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
+  let cmpZ = ndc.z - 0.001;
+  let ts = 1.0 / 4096.0;
+  var vis = 0.0;
+  for (var y = -1; y <= 1; y++) {
+    for (var x = -1; x <= 1; x++) {
+      vis += textureSampleCompare(shadowMap, shadowSampler, suv + vec2f(f32(x), f32(y)) * ts, cmpZ);
+    }
+  }
+  return vis / 9.0;
+}
+
+const PI_B: f32 = 3.141592653589793;
+const F0_BODY: f32 = 0.04;
+const BODY_ROUGHNESS: f32 = 0.3;
+// Dump: 层权重.002 Blend; 运算.007 POWER exponent Value_001; 背景 Color; 运算.004 after invert
+const BODY_RIM2_LAYER_BLEND: f32 = 0.20000000298023224;
+const BODY_RIM2_POW: f32 = 1.4300000667572021;
+const BODY_RIM2_BG: vec3f = vec3f(1.0, 0.4303792119026184, 0.3315804898738861);
+const BODY_WARM_AO_MUL: f32 = 0.30000001192092896;
+const BODY_MIX_NPR: f32 = 0.5;
+
+fn ggx_d_body(ndoth: f32, a2: f32) -> f32 {
+  let denom = ndoth * ndoth * (a2 - 1.0) + 1.0;
+  return a2 / (PI_B * denom * denom);
+}
+
+fn smith_g1_body(ndotx: f32, a2: f32) -> f32 {
+  return 2.0 * ndotx / (ndotx + sqrt(a2 + (1.0 - a2) * ndotx * ndotx));
+}
+
+fn fresnel_schlick_body(cosTheta: f32, f0: f32) -> f32 {
+  return f0 + (1.0 - f0) * pow(1.0 - cosTheta, 5.0);
+}
+
+// smoothstep-based ramp: t*t*(3-2*t) between two color stops
+fn ramp_ease(f: f32, p0: f32, c0: vec4f, p1: f32, c1: vec4f) -> vec4f {
+  let t = saturate((f - p0) / max(p1 - p0, 1e-6));
+  let ss = t * t * (3.0 - 2.0 * t);
+  return mix(c0, c1, ss);
+}
+
+@vertex fn vs(
+  @location(0) position: vec3f,
+  @location(1) normal: vec3f,
+  @location(2) uv: vec2f,
+  @location(3) joints0: vec4<u32>,
+  @location(4) weights0: vec4<f32>
+) -> VertexOutput {
+  var output: VertexOutput;
+  let pos4 = vec4f(position, 1.0);
+  let weightSum = weights0.x + weights0.y + weights0.z + weights0.w;
+  let invWeightSum = select(1.0, 1.0 / weightSum, weightSum > 0.0001);
+  let nw = select(vec4f(1.0, 0.0, 0.0, 0.0), weights0 * invWeightSum, weightSum > 0.0001);
+  var skinnedPos = vec4f(0.0);
+  var skinnedNrm = vec3f(0.0);
+  for (var i = 0u; i < 4u; i++) {
+    let m = skinMats[joints0[i]];
+    let w = nw[i];
+    skinnedPos += (m * pos4) * w;
+    skinnedNrm += (mat3x3f(m[0].xyz, m[1].xyz, m[2].xyz) * normal) * w;
+  }
+  output.position = camera.projection * camera.view * vec4f(skinnedPos.xyz, 1.0);
+  output.normal = normalize(skinnedNrm);
+  output.uv = uv;
+  output.worldPos = skinnedPos.xyz;
+  return output;
+}
+
+@fragment fn fs(input: VertexOutput) -> @location(0) vec4f {
+  let alpha = material.alpha;
+  if (alpha < 0.001) { discard; }
+
+  let n = normalize(input.normal);
+  let v = normalize(camera.viewPos - input.worldPos);
+  let l = -light.lights[0].direction.xyz;
+  let sun = light.lights[0].color.xyz * light.lights[0].color.w;
+
+  let tex_color = textureSample(diffuseTexture, diffuseSampler, input.uv).rgb;
+  let shadow = sampleShadow(input.worldPos, n);
+
+  // ═══ TOON MASK: ShaderToRGB → ramp.008 CONSTANT [0→black, 0.2966→white] ═══
+  let ndotl_raw = shader_to_rgb_diffuse(n, l, sun, light.ambientColor.xyz, shadow);
+  let toon = ramp_constant(ndotl_raw, 0.0, vec4f(0,0,0,1), 0.2966, vec4f(1,1,1,1)).r;
+
+  // ═══ TOON COLOR: Mix.004 A=HueSat, B=HueSat.001, Fac=ramp.008 (R) ═══
+  let shadow_tint = hue_sat(0.5, 2.0, 0.3499999940395355, 1.0, tex_color);
+  let lit_tint = hue_sat(0.5, 1.5, 1.0, 1.0, tex_color);
+  let toon_color = mix_blend(toon, shadow_tint, lit_tint);
+  let bc = bright_contrast(toon_color, 0.1, 0.2);
+
+  // ═══ AO CHAIN: AO → ramp CONSTANT [0→white, 0.5995→black] → Mix.003 ═══
+  let ao = ao_fake(n, v);
+  let ao_ramp = ramp_constant(ao, 0.0, vec4f(1,1,1,1), 0.5995, vec4f(0,0,0,1)).r;
+  let ao_mixed = mix_blend(ao_ramp, bc, vec3f(0.8301780223846436, 0.3345769941806793, 0.27946099638938904));
+
+  // ═══ EMISSION.003 (strength=4.0) ═══
+  let emission3 = ao_mixed * 4.0;
+
+  // ═══ WARM: 颜色渐变.008 → 运算.006 ADD +0.5 (m_graphs) → clamp → 颜色渐变.003 ═══
+  let ao_inv = invert_f(1.0, ao_ramp);
+  let warm_str = ao_inv * BODY_WARM_AO_MUL;
+  let warm_input = clamp(toon + 0.5, 0.0, 1.0);
+  let warm_color = ramp_cardinal(warm_input, 0.2409,
+    vec4f(0.2426, 0.068, 0.0588, 1.0), 0.4663,
+    vec4f(0.6677, 0.5024, 0.5126, 1.0)).rgb;
+  let warm_emission = warm_color * warm_str;
+
+  // ═══ RIM 1: 菲涅尔 × 层权重.001 Facing Blend=0.24 → 自发光 Strength ═══
+  let rim1_str = fresnel(2.0, n, v) * layer_weight_facing(0.24000005424022675, n, v);
+  let rim1 = vec3f(0.984157919883728, 0.6110184788703918, 0.5736401677131653) * rim1_str;
+
+  // ═══ RIM 2: 层权重.002 Facing → 运算.007 POWER → 颜色渐变.010 EASE → MixShader.002 Fac ═══
+  let facing_raw = layer_weight_facing(BODY_RIM2_LAYER_BLEND, n, v);
+  let facing_pow = math_power(facing_raw, BODY_RIM2_POW);
+  let rim2_fac = ramp_ease(facing_pow, 0.0, vec4f(0,0,0,1), 0.5052, vec4f(1,1,1,1)).r;
+  let rim2_mixed = mix(emission3, BODY_RIM2_BG, rim2_fac);
+
+  // ═══ NPR STACK: AddShader chain (no bright gate in body) ═══
+  let add0 = rim1 + rim2_mixed;
+  let npr_stack = add0 + warm_emission;
+
+  // ═══ PRINCIPLED BSDF: noise bump, GGX specular, SSS from AO ═══
+  let gen = mapping_point(input.worldPos, vec3f(0.0), vec3f(0.0), vec3f(1.0, 1.0, 1.5));
+  let noise_val = tex_noise(gen, 1.0, 2.0, 0.5, 0.0);
+  let noise_ramp = ramp_linear(noise_val, 0.0, vec4f(0,0,0,1), 1.0, vec4f(1,1,1,1)).r;
+  let bumped_n = bump_lh(0.324644535779953, noise_ramp, n, input.worldPos);
+
+  let principled_base = mix_blend(noise_ramp, bc, vec3f(0.6831911206245422, 0.19474034011363983, 0.13732507824897766));
+  let p_emission = bc * 0.2;
+
+  let ao2 = ao_fake(n, v);
+  let sss = ramp_linear(ao2, 0.003, vec4f(0,0,0,1), 1.0, vec4f(0.0786, 0.0786, 0.0786, 1.0)).r;
+
+  let p_ndotl = max(dot(bumped_n, l), 0.0);
+  let p_ndotv = max(dot(bumped_n, v), 0.001);
+  let h = normalize(l + v);
+  let p_ndoth = max(dot(bumped_n, h), 0.0);
+  let p_vdoth = max(dot(v, h), 0.0);
+  let a2 = BODY_ROUGHNESS * BODY_ROUGHNESS;
+  let D = ggx_d_body(p_ndoth, a2);
+  let G = smith_g1_body(p_ndotl, a2) * smith_g1_body(p_ndotv, a2);
+  let F = fresnel_schlick_body(p_vdoth, F0_BODY);
+  let spec = (D * G * F) / max(4.0 * p_ndotl * p_ndotv, 0.001) * ltc_brdf_scale(p_ndotv, BODY_ROUGHNESS);
+  let kd = (1.0 - F) * principled_base / PI_B;
+  let direct = (kd + spec) * sun * p_ndotl * shadow;
+  // Indirect diffuse = base_color × L_w per Blender closure_eval_surface_lib.glsl line 302;
+  // probe_evaluate_world_diff returns radiance (SH-projected, not cosine-convolved).
+  let ambient = principled_base * light.ambientColor.xyz;
+  let principled = ambient + direct + p_emission + vec3f(sss);
+
+  // 混合着色器.001: Shader=相加着色器.001, Shader_001=原理化BSDF
+  let final_color = mix(npr_stack, principled, BODY_MIX_NPR);
+
+  return vec4f(final_color, alpha);
+}
+
+`

package/src/shaders/classify.ts

@@ -0,0 +1,25 @@
+// Material preset types for NPR pipeline dispatch.
+// Mapping is explicit — the consumer provides a MaterialPresetMap that assigns
+// material names to presets. Unmapped materials fall back to "default" (Principled BSDF).
+
+export type MaterialPreset =
+  | "default"
+  | "face"
+  | "hair"
+  | "body"
+  | "eye"
+  | "stockings"
+  | "metal"
+  | "cloth_smooth"
+  | "cloth_rough"
+
+// Keys = preset name, values = array of material names that should use that preset.
+export type MaterialPresetMap = Partial<Record<MaterialPreset, string[]>>
+
+export function resolvePreset(materialName: string, map: MaterialPresetMap | undefined): MaterialPreset {
+  if (!map) return "default"
+  for (const [preset, names] of Object.entries(map)) {
+    if (names && names.includes(materialName)) return preset as MaterialPreset
+  }
+  return "default"
+}

package/src/shaders/cloth_rough.ts

@@ -0,0 +1,174 @@
+// M_Rough_Cloth — NPR graph identical to M_Smooth_Cloth but bump chain IS live
+// (噪波→渐变→凹凸.Normal → 原理化BSDF.Normal in m_graphs) and Roughness=0.8187.
+
+import { NODES_WGSL } from "./nodes"
+
+export const CLOTH_ROUGH_SHADER_WGSL = /* wgsl */ `
+
+${NODES_WGSL}
+
+struct CameraUniforms {
+  view: mat4x4f,
+  projection: mat4x4f,
+  viewPos: vec3f,
+  _padding: f32,
+};
+
+struct Light {
+  direction: vec4f,
+  color: vec4f,
+};
+
+struct LightUniforms {
+  ambientColor: vec4f,
+  lights: array<Light, 4>,
+};
+
+struct MaterialUniforms {
+  diffuseColor: vec3f,
+  alpha: f32,
+};
+
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) normal: vec3f,
+  @location(1) uv: vec2f,
+  @location(2) worldPos: vec3f,
+};
+
+struct LightVP { viewProj: mat4x4f, };
+
+@group(0) @binding(0) var<uniform> camera: CameraUniforms;
+@group(0) @binding(1) var<uniform> light: LightUniforms;
+@group(0) @binding(2) var diffuseSampler: sampler;
+@group(0) @binding(3) var shadowMap: texture_depth_2d;
+@group(0) @binding(4) var shadowSampler: sampler_comparison;
+@group(0) @binding(5) var<uniform> lightVP: LightVP;
+@group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
+@group(2) @binding(0) var diffuseTexture: texture_2d<f32>;
+@group(2) @binding(1) var<uniform> material: MaterialUniforms;
+
+fn sampleShadow(worldPos: vec3f, n: vec3f) -> f32 {
+  let biasedPos = worldPos + n * 0.08;
+  let lclip = lightVP.viewProj * vec4f(biasedPos, 1.0);
+  let ndc = lclip.xyz / max(lclip.w, 1e-6);
+  let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
+  let cmpZ = ndc.z - 0.001;
+  let ts = 1.0 / 4096.0;
+  var vis = 0.0;
+  for (var y = -1; y <= 1; y++) {
+    for (var x = -1; x <= 1; x++) {
+      vis += textureSampleCompare(shadowMap, shadowSampler, suv + vec2f(f32(x), f32(y)) * ts, cmpZ);
+    }
+  }
+  return vis / 9.0;
+}
+
+const PI_CR: f32 = 3.141592653589793;
+const CLOTH_R_SPECULAR: f32 = 0.8;
+const CLOTH_R_ROUGHNESS: f32 = 0.8187;
+const CLOTH_R_TOON_EDGE: f32 = 0.2966;
+const CLOTH_R_MIX04_MUL: f32 = 0.5;
+const CLOTH_R_EMIT_STR: f32 = 18.200000762939453;
+const CLOTH_R_MIX_SHADER_FAC: f32 = 0.8999999761581421;
+const CLOTH_R_NOISE_SCALE: f32 = 17.7;
+const CLOTH_R_BUMP_STR: f32 = 1.0;
+
+@vertex fn vs(
+  @location(0) position: vec3f,
+  @location(1) normal: vec3f,
+  @location(2) uv: vec2f,
+  @location(3) joints0: vec4<u32>,
+  @location(4) weights0: vec4<f32>
+) -> VertexOutput {
+  var output: VertexOutput;
+  let pos4 = vec4f(position, 1.0);
+  let weightSum = weights0.x + weights0.y + weights0.z + weights0.w;
+  let invWeightSum = select(1.0, 1.0 / weightSum, weightSum > 0.0001);
+  let nw = select(vec4f(1.0, 0.0, 0.0, 0.0), weights0 * invWeightSum, weightSum > 0.0001);
+  var skinnedPos = vec4f(0.0);
+  var skinnedNrm = vec3f(0.0);
+  for (var i = 0u; i < 4u; i++) {
+    let m = skinMats[joints0[i]];
+    let w = nw[i];
+    skinnedPos += (m * pos4) * w;
+    skinnedNrm += (mat3x3f(m[0].xyz, m[1].xyz, m[2].xyz) * normal) * w;
+  }
+  output.position = camera.projection * camera.view * vec4f(skinnedPos.xyz, 1.0);
+  output.normal = normalize(skinnedNrm);
+  output.uv = uv;
+  output.worldPos = skinnedPos.xyz;
+  return output;
+}
+
+@fragment fn fs(input: VertexOutput) -> @location(0) vec4f {
+  let n = normalize(input.normal);
+  let v = normalize(camera.viewPos - input.worldPos);
+  let l = -light.lights[0].direction.xyz;
+  let sun = light.lights[0].color.xyz * light.lights[0].color.w;
+  let amb = light.ambientColor.xyz;
+  let shadow = sampleShadow(input.worldPos, n);
+
+  let tex_s = textureSample(diffuseTexture, diffuseSampler, input.uv);
+  let tex_rgb = tex_s.rgb;
+  let out_alpha = material.alpha * tex_s.a;
+  if (out_alpha < 0.001) { discard; }
+
+  // Shader→RGB → 颜色渐变.008 CONSTANT (edge AA terminator)
+  let lum_shade = shader_to_rgb_diffuse(n, l, sun, amb, shadow);
+  let ramp008 = ramp_constant_edge_aa(lum_shade, CLOTH_R_TOON_EDGE, vec4f(0,0,0,1), vec4f(1,1,1,1));
+  let toon_r = ramp008.r;
+  let mix04_fac = math_multiply(toon_r, CLOTH_R_MIX04_MUL);
+
+  // 混合.004: A=色相/饱和度/明度.002(Hue=0.5 Sat=1.0 Val=0.2), B=纹理
+  let dark_tex = hue_sat(0.5, 1.0, 0.19999998807907104, 1.0, tex_rgb);
+  let mix04 = mix_blend(mix04_fac, dark_tex, tex_rgb);
+
+  // 倒角.001.Z → 混合.003: A=混合.004, B=色相/饱和度/明度.002
+  let bevel_z = clamp(n.y, 0.0, 1.0);
+  let mix03 = mix_blend(bevel_z, mix04, dark_tex);
+
+  // 环境光遮蔽 → 颜色渐变.001 LINEAR → 混合.001 (white/black) → 混合.002 OVERLAY Fac
+  let ao = ao_fake(n, v);
+  let ao_ramp_c = ramp_linear(ao, 0.0, vec4f(1,1,1,1), 0.8808, vec4f(0,0,0,1));
+  let mix01_fac = ao_ramp_c.r;
+  let mix01_rgb = mix(vec3f(1.0), vec3f(0.0), mix01_fac);
+
+  // 混合.002 OVERLAY: Fac=混合.001, A=混合.003, B=色相/饱和度/明度.004
+  let hue004 = hue_sat(0.5, 0.800000011920929, 2.0, 1.0, mix03);
+  let overlay_fac = mix01_rgb.r;
+  let npr_rgb = mix_overlay(overlay_fac, mix03, hue004);
+  let npr_emission = npr_rgb * CLOTH_R_EMIT_STR;
+
+  // 噪波→渐变→凹凸 (LIVE in M_Rough_Cloth — unlike Smooth Cloth): Strength=1.0, noise Scale=17.7.
+  let noise_uv = mapping_point(input.worldPos, vec3f(0.0), vec3f(0.0), vec3f(1.0));
+  let noise_val = tex_noise(noise_uv, CLOTH_R_NOISE_SCALE, 2.0, 0.5, 0.0);
+  let noise_ramp = ramp_linear(noise_val, 0.0, vec4f(0,0,0,1), 1.0, vec4f(1,1,1,1)).r;
+  let bumped_n = bump_lh(CLOTH_R_BUMP_STR, noise_ramp, n, input.worldPos);
+
+  // 原理化BSDF (EEVEE port): metallic=0, specular=0.8, roughness=0.8187, specular_tint=0.
+  let principled_base = hue_sat(0.5, 1.0, 0.800000011920929, 1.0, tex_rgb);
+  let NL = max(dot(bumped_n, l), 0.0);
+  let NV = max(dot(bumped_n, v), 1e-4);
+
+  let f0 = vec3f(0.08 * CLOTH_R_SPECULAR);
+  let f90 = mix(f0, vec3f(1.0), sqrt(CLOTH_R_SPECULAR));
+  let split_sum = brdf_lut_baked(NV, CLOTH_R_ROUGHNESS);
+  let reflection_color = F_brdf_multi_scatter(f0, f90, split_sum);
+
+  let spec_direct = bsdf_ggx(bumped_n, l, v, CLOTH_R_ROUGHNESS) * sun * shadow * ltc_brdf_scale(NV, CLOTH_R_ROUGHNESS);
+  let spec_indirect = amb;
+  let spec_radiance = (spec_direct + spec_indirect) * reflection_color;
+
+  // Indirect diffuse = base_color × L_w per Blender closure_eval_surface_lib.glsl line 302;
+  // probe_evaluate_world_diff returns radiance (SH-projected, not cosine-convolved).
+  let diffuse_radiance = principled_base * (sun * NL * shadow / PI_CR + amb);
+  let principled = diffuse_radiance + spec_radiance;
+
+  // 混合着色器.001 Fac=0.9: Shader=自发光.005, Shader_001=原理化BSDF
+  let final_color = mix(npr_emission, principled, CLOTH_R_MIX_SHADER_FAC);
+
+  return vec4f(final_color, out_alpha);
+}
+
+`