A8 texture sampler.

Return all light types.

Class to store a normalised single channel value in 1 byte.

A thread group which executes Enlighten tasks by calling the AsyncTaskCallback a given number of times, and uses GeoEvent signalling to wait until all threads have completed execution.

Automatic Probe Volumes Placement.

Parameters to be enqueued for a SetBakedProbeOutput() command The pointer contents will be copied; when the command has executed the original data may be released.

The input light type for baking.

Data about a mesh, used as a parameter to IBakeInputSystem::AddMesh.

Texture object for the Baking.

The material description for baking.

Base Albedo Handler.

Base class used by the update manager to hold all of the resources for a cube map (regardless of where the solving happens).

Base class which holds everything a dynamic object must have (regardless of where the solving happens).

Trivial base class used to lend a base type to environment maps.

Public interface for querying common metadata of a single light (shared by spotlights, point lights etc.).

Class used by the update manager to hold all of the resources for a probe set together.

Base class which holds everything a system must have (regardless of where the solving happens).

Base implementation of ISystemSolutionSpace.

Base implementation of the IUpdateManager interface. All update managers derive from this class.

Base implementation of the worker class, containing functionality common to all platforms.

Bounding box in 2D.

BoxSpotlight class used by extended input lighting.

Box volume primitive.

Selects the Cached type for the input light.

Cached Lights writer.

===============================

An object that can be called to enqueue a command

By default, light types do not support quickshade.

Specialization to enable QuickShade on this light type.

Constitutes the precomputed material data for a system.

Enlighten internal class for per material dynamic updates.

Enlighten internal implementation for cluster albedo materials.

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

Cluster probe bounce sample (internal).

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

The ClusterRange describes a range of leaf clusters that belong to a certain cluster in the tree.

Basic interface for commands to be executed on the worker thread.

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

Parameters to be enqueued for a CopyInputLightingBuffer() command.

Parameters to be enqueued for a CopyInputLightingBuffer() command.

Parameters to be enqueued for a CopyInputLightingBuffer() command.

Parameters to be enqueued for the CopyEmissiveEnvironment() command.

Parameters to be enqueued for a CopyInputLightingBuffer() command.

Parameters to be enqueued for a CopyProbeOutputInfo() command.

Parameters to be enqueued for a CopyRawOutput() command.

Parameters to be enqueued for a CopyMaterialTransparencyBuffer() or CopyGeometryTransparencyBuffer() command.

Parameters to be enqueued for a CopyVisibilityBuffer() command.

Count light size.

Implementation of BaseAlbedoHandler for the CPU solver.

Derived class of BaseCubeMap used by the CPU and console update managers.

Implementation of BaseDynamicObject for Cpu Solving.

Class used by the CPU and console update managers to represent an environment map.

System for the CPU solver.

System solution space for the CPU solver.

CPU texture sampler base class.

Base class update managers for Enlighten that perform updates on the CPU, and aren't blocking the rendering thread.

Implementation of the worker class, containing functionality common to all platforms which solve radiosity on a CPU or SPU.

A CubeMap data block which contains the precompute data required by Enlighten at runtime.

Public interface for querying metadata of a single cube map.

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.

Default implementation of IThreadGroup which executes tasks serially on the calling thread (the worker thread).

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

DirectionalLight class used by extended input lighting.

Public interface for querying common metadata of a single directional light.

Implementation for managing solver output and Dx11 GPU textures.

Implementation for managing solver output and Dx9 GPU textures.

Enlighten object used for dynamic material updates at runtime.

Class representing the local bounding box and corresponding output probe resolution of a dynamic object, so that it can be lit with volume textures of SH probe data.

The different ways a mesh can be lit by Enlighten.

A generic Enlighten data block.

A container for Enlighten runtime profile statistics.

A task to be executed by a TaskProcessor. It consists of a task type and an object pointer.

An EntireProbeSetTask solves an entire set of probes as an atomic block.

Public interface for querying common metadata of a single environment light.

Return all types except quick shade lights.

This is a model class, which can currently only be a plane or a cylinder.

Simple implementation of ILimiter which prevents new tasks from starting after a fixed time has elapsed from the start of UpdateRadiosity().

FP16 texture sampler.

FrustumLight class used by extended input lighting.

