@call-me-sensei/toonlab 0.1.1

package/src/toon/settings/outlineSettings.js

@@ -0,0 +1,263 @@
+import * as THREE from 'three';
+
+export const DEFAULT_OUTLINE_SETTINGS = Object.freeze({
+  defaultLightingMix: 0.28,
+  defaultMaxBrightness: 0.38,
+  defaultMinBrightness: 0.04,
+  defaultTintColor: [0.34, 0.33, 0.4],
+  defaultWidth: 0.002,
+  depthOffset: 0,
+  depthTest: true,
+  depthWrite: false,
+  enabled: true,
+  eyeLightingMix: 0.28,
+  eyeMaxBrightness: 0.38,
+  eyeMinBrightness: 0.04,
+  eyeTintColor: [0.34, 0.33, 0.4],
+  eyeWidth: 0,
+  faceLightingMix: 0.28,
+  faceMaxBrightness: 0.48,
+  faceMinBrightness: 0.04,
+  faceTintColor: [0.62, 0.36, 0.34],
+  faceWidth: 0,
+  hairCutoutWidth: 0,
+  hairLightingMix: 0.08,
+  hairMaxBrightness: 0.68,
+  hairMinBrightness: 0.085,
+  hairTintColor: [0.72, 0.78, 0.9],
+  hairWidth: 0.00055,
+  maxWidth: 0.006,
+  metalLightingMix: 0.28,
+  metalMaxBrightness: 0.38,
+  metalMinBrightness: 0.04,
+  metalTintColor: [0.34, 0.33, 0.4],
+  metalWidth: 0.002,
+  polygonOffset: false,
+  polygonOffsetFactor: 1,
+  polygonOffsetUnits: 1,
+  // Screen-space width correction: scales the view-space expansion by camera
+  // distance and FOV so the outline keeps a consistent on-screen width, then
+  // stops growing past widthFadeDistance so far-away characters lose outline
+  // weight instead of turning into black blobs. 0 restores the legacy
+  // constant view-space offset. referenceDistance/referenceFov define the
+  // framing at which configured widths mean what they meant before.
+  referenceDistance: 4,
+  referenceFov: 40,
+  screenSpaceWidth: 1,
+  // Average normals across position-duplicate vertices at conversion time so
+  // hard-edged geometry (Rigify mannequin, arbitrary GLB) keeps a closed hull.
+  smoothNormals: true,
+  widthFadeDistance: 12,
+  skinLightingMix: 0.28,
+  skinMaxBrightness: 0.48,
+  skinMinBrightness: 0.04,
+  skinTintColor: [0.62, 0.36, 0.34],
+  skinWidth: 0.001,
+  transparentOverlayWidth: 0,
+  widthScale: 1,
+});
+
+function firstDefined(source, keys) {
+  for (const key of keys) {
+    if (source?.[key] !== undefined) return source[key];
+  }
+  return undefined;
+}
+
+function numberOption(value, fallback, { min = -Infinity, max = Infinity } = {}) {
+  const nextValue = Number(value);
+  if (!Number.isFinite(nextValue)) return fallback;
+  return Math.min(max, Math.max(min, nextValue));
+}
+
+function colorOption(value, fallback) {
+  if (value?.isColor) return value.clone();
+
+  if (Array.isArray(value) && value.length >= 3) {
+    return new THREE.Color(
+      numberOption(value[0], fallback[0] ?? fallback.r ?? 1),
+      numberOption(value[1], fallback[1] ?? fallback.g ?? 1),
+      numberOption(value[2], fallback[2] ?? fallback.b ?? 1),
+    );
+  }
+
+  if (typeof value === 'object' && value !== null) {
+    return new THREE.Color(
+      numberOption(value.r ?? value.x, fallback[0] ?? fallback.r ?? 1),
+      numberOption(value.g ?? value.y, fallback[1] ?? fallback.g ?? 1),
+      numberOption(value.b ?? value.z, fallback[2] ?? fallback.b ?? 1),
+    );
+  }
+
+  if (typeof value === 'string' || typeof value === 'number') {
+    try {
+      return new THREE.Color(value);
+    } catch {
+      // Fall through to fallback.
+    }
+  }
+
+  return Array.isArray(fallback)
+    ? new THREE.Color(fallback[0], fallback[1], fallback[2])
+    : fallback.clone();
+}
+
+function enabledOption(value) {
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    return normalized !== 'off' && normalized !== 'none' && normalized !== 'false' && normalized !== '0';
+  }
+  return value !== false;
+}
+
+function normalizeOutlineOptions(options) {
+  if (options === false) return { enabled: false };
+  if (options === true) return { enabled: true };
+  if (typeof options === 'string') return { enabled: enabledOption(options) };
+  return options || {};
+}
+
+function roleNumber(source, role, property, fallback, aliases = [], bounds = {}) {
+  const rolePrefix = role ? `${role}${property[0].toUpperCase()}${property.slice(1)}` : property;
+  return numberOption(firstDefined(source, [rolePrefix, ...aliases]), fallback, bounds);
+}
+
+function roleColor(source, role, property, fallback, aliases = []) {
+  const rolePrefix = role ? `${role}${property[0].toUpperCase()}${property.slice(1)}` : property;
+  return colorOption(firstDefined(source, [rolePrefix, ...aliases]), fallback);
+}
+
+function roleValue(settings, role, property, fallback) {
+  return settings[`${role}${property[0].toUpperCase()}${property.slice(1)}`] ?? fallback;
+}
+
+export function createOutlineSettings(options = null) {
+  const source = normalizeOutlineOptions(options);
+  const enabled = enabledOption(source.enabled);
+
+  return {
+    defaultLightingMix: enabled
+      ? roleNumber(source, 'default', 'lightingMix', DEFAULT_OUTLINE_SETTINGS.defaultLightingMix, ['lightingMix'], { min: 0, max: 1 })
+      : DEFAULT_OUTLINE_SETTINGS.defaultLightingMix,
+    defaultMaxBrightness: roleNumber(source, 'default', 'maxBrightness', DEFAULT_OUTLINE_SETTINGS.defaultMaxBrightness, ['maxBrightness'], { min: 0, max: 2 }),
+    defaultMinBrightness: roleNumber(source, 'default', 'minBrightness', DEFAULT_OUTLINE_SETTINGS.defaultMinBrightness, ['minBrightness'], { min: 0, max: 2 }),
+    defaultTintColor: roleColor(source, 'default', 'tintColor', DEFAULT_OUTLINE_SETTINGS.defaultTintColor, ['tintColor', 'color']),
+    defaultWidth: enabled
+      ? roleNumber(source, 'default', 'width', DEFAULT_OUTLINE_SETTINGS.defaultWidth, ['width', 'thickness'], { min: 0, max: 0.05 })
+      : 0,
+    depthOffset: enabled
+      ? numberOption(firstDefined(source, ['depthOffset', 'zOffset', 'viewDepthOffset']), DEFAULT_OUTLINE_SETTINGS.depthOffset, { min: 0, max: 0.05 })
+      : 0,
+    depthTest: source.depthTest !== undefined ? enabledOption(source.depthTest) : DEFAULT_OUTLINE_SETTINGS.depthTest,
+    depthWrite: source.depthWrite !== undefined ? enabledOption(source.depthWrite) : DEFAULT_OUTLINE_SETTINGS.depthWrite,
+    enabled,
+    eyeLightingMix: enabled ? roleNumber(source, 'eye', 'lightingMix', DEFAULT_OUTLINE_SETTINGS.eyeLightingMix, [], { min: 0, max: 1 }) : DEFAULT_OUTLINE_SETTINGS.eyeLightingMix,
+    eyeMaxBrightness: roleNumber(source, 'eye', 'maxBrightness', DEFAULT_OUTLINE_SETTINGS.eyeMaxBrightness, [], { min: 0, max: 2 }),
+    eyeMinBrightness: roleNumber(source, 'eye', 'minBrightness', DEFAULT_OUTLINE_SETTINGS.eyeMinBrightness, [], { min: 0, max: 2 }),
+    eyeTintColor: roleColor(source, 'eye', 'tintColor', DEFAULT_OUTLINE_SETTINGS.eyeTintColor),
+    eyeWidth: enabled ? roleNumber(source, 'eye', 'width', DEFAULT_OUTLINE_SETTINGS.eyeWidth, [], { min: 0, max: 0.05 }) : 0,
+    faceLightingMix: enabled ? roleNumber(source, 'face', 'lightingMix', DEFAULT_OUTLINE_SETTINGS.faceLightingMix, [], { min: 0, max: 1 }) : DEFAULT_OUTLINE_SETTINGS.faceLightingMix,
+    faceMaxBrightness: roleNumber(source, 'face', 'maxBrightness', DEFAULT_OUTLINE_SETTINGS.faceMaxBrightness, [], { min: 0, max: 2 }),
+    faceMinBrightness: roleNumber(source, 'face', 'minBrightness', DEFAULT_OUTLINE_SETTINGS.faceMinBrightness, [], { min: 0, max: 2 }),
+    faceTintColor: roleColor(source, 'face', 'tintColor', DEFAULT_OUTLINE_SETTINGS.faceTintColor),
+    faceWidth: enabled ? roleNumber(source, 'face', 'width', DEFAULT_OUTLINE_SETTINGS.faceWidth, [], { min: 0, max: 0.05 }) : 0,
+    hairCutoutWidth: enabled
+      ? numberOption(firstDefined(source, ['hairCutoutWidth', 'hairCardWidth', 'hairAlphaWidth']), DEFAULT_OUTLINE_SETTINGS.hairCutoutWidth, { min: 0, max: 0.05 })
+      : 0,
+    hairLightingMix: enabled ? roleNumber(source, 'hair', 'lightingMix', DEFAULT_OUTLINE_SETTINGS.hairLightingMix, [], { min: 0, max: 1 }) : DEFAULT_OUTLINE_SETTINGS.hairLightingMix,
+    hairMaxBrightness: roleNumber(source, 'hair', 'maxBrightness', DEFAULT_OUTLINE_SETTINGS.hairMaxBrightness, [], { min: 0, max: 2 }),
+    hairMinBrightness: roleNumber(source, 'hair', 'minBrightness', DEFAULT_OUTLINE_SETTINGS.hairMinBrightness, [], { min: 0, max: 2 }),
+    hairTintColor: roleColor(source, 'hair', 'tintColor', DEFAULT_OUTLINE_SETTINGS.hairTintColor),
+    hairWidth: enabled ? roleNumber(source, 'hair', 'width', DEFAULT_OUTLINE_SETTINGS.hairWidth, [], { min: 0, max: 0.05 }) : 0,
+    maxWidth: numberOption(firstDefined(source, ['maxWidth', 'maxThickness']), DEFAULT_OUTLINE_SETTINGS.maxWidth, { min: 0, max: 0.05 }),
+    metalLightingMix: enabled ? roleNumber(source, 'metal', 'lightingMix', DEFAULT_OUTLINE_SETTINGS.metalLightingMix, [], { min: 0, max: 1 }) : DEFAULT_OUTLINE_SETTINGS.metalLightingMix,
+    metalMaxBrightness: roleNumber(source, 'metal', 'maxBrightness', DEFAULT_OUTLINE_SETTINGS.metalMaxBrightness, [], { min: 0, max: 2 }),
+    metalMinBrightness: roleNumber(source, 'metal', 'minBrightness', DEFAULT_OUTLINE_SETTINGS.metalMinBrightness, [], { min: 0, max: 2 }),
+    metalTintColor: roleColor(source, 'metal', 'tintColor', DEFAULT_OUTLINE_SETTINGS.metalTintColor),
+    metalWidth: enabled ? roleNumber(source, 'metal', 'width', DEFAULT_OUTLINE_SETTINGS.metalWidth, [], { min: 0, max: 0.05 }) : 0,
+    polygonOffset: source.polygonOffset === true,
+    polygonOffsetFactor: numberOption(firstDefined(source, ['polygonOffsetFactor']), DEFAULT_OUTLINE_SETTINGS.polygonOffsetFactor, { min: -64, max: 64 }),
+    polygonOffsetUnits: numberOption(firstDefined(source, ['polygonOffsetUnits']), DEFAULT_OUTLINE_SETTINGS.polygonOffsetUnits, { min: -1024, max: 1024 }),
+    referenceDistance: numberOption(
+      firstDefined(source, ['referenceDistance', 'widthReferenceDistance']),
+      DEFAULT_OUTLINE_SETTINGS.referenceDistance,
+      { min: 0.1, max: 100 },
+    ),
+    referenceFov: numberOption(
+      firstDefined(source, ['referenceFov', 'widthReferenceFov']),
+      DEFAULT_OUTLINE_SETTINGS.referenceFov,
+      { min: 5, max: 150 },
+    ),
+    screenSpaceWidth: numberOption(
+      firstDefined(source, ['screenSpaceWidth', 'screenSpaceWidthFix', 'widthDistanceFix']),
+      DEFAULT_OUTLINE_SETTINGS.screenSpaceWidth,
+      { min: 0, max: 1 },
+    ),
+    smoothNormals: firstDefined(source, ['smoothNormals', 'smoothedNormals', 'bakeSmoothNormals']) !== false,
+    widthFadeDistance: numberOption(
+      firstDefined(source, ['widthFadeDistance', 'maxWidthDistance', 'fadeDistance']),
+      DEFAULT_OUTLINE_SETTINGS.widthFadeDistance,
+      { min: 0.5, max: 200 },
+    ),
+    skinLightingMix: enabled ? roleNumber(source, 'skin', 'lightingMix', DEFAULT_OUTLINE_SETTINGS.skinLightingMix, [], { min: 0, max: 1 }) : DEFAULT_OUTLINE_SETTINGS.skinLightingMix,
+    skinMaxBrightness: roleNumber(source, 'skin', 'maxBrightness', DEFAULT_OUTLINE_SETTINGS.skinMaxBrightness, [], { min: 0, max: 2 }),
+    skinMinBrightness: roleNumber(source, 'skin', 'minBrightness', DEFAULT_OUTLINE_SETTINGS.skinMinBrightness, [], { min: 0, max: 2 }),
+    skinTintColor: roleColor(source, 'skin', 'tintColor', DEFAULT_OUTLINE_SETTINGS.skinTintColor),
+    skinWidth: enabled ? roleNumber(source, 'skin', 'width', DEFAULT_OUTLINE_SETTINGS.skinWidth, [], { min: 0, max: 0.05 }) : 0,
+    transparentOverlayWidth: enabled
+      ? numberOption(firstDefined(source, ['transparentOverlayWidth', 'overlayWidth', 'decalWidth']), DEFAULT_OUTLINE_SETTINGS.transparentOverlayWidth, { min: 0, max: 0.05 })
+      : 0,
+    widthScale: enabled
+      ? numberOption(firstDefined(source, ['widthScale', 'scale', 'thicknessScale']), DEFAULT_OUTLINE_SETTINGS.widthScale, { min: 0, max: 20 })
+      : 0,
+  };
+}
+
+export function resolveOutlineForMaterial(settings, {
+  alphaTest = -1,
+  isEye = false,
+  isFace = false,
+  isHair = false,
+  isMetal = false,
+  isSkin = false,
+  isTransparentOverlay = false,
+} = {}) {
+  let role = 'default';
+  if (isEye) role = 'eye';
+  else if (isFace) role = 'face';
+  else if (isSkin) role = 'skin';
+  else if (isHair) role = 'hair';
+  else if (isMetal) role = 'metal';
+
+  let width = role === 'hair' && alphaTest >= 0
+    ? settings.hairCutoutWidth
+    : roleValue(settings, role, 'width', settings.defaultWidth);
+
+  if (isTransparentOverlay) {
+    width = settings.transparentOverlayWidth;
+  }
+
+  width = Math.min(settings.maxWidth, Math.max(0, width * settings.widthScale));
+
+  return {
+    depthOffset: settings.depthOffset,
+    depthTest: settings.depthTest,
+    depthWrite: settings.depthWrite,
+    enabled: settings.enabled && width > 0,
+    lightingMix: roleValue(settings, role, 'lightingMix', settings.defaultLightingMix),
+    maxBrightness: roleValue(settings, role, 'maxBrightness', settings.defaultMaxBrightness),
+    minBrightness: roleValue(settings, role, 'minBrightness', settings.defaultMinBrightness),
+    polygonOffset: settings.polygonOffset,
+    polygonOffsetFactor: settings.polygonOffsetFactor,
+    polygonOffsetUnits: settings.polygonOffsetUnits,
+    referenceDistance: settings.referenceDistance,
+    referenceFov: settings.referenceFov,
+    screenSpaceWidth: settings.screenSpaceWidth,
+    smoothNormals: settings.smoothNormals,
+    widthFadeDistance: settings.widthFadeDistance,
+    skinTintColor: settings.skinTintColor,
+    skinTintStrength: 1,
+    tintColor: roleValue(settings, role, 'tintColor', settings.defaultTintColor),
+    width,
+  };
+}

