@forgeax/engine-render 0.1.7 → 0.1.20

package/src/index.ts

@@ -1,8 +1,8 @@
 // @forgeax/engine-render — AI-facing render vocabulary.
 //
 // The root is deliberately small: ECS render components, grouped closed
-// values, the renderer lifecycle/receipt contract, and the declarative
-// RenderFeature plan. Graph builders, prepared GPU state, pipeline
+// values, immutable frame facts, the renderer lifecycle/receipt contract, and
+// the declarative RenderFeature plan. Graph builders, prepared GPU state, pipeline
 // implementations, builtin feature factories, and diagnostic class names are
 // owner-local implementation details.
 
@@ -11,13 +11,20 @@ export {
   renderPipelineContribution,
   samplerContribution,
 } from './assets/asset-decoders';
-
+export { Atmosphere } from './components/atmosphere';
 // ECS render vocabulary and grouped closed values.
-export type { Antialias, BloomEnabled, CameraProjection, Tonemap } from './components/camera';
+export type {
+  Antialias,
+  BloomEnabled,
+  CameraData,
+  CameraProjection,
+  Tonemap,
+} from './components/camera';
 export {
   ANTIALIAS_FXAA,
   ANTIALIAS_MSAA,
   ANTIALIAS_NONE,
+  ANTIALIAS_TAA,
   BLOOM_DISABLED,
   BLOOM_ENABLED,
   CAMERA_PROJECTION_ORTHOGRAPHIC,
@@ -36,11 +43,13 @@ export {
   TONEMAP_REINHARD_EXTENDED,
 } from './components/camera';
 export * from './components/directional-light';
+export { Fog } from './components/fog';
 export { Instances, type InstancesData } from './components/instances';
 export { Layer } from './components/layer';
 export { Lines } from './components/lines';
 export * from './components/mesh-filter';
 export * from './components/mesh-renderer';
+export { MotionBlur } from './components/motion-blur';
 export { PointLight } from './components/point-light';
 export { PointLightShadow } from './components/point-light-shadow';
 export {
@@ -58,6 +67,7 @@ export {
 } from './components/skybox-background';
 export { Skylight } from './components/skylight';
 export { SortKey } from './components/sort-key';
+export type { SpotLightAuthoring, SpotLightProjector } from './components/spot-light';
 export { SpotLight } from './components/spot-light';
 export {
   Visibility,
@@ -65,9 +75,35 @@ export {
   VisibilityStateValue,
   visibilityStateFromU32,
 } from './components/visibility';
+export type {
+  EnvironmentInspection,
+  EnvironmentInspectionFailure,
+  EnvironmentInspectionGeneration,
+  EnvironmentInspectionStatus,
+} from './environment/inspection';
 // Public structured operation failure union. Concrete error classes stay
 // behind the Renderer Result/event boundary.
-export type { RenderError, RenderErrorCode } from './errors/render';
+export type {
+  RenderError,
+  RenderErrorCode,
+  SceneDataUnavailableDetail,
+  SceneDataUnavailableReason,
+} from './errors/render';
+export {
+  AtmosphereInvalidParameterError,
+  EnvironmentGenerationFailedError,
+  EnvironmentSourceConflictError,
+  FogCardinalityError,
+  OwnerStageFailedError,
+  SceneDataUnavailableError,
+  TaaCapsInsufficientError,
+} from './errors/render';
+export type {
+  EnvironmentFrame,
+  EnvironmentSource,
+  FogFrame,
+  FramePlan,
+} from './extract/environment';
 export {
   resolveVisibility,
   type VisibilityResolution,
@@ -75,6 +111,7 @@ export {
 } from './extract/visibility';
 export type {
   RenderFeatureLogicalTarget,
+  RenderFeatureMaterialShaderBindingContract,
   RenderFeaturePassDeclaration,
   RenderFeaturePlan,
   RenderFeaturePlanContext,
@@ -90,13 +127,24 @@ export type {
   RenderFeatureErrorDescriptor,
   RenderFeatureExtractContext,
   RenderFeatureHiddenEntityReport,
+  RenderFeatureShaderModuleMode,
   RenderFeatureStatus,
   RenderFeatureWorldVisibilitySnapshot,
 } from './features/types';
-export { Materials } from './materials';
+export type {
+  BloomInspection,
+  MotionBlurInspection,
+  MotionBlurInspectionStatus,
+  TransmissionInspection,
+} from './inspection-types';
+export { Materials, MaterialTransmissionContractError } from './materials';
 // The host-facing default is a stable profile value; implementation-only
 // pipeline helpers remain behind the package boundary.
-export { DEFAULT_STANDARD_PROFILE } from './pipeline/standard-profile';
+export {
+  DEFAULT_STANDARD_PROFILE,
+  type StandardVolumetricFogProfile,
+  type StandardVolumetricFogQuality,
+} from './pipeline/standard-profile';
 export { renderComponentsPlugin } from './plugin';
 export {
   admitPointsLines,
@@ -127,3 +175,52 @@ export type {
   RenderWorldLease,
 } from './render-contract';
 export { RENDER_PHASE_CATALOG } from './render-contract';
+export type {
+  TemporalInspectionInput,
+  TemporalInspectionStatus,
+} from './renderer-inspect';
+export type { TemporalInspection, TemporalResourceInspection } from './temporal/inspection';
+export {
+  SCENE_DATA_TEMPORAL_V1_DESCRIPTOR,
+  SCENE_DATA_TEMPORAL_V1_SCHEMA,
+  type SceneDataLane,
+  type SceneDataSchemaId,
+  type SceneDataTarget,
+  type SceneDataTemporalV1Descriptor,
+} from './temporal/scene-data';
+export {
+  createSceneDataCatalog,
+  type SceneDataAvailability,
+  type SceneDataCatalog,
+  type SceneDataCatalogOptions,
+  type SceneDataInspection,
+} from './temporal/scene-data-catalog';
+export type { TemporalView } from './temporal/view';
+export {
+  hasVolumetricFogCapability,
+  type IntegratedVolumeResource,
+  resolveIntegratedVolumeConsumer,
+  resolveSelectedVolumetricLight,
+  resolveVolumetricFogLightPair,
+  type VolumeConsumer,
+  type VolumetricFogLightKind,
+  type VolumetricFogLightPairResolution,
+  type VolumetricFogLightResolution,
+} from './volume/capability';
+export {
+  type ValidatedVolumetricFog,
+  type VolumeBounds,
+  type VolumeDensityBinding,
+  VolumetricFog,
+  type VolumetricFogAuthoring,
+  type VolumetricFogLightSelection,
+  validateVolumetricFog,
+} from './volume/component';
+export { extractVolumetricFog, type VolumetricFogExtract } from './volume/extract';
+export {
+  inspectVolumetricFog,
+  type VolumetricFogInspection,
+  type VolumetricFogInspectionInput,
+  type VolumetricFogInspectionStatus,
+  type VolumetricFogResourceStage,
+} from './volume/inspection';

package/src/inspection-types.ts

@@ -6,6 +6,24 @@
 
 import type { PointsLinesInspection } from './points-lines/inspection';
 
+export type BloomGraphStatus = 'empty' | 'valid' | 'invalid';
+
+export interface BloomInspection {
+  readonly graphStatus: BloomGraphStatus;
+  readonly enabled: boolean;
+  readonly targetCount: number;
+  readonly targetBytes: number;
+  readonly resourceCount: number;
+  readonly passCount: number;
+  readonly encodeCount: number;
+  readonly bindGroupCount: number;
+  readonly uploadCount: number;
+  readonly residentChildBytes: number;
+  readonly generation: number;
+  readonly state: 'off' | 'active' | 'retiring';
+}
+export type { TransmissionInspection } from './transmission/inspection';
+
 export interface BatchTopologyInspection {
   readonly revision: number;
   readonly batchCount: number;
@@ -47,6 +65,36 @@ export interface GpuDrivenProductionInspection {
   readonly cpuFallbackDrawItems: number;
 }
 
+/** Detached semantic descriptor for the Standard scene-temporal producer. */
+export interface TemporalTargetInspection {
+  readonly identity: 'standard-scene-temporal';
+  readonly producerId: 'forgeax::standard::scene-data';
+  readonly schema: 'forgeax::scene-data::temporal-v1';
+  readonly targetCount: 1;
+  readonly descriptor: {
+    readonly format: 'rgba16float';
+    readonly width: number;
+    readonly height: number;
+    readonly sampleCount: 1;
+    readonly bytes: number;
+  };
+}
+
+/** Detached, bounded Motion Blur facts; no graph, device, target, or history handle. */
+export type MotionBlurInspectionStatus = 'off' | 'active' | 'reset' | 'invalid';
+
+export interface MotionBlurInspection {
+  readonly enabled: boolean;
+  readonly status: MotionBlurInspectionStatus;
+  readonly shutterAngle: number;
+  readonly maxRadiusPixels: number;
+  readonly sampleCount: number;
+  readonly temporalDemand: 'none' | 'scene-data-temporal-v1';
+  readonly passName: 'motion-blur';
+  readonly historyWrites: 0;
+  readonly lastFailure?: 'invalid-params' | 'scene-data-unavailable';
+}
+
 export type RenderSceneResyncReason =
   | 'attach'
   | 'asset-catalog-changed'

package/src/internal.ts

@@ -7,3 +7,8 @@ export {
   type TilesetRuntimeError,
   type TilesetRuntimeErrorCode,
 } from '@forgeax/engine-assets-runtime';
+export {
+  type GraphTargetCaptureReadbackValidation,
+  validateGraphTargetCaptureReadback,
+} from './record/frame-snapshot';
+export { TemporalFrameCoordinator } from './temporal/frame-coordinator';

package/src/light-buffer-layout.ts

@@ -15,23 +15,24 @@
 //             PointLight in common.wgsl. -1 (0xFFFFFFFF) is the no-shadow
 //             sentinel — shader path samples shadow only when layer >= 0.
 //
-//   SpotLight (64 B / 16 floats):
+//   SpotLight (80 B / 20 floats):
 //     [ 0..2 ] position vec3<f32>
 //     [   3 ] invRangeSquared f32
 //     [ 4..6 ] color vec3<f32> (host-pre-multiplied)
 //     [   7 ] cosInner f32
 //     [ 8..10] direction vec3<f32> (raw outgoing vector)
 //     [  11 ] cosOuter f32
-//     [12..14] pad f32 = 0 (std430 vec4 stride alignment)
+//     [12] depthBias, [13] normalBias, [14] pcfKernelSize
 //     [  15 ] shadowAtlasTile i32 (sentinel -1 = unassigned/clipped; 0..3 = tile)
 //             — feat-20260625-spot-light-shadow-mapping M2 / w8 (D-4):
-//             SpotLight GPU struct had no free pad lane (8 lanes full), so the
-//             clip signal extends the struct to a 4th vec4 column. The lane is
-//             written i32 via an Int32Array view of the same backing
+//             SpotLight receiver controls occupy the 4th vec4 column. The tile
+//             lane is written i32 via an Int32Array view of the same backing
 //             ArrayBuffer; the shader reads `shadowAtlasTile: i32` from byte
 //             60..64 of struct SpotLight (common.wgsl). -1 (0xFFFFFFFF) is the
 //             unassigned/clipped sentinel — shader samples shadow only when
 //             tile >= 0. Mirrors point's slot-7 shadowAtlasLayer pattern.
+//     [  16 ] shadowIntensity f32 (default 1; [0,1] residual visibility)
+//     [17..19] std430 tail pad (the struct rounds to the next 16 B boundary)
 //
 // Array header (16 B, std430 stride alignment):
 //     [ 0 ] count u32 (number of valid slots in the trailing array)
@@ -69,13 +70,16 @@ import type { PointLightSnapshot, SpotLightSnapshot } from './render-system-extr
 //   [  11 ] cosOuter          f32         (point: 0.0)
 //   [  12 ] kind              u32         (POINT = 0, SPOT = 1)
 //   [  13 ] shadow identity   i32         (point layer / spot tile, -1 sentinel)
-//   [14..15] point depth       f32x2       (point near/far; spot zero)
+//   [14] point near / spot shadowIntensity f32
+//   [15] point far / spot pcfKernelSize f32
 //
 // Design: research Finding 1 (Bevy GpuClusteredLight 152B -> forgeax 64B),
 // plan-strategy D-light-slot (kind bit-tag discriminant).
 //
-// The existing URP PointLight (32B) / SpotLight (48B) pack functions remain
-// untouched; packLightSlot is the new HDRP-only entry.
+// The existing URP PointLight (32B) pack function remains unchanged; the URP
+// SpotLight grows from 64B to 80B to carry the independent shadow visibility
+// factor without stealing the tile or PCF lanes. packLightSlot remains the
+// compact 64B HDRP owner and uses a spot-only pad lane for the same value.
 
 /** Byte size of one HDRP LightSlot in std430 (16 x f32). AC-11 absolute-value lock. */
 export const BYTES_PER_LIGHT_SLOT = 64;
@@ -99,9 +103,11 @@ export type LightSlotKind = (typeof LightSlotKind)[keyof typeof LightSlotKind];
  * feat-20260612-point-light-shadows-urp-hdrp M4 / T-M4-4 (plan-strategy §D-8):
  * the prior u32x3 pad lanes at byte 52..64 carry shadow-side data on the HDRP
  * path. `kind_and_pad.x = kind` (u32), `.y = shadow identity` (i32, sentinel
- * -1 = no shadow), `.z = near` (f32 via bitcast), `.w = far`
- * (f32 via bitcast). The shader reads near/far through `bitcast<f32>(...)`
- * to keep the WGSL struct as `vec4<u32>` (alignment + naga_oil unchanged).
+ * -1 = no shadow). For point lights `.z/.w` carry near/far (f32 via bitcast);
+ * for spot lights `.z` carries shadowIntensity and `.w` carries the PCF
+ * kernel width (f32 via bitcast). The shader reads these lanes through
+ * `bitcast<f32>(...)` to
+ * keep the WGSL struct as `vec4<u32>` (alignment + naga_oil unchanged).
  */
 export const LIGHTSLOT_LAYOUT = {
   byteSize: BYTES_PER_LIGHT_SLOT,
@@ -117,6 +123,7 @@ export const LIGHTSLOT_LAYOUT = {
   shadowAtlasTileOffset: 52,
   shadowNearOffset: 56,
   shadowFarOffset: 60,
+  spotPcfKernelSizeOffset: 60,
   floatCount: 16,
   vec4Count: 4,
 } as const;
@@ -137,16 +144,18 @@ export const STORAGE_BUFFER_MIN_REQUIRED = 4;
 /** Byte size of one PointLight std430 slot (vec4 * 2). */
 export const POINT_LIGHT_STD430_BYTES = 32;
 /**
- * Byte size of one SpotLight std430 slot (vec4 * 4).
+ * Byte size of one SpotLight std430 slot (five 16-byte columns).
  *
- * feat-20260625-spot-light-shadow-mapping M2 / w8 (D-4): grew 48 -> 64 to make
- * room for the `shadowAtlasTile: i32` clip-signal lane (slot 15). Slots 0..11
- * keep the prior layout; slots 12..14 are vec4-alignment padding.
+ * feat-20260625-spot-light-shadow-mapping M2 / w8 (D-4) grew 48 -> 64 for
+ * `shadowAtlasTile`; the visual-parity contract then adds a fifth column for
+ * `shadowIntensity` rather than overloading the tile/PCF lanes.
  */
-export const SPOT_LIGHT_STD430_BYTES = 64;
+export const SPOT_LIGHT_STD430_BYTES = 80;
 
 /** Sentinel value for SpotLight slot[15] meaning "no shadow / clipped". */
 export const SPOT_LIGHT_SHADOW_TILE_SENTINEL = -1;
+/** Sentinel for a projector-only SpotLight with no shadow atlas tile. */
+export const SPOT_LIGHT_PROJECTOR_ONLY_SENTINEL = -2;
 /** Byte size of the array header (count u32 + 12 B pad to 16 B stride). */
 export const LIGHT_ARRAY_HEADER_BYTES = 16;
 /** Maximum number of slots packed in the first-slice cap layout (D-S3). */
@@ -182,7 +191,7 @@ export function packPointLight(snap: PointLightSnapshot): Float32Array {
 }
 
 /**
- * Pack one SpotLightSnapshot into 16 floats (64 B byte-for-byte std430).
+ * Pack one SpotLightSnapshot into 20 floats (80 B byte-for-byte std430).
  *
  * cosInner / cosOuter ride the otherwise-padding `.w` lanes of the
  * `color` and `direction` vec4 columns (AC-04 c + plan D-S2 16 B alignment
@@ -190,10 +199,13 @@ export function packPointLight(snap: PointLightSnapshot): Float32Array {
  * (sentinel -1 = unassigned/clipped, 0..3 = atlas tile) written through an
  * Int32Array view so the shader's `i32` read at byte 60..64 of struct SpotLight
  * (common.wgsl) sees the correct two's-complement bits (-1 = 0xFFFFFFFF).
- * Slots 12..14 stay zero (vec4-alignment padding). feat-20260625 M2 / w8 (D-4).
+ * Slots 12..14 carry the shared receiver controls; slot 15 remains the i32
+ * shadow tile sentinel; slot 16 carries shadowIntensity and slots 17..19 are
+ * alignment tail padding. Surface and volume consumers therefore share one
+ * extracted shadow configuration.
  */
 export function packSpotLight(snap: SpotLightSnapshot): Float32Array {
-  const out = new Float32Array(16);
+  const out = new Float32Array(20);
   out[0] = snap.position[0] ?? 0;
   out[1] = snap.position[1] ?? 0;
   out[2] = snap.position[2] ?? 0;
@@ -206,10 +218,20 @@ export function packSpotLight(snap: SpotLightSnapshot): Float32Array {
   out[9] = snap.direction[1] ?? 0;
   out[10] = snap.direction[2] ?? 0;
   out[11] = snap.cosOuter;
-  // Slots 12..14 stay zero (vec4-alignment padding).
+  out[12] = snap.depthBias ?? 0.005;
+  out[13] = snap.normalBias ?? 0.05;
+  out[14] = snap.pcfKernelSize ?? 3;
   // Slot 15: shadowAtlasTile i32 via Int32Array view (sentinel -1 default).
   const i32 = new Int32Array(out.buffer);
-  i32[15] = snap.shadowAtlasTile ?? SPOT_LIGHT_SHADOW_TILE_SENTINEL;
+  i32[15] =
+    snap.shadowAtlasTile >= 0
+      ? snap.shadowAtlasTile
+      : snap.projectorAsset !== undefined && snap.lightViewProj !== undefined
+        ? SPOT_LIGHT_PROJECTOR_ONLY_SENTINEL
+        : SPOT_LIGHT_SHADOW_TILE_SENTINEL;
+  // Slot 16 begins the fifth vec4 column. The remaining tail lanes stay zero
+  // so the std430 array stride is the explicit 80-byte contract.
+  out[16] = snap.shadowIntensity ?? 1;
   return out;
 }
 
@@ -275,8 +297,8 @@ export interface PointShadowSlotInfo {
  * feat-20260612-point-light-shadows-urp-hdrp M4 / T-M4-4 (plan-strategy §D-8):
  * the optional point `shadow` info threads through to bytes 52..64 as
  * `(shadowAtlasLayer i32, near f32, far f32)`. Spot snapshots write their
- * `shadowAtlasTile` directly into the same identity lane and keep near/far 0.
- * The shader reads `near`/`far`
+ * `shadowAtlasTile` directly into the same identity lane, put shadowIntensity
+ * in the `.z` lane, and the PCF kernel width in `.w`. The shader reads `near`/`far`
  * through `bitcast<f32>(kind_and_pad.zw)` so the WGSL struct stays
  * `kind_and_pad: vec4<u32>` (alignment + naga_oil compose unchanged). When
  * `shadow` is undefined (no PointLightShadow) the lanes default to
@@ -309,15 +331,26 @@ export function packLightSlot(
   // Float32Array: SPOT=1 must be 0x00000001, not f32(1.0) bits.
   const u32 = new Uint32Array(out.buffer);
   u32[12] = snap.kind === 'point' ? LightSlotKind.POINT : LightSlotKind.SPOT;
-  // Lanes 13..15 carry one kind-discriminated shadow identity. Point keeps
-  // layer/near/far; spot writes its snapshot tile and leaves near/far zero.
+  // Lanes 13..15 carry one kind-discriminated shadow payload. Point keeps
+  // layer/near/far; spot writes its snapshot tile, shadowIntensity, and PCF
+  // kernel width.
   const i32 = new Int32Array(out.buffer);
   if (snap.kind === 'point' && shadow !== undefined) {
     i32[13] = shadow.shadowAtlasLayer;
     out[14] = shadow.near;
     out[15] = shadow.far;
   } else if (snap.kind === 'spot') {
-    i32[13] = snap.shadowAtlasTile;
+    i32[13] =
+      snap.shadowAtlasTile >= 0
+        ? snap.shadowAtlasTile
+        : snap.projectorAsset !== undefined && snap.lightViewProj !== undefined
+          ? SPOT_LIGHT_PROJECTOR_ONLY_SENTINEL
+          : SPOT_LIGHT_SHADOW_TILE_SENTINEL;
+    out[14] = snap.shadowIntensity ?? 1;
+    // HDRP has no separate 80-byte SpotLight payload. Reuse the otherwise
+    // unused spot `.w` lane so the cluster path consumes the same authored PCF
+    // width as the URP and volume paths.
+    out[15] = snap.pcfKernelSize ?? 3;
   } else {
     i32[13] = POINT_LIGHT_SHADOW_LAYER_SENTINEL;
     // out[14] / out[15] remain zero (Float32Array zero-init).

package/src/materials.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA } from '@forgeax/engine-shader';
 import type {
   MaterialAsset,
   MaterialColorSpace,
@@ -7,6 +8,49 @@ import type {
   MaterialValue,
 } from '@forgeax/engine-types';
 
+export type MaterialTransmissionValidationReason =
+  | 'non-finite'
+  | 'range'
+  | 'shape'
+  | 'blend'
+  | 'depth-write';
+
+/** Structured authoring failure for the Standard transmission contract. */
+export class MaterialTransmissionContractError extends Error {
+  readonly code = 'material-transmission-contract-invalid' as const;
+  readonly expected = 'transmission material values satisfy finite ranges and Forward depth rules';
+  readonly hint =
+    'repair the named transmission value or pass state before publishing the material';
+  readonly detail: {
+    readonly code: 'material-transmission-contract-invalid';
+    readonly material: 'Standard';
+    readonly parameter:
+      | 'transmission'
+      | 'ior'
+      | 'thickness'
+      | 'attenuationColor'
+      | 'attenuationDistance';
+    readonly reason: MaterialTransmissionValidationReason;
+    readonly actual?: unknown;
+  };
+
+  constructor(
+    parameter: (typeof MaterialTransmissionContractError.prototype.detail)['parameter'],
+    reason: MaterialTransmissionValidationReason,
+    actual?: unknown,
+  ) {
+    super(`Materials.standard: ${parameter} violates the transmission contract (${reason})`);
+    this.name = 'MaterialTransmissionContractError';
+    this.detail = {
+      code: 'material-transmission-contract-invalid',
+      material: 'Standard',
+      parameter,
+      reason,
+      ...(actual === undefined ? {} : { actual }),
+    };
+  }
+}
+
 export const SPRITE_PREMULTIPLIED_ALPHA_BLEND: GPUBlendState = {
   color: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
   alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
@@ -31,28 +75,26 @@ function authoredColorParameter(
 }
 
 function standardParameters(colorSpace: MaterialColorSpace): readonly MaterialParameter[] {
-  return [
-    authoredColorParameter('baseColor', 'color', colorSpace),
-    { name: 'metallic', type: 'f32' },
-    { name: 'roughness', type: 'f32' },
-    { name: 'metallicChannel', type: 'f32', optional: true },
-    { name: 'roughnessChannel', type: 'f32', optional: true },
-    { name: 'aoChannel', type: 'f32', optional: true },
-    { name: 'extraChannel', type: 'f32', optional: true },
-    authoredColorParameter('emissive', 'vec3', colorSpace, true),
-    { name: 'emissiveIntensity', type: 'f32', optional: true },
-    { name: 'occlusionStrength', type: 'f32', optional: true },
-    { name: 'alphaCutoff', type: 'f32', optional: true },
-    { name: 'clearcoat', type: 'f32', optional: true },
-    { name: 'clearcoatRoughness', type: 'f32', optional: true },
-    authoredColorParameter('specularTint', 'vec3', colorSpace, true),
-    { name: 'baseColorTexture', type: 'texture', optional: true },
-    { name: 'metallicRoughnessTexture', type: 'texture', optional: true },
-    { name: 'normalTexture', type: 'texture', optional: true },
-    { name: 'specularTintTexture', type: 'texture', optional: true },
-    { name: 'emissiveTexture', type: 'texture', optional: true },
-    { name: 'occlusionTexture', type: 'texture', optional: true },
-  ];
+  return DEFAULT_STANDARD_PBR_PARAM_SCHEMA.map((entry) => {
+    const type = entry.type.startsWith('texture') ? 'texture' : entry.type;
+    const isRequired =
+      entry.name === 'baseColor' || entry.name === 'metallic' || entry.name === 'roughness';
+    const authoredColor =
+      entry.type === 'color' || (entry.type === 'vec3' && entry.name !== 'attenuationColor');
+    const schemaColorSpace = 'colorSpace' in entry ? entry.colorSpace : undefined;
+    const colorSpaceProjection: { colorSpace?: MaterialColorSpace } = {};
+    if (authoredColor && !(type === 'color' && colorSpace === 'srgb')) {
+      colorSpaceProjection.colorSpace = colorSpace;
+    } else if (!authoredColor && schemaColorSpace !== undefined) {
+      colorSpaceProjection.colorSpace = schemaColorSpace;
+    }
+    return {
+      name: entry.name,
+      type,
+      ...colorSpaceProjection,
+      ...(isRequired ? {} : { optional: true }),
+    } as MaterialParameter;
+  });
 }
 
 function unlitParameters(colorSpace: MaterialColorSpace): readonly MaterialParameter[] {
@@ -143,6 +185,13 @@ interface StandardOpts {
   readonly occlusionTexture?: MaterialValue;
   readonly occlusionStrength?: number;
   readonly alphaCutoff?: number;
+  readonly transmission?: number;
+  readonly transmissionTexture?: MaterialValue;
+  readonly ior?: number;
+  readonly thickness?: number;
+  readonly thicknessTexture?: MaterialValue;
+  readonly attenuationColor?: readonly [number, number, number];
+  readonly attenuationDistance?: number;
   readonly renderState?: MaterialRenderState;
   readonly castShadow?: boolean;
   readonly queue?: number;
@@ -157,6 +206,21 @@ function validateChannel(
   }
 }
 
+function validateFiniteRange(
+  name: 'transmission' | 'ior' | 'thickness' | 'attenuationDistance',
+  value: number | undefined,
+  minimum: number,
+  maximum?: number,
+): void {
+  if (value === undefined || !Number.isFinite(value)) {
+    if (value === undefined) return;
+    throw new MaterialTransmissionContractError(name, 'non-finite', value);
+  }
+  if (value < minimum || (maximum !== undefined && value > maximum)) {
+    throw new MaterialTransmissionContractError(name, 'range', value);
+  }
+}
+
 function standard(opts: StandardOpts): MaterialAsset {
   const occlusionStrength = opts.occlusionStrength ?? 1;
   if (occlusionStrength < 0 || occlusionStrength > 1) {
@@ -169,12 +233,36 @@ function standard(opts: StandardOpts): MaterialAsset {
   }
   validateChannel('metallicChannel', opts.metallicChannel);
   validateChannel('roughnessChannel', opts.roughnessChannel);
+  const transmission = opts.transmission ?? 0;
+  const ior = opts.ior ?? 1.5;
+  const thickness = opts.thickness ?? 0;
+  const attenuationColor = opts.attenuationColor ?? [1, 1, 1];
+  validateFiniteRange('transmission', transmission, 0, 1);
+  validateFiniteRange('ior', ior, 1);
+  validateFiniteRange('thickness', thickness, 0);
+  validateFiniteRange('attenuationDistance', opts.attenuationDistance, Number.MIN_VALUE);
+  if (
+    attenuationColor.length !== 3 ||
+    attenuationColor.some((value) => !Number.isFinite(value) || value < 0 || value > 1)
+  ) {
+    throw new MaterialTransmissionContractError('attenuationColor', 'shape', attenuationColor);
+  }
+  if (transmission > 0 && opts.renderState?.blend !== undefined) {
+    throw new MaterialTransmissionContractError('transmission', 'blend', opts.renderState.blend);
+  }
+  if (transmission > 0 && opts.renderState?.depthWriteEnabled === true) {
+    throw new MaterialTransmissionContractError('transmission', 'depth-write', true);
+  }
   const values: Record<string, MaterialValue> = {
     baseColor: opts.baseColor,
     metallic: opts.metallic ?? 0,
     roughness: opts.roughness ?? 0.5,
     occlusionStrength,
     specularTint: opts.specularTint ?? [1, 1, 1],
+    transmission,
+    ior,
+    thickness,
+    attenuationColor,
   };
   if (opts.metallicChannel !== undefined) values.metallicChannel = opts.metallicChannel;
   if (opts.roughnessChannel !== undefined) values.roughnessChannel = opts.roughnessChannel;
@@ -193,10 +281,17 @@ function standard(opts: StandardOpts): MaterialAsset {
     values.specularTintTexture = opts.specularTintTexture;
   }
   if (opts.alphaCutoff !== undefined) values.alphaCutoff = opts.alphaCutoff;
+  if (opts.transmissionTexture !== undefined) values.transmissionTexture = opts.transmissionTexture;
+  if (opts.thicknessTexture !== undefined) values.thicknessTexture = opts.thicknessTexture;
+  if (opts.attenuationDistance !== undefined) values.attenuationDistance = opts.attenuationDistance;
+  const forwardRenderState =
+    transmission > 0 ? { ...(opts.renderState ?? {}), depthWriteEnabled: false } : opts.renderState;
   const passes: [MaterialPass, ...MaterialPass[]] = [
-    pass('forward', STANDARD_MODULE, opts.renderState, 'fs_main', opts.queue),
-    pass('deferred', STANDARD_MODULE, opts.renderState, 'fs_gbuffer', opts.queue),
+    pass('forward', STANDARD_MODULE, forwardRenderState, 'fs_main', opts.queue),
   ];
+  if (transmission === 0) {
+    passes.push(pass('deferred', STANDARD_MODULE, opts.renderState, 'fs_gbuffer', opts.queue));
+  }
   if (opts.castShadow !== false) passes.push(pass('shadow-caster', STANDARD_MODULE, undefined));
   return {
     kind: 'material',