=============================== Callable object (incl.

Generic class to store an array of values for a given system.

Debugging output representation of a value in the clustering metric.

Debugging output representation of a set of clustering metric hierarchies.

Debugging output representation of a hierarchy of clustering metrics.

Debugging output representation of a point with a normal.

A Geometry data block which contains the precompute data required by Enlighten at runtime.

Public interface for querying metadata of a single geom mesh.

Public interface for querying metadata of a single geom.

Debugging output representation of a ray origin.

Implementation for managing solver output and OpenGL GPU textures.

Concrete implementation of IGpuTexture.

Hash lights functor.

Async task interface.

The Low Level Enlighten Baking API.

Interface for providing lighting normals for the geometry.

Interface for providing tangents for the geometry.

Interface for providing tangents for the geometry.

Input lighting for the offline baking; mainly a collection of EnlightenLight structures.

The material descriptions for a bake system. This will have a BakeMaterialInfo for each facegroup in each mesh in each geometry, with optional overrides per-instance.

Interface for providing lighting normals for the mesh.

Interface for providing tangents for the mesh.

Interface for providing tangents for the mesh.

Bake properties class, used by calculation tasks to hold global and task specific data.

The ray origin positions for all systems.

The Enlighten runtime objects; RadDataCore, InputWorkspace, et al.

A triangle list and GBuffer of the incoming system.

Baking output for a probe set.

Baking output for per light visibility.

Baking output for ambient occlusion.

Baking output for direct lighting.

Baking output for indirect lighting from Final Gather.

Baking output for indirect lighting.

Baking output for radiosity normal texture.

Baking output for per light visibility.

Material textures for the albedo and emissive channels, in Enlighten UV space.

Interface for providing radiosity output for systems and probesets for baking.

System data for baking.

Interface for providing and caching textures.

Visibility information for a light map.

An interface for diagnosing the quality and any issues with the clustering process in EnlightenPrecomp2.

IGpuTexture is the main interface used by the HLRT to keep track of output textures.

Interface which enables Enlighten to allocate GPU textures to hold the solved output.

IGpuTextureUpdater is the interface used by the HLRT to manage Enlighten solver output and associated GPU texture resources.

An interface for diagnosing the quality and any issues with the light transport process in EnlightenPrecomp2.

Interface which can prevent Enlighten tasks from starting in the current call to UpdateRadiosity.

Implement this interface to receive messages from Enlighten.

An interface for diagnosing the quality and any issues with the mesh simplification process in EnlightenPrecomp2.

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 class containing the parameters to be used as input to the indirect input lighting stage.

A set of regions of the indirection texture, one per clipmap level.

A base class all light types must derive from to work with any input lighting API.

Class encapsulating the description of a light falloff curve.

A single frame of the InputWorkspace lighting (internal).

Builds an octree.

A class containing the parameters to be used as input to the albedo/emissive/transparency sampling stage.

Constitutes the core precomputed data for the input lighting generation for a system.

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

A structure for receiving the data held internally about a duster point for debugging visualisation purposes.

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

Runtime data about the dusters (internal).

A data block that describes essential properties of an input workspace.

Minimal description of an instance.

The light table stores the falloff model of a light.

Data structure describing a point in space to receive interpolated probe output.

Data structure describing the inputs and outputs of a probe set to be used as input data for interpolation.

User callbacks to handle updates to pppi textures.

A class containing various parameters and dials for the system level precompute process.

Precompute parameters for cube maps.

A class containing a data block that is used by the run-time to generate cube maps.

Handle to the depth cube map data.

Result of the the IPrecompute::CreateSystemsByVoxelisation() call.

A class representing a cube map object which the run-time can generate dynamically.

Handle to the InputGeometry.

A collection of item dependencies.

The standard precompute mesh input class.

Represents a region of 3D space within which sets of probe positions are adaptively generated.

Represents a region of 3D space voxelized at various resolutions.

A class representing a set of sample points for which the run-time can generate spherical harmonic representations of the diffuse light incident on each sample point.

Handle to the InputSystem.

An interface containing methods for analyzing meshes.

Handle to the precompute output data for cube maps.

A class representing an octree which defines sets of probe positions within a volume.

Handle to the LightTransport data for probesets.

Handle to the PackedGeometry.

Handle to the PackedInstance.

Class encapsulating the geometry and additional data for a system, light-mapped or otherwise.

A class defining parameters for SH sample probe building.

A class containing a set of data blocks that are used by the run-time to generate SH representations for the related IPrecompInputProbeSet.

Handle to the radiosity normal texture.

Handle to the SystemClustering.

Handle to a compressed SystemLightTransport.

Handle to the SystemDependencies.

Handle to the platform-agnostic input sample points (dusters).

Handle to the SystemLightTransport.

Handle to the SystemPreClustering.

Handle to the SystemRadiosity.

Holds IPrecompSystemDependencies for multiple systems.

The Low Level Enlighten Precompute API.

The Interface to CubeMap data.

The Interface to Geometry data.

The Interface to ProbeSet data.

The Interface to System data.

A class representing a region of 3D space which can be tested for intersection against an axis-aligned box.

Probe Set Manager interface class.

Irradiance and directional irradiance output capture.

A solution space for a system.

Interface through which MultithreadCpuWorker runs tasks on multiple threads in parallel.

This class is the base interface for the singleton object which manages all of the Enlighten updates for the systems and lights in the world, according to the current update strategy, solve type and albedo type.

Interface of the update manager worker.

A view volume implemented by the application.

Light Method Selector.

Selects the input light type.

Debugging output representation of an output pixel.

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.

A line in 2D defined by two points.

A 4-element colour stored in linear color space.

LRB texture sampler.

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

MaterialComponentBuffer type interface.

Emissive sampler reads the emissive for the cluster.

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

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

Transparency sampler reads the transparency for the cluster.

This is the very basic geometry description we operate on.

This is a cache of some various group-related data for use while merging charts.

Details of how the old groups have been merged into new groups.

Parameters controlling the model fitting.

Stats from the result of the merge.

Parameters controlling the merge behaviour of a particular tri group.

A compact block of Enlighten scene metadata providing efficient queries.

Builds compact blocks of metadata which can be loaded by the Enlighten3Meta library.

An update manager for Enlighten that does CPU updates.

Worker for the mulithreaded CPU update manager.

Implementation of the worker class, containing functionality for platforms which run tasks on a multithreaded CPU.

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.

Builds an octree.

An octree node.

Result of an octree search.

Output octree builder.

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

A cubemap object, corresponding to a <cubeMap> element in the .scene file.

An instance object, corresponding to an <instance> element in the .scene file.

A geometry object, corresponding to a single .geom file.

The properties of a .geom that are relevant to the precompute.

The parameters that affect the precompute for all instances in the scene.

Recommended default values for parameters that affect the precompute for a subset of instances in the scene.

Lazy file writer that only actually updates the file on disk if the contents have changed.

The properties of an Enlighten material that are relevant to radiosity.

A mesh object, corresponding to a single <mesh> element within the .geom file.

The paths to the exported scene data.

A probe region object, corresponding to a <probeRegion> element in the .scene file.

A probe volume object, corresponding to a <probeVolume> element in the .scene file.

An instance object, corresponding to an <instance> element in the .scene file.

The properties of an instance that are relevant to the precompute.

The transform used by each instance object.

The permutation of the "axes" attribute of the <scene> element of the .scene file Use this to enable the Enlighten debugging tools to display your scene correctly.

Data about a given pixel in the lightmap.

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

PointLight class used by extended input lighting.

Public interface for querying common metadata of a single point light.

Utility class for projecting points into a triangle surface, and optionally 'pushing up'.

Projection options for the point projection functionality.

Reusable search scratch memory while projecting points.

A surface we can project points onto.

Description of the point projection of one instance to a set of surfaces.

Simple position & normal structure.

Description of a volume texture written to by the per-pixel probe interpolation runtime which represents a clipmap, where each level of the clipmap is stacked along the Z-axis of the volume texture.

PppiConfiguration.

Pppi debug information.

L1 SH RGB representation of irradiance.

Class that manages the various resources needed for octree probe interpolation.

The size and format of the required output textures.

Information required by the per-pixel probe interpolation runtime for updating all volume textures managed by it.

The shader parameters required to sample per pixel probe lighting.

Description of a volume texture written to by the per-pixel probe interpolation runtime.

Updates output textures for all probe sets in the world.

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

Precomp Input Auto Probe Volume.

A face (triangle) in EnlightenPrecomp input geometry.

A simple class housing the data required with each stand-alone instance of some geometry.

A set of boxes for which probes will be placed at the specified resolution.

A set of points for which probes will be placed at the specified resolution.

A volume for which probes will be placed at the specified resolution.

A vertex in EnlightenPrecomp input geometry.

Material precompute properties. Assign these to specific instance, mesh and material GUIDs using SetMaterialInfo on an IPrecompInputSystem object.

Simple struct to identify an IPrecompInputMesh with the name and GUID of the geom and the index and GUID of the mesh.

Properties of input meshes.

A serialisable representation of an octree node.

Provides an ordering of probe voxel positions by their depth within the octree.

CubeMap precompute data.

Runtime data storing precomputed visibility information (eg, for directional lights)

Runtime data allocated by end user that stores uncompressed precomputed visibility data.

Indicates an error during the export-precompute-import process.

A class to build data for the Enlighten3PrecomputeLoader API.

The arguments to the HLBS precompute process.

Exports the scene and runs the precompute process.

ProbeSet precompute data.

Class for handling a long running external process.

System precompute data.

An example implementation of IPrecompVolumeQuery which defines a region of 3D space as a set of boxes.

Unique ID of a voxel.

A voxel in an octree.

A path to a voxel.

A volume voxel in an octree.

Probe bounce workspace.

Workspace used for probe bounce (internal).

Data structure identifying a probe and associated weight (influence) which forms part of a set to be interpolated.

Task describing a set of probe sets to be used as inputs for interpolation, and a set of points which require interpolated outputs.

A probe sample.

A ProbeSet data block which contains the precompute data required by Enlighten at runtime.

Probe Set Manager Voxel class Implementation of the IProbeSetManager interface class This implementation is based on a voxel grid acceleration data structure.

Public interface for querying metadata of a single probe set.

The data associated with each non-empty octree node.

A pair of probes which can be averaged to produce a 'virtual' probe output.

Probe system hit.

A simple class for recording a history of double valued stats.

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.

Constitutes the core precomputed data for a cube map.

A data block that describes essential properties of a cube map.

Structure describing a task to generate a cube map.

Facilitates storage of core Enlighten data.

Structure describing an internal debugging task to colour output pixels according to debug data.

Structure describing a task to colour output pixels according to debug data.

Extended information about a pixel in the Enlighten output for internal debugging purposes.

Compressed description of the input cluster tree.

Structure describing a task using the irradiance technique.

Constitutes the core precomputed data for a probe set.

A data block that describes essential properties of a run-time probe set.

A Probe task specifies a list of probe points whose lighting values will be calculated when the task is solved.

Constitutes the core precomputed data for a system.

A data block that describes essential properties of a rad system, including it's id, output and input textures sizes, budget, pixel utilisation and other debugging data.

A range of bytes.

Parameters to be enqueued for a ReadInputLightingBufferInfo() command.

RectangleLight class used by extended input lighting.

Texture allocator for creating CPU solution spaces for Enlighten without any associated GPU resources.

Reference texture updater.

Parameters to be enqueued for a ReleaseSystemSolutionSpaces() command.

Parameters to be enqueued for a RemoveSystem(), RemoveProbeSet(), RemoveCubeMap() or RemoveDynamicObject() command.

A class containing the parameters to be used as input to the bounce resampling stage.

A class containing the parameters to be used if sampling from a texture is required.

Class to store 32-bit colour values in gamma space.

Class to store a HDR value using FP16 precision.

RGBA texture sampler.

RGBM texture sampler.

Selector which selects all lights.

Selector which selects culled lights.

Selector which selects unculled lights.

Parameters to be enqueued for a SetLightBankUpdateCounter() command.

Command to set a parameter on an object.

Parameters to be enqueued for a SetProbeSetTransform() command.

Command to set solutions spaces for given system.

Parameters to be enqueued for a SetTransparencySamplePositionOffset() command.

Parameters to be enqueued for a SetVisibilityBits() command.

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

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

Structure describing a task which solves directly to the bounce buffer and does not update any textures.

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.

Public interface for querying metadata of a single source mesh instance.

Sphere volume primitive.

Spotlight class used by extended input lighting.

Public interface for querying common metadata of a single spotlight.

A set of initialisers for the dynamicity of surface colours.

Class representing the albedo data for a system (or dynamic object which contributes to radiosity).

A System data Block which contains the precompute data required by Enlighten at runtime.

A list of system dependencies.

A groupings of instances into systems.

Public interface for querying metadata of a single system.

TaskProcessor runs a loop for pulling tasks off the current queue until either the whole list is done, or an ILimiter tells it to stop.

Specify the albedo/emissive texture resolution relative to the light map resolution.

Defines a sub-section of a texture, specified in texels.

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

Surroundings sampler for transparency.

Base class for transparency volumes.

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

A triangle in 2D defined by three points.

Command to trigger a transprency volume.

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.

Parameters to be enqueued for the UpdateEmissiveEnvironment() command.

Command to update a light.

Parameters to be enqueued for the UpdateLight() command.

Optional parameters to the UpdateLight() command.

Class which extends the Enlighten input light class with extra data used only by the high level runtime, and not by Enlighten itself.

This class contains the properties of an Update Manager which must be supplied on creation and can't be changed.

Class representing the global state of the update manager worker.

Stats reported by UpdatePppiAtlas().

Stats reported by PppiWorld::Update().

The set of regions within the PPPI output textures that have been updated and therefore need uploading to the GPU.

Vertex in 2D.

Encapsulation of light visibility information.

Supported formats for visibility data.

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

Visitor terminator.

Visitor for selected lights.

Visitor for selected lights.

A region of a volume texture defined by two corners.

Command to execute a function in the IUpdaetManagerWorker interface with no input arguments.

Command to execute a function in the IUpdateManagerWorker interface with one input argument.

Command to execute a function in the IUpdateManagerWorker interface with two parameters.

===============================

A command that holds a reference to its movable parameter

Command to execute paramless method on an an object specified by the guid.

Helper class for holding per-thread working data.

A specialised circular/stack allocator hybrid for allocating solve workspace memory.

Exports pretty-printed XML to a file.

Adds light values from one input lighting buffer to another.

Adds light values laid out in a duster block to an Enlighten input workspace.

Adds light values laid out in a duster block to an Enlighten input workspace.

Adds a compiled PPPI probe set to the PPPI workspace.

Returns true if all of the given light inputs did not change the last time they were updated.

Allocate memory for a RadDataBlock based on the block's m_Length member and required alignment.

Mark the quads transparency value using a box volume.

Mark the quads transparency value using a sphere volume.

Computes the unsigned area of a triangle defined by three Vertex2D.

Determines the sign of the area of a triangle defined by three Vertex2D.

Computes the unsigned area of a triangle defined by three Vertex2D multiplied by two.

Calculate the size of the AlbedoBuffer for a system.

Tells you the amount of memory required to hold bounce lighting for a given system.

Tells you how much memory in a RadSystemCore is used by the directional irradiance technique.

Tells you how much memory is required to create a DirectionPalette, which is a required input to an Enlighten::EntireProbeSetTask.

Calculate the size of the DynamicMaterialWorkspace.

Calculate the size of the EmissiveBuffer for a system.

Tells you the amount of memory required to hold input lighting for a given environment resolution.

Tells you the amount of memory required to hold incident lighting for a given system.

Tells you the amount of memory required to hold input lighting for a given system.

Tells you how much memory in a RadSystemCore is used by the irradiance technique.

Calculate the maximum memory required to hold the lights table.

Return the size of the light value given the precision hint.

Determine how much memory is required for a light visibility block.

Determine how much memory is required for a light visibility block.

Returns the total number of values in the emissive environment cluster tree.

Calculate how much space is required to create a PppiCompiledProbeSet for the given probe set.

Returns the required memory size to create PppiWorkspace.

Determine how much memory is required for a precomputed visibility workspace.

Tells you the amount of memory required for the probe bounce buffer for a given system.

Tells you the amount of memory required for the probe bounce buffer for a given system.

Tells you how much memory in total is used by a RadCubeMapCore.

Tells you how much memory in total is used by a RadProbeSetCore.

Tells you how much memory in total is used by a RadSystemCore.

Returns an intensity normalisation factor for area lights.

Returns a minimum edge length for rectangular lights that should minimise noise from float precision.

Tells you how much memory is required for the intermediate bounce output data for this radiosity core.

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

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

Tells you how much workspace memory is required by SolveCubeMapTask to solve a specific cube map.

Calculate the size of the TransparencyBuffer for a system.

Tells you the amount of memory required for the transparency workspace for a given system.

Tells you the amount of memory required for the transparency workspace for a given system.

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

Calculate the size of the cached lighting data.

Calculate an error of the UV mapping for a given group.

Calculate an overlap of the UV mapping for a given group.

Utility to calculate the correct UV scaling and world-space output pixel size for a given instance of a given geometry.

Use the above functions to determine which set of uv is better.

Clear the input lighting to black.

The tri group merge finding algorithm.

Compares Returns true if the bounce buffers could be compared.

Compares Returns true if the lighting buffers could be compared.

Compares Returns true if the lighting buffers could be compared.

Compares a pair of Enlighten irradiance outputs.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Converts the endian format of a runtime object.

Byte-swap the members of RadDataBlock depending on the specified endian mode.

Create an IPrecompGeneratedSystems object from inputSystem.

Function to convert an IPrecompInputMesh into an AtlasMesh.

Helper function to convert from platform independent Enlighten::TextureFormat to Dx9 texture format.

Helper function to convert from platform independent Enlighten::TextureFormat to DXGI texture format.

Copy an InputLightingBuffer object.

Copy contents of a RadDataBlock.

Copy an DynamicMaterialWorkspace object.

Copy an InputLightingBuffer object.

Copy an IncidentLightingBuffer object.

Copy an InputLightingBuffer object.

Copies a RadCubeMapCore.

Copies a RadSystemCore.

Create an AlbedoBuffer for a system.

Create an instance of Enlighten Bake interface.

Construct a BounceBuffer inside the memory provided.

Determine the specific material ID for a given instance, mesh and 32-bit material ID.

Creates a debug IClusteringOutput interface representing the clustering of an environment at the given resolution.

Create a Direction Palette for use with an EntireProbeSetTask.

Create a DynamicMaterialWorkspace which is used for dynamic updates of material colours at runtime.

Create an EmissiveBuffer for a system.

Construct an InputLightingBuffer inside the memory provided.

Construct an IncidentLightingBuffer inside the memory provided.

Construct an InputLightingBuffer inside the memory provided.

Create the PppiCompiledProbeSet for the given input ProbeSet in user supplied memory.

Create a PppiWorkspace in input memory.

Create an instance of the Precompute.

Construct an PrecomputedVisibilityWorkspace inside the memory provided.

Construct a ProbeBounceBuffer inside the memory provided.

Construct a ProbeBounceBuffer inside the memory provided.

Create the buffer of lights sorted by type.

Create a TransparencyBuffer for a system.

Construct an TransparencyWorkspace inside the memory provided.

Construct an TransparencyWorkspace inside the memory provided.

Utility to create the tri group structure defined by the input mesh.

Helper function to convert CPU cycles to milliseconds.

Helper function to convert CPU cycles to seconds.

Free an AlbedoBuffer object, and all the memory it owns.

Free an ClusterAlbedoWorkspaceMaterialData object, and all the memory (RadDataBlocks) it owns.

Free an DynamicMaterialWorkspace object, and all the memory it owns.

Free an EmissiveBuffer object, and all the memory it owns.

Free an IncidentLightingBuffer object, and all the memory it owns.

Free an InputLightingBuffer object, and all the memory it owns.

Free an InputWorkspace object, and all the memory (RadDataBlocks) it owns.

Deletes a MetaBlock which was returned from ReadMetaBlock() or ReadMetaBlockFromFile().

Free a PrecomputedVisibilityData object, and all the memory (RadDataBlocks) it owns.

Free a RadCubeMapCore object, and all the memory (RadDataBlocks) it owns.

Free a RadProbeSetCore object, and all the memory (RadDataBlocks) it owns.

Free a RadSystemCore object, and all the memory (RadDataBlocks) it owns.

Free a TransparencyBuffer object, and all the memory it owns.

Computes the distance between two Vertex2D.

Computes the squared distance between two Vertex2D.

Write debugging colours to an output texture.

Do the Direct input lighting stage.

Do the internal direct input lighting stage.

Simple test to see if projection data is available.

Do the indirect input lighting stage.

Do the internal indirect input lighting stage.

Performs an interpolation of SH coefficients for a given set of points in space and probe sets.

Utility function for converting floating point values to the RGBM format.

Enqueues a command.

Enqueue a functor object or lambda expression as a command with no arguments.

Enqueues a command to set a parameter on an object on the worker thread.

Enqueues a command to set a parameter on an object on the worker thread.

Enqueues a command to set a parameter on an object on the worker thread.

Enqueues a command to set a parameter on an object on the worker thread.

Enqueue a functor object or lambda expression as a worker command.

Estimate the dependencies between a set of systems.

Estimate the dependencies between a set of systems.

Extract the probe positions within a ProbeOctree.

Fill in a RadDebugPixelInfo for a specified UV coordinate (for internal debugging purposes).

Returns a search result containing information about the node containing the specified point.

Free a RadDataBlock object, and all the memory it owns.

The temporal coherence optimization - if used - requires that all probe sets are kept in sync, so that no changes in lighting are missed.

The temporal coherence optimisation - if used - requires that all systems are kept in sync, so that no changes in lighting are missed.

The temporal coherence optimization - if used - requires that all systems are kept in sync, so that no changes in lighting are missed.

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 function that generates a Falloff Table using an inverse squared light falloff function, closely approximating real world light falloff.

Helper function that generates a falloff table compatible with the Unity light falloff model.

Helper function that generates a Falloff Table compatible with the Unreal light falloff model.

Generate UVs for merged geometry.

Returns the size of the specified BounceBuffer object.

Get system id from BounceBuffer.

Returns the size of the specified ClusterAlbedoWorkspaceMaterialData object.

Returns a list of all material Ids referenced by this albedo workspace.

Returns the number of material Ids referenced by this albedo workspace.

Get the cluster albedo value of a debug point from an AlbedoBuffer.

Get the cluster emissive value of a debug point from an EmissiveBuffer.

Get the cluster transparency value of a debug point from an TransparencyBuffer.

Helper function to calculate the number of texture bytes per pixel for DXGI texture formats supported by Enlighten.

Helper function for getting irradiance output format friendly name.

Helper function to get the number of bytes/pixel per texture for a given output format.

Get the state of the force disable FMA4 support flag.

Returns the size of the specified IncidentLightingBuffer object.

Get system id from IncidentLightingBuffer.

Fill the specified array with the current light value for the given cluster index.

Returns the size of the specified InputLightingBuffer object.

Get system id from InputLightingBuffer.

Return a debug iterator object in {debugIterator} which can be used to iterate through the systems debug points.

Fill the specified debug data structure with the current values for the given input workspace sample point.

Returns the GUID of a specific entry in the expected input lighting buffer list.

Returns the GUID of a specific entry in the expected input lighting buffer list.

Returns the GUID of a specific entry in the expected input lighting buffer list.

Returns the GUID of a specific entry in the expected input lighting buffer list.

Get all the instance GUIDs in this system.

Returns the length of the input lighting buffer list expected when solving radiosity using this core data.

Returns the length of the input lighting buffer list expected when solving radiosity using this core data.

Returns the length of the input lighting buffer list expected when solving radiosity using this core data.

Returns the length of the input lighting buffer list expected when solving radiosity using this core data.

Fill the specified debug data structure with the current values for the given input workspace sample point.

Get the maximum number of projected points associated with any instance.

Get the maximum number of versions of projected points associated with any instance.

Fills an array with the normals of all of the input points in an input workspace.

Get the number of instance GUIDs in this system.

Fills the array with the number of points per cluster.

Get the number of points associated with the specified instance.

Get the number of versions associated with the specified instance.

Fills arrays with the positions and normals of all of the input points in an input workspace.

Fills an array with the positions of all of the input points in an input workspace.

Get the projected points for a specified version and instance.

Returns the size of the specified InputWorkspace object.

Get the list of version ids stored for a specified instance.

Computes the intersection between two Line2D.

Returns the total number of clusters in an input workspace.

Returns the total number of output buckets.

Returns the total number of output pixels being lit.

Returns the total number of output pixels in the given bucket.

Returns the total number of sample duster points in an input workspace.

Returns the total number of tree clusters in an input workspace.

Returns the number of octree nodes within the specified octree probe set.

Returns the number of virtual probes within the specified probe set.

Returns a pointer to the array of octree nodes within the specified octree probe set.

Returns the number of LODs for the specified octree probe set.

Returns the number of probes within the specified LOD for the specified octree probe set.

Returns the number of virtual probes within the specified LOD for the specified octree probe set.

Returns the number of PPPI instances within the specified octree probe set at the specified lod.

Returns the number of PPPI instances within the specified octree probe set.

Returns a pointer to the array of PPPI instance probe ids within the specified octree probe set.

Returns a pointer to the array of PPPI nodes within the specified octree probe set.

Returns a pointer to the array of PPPI probe instances within the specified octree probe set.

Returns the number of PPPI targets within the specified octree probe set.

Returns a pointer to the array of PPPI targets within the specified octree probe set.

Returns a pointer to the root probes in the specified octree probe set.

Function returning the correct optimised solver based on the compilation environment.

Return the end of the range of output texture types that can be updated for this combination of solve type and radiosity core.

Returns the size of the output texture required for this radiosity data.

Returns the size of the output texture required for this radiosity data.

Get Pppi debug information.

Get the number of levels in the indirection clipmap.

Get the world-space quantised origin of the indirection clipmap.

Get the size in world units of each leaf node in the octree.

Returns the required output textures for the specified configuration.

Returns the Enlighten SDK version number.

Returns the size of the specified PrecomputedVisibilityData object.

Retrieves the light probe environment visibility for the given probe in the volume probe data.

Retrieves the probes interpolants for a given point for multiple probe set.

Retrieves the probes interpolants for a given point for a single probe set.

Retrieves the probes interpolants for a given point for multiple probe set, without performing any kind of validation on the input arguments.

Retrieves the probe set interpolants for a given point.

Retrieves the interpolated light probe spherical harmonics coefficients for a point based on a single input probe set.

Retrieves the interpolated light probe spherical harmonics coefficients for a point based on multiple input probe sets.

Retrieves the light probe visibility for the given probe in the volume probe data.

Defines a platform specific extension for some files, such as the InputWorkspace, that differ in content between platforms.

Returns the axis-aligned bounding box of the set of input points in the input workspace.

Retrieve the bounding volume of the system.

Returns the size of a pixel in bytes for the specified format, if supported.

Gets the number of bytes required for each pixel of the given texture format.

Returns the size of a pixel in bytes for the specified format and type, if supported.

Returns the required dimensions of the albedo and emissive textures for a given radiosity core.

Inline function that returns the required dimensions of the albedo and emissive textures for a given a texture width and height.

Returns a pointer to the array of virtual probes within the specified probe set.

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.

Group instances into systems.

Hash the guids and pointers of the InputLightingBuffer array.

Sets the albedo colours for an AlbedoBuffer based on the individual sample points.

Sets the albedo colours for an AlbedoBuffer from a materialWorkspace.

Sets the albedo colours for an AlbedoBuffer from an albedo texture expected in RGBA format in gamma-2 colour space.

Sets the emissive colours for an EmissiveBuffer based on the individual sample points.

Sets the emissive colours for an EmissiveBuffer from a materialWorkspace.

Sets the emissive colours for an EmissiveBuffer from an emissive texture expected in RGBM format in linear colour space.

Sets the emissive colours for an EmissiveBuffer from an emissive texture expected in FP16 format in linear colour space.

Initialise all the materials of an instance in the DynamicMaterialWorkspace as dynamic.

If you are using the Intel Graphical Performance Analyzer, call this function at application startup.

Initialise a material component in the DynamicMaterialWorkspace as static or dynamic.

Initialise a material emissive component in the DynamicMaterialWorkspace as dynamic.

Initialise all the materials in the DynamicMaterialWorkspace as dynamic.

Sets the transparency for a TransparencyBuffer based on the individual sample points.

Sets the values for a TransparencyBuffer from a materialWorkspace.

Sets the values for a TransparencyBuffer from a the alpha channel in the albedo texture in RGBA format.

Tests if a Vertex2D is within a bounding box defined by two Vertex2D.

Tests if a Vertex2D is within a bounding box defined by two Vertex2D.

Determine if the buffer needs to be initialised.

Determine if the buffer needs to be initialised.

Tests if barycentric coordinates are valid.

Returns true for formats with a fixed range (0-1).

Returns true if the given light input buffer did not change the last time it was updated.

Tests if a set of barycentric coordinates define a point within a triangle.

Returns true if the specified probe set core is a ProbeOctree.

Returns TRUE if the probe was culled during precompute.

Determine if the buffer needs to be initialised.

Function that tests if the data object provided is valid (pointer checks, metadata, etc).

Function that tests if the data object provided is valid (pointer checks, metadata, etc).

Function that tests if the data object provided is valid (pointer checks, metadata, etc).

Function that tests if the data object provided is valid (pointer checks, metadata, etc).

Function that tests if the data object provided is valid (pointer checks, metadata, etc).

Function that tests if the data object provided is valid (pointer checks, metadata, etc).

Function that tests if the data object provided is valid (pointer checks, metadata, etc).

Function that tests if the data object provided is valid (pointer checks, metadata, etc).

Function that tests if the data object provided is valid (pointer checks, metadata, etc).

Function that tests if the data object provided is valid (pointer checks, metadata, etc).

Checks if the given output format enumeration is valid.

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

Compute the area and directional normalization factors for each texel of a single environment cubemap face.

All surfaces matching the specified instance.

The surface matching the instanceId, meshIndex and materialId combination.

All surfaces in the system.

Returns a Vertex2D as the componentwise minimum of two Vertex2D.

Returns a Vertex2D as the componentwise minimum of two Vertex2D.

Normalises a Vector2D to a length of one.

Componentwise subtraction operator for two Vertex2D.

Returns true if the arguments are not equal.

Returns true if the keys are not equal.

Returns true if the paths are not equal.

Returns true if the nodes are not equal.

Bitwise AND of two dynamic material workspace statuses.

Componentwise multiplication by scalar for Vertex2D.

Componentwise multiplication by scalar for Vertex2D.

Bitwise OR of two dynamic material workspace statuses.

Bitwise NOT of a dynamic material workspace status.

Componentwise addition operator for two Vertex2D.

Moves a triangle by a given Vector2D.

Returns true if the left argument is ordered before the right argument.

Returns true if the left argument is ordered before the right argument.

Moves a triangle by a given Vector2D into it's opposite direction.

Componentwise subtraction and assignment operator for two Vertex2D.

Returns true if the arguments are equal.

Returns true if the keys are equal.

Returns true if the paths are equal.

Returns true if the nodes are equal.

Places the unordered list of lighting buffers into the correct order for the solver.

Places the unordered list of lighting buffers into the correct order for the solver.

Places the unordered list of lighting buffers into the correct order for the solver.

Places the unordered list of lighting buffers into the correct order for the solver.

Project the environment cubemap irradiance values to L1 SH coefficients.

Read an AlbedoBuffer from a stream.

These utilities perform in-place fixup of the various enlighten data structures.

Read an ClusterAlbedoWorkspaceMaterialData from a stream.

Read an ClusterAlbedoWorkspaceMaterialData from file.

These utilities perform in-place fixup of the various enlighten data structures.

Read a RadDataBlock from a Geo::IGeoInputStream. Will return an object that should be released with FreeDataBlockContents().

These utilities perform in-place fixup of the various enlighten data structures.

Read an DynamicMaterialWorkspace from a stream.

These utilities perform in-place fixup of the various enlighten data structures.

Read an EmissiveBuffer from a stream.

These utilities perform in-place fixup of the various enlighten data structures.

Read an IncidentLightingBuffer from a stream.

These utilities perform in-place fixup of the various enlighten data structures.

Read an InputLightingBuffer from a stream.

These utilities perform in-place fixup of the various enlighten data structures.

Read an InputWorkspace from a stream.

Read an InputWorkspace from file.

These utilities perform in-place fixup of the various enlighten data structures.

Reads a MetaBlock from a stream or file that was saved by WriteMetaBlock() or WriteMetaBlockToFile().

Reads a MetaBlock from a stream or file that was saved by WriteMetaBlock() or WriteMetaBlockToFile().

Read or skip a RadDataBlock in a Geo::IGeoInputStream, depending on the sections requested and the id of the block.

Read a PrecomputedVisibilityData struct from a stream.

These utilities perform in-place fixup of the various enlighten data structures.

Read the RadProbeTask results data from a file/stream.

Read the RadProbeTask results data from a file/stream.

Read a RadCubeMapCore from a stream.

Read a RadCubeMapCore from file.

These utilities perform in-place fixup of the various enlighten data structures.

Read run-time probeset data from a file.

Read run-time probe set data from a file.

These utilities perform in-place fixup of the various enlighten data structures.

Read a RadSystemCore from a stream.

Read a RadSystemCore from file.

These utilities perform in-place fixup of the various enlighten data structures.

Read the RadIrradianceTask results data from a file/stream.

These utilities perform in-place fixup of the various enlighten data structures.

Removes a compiled PPPI probe set from the PPPI workspace.

After SolveIrradianceTask is run, the ResampleBounce() function populates an Enlighten::BounceBuffer with bounce data.

Generate a texture that highlights the information specified in the task object.

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.

Set visibility in an input workspace for a directional light, using precomputed visibility data.

Sets the environment light values.

Set whether to force disable FMA4 support.

Set the colour of a material selection within the DynamicMaterialWorkspace.

Set the emissive colour of a material selection within the DynamicMaterialWorkspace.

Set the transparency of a material selection within the DynamicMaterialWorkspace.

Set all transparency values of transparencyWorkspace to the given value.

Skip a RadDataBlock in a Geo::IGeoStream. Will advance the stream past a RadDataBlock without reading the contents.

Solve the radiosity directly to a bounce buffer only.

Solve the specified cube map task using a given workspace.

Solve the specified EntireProbeSetTask.

Solve the specified irradiance task using a given workspace.

Solve the specified L1 probe task.

Solve the specified L2 probe task.

Utility to temporarily pack scale and translation into the PrecompOutputInstance object.

Update an AlbedoBuffer from the DynamicMaterialWorkspace.

Update an EmissiveBuffer from the DynamicMaterialWorkspace.

Updates the PPPI atlas textures based on a change to solved probe values for the given probe set.

Updates the PPPI border lighting used when sampling areas outside the volume texture.

Updates the PPPI indirection texture based on a change in camera position.

Update the probe bounce buffer with values calculated from interpolated probes.

Update the probe bounce buffer with values calculated from interpolated probes.

Update a TransparencyBuffer from the DynamicMaterialWorkspace.

Update the transparency workspace with values calculated from interpolated probes.

Update the transparency workspace with values calculated from interpolated probes.

Returns true if there are no NaN's or non-finite numbers in the specified BounceBuffer object.

Returns true if there are no NaN's or non-finite numbers in the specified InputLightingBuffer object.

Returns true if there are no NaN's or non-finite numbers in the specified InputLightingBuffer object.

Visitor function to apply the visitor functor to each light.

Visits the selected lights with the given visitor.

Write an AlbedoBuffer to a stream.

These utilities perform in-place fixup of the various enlighten data structures.

Write an ClusterAlbedoWorkspaceMaterialData to a stream, ready to be loaded on the target platform.

These utilities perform in-place fixup of the various enlighten data structures.

Write an ClusterAlbedoWorkspaceMaterialData to file, ready to be loaded on the target platform.

Write a RadDataBlock to a Geo::IGeoStream.

These utilities perform in-place fixup of the various enlighten data structures.

Write an DynamicMaterialWorkspace to a stream.

These utilities perform in-place fixup of the various enlighten data structures.

Write an EmissiveBuffer to a stream.

These utilities perform in-place fixup of the various enlighten data structures.

Write an IncidentLightingBuffer to a stream.

These utilities perform in-place fixup of the various enlighten data structures.

Overwrite an InputLightingBuffer with another InputLightingBuffer.

Write an InputLightingBuffer to a stream.

These utilities perform in-place fixup of the various enlighten data structures.

Write an InputWorkspace to a stream, ready to be loaded on the target platform.

These utilities perform in-place fixup of the various enlighten data structures.

Write an InputWorkspace to file, ready to be loaded on the target platform.

Writes a MetaBlock to a stream or file, ready to be loaded on the target platform.

Writes a MetaBlock to a stream or file, ready to be loaded on the target platform.

Write a PrecomputedVisibilityData structure to a stream.

These utilities perform in-place fixup of the various enlighten data structures.

Write the RadProbeTask results data to a file/stream.

Write the RadProbeTask results data to a file/stream.

Write a RadCubeMapCore to a stream, ready to be loaded on the target platform.

These utilities perform in-place fixup of the various enlighten data structures.

Write a RadCubeMapCore to file, ready to be loaded on the target platform.

Write the RadIrradianceTask results data to a file/stream.

Write the RadIrradianceTask results data to a file/stream.

Write run-time probeset data to a stream, ready to be loaded on the target platform.

These utilities perform in-place fixup of the various enlighten data structures.

Write run-time probeset data to file, ready to be loaded on the target platform.

Write a RadSystemCore to a stream, ready to be loaded on the target platform.

These utilities perform in-place fixup of the various enlighten data structures.

Write a RadSystemCore to file, ready to be loaded on the target platform.

Write the sorted lights to memory.

These utilities perform in-place fixup of the various enlighten data structures.

Albedo buffer type used as input to the IndirectInputLighting stage of the runtime.

A unique pointer which controls the lifetime of the object.

Function pointer type for the callback for executing tasks asynchronously.

Barycentric coordinates.

BounceBuffer type used for re-sampling the bounce for feedback into the input lighting.

A unique pointer which controls the lifetime of the object.

Lookup from linear cluster ID to node.

Collection of cluster ranges.

Callback signature for when a command is completed.

Structure defining the memory layout of CPU texture data used by Enlighten for texture albedo and emissive.

A unique pointer which controls the lifetime of the object.

Emissive buffer type used as input to the IndirectInputLighting stage of the runtime.

A unique pointer which controls the lifetime of the object.

History profile for aggregate stats.

History profile for cube maps.

History profile for probesets.

History profile for systems.

A unique pointer which controls the lifetime of the object.

Collection of points with normals for debugging.

Collection of ray origins for debugging.

Collection of ray origins for debugging.

Texture filename string.

Collection of triangles for debugging.

String containing the Enlighten SDK version number.

A unique pointer to an IPrecompInputProbeRegion object.

A unique pointer which controls the lifetime of the object.

LightTypeIds type.

Convenience value type for a full precision lighting value.

Material component for albedo.

Material component for emissive.

A mapping between a material GUID and a 32-bit material ID.

Material component for transparency.

A unique pointer which controls the lifetime of the object.

A unique pointer which controls the lifetime of the object.

A unique pointer which controls the lifetime of the object.

A handle which uniquely identifies a probe set.

A level of detail in respect to a probe set.

A unique pointer which controls the lifetime of the object.

String for describing a profile, used by EnlightenProfile.

A unique pointer which controls the lifetime of the object.

A unique pointer which controls the lifetime of the object.

A unique pointer which controls the lifetime of the object.

A unique pointer which controls the lifetime of the object.

Selects a set of surfaces within a system.

A unique pointer which controls the lifetime of the object.

GeoGuid-to-s32 map used by EnlightenProfile.

Transparency buffer type used as input to the IndirectInputLighting stage of the runtime.

Vector in 2D.

The recommended value of simpNumMaxSimps.

The recommended value of simpNumIterationsPerSimp.

CubeMap loading flags to request the optional data blocks.

Constant defining the default affinity for the worker thread of a MultithreadCpuWorker.

By default, do not consider a system as a dependency if its visibility is smaller than this threshold.

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

Arbitrary number that is used to check that a serialised object is of the correct type and endian-ness.

This probe index refers to a culled probe.

Arbitrary number that is used to check that the object is of correct type (and endian-ness).

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);.