package/src/toon/settings/perspectiveRemovalSettings.js

@@ -0,0 +1,60 @@
+// Perspective removal (portrait flattening).
+//
+// Re-divides the clip-space XY of vertices near the character's head by the
+// head center's view depth instead of their own W, progressively removing
+// perspective distortion in closeups — the anime-portrait "long lens" look
+// without moving the camera. Masked by a sphere around the tracked head bone
+// and a world-height fade so feet stay grounded in true perspective.
+//
+// Requires the runtime head tracker (characterRenderPasses); inert otherwise.
+// Note: extreme amounts can confuse CPU frustum culling because the GPU moves
+// vertices the CPU cannot see — character meshes in this project already
+// disable frustum culling, so this is safe here.
+
+export const DEFAULT_PERSPECTIVE_REMOVAL_SETTINGS = Object.freeze({
+  amount: 0,
+  enabled: false,
+  // Sphere radius (meters) around the head bone that receives the effect.
+  radius: 1.4,
+  // World-height fade: 0 at startHeight, full at endHeight.
+  startHeight: 0,
+  endHeight: 1,
+});
+
+function firstDefined(source, keys) {
+  for (const key of keys) {
+    if (source?.[key] !== undefined) return source[key];
+  }
+  return undefined;
+}
+
+function numberOption(value, fallback, { min = -Infinity, max = Infinity } = {}) {
+  const nextValue = Number(value);
+  if (!Number.isFinite(nextValue)) return fallback;
+  return Math.min(max, Math.max(min, nextValue));
+}
+
+function normalizePerspectiveRemovalOptions(options) {
+  if (options === false) return { enabled: false };
+  if (options === true) return { enabled: true };
+  if (typeof options === 'number') return { amount: options, enabled: options > 0 };
+  return options || {};
+}
+
+export function createPerspectiveRemovalSettings(options = null) {
+  const source = normalizePerspectiveRemovalOptions(options);
+  const requestedAmount = numberOption(
+    firstDefined(source, ['amount', 'strength', 'perspectiveRemovalAmount']),
+    DEFAULT_PERSPECTIVE_REMOVAL_SETTINGS.amount,
+    { min: 0, max: 1 },
+  );
+  const enabled = source.enabled === true || (source.enabled !== false && requestedAmount > 0);
+
+  return {
+    amount: enabled ? requestedAmount : 0,
+    enabled: enabled && requestedAmount > 0,
+    endHeight: numberOption(firstDefined(source, ['endHeight']), DEFAULT_PERSPECTIVE_REMOVAL_SETTINGS.endHeight, { min: -100, max: 1000 }),
+    radius: numberOption(firstDefined(source, ['radius']), DEFAULT_PERSPECTIVE_REMOVAL_SETTINGS.radius, { min: 0.05, max: 50 }),
+    startHeight: numberOption(firstDefined(source, ['startHeight']), DEFAULT_PERSPECTIVE_REMOVAL_SETTINGS.startHeight, { min: -100, max: 1000 }),
+  };
+}

