@call-me-sensei/toonlab 0.2.0 → 0.3.0

package/src/shaders-tsl/woody-surface.js

@@ -0,0 +1,154 @@
+// Opaque stylized material for trunks, branches, roots, and other woody
+// surfaces. Bark is intentionally not routed through thin-surface lighting:
+// it shares the IP lighting/weather treatment, but owns its toon ramp and
+// woody accents independently from leaves, petals, and grass blades.
+
+import * as THREE from 'three';
+import {
+  abs,
+  cameraPosition,
+  clamp,
+  dot,
+  floor,
+  Fn,
+  max,
+  mix,
+  normalize,
+  normalWorld,
+  positionLocal,
+  positionWorld,
+  pow,
+  smoothstep,
+  texture,
+  uniform,
+  uv,
+  vec3,
+  vec4,
+} from 'three/tsl';
+import { NodeMaterial } from 'three/webgpu';
+
+import { sampleEnvironmentSunShadow } from './chunks/environment-sun-shadow.js';
+import {
+  createVegetationStyleUniforms,
+  tagVegetationRole,
+} from './chunks/vegetation-style.js';
+
+export function createWoodySurfaceNodeMaterial({
+  color = 0xc9ab8a,
+  height = 1,
+  map = null,
+  vegetationShader = null,
+} = {}) {
+  const u = {
+    uBaseColor: uniform(new THREE.Color(color)),
+    uHeight: uniform(Math.max(Number(height) || 1, 1e-3)),
+    uSkyColor: uniform(new THREE.Color().setRGB(0.72, 0.87, 1, THREE.SRGBColorSpace)),
+    uSunColor: uniform(new THREE.Color().setRGB(1, 0.96, 0.86, THREE.SRGBColorSpace)),
+    uSunDirection: uniform(new THREE.Vector3(0.45, 0.75, 0.5).normalize()),
+    ...createVegetationStyleUniforms(vegetationShader, 'woodySurface'),
+  };
+  const albedo = map ? texture(map).rgb.mul(u.uBaseColor) : u.uBaseColor;
+
+  const material = new NodeMaterial();
+  material.name = 'StylizedWoodySurface';
+  material.fog = true;
+  material.map = map;
+  material.fragmentNode = Fn(() => {
+    const normal = normalize(normalWorld);
+    const sunDirection = normalize(u.uSunDirection);
+    const light = clamp(dot(normal, sunDirection).mul(0.5).add(0.5), 0, 1).toVar();
+    const steps = max(floor(u.uStyleBarkBandCount), 2);
+    const intervals = max(steps.sub(1), 1);
+    const hardBand = floor(light.mul(intervals).add(1e-4)).div(intervals);
+    const band = mix(hardBand, light, u.uStyleBarkBandSoftness).toVar();
+    const visibility = sampleEnvironmentSunShadow(positionWorld).toVar();
+    const lit = band.mul(visibility).toVar();
+
+    const localHeight = clamp(positionLocal.y.div(u.uHeight), 0, 1);
+    const verticalShade = mix(
+      u.uStyleBarkVerticalShadeStrength.oneMinus(),
+      1,
+      localHeight,
+    );
+    const colorNode = albedo.mul(mix(u.uStyleBarkShadowFloor, 1, lit))
+      .mul(verticalShade).toVar();
+
+    const shadowAmount = visibility.oneMinus()
+      .mul(u.uStyleLightingShadowTintStrength);
+    colorNode.mulAssign(mix(
+      vec3(1),
+      u.uStyleLightingShadowTint,
+      clamp(shadowAmount, 0, 1),
+    ));
+    colorNode.mulAssign(mix(
+      vec3(1),
+      u.uSunColor,
+      lit.mul(u.uStyleLightingSunTintStrength.add(u.uStyleBarkSunTintStrength)),
+    ));
+    colorNode.addAssign(
+      u.uSkyColor.mul(lit.oneMinus())
+        .mul(u.uStyleLightingSkyFillStrength.add(u.uStyleBarkSkyFillStrength)),
+    );
+
+    const viewDirection = normalize(cameraPosition.sub(positionWorld));
+    const rim = pow(
+      clamp(abs(dot(normal, viewDirection)).oneMinus(), 0, 1),
+      u.uStyleLightingRimPower,
+    );
+    colorNode.addAssign(
+      u.uSkyColor.mul(rim)
+        .mul(u.uStyleLightingRimStrength.add(u.uStyleBarkRimStrength)),
+    );
+
+    const halfVector = normalize(sunDirection.add(viewDirection));
+    const specular = pow(clamp(dot(normal, halfVector), 0, 1), 24)
+      .mul(visibility).mul(u.uStyleBarkSpecularStrength);
+
+    const wet = clamp(u.uWetness.mul(u.uWetnessResponse), 0, 1).toVar();
+    colorNode.mulAssign(wet.mul(u.uStyleWeatherResponseWetDarkening).oneMinus());
+    const luminance = dot(colorNode, vec3(0.299, 0.587, 0.114));
+    colorNode.assign(mix(
+      colorNode,
+      vec3(luminance),
+      wet.mul(u.uStyleWeatherResponseWetDesaturation),
+    ));
+    colorNode.addAssign(
+      u.uSunColor.mul(specular.add(
+        wet.mul(u.uStyleWeatherResponseWetHighlightStrength)
+          .mul(rim.mul(0.5).add(0.08)),
+      )),
+    );
+
+    const snowSoftness = u.uStyleWeatherResponseSnowEdgeSoftness.max(0.001);
+    const snowFacing = smoothstep(
+      snowSoftness.mul(-0.25),
+      snowSoftness.mul(0.75),
+      normal.y,
+    );
+    const snow = clamp(u.uSnowCover.mul(u.uSnowRetention).mul(snowFacing), 0, 1);
+    const snowTint = u.uStyleWeatherResponseSnowTint.mul(mix(
+      u.uStyleWeatherResponseSnowShadowStrength,
+      1,
+      visibility,
+    ));
+    colorNode.assign(mix(colorNode, snowTint, snow));
+
+    return vec4(colorNode, 1);
+  })();
+
+  material.uniforms = u;
+  return tagVegetationRole(material, 'woodySurface', 'mesh');
+}
+
+export function setWoodySurfaceSun(material, {
+  color = [1, 0.96, 0.86],
+  direction = [0.45, 0.75, 0.5],
+  sky = [0.72, 0.87, 1],
+} = {}) {
+  const uniforms = material?.uniforms;
+  if (!uniforms) return material;
+  uniforms.uSunDirection?.value.set(...direction).normalize();
+  uniforms.uSunColor?.value.setRGB(...color, THREE.SRGBColorSpace);
+  uniforms.uSkyColor?.value.setRGB(...sky, THREE.SRGBColorSpace);
+  return material;
+}