Set the update counter for a system to this value to request continuous updates.

Equivalent to light visibility data with all bits set to 0.

The material albedo/emissive color that GeoRadiosity uses if no color is specified.

A special handle value indicating an invalid handle.

A special value which indicates an invalid level of detail.

ProbeSet loading flags to request the optional data blocks.

System loading flags to request the optional data blocks.

System loading flags to request the optional data blocks.

System loading flags to request the optional data blocks.

Items we record for totals.

The way an instance receives Enlighten lighting output.

Items we record against cube maps.

The UV auto generation / simplification mode for a mesh.

Different types of baking input lights.

Bake output format.

Different types of Enlighten input lights.

Enumeration for reporting results of the first step of Mesh Classification (lightmap-lit or probe-lit).

The MultithreadCpuWorker works by putting tasks in a list, and then executing TaskProcessors on several threads in parallel.

Output formats.

To support both DX9 and DX11 rendering with the same shader code, the solve functions can output 8-bit-per-pixel texture data in either byte order.

Volume texture formats used by the per-pixel probe interpolation runtime.

Quality levels for the raytracing in the cube map precompute.

Determines how to treat back faces when precomputing light transport.

Determines which faces cast shadows when precomputing directional visibility.

Quality levels for majority of raytracing in the precompute, except cube maps.

