@call-me-sensei/toonlab 0.4.21 → 0.4.22

package/src/catalog/officialCatalogProvider.js

@@ -10,8 +10,21 @@ export const OFFICIAL_CATALOG_PROVIDER_TRANSPORTS = Object.freeze([
   'public-rock',
 ]);
 
-const ROCK_ID = /^rock-\d{4}$/u;
+const LEGACY_ROCK_ID = /^rock-\d{4}$/u;
+const NATURE_REFERENCE_ROCK_ID = /^rock-c8-[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 const ROCK_RECIPE_KIND = 'toonlab/rock-recipe';
+const ROCK_GALLERY_RECIPE_SCHEMA = 'toonlab/rock-gallery-recipe';
+
+function isRockId(value) {
+  return LEGACY_ROCK_ID.test(value) || NATURE_REFERENCE_ROCK_ID.test(value);
+}
+
+function isRockRecipe(value) {
+  return isRecord(value) && (
+    value.kind === ROCK_RECIPE_KIND
+    || value.schema === ROCK_GALLERY_RECIPE_SCHEMA
+  );
+}
 
 function isRecord(value) {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
@@ -61,6 +74,15 @@ function artifactName(artifact) {
   return String(artifact?.name ?? artifact?.relative_path ?? artifact?.relativePath ?? '');
 }
 
+function artifactKey(value) {
+  return String(value ?? '').trim().replace(/^\.\//u, '').toLowerCase();
+}
+
+function artifactByName(artifacts, ...names) {
+  const wanted = new Set(names.map(artifactKey));
+  return artifacts.find((artifact) => wanted.has(artifactKey(artifactName(artifact)))) ?? null;
+}
+
 function isModelArtifact(artifact) {
   const name = artifactName(artifact).toLowerCase();
   const contentType = String(artifact?.contentType ?? artifact?.content_type ?? '').toLowerCase();
@@ -107,7 +129,7 @@ export function normalizeOfficialCatalogAsset(rawAsset, {
   const source = String(rawAsset.source ?? metadata.source ?? expectedSource ?? '').trim();
   const kind = String(rawAsset.kind ?? 'model').trim();
   const catalog = String(metadata.catalog ?? rawAsset.catalog ?? (
-    recipe?.kind === ROCK_RECIPE_KIND ? 'rocks' : ''
+    isRockRecipe(recipe) ? 'rocks' : ''
   )).trim().toLowerCase();
   const revision = Number(rawAsset.revision ?? metadata.revision);
   const recipeHash = String(rawAsset.recipeHash ?? metadata.recipeHash ?? '').trim();
@@ -115,7 +137,7 @@ export function normalizeOfficialCatalogAsset(rawAsset, {
     ...(Array.isArray(rawAsset.artifacts) ? rawAsset.artifacts : []),
     ...(Array.isArray(rawAsset.files) ? rawAsset.files : []),
   ].filter(isRecord);
-  const modelArtifact = artifacts.find((entry) => artifactName(entry) === 'rock.glb')
+  const modelArtifact = artifactByName(artifacts, 'rock.glb')
     ?? artifacts.find(isModelArtifact)
     ?? null;
   const modelReference = rawAsset.download_url
@@ -137,9 +159,11 @@ export function normalizeOfficialCatalogAsset(rawAsset, {
   if (kind !== 'model') errors.push(`kind must be model, received ${kind || '(empty)'}`);
   if (!modelReference) errors.push('a model download URL is required');
   if (source === 'toonlab-rock') {
-    if (!ROCK_ID.test(id)) errors.push('ToonLab rock id must match rock-0001');
+    if (!isRockId(id)) errors.push('ToonLab rock id must match rock-0001 or rock-c8-geology-subtype');
     if (catalog !== 'rocks') errors.push(`catalog must be rocks, received ${catalog || '(empty)'}`);
-    if (recipe?.kind !== ROCK_RECIPE_KIND) errors.push(`recipe kind must be ${ROCK_RECIPE_KIND}`);
+    if (!isRockRecipe(recipe)) {
+      errors.push(`recipe must use ${ROCK_RECIPE_KIND} or ${ROCK_GALLERY_RECIPE_SCHEMA}`);
+    }
     if (!Number.isInteger(revision) || revision < 1) errors.push('positive integer revision is required');
     if (!recipeHash) errors.push('recipeHash is required');
   }
@@ -157,15 +181,61 @@ export function normalizeOfficialCatalogAsset(rawAsset, {
     sha256: String(artifact.sha256 ?? ''),
     url: resolveOfficialCatalogUrl(artifactUrl(artifact), baseUrl),
   }));
+  const artifactMap = Object.freeze(Object.fromEntries(normalizedArtifacts
+    .filter((artifact) => artifact.name && artifact.url)
+    .map((artifact) => [artifact.name, artifact])));
+  const artifactUrlByName = (...names) => {
+    const artifact = artifactByName(normalizedArtifacts, ...names);
+    return artifact?.url ?? null;
+  };
   const release = String(rawAsset.release ?? metadata.release ?? releaseFromUrl(modelUrl) ?? '').trim() || null;
   const domain = catalog === 'rocks' ? 'natural.rock' : String(metadata.domain ?? '').trim() || null;
-  const lod = isRecord(recipe?.lod) ? frozenCopy(recipe.lod) : null;
+  const recipeLod = isRecord(recipe?.lod) ? recipe.lod : null;
+  const metadataLod = isRecord(rawAsset.lod ?? metadata.lod) ? rawAsset.lod ?? metadata.lod : null;
+  const lodLevels = Array.isArray(recipe?.output?.lods)
+    ? recipe.output.lods.map(String)
+    : Array.isArray(metadataLod?.levels)
+      ? metadataLod.levels.map(String)
+      : [];
+  const lodUrls = Object.freeze(Array.from({ length: 5 }, (_, level) => (
+    artifactUrlByName(`lod${level}.glb`, `lod/LOD${level}.glb`)
+  )));
+  const hasLodPackage = lodUrls.some(Boolean) || lodLevels.length > 0;
+  const lod = recipeLod || metadataLod || hasLodPackage
+    ? Object.freeze({
+      ...frozenCopy(recipeLod ?? metadataLod ?? {}),
+      cullBelowPixels: Number(
+        recipe?.output?.cullBelowPixels
+        ?? metadataLod?.cullBelowPixels
+        ?? 0,
+      ) || 0,
+      levels: Object.freeze(lodLevels),
+      urls: lodUrls,
+    })
+    : null;
+  const packageFiles = Object.freeze({
+    collisionModelUrl: artifactUrlByName('collision.glb'),
+    controlModelUrl: artifactUrlByName('control.glb'),
+    lodModelUrls: lodUrls,
+    manifestUrl: artifactUrlByName('manifest.json'),
+    materialConfigUrl: artifactUrlByName('material-config.json'),
+    natureProvenanceUrl: artifactUrlByName('nature-provenance.json', 'nature/provenance.json'),
+    natureReferenceUrl: artifactUrlByName('nature-reference.jpg', 'nature/reference.jpg'),
+    realisticModelUrl: modelUrl,
+    realisticPreviewUrl: artifactUrlByName('realistic-preview.png'),
+    recipeUrl: artifactUrlByName('recipe.json'),
+    retainedHighModelUrl: artifactUrlByName('retained-high.glb', 'high.glb'),
+    stylizedModelUrl: artifactUrlByName('rock-stylized.glb'),
+    stylizedPreviewUrl: artifactUrlByName('stylized-preview.png'),
+  });
+  const collisionMetadata = rawAsset.collision ?? metadata.collision;
 
   return Object.freeze({
     artifacts: Object.freeze(normalizedArtifacts),
+    artifactMap,
     catalog,
-    collision: isRecord(rawAsset.collision ?? metadata.collision)
-      ? frozenCopy(rawAsset.collision ?? metadata.collision)
+    collision: isRecord(collisionMetadata) && typeof collisionMetadata.kind === 'string'
+      ? frozenCopy(collisionMetadata)
       : null,
     domain,
     id,
@@ -175,6 +245,7 @@ export function normalizeOfficialCatalogAsset(rawAsset, {
     lod,
     metadata: frozenCopy(metadata),
     modelUrl,
+    packageFiles,
     provider,
     provenance: Object.freeze({
       modelSha256: String(modelArtifact?.sha256 ?? metadata.modelSha256 ?? ''),

package/src/catalog/officialCatalogRockPackage.js

@@ -0,0 +1,172 @@
+import {
+  LinearFilter,
+  LinearMipmapLinearFilter,
+  NoColorSpace,
+  RepeatWrapping,
+  SRGBColorSpace,
+  TextureLoader,
+} from 'three';
+
+export const OFFICIAL_ROCK_GALLERY_RECIPE_SCHEMA = 'toonlab/rock-gallery-recipe';
+export const OFFICIAL_ROCK_MATERIAL_SCHEMA = 'toonlab.pro-rock-material';
+
+function isRecord(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function frozenCopy(value) {
+  if (Array.isArray(value)) return Object.freeze(value.map(frozenCopy));
+  if (!isRecord(value)) return value;
+  return Object.freeze(Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [key, frozenCopy(entry)]),
+  ));
+}
+
+function artifactName(value) {
+  return String(value ?? '').trim().replace(/^\.\//u, '').toLowerCase();
+}
+
+export function findOfficialCatalogArtifact(asset, ...names) {
+  const wanted = new Set(names.map(artifactName));
+  return asset?.artifacts?.find((artifact) => wanted.has(artifactName(artifact.name))) ?? null;
+}
+
+export function getOfficialCatalogArtifactUrl(asset, ...names) {
+  return findOfficialCatalogArtifact(asset, ...names)?.url ?? null;
+}
+
+async function fetchJson(fetchImpl, url, label) {
+  if (!url) return null;
+  if (typeof fetchImpl !== 'function') throw new TypeError(`${label} requires fetch().`);
+  const response = await fetchImpl(url, { headers: { accept: 'application/json' } });
+  if (!response?.ok) {
+    throw new Error(`${label} returned HTTP ${response?.status ?? 'unknown'}: ${url}`);
+  }
+  try {
+    return await response.json();
+  } catch (cause) {
+    throw new Error(`${label} returned invalid JSON: ${url}`, { cause });
+  }
+}
+
+function validateRecipe(asset, recipe) {
+  if (!recipe) return null;
+  if (recipe.schema !== OFFICIAL_ROCK_GALLERY_RECIPE_SCHEMA || recipe.version !== 1) {
+    throw new Error(`${asset.id} has an unsupported editable rock recipe.`);
+  }
+  if (recipe.generator?.unit !== 'metre') {
+    throw new Error(`${asset.id} editable recipe must use metres.`);
+  }
+  return frozenCopy(recipe);
+}
+
+function validateMaterialConfig(asset, materialConfig) {
+  if (!materialConfig) return null;
+  if (materialConfig.schema !== OFFICIAL_ROCK_MATERIAL_SCHEMA || materialConfig.version !== 2) {
+    throw new Error(`${asset.id} has an unsupported Call Me Sensei material package.`);
+  }
+  if (materialConfig.assetId !== asset.id || materialConfig.shader?.preset !== 'call_me_sensei') {
+    throw new Error(`${asset.id} material package failed identity or preset validation.`);
+  }
+  if (!isRecord(materialConfig.textures)) {
+    throw new Error(`${asset.id} material package has no texture bindings.`);
+  }
+  return frozenCopy(materialConfig);
+}
+
+/**
+ * Load the immutable documents associated with a nature-reference rock.
+ * Legacy 480 rocks remain valid and simply return null for documents they do
+ * not publish.
+ */
+export async function loadOfficialCatalogRockPackage(asset, {
+  fetchImpl = globalThis.fetch?.bind(globalThis),
+  includeManifest = false,
+  includeNatureProvenance = false,
+} = {}) {
+  if (!asset || asset.domain !== 'natural.rock') {
+    throw new TypeError('Official rock package loading requires a normalized natural.rock asset.');
+  }
+  const files = asset.packageFiles ?? {};
+  const [recipeDocument, materialDocument, manifest, natureProvenance] = await Promise.all([
+    files.recipeUrl ? fetchJson(fetchImpl, files.recipeUrl, `${asset.id} recipe`) : asset.recipe,
+    fetchJson(fetchImpl, files.materialConfigUrl, `${asset.id} material package`),
+    includeManifest ? fetchJson(fetchImpl, files.manifestUrl, `${asset.id} manifest`) : null,
+    includeNatureProvenance
+      ? fetchJson(fetchImpl, files.natureProvenanceUrl, `${asset.id} nature provenance`)
+      : null,
+  ]);
+  const recipe = recipeDocument?.schema === OFFICIAL_ROCK_GALLERY_RECIPE_SCHEMA
+    ? validateRecipe(asset, recipeDocument)
+    : frozenCopy(asset.recipe);
+  const materialConfig = validateMaterialConfig(asset, materialDocument);
+  return Object.freeze({
+    asset,
+    files,
+    manifest: frozenCopy(manifest),
+    materialConfig,
+    natureProvenance: frozenCopy(natureProvenance),
+    recipe,
+  });
+}
+
+function configureRockTexture(texture, descriptor, role) {
+  texture.name = `ToonLab ${role} · ${descriptor.url}`;
+  texture.colorSpace = descriptor.srgb === true ? SRGBColorSpace : NoColorSpace;
+  texture.flipY = false;
+  texture.wrapS = RepeatWrapping;
+  texture.wrapT = RepeatWrapping;
+  texture.magFilter = LinearFilter;
+  texture.minFilter = LinearMipmapLinearFilter;
+  texture.generateMipmaps = true;
+  texture.userData.toonlabOfficialRockRole = role;
+  texture.userData.toonlabOfficialRockUrl = descriptor.url;
+  texture.needsUpdate = true;
+  return texture;
+}
+
+/** Load the exact texture slots consumed by applyRockShader(). */
+export async function loadOfficialCatalogRockShaderInput(rockPackage, {
+  textureLoader = new TextureLoader(),
+} = {}) {
+  const config = rockPackage?.materialConfig;
+  if (!config) return null;
+  const textures = {};
+  await Promise.all(Object.entries(config.textures).map(async ([role, descriptor]) => {
+    if (!descriptor?.url) throw new Error(`${config.assetId}/${role} has no immutable texture URL.`);
+    const texture = await textureLoader.loadAsync(descriptor.url);
+    textures[role] = configureRockTexture(texture, descriptor, role);
+  }));
+  return Object.freeze({
+    materialConfig: config,
+    settings: frozenCopy(config.shader?.settings ?? {}),
+    textures: Object.freeze(textures),
+  });
+}
+
+/**
+ * Portable hand-off for Rock Lab or another editor. Geometry derivatives are
+ * deliberately separate: edits target control.glb, while retained high, LODs,
+ * collision, and baked/runtime outputs can be regenerated or replaced.
+ */
+export function createOfficialCatalogRockEditorDescriptor(asset, rockPackage = null) {
+  if (!asset || asset.domain !== 'natural.rock') {
+    throw new TypeError('Official rock editor descriptors require a normalized natural.rock asset.');
+  }
+  const recipe = rockPackage?.recipe ?? asset.recipe;
+  const files = asset.packageFiles ?? {};
+  if (recipe?.schema !== OFFICIAL_ROCK_GALLERY_RECIPE_SCHEMA) return null;
+  return Object.freeze({
+    assetId: asset.id,
+    controlModelUrl: files.controlModelUrl,
+    cullBelowPixels: asset.lod?.cullBelowPixels ?? recipe.output?.cullBelowPixels ?? 0,
+    editing: frozenCopy(recipe.editing ?? {}),
+    lodModelUrls: asset.lod?.urls ?? files.lodModelUrls ?? Object.freeze([]),
+    materialConfigUrl: files.materialConfigUrl,
+    recipe: frozenCopy(recipe),
+    recipeUrl: files.recipeUrl,
+    retainedHighModelUrl: files.retainedHighModelUrl,
+    collisionModelUrl: files.collisionModelUrl,
+    worldUnitMetres: recipe.generator?.unit === 'metre' ? 1 : null,
+  });
+}

package/src/rock-shader/rockMaterial.js

@@ -131,6 +131,8 @@ export const TOONLAB_ROCK_PROFILE_DEFAULTS = Object.freeze({
     distanceScale: 1,
   }),
   base: Object.freeze({
+    mode: 'triplanar',
+    upAxis: 'y',
     scale: 1,
     tint: Object.freeze([1, 1, 1]),
     saturation: 1,
@@ -335,6 +337,14 @@ function bool(value, fallback) {
   return fallback;
 }
 
+function projectionMode(value, fallback = 'triplanar') {
+  return value === 'directional-bedding' || value === 'triplanar' ? value : fallback;
+}
+
+function projectionUpAxis(value, fallback = 'y') {
+  return value === 'x' || value === 'y' || value === 'z' ? value : fallback;
+}
+
 function color3(value, fallback) {
   if (Array.isArray(value)) {
     return [
@@ -401,6 +411,8 @@ export function normalizeToonLabRockProfile(profile = {}) {
       ),
     },
     base: {
+      mode: projectionMode(base.mode, defaults.base.mode),
+      upAxis: projectionUpAxis(base.upAxis, defaults.base.upAxis),
       scale: finite(base.scale, defaults.base.scale),
       tint: color3(base.tint, defaults.base.tint),
       saturation: finite(base.saturation, defaults.base.saturation),
@@ -944,6 +956,87 @@ export function toonLabTriplanarColor(map, scale, blend = 1, coordinates = { zSi
     .add(mapNode.sample(projected.xy).rgb.mul(weights.z));
 }
 
+const DIRECTIONAL_BEDDING_AXES = Object.freeze({
+  x: Object.freeze({
+    lateral: Object.freeze([
+      Object.freeze({ faceAxis: 'y', uAxis: 'z', uv: 'zx' }),
+      Object.freeze({ faceAxis: 'z', uAxis: 'y', uv: 'yx' }),
+    ]),
+    suppressedProjectionAxis: 'x',
+    upAxis: 'x',
+  }),
+  y: Object.freeze({
+    lateral: Object.freeze([
+      Object.freeze({ faceAxis: 'x', uAxis: 'z', uv: 'zy' }),
+      Object.freeze({ faceAxis: 'z', uAxis: 'x', uv: 'xy' }),
+    ]),
+    suppressedProjectionAxis: 'y',
+    upAxis: 'y',
+  }),
+  z: Object.freeze({
+    lateral: Object.freeze([
+      Object.freeze({ faceAxis: 'x', uAxis: 'y', uv: 'yz' }),
+      Object.freeze({ faceAxis: 'y', uAxis: 'x', uv: 'xz' }),
+    ]),
+    suppressedProjectionAxis: 'z',
+    upAxis: 'z',
+  }),
+});
+
+/**
+ * Describes the compile-time directional-bedding graph. The returned data is
+ * deliberately plain CPU data so authoring tools and focused verifiers can
+ * prove which axis is suppressed without compiling a WebGPU pipeline.
+ */
+export function describeToonLabDirectionalBeddingProjection(upAxis = 'y') {
+  const resolved = projectionUpAxis(upAxis, 'y');
+  const descriptor = DIRECTIONAL_BEDDING_AXES[resolved];
+  return {
+    lateral: descriptor.lateral.map((entry) => ({ ...entry })),
+    suppressedProjectionAxis: descriptor.suppressedProjectionAxis,
+    upAxis: descriptor.upAxis,
+  };
+}
+
+function directionalBeddingState(scale, blend, coordinates, upAxis) {
+  const descriptor = DIRECTIONAL_BEDDING_AXES[projectionUpAxis(upAxis, 'y')];
+  const projected = toonLabSourcePosition(coordinates).div(safeScale(scale));
+  const geometryNormal = toonLabSourceGeometryNormal(coordinates);
+  const exponent = float(Math.max(finite(blend, 1), 0.000001));
+  const upWeight = pow(
+    max(abs(geometryNormal[descriptor.upAxis]), TOONLAB_FLOAT_EPSILON),
+    exponent,
+  );
+  const lateralWeights = descriptor.lateral.map(({ faceAxis }) => pow(
+    max(abs(geometryNormal[faceAxis]), TOONLAB_FLOAT_EPSILON),
+    exponent,
+  ).add(upWeight.mul(0.5)));
+  const denominator = max(lateralWeights[0].add(lateralWeights[1]), 0.000001);
+  return {
+    descriptor,
+    geometryNormal,
+    projected,
+    weights: lateralWeights.map((weight) => weight.div(denominator)),
+  };
+}
+
+export function toonLabDirectionalBeddingColor(
+  map,
+  scale,
+  blend = 1,
+  coordinates = { zSign: 1 },
+  upAxis = 'y',
+) {
+  const mapNode = texture(map);
+  const state = directionalBeddingState(scale, blend, coordinates, upAxis);
+  const sample = ({ uv: swizzle }) => mapNode.sample(vec2(
+    state.projected[swizzle[0]],
+    state.projected[swizzle[1]],
+  )).rgb;
+  return sample(state.descriptor.lateral[0]).mul(state.weights[0])
+    .add(sample(state.descriptor.lateral[1]).mul(state.weights[1]));
+}
+
 function toonLabSideProjection(map, scale, projectionContrast, {
   negativeScale = true,
   clampResult = true,
@@ -966,7 +1059,18 @@ function toonLabSideProjection(map, scale, projectionContrast, {
 }
 
 function toonLabRockProjection(map, profile) {
-  return profile.base.sideOnly
+  // Directional bedding has explicit precedence. `sideOnly` remains the exact
+  // legacy graph for old presets, but cannot re-enable the suppressed top-axis
+  // sample on a bedded C8 surface.
+  return profile.base.mode === 'directional-bedding'
+    ? toonLabDirectionalBeddingColor(
+      map,
+      profile.base.scale,
+      profile.base.projectionContrast,
+      profile.coordinates,
+      profile.base.upAxis,
+    )
+    : profile.base.sideOnly
     ? toonLabSideProjection(map, profile.base.scale, profile.base.projectionContrast, {
       coordinates: profile.coordinates,
     })
@@ -993,13 +1097,18 @@ function normalGreenSignForTexture(map, profileSign) {
   return finite(profileSign, 1) * importerSign;
 }
 
+function safeNormalizeDirection(direction, fallback = vec3(0, 0, 1)) {
+  const valid = step(float(1e-12), dot(direction, direction));
+  return normalize(mix(fallback, direction, valid));
+}
+
 function worldNormalToTangent(worldNormal) {
   const viewNormal = transformNormalByViewMatrix(worldNormal, cameraViewMatrix);
-  return normalize(transpose(TBNViewMatrix).mul(viewNormal));
+  return safeNormalizeDirection(transpose(TBNViewMatrix).mul(viewNormal));
 }
 
 export function tangentNormalToView(tangentNormal) {
-  return normalize(TBNViewMatrix.mul(tangentNormal));
+  return safeNormalizeDirection(TBNViewMatrix.mul(tangentNormal));
 }
 
 export function toonLabTriplanarNormal(map, scale, blend, greenSign, coordinates) {
@@ -1027,6 +1136,52 @@ export function toonLabTriplanarNormal(map, scale, blend, greenSign, coordinates
   return worldNormalToTangent(worldNormal);
 }
 
+function directionalBeddingNormalCandidate(decoded, geometryNormal, entry, upAxis) {
+  const components = {
+    x: geometryNormal.x,
+    y: geometryNormal.y,
+    z: geometryNormal.z,
+  };
+  components[entry.faceAxis] = abs(decoded.z).mul(geometryNormal[entry.faceAxis]);
+  components[entry.uAxis] = decoded.x.add(geometryNormal[entry.uAxis]);
+  components[upAxis] = decoded.y.add(geometryNormal[upAxis]);
+  return vec3(components.x, components.y, components.z);
+}
+
+export function toonLabDirectionalBeddingNormal(
+  map,
+  scale,
+  blend,
+  greenSign,
+  coordinates,
+  upAxis = 'y',
+) {
+  const state = directionalBeddingState(scale, blend, coordinates, upAxis);
+  const mapNode = texture(map);
+  const candidates = state.descriptor.lateral.map((entry) => {
+    const decoded = decodeToonLabNormal(mapNode.sample(vec2(
+      state.projected[entry.uv[0]],
+      state.projected[entry.uv[1]],
+    )).rgb, greenSign);
+    return directionalBeddingNormalCandidate(
+      decoded,
+      state.geometryNormal,
+      entry,
+      state.descriptor.upAxis,
+    );
+  });
+  const sourceWorldNormal = safeNormalizeDirection(
+    candidates[0].mul(state.weights[0]).add(candidates[1].mul(state.weights[1])),
+    state.geometryNormal,
+  );
+  const worldNormal = safeNormalizeDirection(vec3(
+    sourceWorldNormal.x,
+    sourceWorldNormal.y,
+    sourceWorldNormal.z.mul(coordinates.zSign),
+  ), state.geometryNormal);
+  return worldNormalToTangent(worldNormal);
+}
+
 function toonLabNormalBlend(a, b) {
   // S_Rock's Normal Blend node uses BlendMode.Default, not RNM.
   return normalize(vec3(a.xy.add(b.xy), a.z.mul(b.z)));
@@ -1286,12 +1441,14 @@ export function createToonRockMaterial({
   // The macro projection carries the authored silhouette-scale color breakup;
   // a second metre-scale octave preserves readable rock surface detail close
   // to the camera without changing that macro identity.
-  const nearDetailSample = toonLabTriplanarColor(
-    textures.rock,
-    resolvedProfile.base.nearDetailScale,
-    resolvedProfile.base.projectionContrast,
-    resolvedProfile.coordinates,
-  );
+  const nearDetailProfile = {
+    ...resolvedProfile,
+    base: {
+      ...resolvedProfile.base,
+      scale: resolvedProfile.base.nearDetailScale,
+    },
+  };
+  const nearDetailSample = toonLabRockProjection(textures.rock, nearDetailProfile);
   const nearDetailValue = dot(nearDetailSample, vec3(0.2126, 0.7152, 0.0722));
   const nearDetailFade = clamp(
     radialDistance.div(resolvedProfile.base.nearDetailDistance),
@@ -1320,16 +1477,24 @@ export function createToonRockMaterial({
   );
 
   if (resolvedProfile.base.striping.enabled) {
-    const stripeProjected = toonLabSideProjection(
-      textures.stripe,
-      resolvedProfile.base.striping.scale,
-      resolvedProfile.base.projectionContrast,
-      {
-        negativeScale: false,
-        clampResult: false,
-        coordinates: resolvedProfile.coordinates,
-      },
-    );
+    const stripeProjected = resolvedProfile.base.mode === 'directional-bedding'
+      ? toonLabDirectionalBeddingColor(
+        textures.stripe,
+        resolvedProfile.base.striping.scale,
+        resolvedProfile.base.projectionContrast,
+        resolvedProfile.coordinates,
+        resolvedProfile.base.upAxis,
+      )
+      : toonLabSideProjection(
+        textures.stripe,
+        resolvedProfile.base.striping.scale,
+        resolvedProfile.base.projectionContrast,
+        {
+          negativeScale: false,
+          clampResult: false,
+          coordinates: resolvedProfile.coordinates,
+        },
+      );
     const stripeOpacity = clamp(
       toonLabContrast(stripeProjected.r, resolvedProfile.base.striping.contrast),
       0,
@@ -1811,16 +1976,28 @@ export function createToonRockMaterial({
     : vec3(0, 0, 1);
   let combinedNormal = stylizedNormal;
   if (textures.rockNormal) {
-    const crackNormal = toonLabTriplanarNormal(
-      textures.rockNormal,
-      resolvedProfile.base.scale,
-      resolvedProfile.base.projectionContrast,
-      normalGreenSignForTexture(
+    const crackNormal = resolvedProfile.base.mode === 'directional-bedding'
+      ? toonLabDirectionalBeddingNormal(
         textures.rockNormal,
-        resolvedProfile.normals.normalGreenSign,
-      ),
-      resolvedProfile.coordinates,
-    );
+        resolvedProfile.base.scale,
+        resolvedProfile.base.projectionContrast,
+        normalGreenSignForTexture(
+          textures.rockNormal,
+          resolvedProfile.normals.normalGreenSign,
+        ),
+        resolvedProfile.coordinates,
+        resolvedProfile.base.upAxis,
+      )
+      : toonLabTriplanarNormal(
+        textures.rockNormal,
+        resolvedProfile.base.scale,
+        resolvedProfile.base.projectionContrast,
+        normalGreenSignForTexture(
+          textures.rockNormal,
+          resolvedProfile.normals.normalGreenSign,
+        ),
+        resolvedProfile.coordinates,
+      );
     const normalFade = clamp(
       radialDistance.div(Math.max(
         resolvedProfile.normals.distance * authoredDistanceScale,

package/src/rock-shader/rockShaderRuntime.js

@@ -226,6 +226,8 @@ export function rockShaderSettingsToProfile(input = {}) {
 
   return normalizeToonLabRockProfile({
     base: {
+      mode: projection.mode,
+      upAxis: projection.upAxis,
       scale: projection.scale,
       projectionContrast: projection.projectionContrast,
       sideOnly: projection.sideOnly,
@@ -373,6 +375,11 @@ function createMaterialForSource({
     materialProfile.shoreline = structuredClone(profile.shoreline);
     materialProfile.base = {
       ...materialProfile.base,
+      // Projection choice belongs to the edited C8 surface package/runtime
+      // binding, not to a shared semantic material set. These strings select
+      // a CPU-authored TSL graph; they are deliberately not shader uniforms.
+      mode: profile.base.mode,
+      upAxis: profile.base.upAxis,
       closeTintDistance: profile.base.closeTintDistance,
       distantTint: profile.base.distantTint,
       distantTintMix: profile.base.distantTintMix,
@@ -529,6 +536,12 @@ function createMaterialForSource({
     },
     sourceTextureCount: rockMaterial.userData.toonlabSourceTextureIds.length,
   };
+  rockMaterial.userData.toonlabRockProjectionContract = {
+    mapRoles: ['BaseColor', 'NearDetail', 'Smoothness', 'NormalGL', 'AO'],
+    mode: materialProfile.base.mode,
+    sideOnly: materialProfile.base.sideOnly,
+    upAxis: materialProfile.base.upAxis,
+  };
   if (semantic) {
     rockMaterial.userData.toonLabRockTextureComposition.materialSetId = semantic.materialSetId;
     rockMaterial.userData.toonLabRockTextureComposition.surfaceState = surfaceState;
@@ -560,8 +573,11 @@ function createMaterialForSource({
         : materialProfile.layers?.[activeLayer]?.roughness ?? null,
     };
     rockMaterial.userData.toonlabRockProjectionContract = {
+      ...rockMaterial.userData.toonlabRockProjectionContract,
       normalBlend: 'whiteout-world-to-tangent',
-      primary: 'world-space-triplanar',
+      primary: materialProfile.base.mode === 'directional-bedding'
+        ? 'world-space-directional-bedding'
+        : 'world-space-triplanar',
       scaleCompensation: 'absolute-world-position',
       texelDensityInvariantUnderNonUniformScale: true,
     };