module Implementation

A8 texture sampler.

Return all light types.

BoxSpotlight class used by extended input lighting.

Cached data for box spotlight.

Selects the Cached type for the input light.

Selects the Cached type for the input light.

Cached Lights writer.

By default, light types do not support quickshade.

Specialization to enable QuickShade on this light type.

Enlighten internal class for per material dynamic updates.

Enlighten internal implementation for cluster albedo materials.

Number of dusters and a material index which is assigned to them.

Precompute data block detailing a buffer of ClusterProbeBounceSamples (internal).

Cluster probe bounce sample (internal).

Precompute data block detailing probe transparency sample data (internal).

Const LightValue iterator. This contains the logic for iterating over LightValue64 or LightValue128 arrays.

Count light size.

CPU texture sampler base class.

A class used to apply cluster-light level culling.

A class used to apply clustergroup-light level culling.

Struct to iterate over the lights of a particular type, applying the culling operation.

Terminator for CullingIterator.

A class used to apply system-light level culling.

The default transparency sampler.

DirectionalLight class used by extended input lighting.

Cached data for DirectionalLight.

Enlighten object used for dynamic material updates at runtime.

Return all types except quick shade lights.

FP16 texture sampler.

FrustumLight class used by extended input lighting.

Cached data for FrustumLight.

Hash lights functor.

A buffer containing the incident lighting for a system's input sample points (internal).

A class containing the parameters to be used as input to the internal indirect input lighting stage.

A single frame of the InputWorkspace lighting (internal).

This class is used to iterate through the duster samples in order to get a InputWorkspaceDebugPoint.

Runtime data about the quad approximations to clusters used for radiosity computations for dynamic systems (internal).

Runtime data about the dusters (internal).

The light table stores the falloff model of a light.

Selects the input light type.

Selects the input light type.

A class which represents a group of a particular type of lights.

Convenience value type for a half precision lighting value.

LightValue iterator. This contains the logic for iterating over LightValue64 or LightValue128 arrays.

LRB texture sampler.

Albedo sampler read the cluster albedo after all the quads have been sampled.

Emissive sampler reads the emissive for the cluster.

Storage of mappings between "old" u64 material IDs and "new" instance, mesh and material GUIDs.

Stored data for a geometry.

Stored data for an instance.

Stored data for a material-guid mapping.

Stored data for a mesh.

Material sampler reads albedo, emissive and transparency for the cluster.

Transparency sampler reads the transparency for the cluster.

A transparency sampler which samples the transparency as opaque.

An emissive material sampler which returns black.

A transparency sampler which samples the transparency as opaque.

A base implementation for a sampler that does nothing.

Surroundings sampler that always returns zero.

This class contains the positions and normals of 4 duster points (internal).

Enlighten internal class for storing a pixel index within an albedo or emissive texture.

PointLight class used by extended input lighting.

Cached data for point light.

Enumeration for the precision hint. The hint is used depending on whether the option is supported on the platform.

Workspace used for probe bounce (internal).

Quad iterator class applies the samplers to a set of quads for a given cluster.

The QuadShader class is responsible for unpacking the quad positions and normal during the constructor call and then later it will then iterate through a given set of lights shading the extracted quad.

The QuickFlatClusterShader class is responsible for unpacking a single normal during the constructor call and then later it will then iterate through a given set of lights shading the extracted normal.

The QuickQuadShader class is responsible for unpacking four quad normals during the constructor call and then later it will then iterate through a given set of lights shading the extracted normals.

Return only quick shade light types.

R11G11B10 texture sampler.

R9G9B9E5 texture sampler.

Compressed description of the input cluster tree.

RectangleLight class used by extended input lighting.

Cached data for rectangle light.

RGBA texture sampler.

RGBM texture sampler.

Selector which selects all lights.

Selector which selects culled lights.

Selector which selects unculled lights.

Visitor operator used to shade four samples for each light type.

Visitor operator used to shade the quad for each light type.

A class used to produce a sorted, culled list of lights.

Sorted lights operator interface.