Probe Interpolation output formats.

Valid data types for use with the RadDataBlock class.

Supported Spherical Harmonic types.

Valid solver types for use with the RadDataBlock class.

Enumeration for reporting geometry build success/fail.

Enumeration of the different output textures produced by the Enlighten solvers.

The allowed values for Environment resolution.

The recommended values for Irradiance Budget.

Whether the instance group can be automatically split by the precompute.

The way an instance receives Enlighten lighting output.

Whether an instance casts an indirect shadow.

The world space axis in which a given axis points.

The way the precompute process should be distributed.

The way the precompute process should be distributed.

The resolution at which probes should be placed.

Items we record against probe sets.

Enumeration of the different probe volume output textures.

Enumeration of the different levels of data removal for probe sets, systems and cube maps.

Enumeration of the different types of solve.

Items we record against systems.

Enumeration of output texture formats used by the high level run-time.

The result of a volume query.

The input workspace memory block used in the two buffers.

The input lighting that is added to.

The input lighting to add.

The input workspace memory block.

The incident lighting buffer to fill with data.

The linear light colour values for the duster array of point samples. The duster (its size, positions, normals etc.) must match the one originally passed to CreateInputWorkspace.

The input workspace memory block.

The lighting buffer to fill with data.

The linear light colour values for the duster array of point samples. The duster (its size, positions, normals etc.) must match the one originally passed to CreateInputWorkspace.

