rayzee 10.0.0 → 11.0.0

package/src/TSL/Random.js

@@ -107,7 +107,7 @@ export const RandomPointInCircle = ( rngState ) => {
 //       +7  ground-catcher cosine BSDF   (ShadeKernel)
 //       +8  indirect-strategy direction  (LightsIndirect)
 //       +9  physical-sky sun disc        (LightsSampling)
-//   1D  +0  (free — was the {lights,BRDF} stochastic strategy pick)
+//   1D  +0  light kind for the picked shadow ray (LightsSampling lightPick, setting shadowRays)
 //       +1  emissive-triangle pick       (EmissiveSampling / LightBVHSampling)
 //       +2  BSDF lobe selection          (ShadeKernel)
 //       +3  Russian roulette             (PathTracerCore)
@@ -123,6 +123,8 @@ export const RandomPointInCircle = ( rngState ) => {
 //      +13  clearcoat lobe               (Clearcoat)
 //      +14  area/spot light phi          (LightsSampling)
 //      +15  light uv second component    (LightsSampling)
+//      +16  light path to connect to     (ConnectKernel, bidirectional)
+//      +17  light vertex on that path    (ConnectKernel, bidirectional)
 //
 // Stride is 32 rather than the ~16 in use so a new call site does not force a renumbering.
 // The index only keys a scramble seed, so spare slots cost nothing.
@@ -131,6 +133,8 @@ export const RandomPointInCircle = ( rngState ) => {
 // the next bounce's dimensions, so they live above AUX_BASE:
 //   AUX_BASE +  0..63   env-backdrop blur taps      (ShadeKernel)
 //   AUX_BASE + 64..    light reservoir, one dimension per scene light (LightsSampling)
+//   AUX_BASE + 2048..  light subpath emission (LightGenerateKernel); light paths draw at pixels
+//                      offset by LIGHT_PIXEL_ROW_OFFSET rows, so no camera path shares a sequence
 export const SAMPLER_DIMS_PER_BOUNCE = 32;
 export const SAMPLER_DIM_AUX_BASE = 4096;
 

package/src/TSL/SceneResources.js

@@ -0,0 +1,51 @@
+/**
+ * A renderer's own scene resources for its shaders: material texture buckets, the albedo maps alpha-cutout
+ * shadow rays read, gobo and IES textures, and the alpha-shadow switch. They ride in the build context of each
+ * kernel that reads them: a TSL function's body runs when its kernel compiles, often at the first dispatch, so
+ * module-level state was read from whichever renderer — or pipeline stage — had set it last.
+ *
+ * @typedef {Object} SceneResources
+ * @property {Array<Node>} srgbBuckets - sRGB material bucket texture nodes (albedo, emissive, sheen, specular colour)
+ * @property {Array<Node>} linearBuckets - linear material bucket texture nodes
+ * @property {?Array<Node>} shadowAlbedoMaps - sRGB buckets alpha-cutout shadow rays sample, or null
+ * @property {?Node} goboMaps - spot / directional gobo texture array, or null
+ * @property {?Node} iesProfiles - IES profile texture array, or null
+ * @property {?Node} alphaShadows - int uniform, 1 = shadow rays test texture alpha; null = never
+ * @property {?Object<string, boolean>} materialLayers - the MATERIAL_LAYERS some material uses; null = all of them
+ */
+
+import { context } from 'three/tsl';
+
+const KEY = 'rayzeeScene';
+
+/** Builds `node` (a kernel's root call) with these resources in its context. */
+export const withSceneResources = ( node, resources ) => context( node, { [ KEY ]: resources } );
+
+/**
+ * The resources of the kernel being built; call from a TSL function body with its builder.
+ * @returns {SceneResources}
+ */
+export function sceneResources( builder ) {
+
+	const resources = builder.context[ KEY ];
+	if ( ! resources ) throw new Error( 'this kernel samples scene resources: build its root with withSceneResources()' );
+	return resources;
+
+}
+
+/** The material layers a kernel compiles only while some material in its scene has them. */
+export const MATERIAL_LAYERS = Object.freeze( [ 'clearcoat', 'sheen', 'iridescence', 'anisotropy', 'subsurface', 'dispersion', 'diffuseTransmission' ] );
+
+/** Every layer compiled in. */
+export const ALL_MATERIAL_LAYERS = Object.freeze( Object.fromEntries( MATERIAL_LAYERS.map( ( layer ) => [ layer, true ] ) ) );
+
+/**
+ * The material layers the kernel being built compiles; call from a TSL function body with its builder. A layer no
+ * material uses is left out of every function that reads it. Outside a scene kernel (a test), every layer is in.
+ * @returns {Object<string, boolean>}
+ */
+export function materialLayers( builder ) {
+
+	return builder.context[ KEY ]?.materialLayers ?? ALL_MATERIAL_LAYERS;
+
+}