package/src/toon/settings/rimLightSettings.js

@@ -0,0 +1,268 @@
+import * as THREE from 'three';
+
+export const RIM_LIGHT_MODES = Object.freeze({
+  fresnel: 'fresnel',
+  depthTexture: 'depthTexture',
+});
+
+export const RIM_LIGHT_MODE_VALUES = Object.freeze({
+  [RIM_LIGHT_MODES.fresnel]: 0,
+  [RIM_LIGHT_MODES.depthTexture]: 1,
+});
+
+export const DEFAULT_RIM_LIGHT_SETTINGS = Object.freeze({
+  blockByShadow: 0.65,
+  defaultIntensity: 0.13,
+  defaultTintColor: [0.82, 0.9, 1.0],
+  // Screen-space depth-sampled edge width, relative to the character.
+  // Only used in depthTexture mode; falls back to fresnel when no depth
+  // prepass is running, so the mode is safe as a default.
+  depthCloseWidthReduce: 1,
+  depthDottedLineFix: true,
+  depthFadeEndDistance: 30,
+  depthFadeRange: 1,
+  depthFadeStartDistance: 20,
+  depthMask3D: false,
+  depthSafeDistance: 1,
+  depthThresholdOffset: 0,
+  depthWidth: 1,
+  enabled: true,
+  eyeIntensity: 0.04,
+  faceIntensity: 0.13,
+  hairIntensity: 0.23,
+  midPoint: 0.48,
+  mixWithBaseMapColor: 0.35,
+  mode: RIM_LIGHT_MODES.depthTexture,
+  skinIntensity: 0.13,
+  softness: 0.1,
+});
+
+function firstDefined(source, keys) {
+  for (const key of keys) {
+    if (source?.[key] !== undefined) return source[key];
+  }
+  return undefined;
+}
+
+function numberOption(value, fallback, { min = -Infinity, max = Infinity } = {}) {
+  const nextValue = Number(value);
+  if (!Number.isFinite(nextValue)) return fallback;
+  return Math.min(max, Math.max(min, nextValue));
+}
+
+function colorOption(value, fallback) {
+  if (value?.isColor) return value.clone();
+
+  if (Array.isArray(value) && value.length >= 3) {
+    return new THREE.Color(
+      numberOption(value[0], fallback[0] ?? fallback.r ?? 1),
+      numberOption(value[1], fallback[1] ?? fallback.g ?? 1),
+      numberOption(value[2], fallback[2] ?? fallback.b ?? 1),
+    );
+  }
+
+  if (typeof value === 'object' && value !== null) {
+    return new THREE.Color(
+      numberOption(value.r ?? value.x, fallback[0] ?? fallback.r ?? 1),
+      numberOption(value.g ?? value.y, fallback[1] ?? fallback.g ?? 1),
+      numberOption(value.b ?? value.z, fallback[2] ?? fallback.b ?? 1),
+    );
+  }
+
+  if (typeof value === 'string' || typeof value === 'number') {
+    try {
+      return new THREE.Color(value);
+    } catch {
+      // Fall through to fallback.
+    }
+  }
+
+  return Array.isArray(fallback)
+    ? new THREE.Color(fallback[0], fallback[1], fallback[2])
+    : fallback.clone();
+}
+
+function enabledOption(value) {
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    return normalized !== 'off' && normalized !== 'none' && normalized !== 'false' && normalized !== '0';
+  }
+  return value !== false;
+}
+
+function normalizeRimLightOptions(options) {
+  if (options === false) return { enabled: false };
+  if (options === true) return { enabled: true };
+  if (typeof options === 'string') return { enabled: enabledOption(options) };
+  return options || {};
+}
+
+function roleNumber(source, role, property, fallback, aliases = [], bounds = {}) {
+  const rolePrefix = role ? `${role}${property[0].toUpperCase()}${property.slice(1)}` : property;
+  return numberOption(firstDefined(source, [rolePrefix, ...aliases]), fallback, bounds);
+}
+
+function rimModeOption(value, fallback) {
+  const key = String(value ?? '')
+    .trim()
+    .replace(/[\s_-]+/g, '')
+    .toLowerCase();
+  if (['depth', 'depthtexture', 'depthtex', 'screenspace', '2d'].includes(key)) {
+    return RIM_LIGHT_MODES.depthTexture;
+  }
+  if (['fresnel', 'classic', 'nov', '3d', 'legacy'].includes(key)) {
+    return RIM_LIGHT_MODES.fresnel;
+  }
+  return fallback;
+}
+
+export function createRimLightSettings(options = null) {
+  const source = normalizeRimLightOptions(options);
+  const enabled = enabledOption(source.enabled);
+  const defaultIntensity = enabled
+    ? roleNumber(
+      source,
+      'default',
+      'intensity',
+      DEFAULT_RIM_LIGHT_SETTINGS.defaultIntensity,
+      ['intensity', 'rimIntensity'],
+      { min: 0, max: 8 },
+    )
+    : 0;
+
+  return {
+    blockByShadow: enabled
+      ? roleNumber(
+        source,
+        '',
+        'blockByShadow',
+        DEFAULT_RIM_LIGHT_SETTINGS.blockByShadow,
+        ['rimBlockByShadow', 'shadowBlocking', 'shadowBlock'],
+        { min: 0, max: 1 },
+      )
+      : 0,
+    defaultIntensity,
+    defaultTintColor: colorOption(
+      firstDefined(source, ['tintColor', 'color', 'rimTintColor', 'defaultTintColor']),
+      DEFAULT_RIM_LIGHT_SETTINGS.defaultTintColor,
+    ),
+    depthCloseWidthReduce: numberOption(
+      firstDefined(source, ['depthCloseWidthReduce', 'closeWidthReduce']),
+      DEFAULT_RIM_LIGHT_SETTINGS.depthCloseWidthReduce,
+      { min: 0, max: 1 },
+    ),
+    depthDottedLineFix: firstDefined(source, ['depthDottedLineFix', 'dottedLineFix']) !== false,
+    depthFadeEndDistance: numberOption(
+      firstDefined(source, ['depthFadeEndDistance']),
+      DEFAULT_RIM_LIGHT_SETTINGS.depthFadeEndDistance,
+      { min: 0, max: 200 },
+    ),
+    depthFadeRange: numberOption(
+      firstDefined(source, ['depthFadeRange', 'depthRimFadeRange']),
+      DEFAULT_RIM_LIGHT_SETTINGS.depthFadeRange,
+      { min: 0.01, max: 20 },
+    ),
+    depthFadeStartDistance: numberOption(
+      firstDefined(source, ['depthFadeStartDistance']),
+      DEFAULT_RIM_LIGHT_SETTINGS.depthFadeStartDistance,
+      { min: 0, max: 200 },
+    ),
+    depthMask3D: firstDefined(source, ['depthMask3D', 'mask3D']) === true,
+    depthSafeDistance: numberOption(
+      firstDefined(source, ['depthSafeDistance', 'safeViewDistance']),
+      DEFAULT_RIM_LIGHT_SETTINGS.depthSafeDistance,
+      { min: 0.05, max: 10 },
+    ),
+    depthThresholdOffset: numberOption(
+      firstDefined(source, ['depthThresholdOffset', 'depthRimThresholdOffset']),
+      DEFAULT_RIM_LIGHT_SETTINGS.depthThresholdOffset,
+      { min: -0.05, max: 1 },
+    ),
+    depthWidth: numberOption(
+      firstDefined(source, ['depthWidth', 'depthRimWidth']),
+      DEFAULT_RIM_LIGHT_SETTINGS.depthWidth,
+      { min: 0, max: 8 },
+    ),
+    enabled,
+    eyeIntensity: enabled
+      ? roleNumber(source, 'eye', 'intensity', DEFAULT_RIM_LIGHT_SETTINGS.eyeIntensity, [], { min: 0, max: 8 })
+      : 0,
+    faceIntensity: enabled
+      ? roleNumber(source, 'face', 'intensity', DEFAULT_RIM_LIGHT_SETTINGS.faceIntensity, [], { min: 0, max: 8 })
+      : 0,
+    hairIntensity: enabled
+      ? roleNumber(source, 'hair', 'intensity', DEFAULT_RIM_LIGHT_SETTINGS.hairIntensity, [], { min: 0, max: 8 })
+      : 0,
+    midPoint: enabled
+      ? roleNumber(
+        source,
+        '',
+        'midPoint',
+        DEFAULT_RIM_LIGHT_SETTINGS.midPoint,
+        ['rimMidPoint', 'threshold', 'rimThreshold'],
+        { min: 0, max: 1 },
+      )
+      : DEFAULT_RIM_LIGHT_SETTINGS.midPoint,
+    mixWithBaseMapColor: enabled
+      ? roleNumber(
+        source,
+        '',
+        'mixWithBaseMapColor',
+        DEFAULT_RIM_LIGHT_SETTINGS.mixWithBaseMapColor,
+        ['rimMixWithBaseMapColor', 'albedoMix', 'baseColorMix'],
+        { min: 0, max: 1 },
+      )
+      : 0,
+    mode: rimModeOption(
+      firstDefined(source, ['mode', 'rimMode', 'technique']),
+      DEFAULT_RIM_LIGHT_SETTINGS.mode,
+    ),
+    skinIntensity: enabled
+      ? roleNumber(source, 'skin', 'intensity', DEFAULT_RIM_LIGHT_SETTINGS.skinIntensity, [], { min: 0, max: 8 })
+      : 0,
+    softness: enabled
+      ? roleNumber(
+        source,
+        '',
+        'softness',
+        DEFAULT_RIM_LIGHT_SETTINGS.softness,
+        ['rimSoftness', 'feather', 'rimFeather'],
+        { min: 0.001, max: 1 },
+      )
+      : DEFAULT_RIM_LIGHT_SETTINGS.softness,
+  };
+}
+
+export function resolveRimLightForMaterial(settings, {
+  isEye = false,
+  isFace = false,
+  isHair = false,
+  isOutline = false,
+  isSkin = false,
+} = {}) {
+  let intensity = settings.defaultIntensity;
+  if (isEye) intensity = settings.eyeIntensity;
+  else if (isFace) intensity = settings.faceIntensity;
+  else if (isSkin) intensity = settings.skinIntensity;
+  else if (isHair) intensity = settings.hairIntensity;
+
+  return {
+    blockByShadow: settings.blockByShadow,
+    depthCloseWidthReduce: settings.depthCloseWidthReduce,
+    depthDottedLineFix: settings.depthDottedLineFix,
+    depthFadeEndDistance: settings.depthFadeEndDistance,
+    depthFadeRange: settings.depthFadeRange,
+    depthFadeStartDistance: settings.depthFadeStartDistance,
+    depthMask3D: settings.depthMask3D,
+    depthSafeDistance: settings.depthSafeDistance,
+    depthThresholdOffset: settings.depthThresholdOffset,
+    depthWidth: settings.depthWidth,
+    enabled: settings.enabled && !isOutline && intensity > 0,
+    intensity,
+    midPoint: settings.midPoint,
+    mixWithBaseMapColor: settings.mixWithBaseMapColor,
+    modeValue: RIM_LIGHT_MODE_VALUES[settings.mode] ?? RIM_LIGHT_MODE_VALUES[RIM_LIGHT_MODES.depthTexture],
+    softness: settings.softness,
+    tintColor: settings.defaultTintColor,
+  };
+}