The compiled probe set to add.

Persistent workspace data.

Defines the indirection and atlas textures which will be updated.

Will be updated to include the regions of the indirection texture which have been updated.

Will be updated to include the regions of the atlas texture which have been updated.

The list of input lighting buffers to check for changes (individual entries can be NULL).

The number of input lighting buffers in the list (can be zero).

The (optional) emissive environment to check for changes.

The input workspace for the system

The TransparencyWorkspace for the system

The volume primitive to use to mark the quads

The input workspace for the system

The TransparencyWorkspace for the system

The volume primitive to use to mark the quads

A valid InputWorkspace for a system

The InputWorkspace for the system.

The hint to what floating point precision to use.

A non-null pointer to a valid RadSystemCore object.

Pointer to the precompute material data.

A valid InputWorkspace for a system

The resolution of the emissive environment.

A hint as to the preferred precision, if available on the platform.

The InputWorkspace for the system.

The hint to what floating point precision to use.

The InputWorkspace for the system.

The hint to what floating point precision to use.

A non-null pointer to a valid RadSystemCore object.

Number of lights in the world

The hint to what floating point precision to use.

The input workspace memory block.

Format of the visibility. Must be one of the types defined in VisibilityFormat

The input workspace memory block.

Type of light; one of the Enlighten light type constants, e.g. LIGHT_TYPE_DIRECTIONAL_LIGHT

