@forgeax/engine-shader 0.1.23 → 0.1.24

package/src/material-schemas.ts

@@ -1,4 +1,8 @@
 import type { ParamSchemaEntry } from '@forgeax/engine-types';
+import {
+  STANDARD_MATERIAL_PARAM_SCHEMA,
+  STANDARD_PHYSICAL_PARAMETER_NAMES,
+} from '@forgeax/engine-types';
 import {
   createStandardPbrArtifactReceipt,
   type MaterialShaderArtifactReceipt,
@@ -7,36 +11,67 @@ import {
 export const STANDARD_PBR_ALPHA_CUTOFF_DEFAULT = 0;
 
 /** Shared material contract for the standard PBR and skinned PBR shaders. */
-export const DEFAULT_STANDARD_PBR_PARAM_SCHEMA: readonly ParamSchemaEntry[] = [
-  { name: 'baseColor', type: 'color', default: [1, 1, 1, 1] },
-  { name: 'metallic', type: 'f32', default: 0 },
-  { name: 'roughness', type: 'f32', default: 0.5 },
-  { name: 'metallicChannel', type: 'f32', default: 2 },
-  { name: 'roughnessChannel', type: 'f32', default: 1 },
-  { name: 'aoChannel', type: 'f32', default: 0 },
-  { name: 'extraChannel', type: 'f32', default: 0 },
-  { name: 'emissive', type: 'vec3', colorSpace: 'srgb', default: [0, 0, 0] },
-  { name: 'emissiveIntensity', type: 'f32', default: 0 },
-  { name: 'occlusionStrength', type: 'f32', default: 1 },
-  { name: 'alphaCutoff', type: 'f32', default: STANDARD_PBR_ALPHA_CUTOFF_DEFAULT },
-  { name: 'clearcoat', type: 'f32', default: 0 },
-  { name: 'clearcoatRoughness', type: 'f32', default: 0.5 },
-  { name: 'specularTint', type: 'vec3', colorSpace: 'srgb', default: [1, 1, 1] },
-  { name: 'normalScale', type: 'f32', default: 1 },
-  { name: 'transmission', type: 'f32', default: 0 },
-  { name: 'ior', type: 'f32', default: 1.5 },
-  { name: 'thickness', type: 'f32', default: 0 },
-  { name: 'attenuationColor', type: 'vec3', colorSpace: 'linear', default: [1, 1, 1] },
-  { name: 'attenuationDistance', type: 'f32' },
-  { name: 'baseColorTexture', type: 'texture2d' },
-  { name: 'metallicRoughnessTexture', type: 'texture2d' },
-  { name: 'normalTexture', type: 'texture2d' },
-  { name: 'specularTintTexture', type: 'texture2d' },
-  { name: 'emissiveTexture', type: 'texture2d' },
-  { name: 'occlusionTexture', type: 'texture2d' },
-  { name: 'transmissionTexture', type: 'texture2d' },
-  { name: 'thicknessTexture', type: 'texture2d' },
-];
+export const DEFAULT_STANDARD_PBR_PARAM_SCHEMA = STANDARD_MATERIAL_PARAM_SCHEMA;
+
+export type { StandardPhysicalTextureField } from '@forgeax/engine-types';
+/**
+ * Backward-compatible export name for callers that need the physical
+ * projection.  Every entry is selected from the Standard root schema above;
+ * no independent defaults or binding inventory can drift from it.
+ */
+/**
+ * Stable physical texture injection order.  The order is part of the
+ * Standard template's resource ABI and is derived from the root schema by
+ * `standardPhysicalTextureFields`; render/cook must not maintain another
+ * field inventory.
+ */
+export {
+  STANDARD_PHYSICAL_TEXTURE_FIELDS,
+  standardPhysicalTextureFields,
+} from '@forgeax/engine-types';
+
+export const STANDARD_PHYSICAL_LAYER_PARAM_SCHEMA: readonly ParamSchemaEntry[] =
+  DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter((entry) =>
+    STANDARD_PHYSICAL_PARAMETER_NAMES.has(entry.name),
+  );
+
+/**
+ * Canonical static Standard entry.  It deliberately contains only the base
+ * contract (including the specular extension) so a base-only material keeps
+ * its Deferred path and carries no second-stage physical resources.
+ */
+export const STANDARD_BASE_PARAM_SCHEMA: readonly ParamSchemaEntry[] =
+  DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter(
+    (entry) =>
+      !STANDARD_PHYSICAL_PARAMETER_NAMES.has(entry.name) &&
+      ![
+        'transmission',
+        'thickness',
+        'attenuationColor',
+        'attenuationDistance',
+        'transmissionTexture',
+        'thicknessTexture',
+      ].includes(entry.name),
+  );
+
+/**
+ * Canonical boot-time user region for the shared Standard material BGL.
+ *
+ * It is still a projection of the root schema, but unlike the author-facing
+ * base-only projection it retains the pre-existing transmission texture pair.
+ * The template reserves those two pairs before the IBL/backdrop injection so
+ * a base-only shader and a transmissive shader can share one boot layout;
+ * physical texture pairs are never included here and are appended only for a
+ * root contract that declares them.
+ */
+export const STANDARD_PIPELINE_PARAM_SCHEMA: readonly ParamSchemaEntry[] =
+  DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter(
+    // The canonical Standard UBO keeps every numeric root coordinate,
+    // including the physical-layer tail. Physical map pairs are engine-owned
+    // resources and are injected after the stable user region.
+    (entry) =>
+      !(STANDARD_PHYSICAL_PARAMETER_NAMES.has(entry.name) && entry.type.startsWith('texture')),
+  );
 
 /** The single producer receipt shared by direct and scene-index Standard PBR. */
 export const STANDARD_PBR_ARTIFACT_RECEIPT: MaterialShaderArtifactReceipt =

package/src/register-default-standard-pbr-skin.ts

@@ -13,7 +13,7 @@
 //   - R-10: paramSchema reuses default-standard-pbr schema (same params)
 
 import type { ShaderRegistry } from './index.js';
-import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA } from './material-schemas.js';
+import { STANDARD_PIPELINE_PARAM_SCHEMA } from './material-schemas.js';
 
 /**
  * paramSchema for forgeax::pbr-skin — mirrors default-standard-pbr 8 fields.
@@ -69,6 +69,6 @@ export function registerDefaultStandardPbrSkin(
   void caps;
   registry.installMaterialArtifact(RESERVED_ID, {
     source: composedWgsl,
-    paramSchema: DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
+    paramSchema: STANDARD_PIPELINE_PARAM_SCHEMA,
   });
 }

package/src/standard-cluster.wgsl

@@ -9,18 +9,11 @@
 #define_import_path forgeax_standard::cluster
 
 #import forgeax_pbr::lighting_punctual::{evalPoint, evalPointFlat, evalSpot, evalSpotFlat, evalSpotShadowed}
-#import forgeax_pbr::lighting_attenuation::{projectSpotUv}
 #import forgeax_pbr::lighting_spot_modifiers::{spotModifierFactors}
 #import forgeax_pbr::lighting_rect_area::{evalRectAreaLtcGgx}
 #import forgeax_view::common::{view}
 #ifdef PROJECTOR_AVAILABLE
-#ifdef EXTENDED_LIGHTING_AVAILABLE
-#import forgeax_view::common::{spotModifierSampler, cookieTexture}
-#else
-#ifndef EXTENDED_LIGHTING_AVAILABLE
-#import forgeax_view::common::{projectorTexture, projectorSampler}
-#endif
-#endif
+#import forgeax_pbr::lighting_spot_projector::{sampleStandardSpotProjector}
 #endif
 #ifdef POINT_SHADOW_AVAILABLE
 #import forgeax_pbr::lighting_punctual::{evalPointShadowed}
@@ -95,34 +88,6 @@ fn ndc_position_to_cluster(
   return vec3(cx, cy, cz);
 }
 
-// Surface SpotLight projector sampling is owned by the same clustered light
-// evaluator as the analytic cone/range contribution. The host marks the
-// selected projector in the DirectLightSlot flag and writes its matrix to the
-// corresponding View lane (lane 0 for projector-only); no second
-// material-local sampling loop or resource owner is allowed.
-fn sampleStandardSpotProjector(
-  lightViewProj : mat4x4<f32>,
-  world_pos    : vec3<f32>,
-  metadata     : vec4<u32>,
-) -> vec3<f32> {
-#ifdef PROJECTOR_AVAILABLE
-  let uv = projectSpotUv(lightViewProj, world_pos);
-  if (!(uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0)) {
-    return vec3<f32>(1.0);
-  }
-#ifdef EXTENDED_LIGHTING_AVAILABLE
-  if (metadata.w == 0xffffffffu) {
-    return vec3<f32>(1.0);
-  }
-  return textureSampleLevel(cookieTexture, spotModifierSampler, uv, metadata.w, 0.0).rgb;
-#else
-  return textureSampleLevel(projectorTexture, projectorSampler, uv, 0.0).rgb;
-#endif
-#else
-  return vec3<f32>(1.0);
-#endif
-}
-
 // Decode one kind first, then delegate the complete evaluation to the shared
 // punctual owner. Unknown kinds are explicitly zero contribution.
 fn evaluate_cluster_light(

package/src/surface_v1.wgsl

@@ -0,0 +1,26 @@
+#define_import_path forgeax_material::surface_v1
+
+// Engine-owned input ABI for authored Standard material surfaces.
+struct SurfaceInput {
+  positionOS : vec3<f32>,
+  positionWS : vec3<f32>,
+  geometricNormalWS : vec3<f32>,
+  tangentWS : vec4<f32>,
+  viewDirectionWS : vec3<f32>,
+  uv0 : vec2<f32>,
+  uv1 : vec2<f32>,
+  vertexColor : vec4<f32>,
+  frontFacing : bool,
+};
+
+// Surface output is consumed by the Standard BRDF and pass family.
+struct SurfaceData {
+  baseColor : vec3<f32>,
+  normalWS : vec3<f32>,
+  metallic : f32,
+  roughness : f32,
+  emissive : vec3<f32>,
+  occlusion : f32,
+  opacity : f32,
+  alphaClipThreshold : f32,
+};