package/src/sky/sceneOverrideLayers.js

@@ -0,0 +1,10 @@
+/**
+ * Ordered transient layers for the active sky. Lower priorities establish a
+ * base that higher priorities can derive from or replace. These values are
+ * runtime policy, never part of a portable sky-look document.
+ */
+export const SKY_SCENE_OVERRIDE_PRIORITIES = Object.freeze({
+  lighting: 100,
+  weather: 200,
+  scene: 300,
+});

package/src/sky/skyQuality.js

@@ -0,0 +1,26 @@
+const TIERS = Object.freeze({
+  low: Object.freeze({ cloudOctaves: 2, id: 'low' }),
+  medium: Object.freeze({ cloudOctaves: 3, id: 'medium' }),
+  high: Object.freeze({ cloudOctaves: 4, id: 'high' }),
+});
+
+/** Compile-time Sky deployment tiers. They never enter portable art presets. */
+export const SKY_QUALITY_TIERS = TIERS;
+export const SKY_QUALITY_OPTIONS = Object.freeze(Object.keys(TIERS));
+
+/**
+ * Resolves a named tier or a custom `{ cloudOctaves }` build policy. Cloud
+ * FBM loops are unrolled, so changing quality requires a material rebuild.
+ */
+export function resolveSkyQuality(value = 'high') {
+  if (value && typeof value === 'object') {
+    const fallback = TIERS[String(value.id ?? value.quality ?? '').toLowerCase()] ?? TIERS.high;
+    const requested = Number(value.cloudOctaves);
+    const cloudOctaves = Number.isFinite(requested)
+      ? Math.min(5, Math.max(1, Math.round(requested)))
+      : fallback.cloudOctaves;
+    const named = Object.values(TIERS).find((tier) => tier.cloudOctaves === cloudOctaves);
+    return Object.freeze({ cloudOctaves, id: named?.id ?? 'custom' });
+  }
+  return TIERS[String(value ?? '').toLowerCase()] ?? TIERS.high;
+}