The input workspace memory block.

The block of precomputed visibilty data.

The InputWorkspace for the system.

The maximum number of interpolants to use.

The InputWorkspace for the system.

The maximum number of interpolants to use.

The number of LODs to use.

A non-null pointer to a valid RadCubeMapCore object.

A non-null pointer to a valid RadProbeSetCore object.

A non-null pointer to a valid RadSystemCore object.

A pointer to a RadSystemCore to compute the bounce output size for.

An array of pointers to input lights.

The number of light pointers in the array.

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.

A non-null pointer to a valid RadCubeMapCore

A valid InputWorkspace for a system

The InputWorkspace for the system.

The maximum number of interpolants to use.

The floating point precision for intermediate values.

The InputWorkspace for the system.

The maximum number of interpolants to use.

The floating point precision for intermediate values.

The number of LODs to use.

The unscaled pixel size

The transform matrix for the instance

Should the scaling of the transform of the instance be taken into account when generating the per-instance lightmap UVs (i.e. should the output pixel size specified for this instance be in world units (true) or in local geometry units (false))

Specifies an additional scale that should be applied to the lightmap UVs for the geometry instance instance (to change the output pixel size). This is applied in addition to any scaling related to the ScaleUvsWithInstanceSize flag.

The UV scale for that instance

The pixel size after instance UV scaling is applied