Sorted lights visibility index writer.

Visitor construct to apply each operator to the relevant light types.

Terminator condition for light visitor.

Spotlight class used by extended input lighting.

Cached data for spotlights.

A struct used to apply a transform to a bounding box.

Surroundings sampler for transparency.

Workspace used for authored destruction of lightmapped geometry (internal).

Convert from type enum to concrete type Put this above the light type includes so the specialisations can go in the same file.

Specialization to convert Light type enumeration to concrete type.

Specialization to convert Light type enumeration to concrete type.

Specialization to convert Light type enumeration to concrete type.

Specialization to convert Light type enumeration to concrete type.

Specialization to convert Light type enumeration to concrete type.

Specialization to convert Light type enumeration to concrete type.

Specialization to convert Light type enumeration to concrete type.

Specialization to convert Light type enumeration to concrete type.

Specialization to convert Light type enumeration to concrete type.

Encapsulation of light visibility information.

Visit the lights of a particular type. Do this recursively.

Visitor terminator.

Visitor for selected lights.

Visitor for selected lights.

This is the number of copies of lightcount pointers we have in the LightDataStack member of InputWorkspaceData in the lighting internals.

Light falloff constants for the function: index = (((samples - 1.0) / (samples - 2.0)) / (1.0 / (samples - 2.0) + d * d);.

Light falloff constants for the function: index = (((samples - 1.0) / (samples - 2.0)) / (1.0 / (samples - 2.0) + d * d);.

Light falloff constants for the function: index = (((samples - 1.0) / (samples - 2.0)) / (1.0 / (samples - 2.0) + d * d);.

Convenience value type for a full precision lighting value.

Material component for albedo.

Material component for emissive.

Material component for transparency.

Calculate the maximum memory required to hold the lights table.

Calculate how much scratchspace memory will be required by the DoDirectInputLighting() function given the lights to be shaded.

Shift by half pixel is needed so that the interpolation code (SampleBilinear) interpolates between correct pixels.

Calculate the size of the cached lighting data.

Create the buffer of lights sorted by type.

Do the internal direct input lighting stage.

Do the internal indirect input lighting stage.

Go through all the sorted lights generating the CachedData for each. Also modifies sortedLights to point to the cached data.

Generate the CacheData for a specific light type.

Specialisation for invalid light types - does nothing.

Helper template to get the zero value of different types.

Helper template to get the zero value of floats.

Helper template to get the zero value of v128s.

common light falloff function used by spot and point lights, computes four lights at a time

Bitwise AND of two dynamic material workspace statuses.

Bitwise OR of two dynamic material workspace statuses.

Bitwise NOT of a dynamic material workspace status.

Quantise the ValueType value based on the ColourType storage.

Samples the given texture at the given co-ordinates, using bilinear filtering.

Selects albedo, emissive, transparency and surroundings.

Selects emissive, transparency and surroundings.

Selects samplers and does indirect input lighting.

Selects surroundings.

Selects transparency and surroundings.

Construct from another SortedLights while applying culling.

Visitor function to apply the visitor functor to each light.

Visits the selected lights with the given visitor.

Write the sorted lights to memory.

Number of lights in the world

An array of pointers to input lights.

The number of light pointers in the array.

each level of culling requires an additional copy of the SortedLights structure.

An unsorted array of pointers to lights

An unsorted array of pointers to visbility buffers. The pointers must correspond to their respective lights in the lights array.

The number of entries in the lights and visibilityPointers arrays.

A pointer to memory where the SortedLights buffer will be constructed.

The size of the bankScratchspace memory. (Reserved for future use)

The size of the buffer required to hold the CachedData objects for the given array of lights.

A pointer to a complete DirectInputLightingParameters object.

A pointer to allocated scratchspace memory.

The size of the scratchspace memory calculated with CalcRequiredScratchSpaceMemory function.

An internal transformation operand.

A pointer to a complete IndirectInputLightingParameters object.

A valid SortedLights buffer created though a call to CreateSortedLights()

A pointer to memory where the CachedData of the sorted lights will be written to.