The input workspace this buffer is used in.

The lighting buffer to clear.

- The result of the comparison. Only written if the function succeeded.

- The first BounceBuffer to compare.

- The second BounceBuffer to compare.

- The result of the comparison. Only written if the function succeeded.

- The first IncidentLightingBuffer to compare.

- The second IncidentLightingBuffer to compare.

- The result of the comparison. Only written if the function succeeded.

- The first InputLightingBuffer to compare.

- The second InputLightingBuffer to compare.

- The result of comparing irradiance. Only written if the function succeeded.

- The result of comparing directional element. Only written if the function succeeded.

- The first irradiance output to compare.

- The second irradiance output to compare.

InputSystem to be converted to PrecompGeneratedSystem

array of geoms referenced by inputsystem

num of geoms in pInputGeoms

IPrecompGeneratedSystems with one system in it.

- The Inputworkspace to use to create the input lighting buffer.

- The AlbedoBuffer to copy from.

- The Inputworkspace to use to create the input lighting buffer.

- The DynamicMaterialWorkspace to copy from.

- The InputWorkspace to use to create the input lighting buffer.

- The EmissiveBuffer to copy from.

- The Inputworkspace to use to create the input lighting buffer.

- TheIncidentLightingBuffer to copy from.

- The Inputworkspace to use to create the input lighting buffer.

- The InputLightingBuffer to copy from.

- The core to copy from.

- The core to copy to.

- The core to copy from.

- The core to copy to.

A valid InputWorkspace for a system

A pointer to 16 byte aligned memory of size returned by CalcAlbedoBufferSize()

A block of memory (size determined by CalcBounceBufferSize) to store the bounce buffer

The InputWorkspace for the system.

The hint to what floating point precision to use.

The first of the basis directions. Must be a unit vector along either the X, Y, or Z axis.

The second of the basis directions. Must be a unit vector along either the X, Y, or Z axis.

The third of the basis directions. Must be a unit vector along either the X, Y, or Z axis.

The output order of the SH coefficients. Must be 9 elements long.

A non-null pointer to a 16-byte aligned block of memory of size calculated with CalcDirectionPaletteSize.

A pointer to the precompute material data.

A pointer to the memory where the DynamicAlbedoWorkspace will be constructed. This block of memory must be at least CalcDynamicMaterialWorkspaceSize() bytes.

A valid InputWorkspace for a system

A pointer to 16 byte aligned memory of size returned by CalcEmissiveBufferSize()

A block of memory (size determined by CalcInputLightingBufferSize) to store the lighting buffer

The resolution of the emissive environment.

A hint as to the preferred precision, if available on the platform.

A block of memory (size determined by CalcIncidentLightingBufferSize) to store the lighting buffer

The InputWorkspace for the system.

The hint to what floating point precision to use.

A block of memory (size determined by CalcInputLightingBufferSize) to store the lighting buffer

The InputWorkspace for the system.

The hint to what floating point precision to use.

Input probe set to be compiled.

Start of memory region where the compiled probe set data can be stored.

Persistent workspace data. duration of this call.

A block of memory (size determined by CalcPrecomputedVisibilityWorkspaceSize) to store the visibility workspace

The input workspace memory block.

The block of precomputed visibilty data.

A block of memory (size determined by CalcProbeBounceBufferSize) to store the workspace for a probe-lit system.

The InputWorkspace for the system.

The maximum number of interpolants to use.

A block of memory (size determined by CalcProbeBounceBufferSize) to store the workspace for a probe-lit system.

The InputWorkspace for the system.