This is the documentation for Enlighten.
module Core Runtime System
Classes
Name | Description |
---|---|
Enlighten::ClusterAlbedoWorkspaceMaterialData | Constitutes the precomputed material data for a system. |
Enlighten::EntireProbeSetTask | An EntireProbeSetTask solves an entire set of probes as an atomic block. |
Enlighten::InputTextureSamplerParameters | A class containing the parameters to be used as input to the albedo/emissive/transparency sampling stage. |
Enlighten::InputWorkspace | Constitutes the core precomputed data for the input lighting generation for a system. |
Enlighten::InputWorkspaceMetaData | A data block that describes essential properties of an input workspace. |
Enlighten::ProbeSetOctreeNode | The data associated with each non-empty octree node. |
Enlighten::ProbeSetVirtualProbe | A pair of probes which can be averaged to produce a 'virtual' probe output. |
Enlighten::RadCubeMapCore | Constitutes the core precomputed data for a cube map. |
Enlighten::RadCubeMapMetaData | A data block that describes essential properties of a cube map. |
Enlighten::RadCubeMapTask | Structure describing a task to generate a cube map. |
Enlighten::RadDataBlock | Facilitates storage of core Enlighten data. |
Enlighten::RadIrradianceTask | Structure describing a task using the irradiance technique. |
Enlighten::RadProbeSetCore | Constitutes the core precomputed data for a probe set. |
Enlighten::RadProbeSetMetaData | A data block that describes essential properties of a run-time probe set. |
Enlighten::RadProbeTask | A Probe task specifies a list of probe points whose lighting values will be calculated when the task is solved. |
Enlighten::RadSystemCore | Constitutes the core precomputed data for a system. |
Enlighten::RadSystemMetaData | 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. |
Enlighten::ResampleBounceParameters | A class containing the parameters to be used as input to the bounce resampling stage. |
Enlighten::ResampleTextureParameters | A class containing the parameters to be used if sampling from a texture is required. |
Enlighten::SolveBounceTask | Structure describing a task which solves directly to the bounce buffer and does not update any textures. |
Functions
Name | Description |
---|---|
AllLightingInputsStatic(const InputLightingBuffer **, Geo::s32, const InputLightingBuffer *) | Returns true if all of the given light inputs did not change the last time they were updated. |
CalcDirectionalIrradianceMemory(const Enlighten::RadSystemCore *) | Tells you how much memory in a RadSystemCore is used by the directional irradiance technique. |
CalcDirectionPaletteSize() | Tells you how much memory is required to create a DirectionPalette, which is a required input to an Enlighten::EntireProbeSetTask. |
CalcIrradianceMemory(const Enlighten::RadSystemCore *) | Tells you how much memory in a RadSystemCore is used by the irradiance technique. |
CalcRadCubeMapCoreTotalMemory(const Enlighten::RadCubeMapCore *) | Tells you how much memory in total is used by a RadCubeMapCore. |
CalcRadProbeSetCoreTotalMemory(const Enlighten::RadProbeSetCore *) | Tells you how much memory in total is used by a RadProbeSetCore. |
CalcRadSystemCoreTotalMemory(const Enlighten::RadSystemCore *) | Tells you how much memory in total is used by a RadSystemCore. |
CalcRequiredPersistentDataSize(const Enlighten::RadSystemCore *) | Tells you how much memory is required for the intermediate bounce output data for this radiosity core. |
CalcRequiredWorkspaceMemory(const RadCubeMapCore *) | Tells you how much workspace memory is required by SolveCubeMapTask to solve a specific cube map. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::InputWorkspace *) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::RadProbeSetCore *) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::RadCubeMapCore *) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::RadSystemCore *) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::ClusterAlbedoWorkspaceMaterialData *) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::InputWorkspaceMetaData *) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::RadCubeMapMetaData *) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::AlbedoBuffer *) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::PrecomputedVisibilityData *) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::DynamicMaterialWorkspace *) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::IncidentLightingBuffer *) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::InputLightingBuffer *) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::RadDataBlock &) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::RadSystemMetaData *) | Converts the endian format of a runtime object. |
ConvertEndian(Geo::EConvertEndianMode, Enlighten::RadProbeSetMetaData *) | Converts the endian format of a runtime object. |
CreateDirectionPalette(const Geo::v128 &, const Geo::v128 &, const Geo::v128 &, const Geo::s8 *, void *) | Create a Direction Palette for use with an EntireProbeSetTask. |
FreezeEntireProbeSetTask(const Enlighten::EntireProbeSetTask *, void *, Geo::u32 &, Geo::u32 &) | The temporal coherence optimization - if used - requires that all probe sets are kept in sync, so that no changes in lighting are missed. |
FreezeInputLightingBuffer(InputLightingBuffer *) | The temporal coherence optimisation - if used - requires that all systems are kept in sync, so that no changes in lighting are missed. |
FreezeIrradianceTask(const Enlighten::RadIrradianceTask *, void *, Geo::u32 &, Geo::u32 &) | The temporal coherence optimization - if used - requires that all systems are kept in sync, so that no changes in lighting are missed. |
GetEnlightenFormatFriendlyName(Geo::u32) | Helper function for getting irradiance output format friendly name. |
GetEnlightenOutputFormatBytesPerPixel(Geo::u32) | Helper function to get the number of bytes/pixel per texture for a given output format. |
GetForceDisableFma4() | Get the state of the force disable FMA4 support flag. |
GetInputWorkspaceGUID(const Enlighten::RadCubeMapCore *, Geo::s32) | Returns the GUID of a specific entry in the expected input lighting buffer list. |
GetInputWorkspaceGUID(const Enlighten::RadProbeSetCore *, Geo::s32) | Returns the GUID of a specific entry in the expected input lighting buffer list. |
GetInputWorkspaceGUID(const Enlighten::RadSystemCore *, Geo::s32) | Returns the GUID of a specific entry in the expected input lighting buffer list. |
GetInputWorkspaceGUID(const Enlighten::RadDataBlock *, Geo::s32) | Returns the GUID of a specific entry in the expected input lighting buffer list. |
GetInputWorkspaceListLength(const Enlighten::RadDataBlock *) | Returns the length of the input lighting buffer list expected when solving radiosity using this core data. |
GetInputWorkspaceListLength(const Enlighten::RadSystemCore *) | Returns the length of the input lighting buffer list expected when solving radiosity using this core data. |
GetInputWorkspaceListLength(const Enlighten::RadCubeMapCore *) | Returns the length of the input lighting buffer list expected when solving radiosity using this core data. |
GetInputWorkspaceListLength(const Enlighten::RadProbeSetCore *) | Returns the length of the input lighting buffer list expected when solving radiosity using this core data. |
GetNumOctreeNodes(const Enlighten::RadProbeSetCore *) | Returns the number of octree nodes within the specified octree probe set. |
GetNumVirtualProbes(const Enlighten::RadProbeSetCore *) | Returns the number of virtual probes within the specified probe set. |
GetOctreeNodes(const Enlighten::RadProbeSetCore *) | Returns a pointer to the array of octree nodes within the specified octree probe set. |
GetOctreeNumLods(const Enlighten::RadProbeSetCore *) | Returns the number of LODs for the specified octree probe set. |
GetOctreeNumProbesLod(const Enlighten::RadProbeSetCore *, Geo::u32) | Returns the number of probes within the specified LOD for the specified octree probe set. |
GetOctreeNumVirtualProbesLod(const Enlighten::RadProbeSetCore *, Geo::u32) | Returns the number of virtual probes within the specified LOD for the specified octree probe set. |
GetOctreePppiInstanceCount(const Enlighten::RadProbeSetCore *) | Returns the number of PPPI instances within the specified octree probe set. |
GetOctreePppiInstanceCount(const Enlighten::RadProbeSetCore *, Geo::u32) | Returns the number of PPPI instances within the specified octree probe set at the specified lod. |
GetOctreePppiInstanceProbeIds(const Enlighten::RadProbeSetCore *) | Returns a pointer to the array of PPPI instance probe ids within the specified octree probe set. |
GetOctreePppiNodes(const Enlighten::RadProbeSetCore *) | Returns a pointer to the array of PPPI nodes within the specified octree probe set. |
GetOctreePppiProbeInstances(const Enlighten::RadProbeSetCore *) | Returns a pointer to the array of PPPI probe instances within the specified octree probe set. |
GetOctreePppiTargetCount(const Enlighten::RadProbeSetCore *) | Returns the number of PPPI targets within the specified octree probe set. |
GetOctreePppiTargets(const Enlighten::RadProbeSetCore *) | Returns a pointer to the array of PPPI targets within the specified octree probe set. |
GetOctreeRootProbes(const Enlighten::RadProbeSetCore *) | Returns a pointer to the root probes in the specified octree probe set. |
GetOptimisedSolverForPlatform(Geo::ePlatform) | Function returning the correct optimised solver based on the compilation environment. |
GetOutputTextureSize(const RadSystemCore &) | Returns the size of the output texture required for this radiosity data. |
GetOutputTextureSize(const RadCubeMapCore &) | Returns the size of the output texture required for this radiosity data. |
GetProbeEnvironmentVisibility(Geo::s32, const Enlighten::RadProbeSetCore *) | Retrieves the light probe environment visibility for the given probe in the volume probe data. |
GetProbeVisibility(Geo::s32, const Enlighten::RadProbeSetCore *, float *) | Retrieves the light probe visibility for the given probe in the volume probe data. |
GetVirtualProbes(const Enlighten::RadProbeSetCore *) | Returns a pointer to the array of virtual probes within the specified probe set. |
HashInputLightingElements(const InputLightingBuffer **, Geo::s32) | Hash the guids and pointers of the InputLightingBuffer array. |
IsFixedPointFormat(eOutputFormat) | Returns true for formats with a fixed range (0-1). |
IsInputLightingBufferStatic(const InputLightingBuffer *) | Returns true if the given light input buffer did not change the last time it was updated. |
IsProbeCulled(Geo::s32, const Enlighten::RadProbeSetCore *) | Returns TRUE if the probe was culled during precompute. |
IsValidOutputFormat(Geo::u32) | Checks if the given output format enumeration is valid. |
PrepareInputLightingList(const Enlighten::RadDataBlock *, const Enlighten::InputLightingBuffer **, Geo::s32, const Enlighten::InputLightingBuffer **) | Places the unordered list of lighting buffers into the correct order for the solver. |
PrepareInputLightingList(const Enlighten::RadProbeSetCore *, const Enlighten::InputLightingBuffer **, Geo::s32, const Enlighten::InputLightingBuffer **) | Places the unordered list of lighting buffers into the correct order for the solver. |
PrepareInputLightingList(const Enlighten::RadCubeMapCore *, const Enlighten::InputLightingBuffer **, Geo::s32, const Enlighten::InputLightingBuffer **) | Places the unordered list of lighting buffers into the correct order for the solver. |
PrepareInputLightingList(const Enlighten::RadSystemCore *, const Enlighten::InputLightingBuffer **, Geo::s32, const Enlighten::InputLightingBuffer **) | Places the unordered list of lighting buffers into the correct order for the solver. |
ResampleBounce(const Enlighten::ResampleBounceParameters &, Geo::u32 &) | After SolveIrradianceTask is run, the ResampleBounce() function populates an Enlighten::BounceBuffer with bounce data. |
SetForceDisableFma4(bool) | Set whether to force disable FMA4 support. |
SolveBounceBufferTask(const Enlighten::SolveBounceTask *, void *, Geo::u32 &, Geo::u32 &) | Solve the radiosity directly to a bounce buffer only. |
SolveCubeMapTask(const Enlighten::RadCubeMapTask *, void *, Geo::u32 &, Geo::u32 &) | Solve the specified cube map task using a given workspace. |
SolveEntireProbeSetTask(const Enlighten::EntireProbeSetTask *, void *, Geo::u32 &, Geo::u32 &) | Solve the specified EntireProbeSetTask. |
SolveIrradianceTask(const Enlighten::RadIrradianceTask *, void *, Geo::u32 &, Geo::u32 &) | Solve the specified irradiance task using a given workspace. |
SolveProbeTaskL1(const Enlighten::RadProbeTask *, Geo::u32 &) | Solve the specified L1 probe task. |
SolveProbeTaskL2(const Enlighten::RadProbeTask *, Geo::u32 &) | Solve the specified L2 probe task. |
Enums
Name | Description |
---|---|
eOutputFormat | Output formats. |
eOutputFormatByteOrder | 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. |
eProbeOutputFormat | Probe Interpolation output formats. |
eRadDataType | Valid data types for use with the RadDataBlock class. |
eSHOrder | Supported Spherical Harmonic types. |
eSolverType | Valid solver types for use with the RadDataBlock class. |
Typedefs
Name | Description |
---|---|
IncidentLightingBuffer BounceBuffer | BounceBuffer type used for re-sampling the bounce for feedback into the input lighting. |
bool GEO_CALL Enlighten::AllLightingInputsStatic
public: bool GEO_CALL AllLightingInputsStatic
(
const InputLightingBuffer ** lightingBuffers,
Geo::s32 numLightingBuffers,
const InputLightingBuffer * emissiveEnvironment
)
Returns true if all of the given light inputs did not change the last time they were updated.
This function is called internally by the CPU versions of the task solvers, so long as a positive temporal coherence threshold is specified. However, if is also provided as a public API function so that unnecessary SPU/GPU tasks can be avoided completely.
Parameters
[in] | lightingBuffers | The list of input lighting buffers to check for changes (individual entries can be NULL). |
[in] | numLightingBuffers | The number of input lighting buffers in the list (can be zero). |
[in] | emissiveEnvironment | The (optional) emissive environment to check for changes. |
Returns
Returns TRUE if all inputs are static; FALSE if at least one has changed.
Geo::u32 GEO_CALL Enlighten::CalcDirectionalIrradianceMemory
public: Geo::u32GEO_CALL CalcDirectionalIrradianceMemory
(
const Enlighten::RadSystemCore * radCore
)
Tells you how much memory in a RadSystemCore is used by the directional irradiance technique.
This is provided for information purposes only (it doesn't relate to any memory buffer requirement).
Parameters
[in] | radCore | A non-null pointer to a valid RadSystemCore object. |
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
Geo::u32 GEO_CALL Enlighten::CalcDirectionPaletteSize
public: Geo::u32GEO_CALL CalcDirectionPaletteSize()
Tells you how much memory is required to create a DirectionPalette, which is a required input to an Enlighten::EntireProbeSetTask.
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
Geo::u32 GEO_CALL Enlighten::CalcIrradianceMemory
public: Geo::u32GEO_CALL CalcIrradianceMemory
(
const Enlighten::RadSystemCore * radCore
)
Tells you how much memory in a RadSystemCore is used by the irradiance technique.
This is provided for information purposes only (it doesn't relate to any memory buffer requirement).
Parameters
[in] | radCore | A non-null pointer to a valid RadSystemCore object. |
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
Geo::u32 GEO_CALL Enlighten::CalcRadCubeMapCoreTotalMemory
public: Geo::u32GEO_CALL CalcRadCubeMapCoreTotalMemory
(
const Enlighten::RadCubeMapCore * radCubeMapCore
)
Tells you how much memory in total is used by a RadCubeMapCore.
This is provided for information purposes only (it doesn't relate to any memory buffer requirement). It is simply the sum of the memory used by each of the RadDataBlocks and the RadCubeMapCore itself.
Parameters
[in] | radCubeMapCore | A non-null pointer to a valid RadCubeMapCore object. |
Returns
Memory in bytes, 0xFFFFFFF upon error.
Geo::u32 GEO_CALL Enlighten::CalcRadProbeSetCoreTotalMemory
public: Geo::u32GEO_CALL CalcRadProbeSetCoreTotalMemory
(
const Enlighten::RadProbeSetCore * radProbeSetCore
)
Tells you how much memory in total is used by a RadProbeSetCore.
This is provided for information purposes only (it doesn't relate to any memory buffer requirement). It is simply the sum of the memory used by each of the RadDataBlocks and the RadProbeSetCore itself.
Parameters
[in] | radProbeSetCore | A non-null pointer to a valid RadProbeSetCore object. |
Returns
Memory in bytes, 0xFFFFFFF upon error.
Geo::u32 GEO_CALL Enlighten::CalcRadSystemCoreTotalMemory
public: Geo::u32GEO_CALL CalcRadSystemCoreTotalMemory
(
const Enlighten::RadSystemCore * radCore
)
Tells you how much memory in total is used by a RadSystemCore.
This is provided for information purposes only (it doesn't relate to any memory buffer requirement). It is simply the sum of the memory used by each of the RadDataBlocks and the RadSystemCore itself.
Parameters
[in] | radCore | A non-null pointer to a valid RadSystemCore object. |
Returns
Memory in bytes, 0xFFFFFFF upon error.
Geo::u32 GEO_CALL Enlighten::CalcRequiredPersistentDataSize
public: Geo::u32GEO_CALL CalcRequiredPersistentDataSize
(
const Enlighten::RadSystemCore * radCore
)
Tells you how much memory is required for the intermediate bounce output data for this radiosity core.
The bounce data is an output of SolveIrradianceTask, and an input to DoEndInputLightingTask and DoInputLightingTask.
Parameters
[in] | radCore | A pointer to a RadSystemCore to compute the bounce output size for. |
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
Geo::u32 GEO_CALL Enlighten::CalcRequiredWorkspaceMemory
public: Geo::u32GEO_CALL CalcRequiredWorkspaceMemory
(
const RadCubeMapCore * cubeMapCore
)
Tells you how much workspace memory is required by SolveCubeMapTask to solve a specific cube map.
Parameters
[in] | cubeMapCore | A non-null pointer to a valid RadCubeMapCore |
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::InputWorkspace * inputWorkspace
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::RadProbeSetCore * probeSetCore
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::RadCubeMapCore * cubeMapCore
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::RadSystemCore * radCore
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::InputWorkspaceMetaData * data
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::RadCubeMapMetaData * data
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::AlbedoBuffer * albedoBuffer
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::PrecomputedVisibilityData * visibilityData
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::DynamicMaterialWorkspace * materialWorkspace
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::IncidentLightingBuffer * incidentLightingBuffer
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::InputLightingBuffer * inputLightingBuffer
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::RadDataBlock & radDataBlock
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::RadSystemMetaData * data
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
void GEO_CALL Enlighten::ConvertEndian
public: void GEO_CALL ConvertEndian
(
Geo::EConvertEndianMode mode,
Enlighten::RadProbeSetMetaData * data
)
Converts the endian format of a runtime object.
All data generated by the precompute is in little endian format and before use on big endian machines (i.e. consoles) it must be converted to the native endian format using these functions. This conversion may be done on load, or by some user-defined content generation step. Note that the loader functions in EnlightenUtils assume the data files to be in little endian format, and call these functions at load time to flip them to the native format.
DirectionPalette* GEO_CALL Enlighten::CreateDirectionPalette
public: DirectionPalette *GEO_CALL CreateDirectionPalette
(
const Geo::v128 & BasisX,
const Geo::v128 & BasisY,
const Geo::v128 & BasisZ,
const Geo::s8 * coefficientOutputOrder,
void * mem
)
Create a Direction Palette for use with an EntireProbeSetTask.
The returned DirectionPalette can be used with any probeset with matching SH order, axis permutation and coefficient output order. The RadProbeSetMetaData class contains the shOrder, basis and coefficient output order for any given probeset.
Parameters
[in] | BasisX | The first of the basis directions. Must be a unit vector along either the X, Y, or Z axis. |
[in] | BasisY | The second of the basis directions. Must be a unit vector along either the X, Y, or Z axis. |
[in] | BasisZ | The third of the basis directions. Must be a unit vector along either the X, Y, or Z axis. |
[in] | coefficientOutputOrder | The output order of the SH coefficients. Must be 9 elements long. |
[in] | mem | A non-null pointer to a 16-byte aligned block of memory of size calculated with CalcDirectionPaletteSize. |
Returns
Pointer to created DirectionPalette, NULL if error.
bool GEO_CALL Enlighten::FreezeEntireProbeSetTask
public: bool GEO_CALL FreezeEntireProbeSetTask
(
const Enlighten::EntireProbeSetTask * task,
void * workspace,
Geo::u32 & timeUs,
Geo::u32 & numSolvedProbes
)
The temporal coherence optimization - if used - requires that all probe sets are kept in sync, so that no changes in lighting are missed.
Nevertheless, some probe sets can be updated less frequently than others by using the Freeze functions in place of a solve. FreezeEntireProbeSetTask performs the minimal housekeeping required to keep track of light changes for the temporal optimization - no output SH coefficients are updated. The input parameters are exactly the same as for SolveEntireProbeSetTask.
Parameters
[in] | task | A valid pointer to the probe task structure to freeze. |
[in] | workspace | A valid pointer to a block of memory to use as a workspace which must be at least as big as m_RequiredWorkspaceSize in the core meta data. |
[out] | timeUs | Number of microseconds it took to freeze the task. |
[out] | numSolvedProbes | Number of probes solved in the task. This will always be 0. |
bool GEO_CALL Enlighten::FreezeInputLightingBuffer
public: bool GEO_CALL FreezeInputLightingBuffer
(
InputLightingBuffer * lightingBuffer
)
The temporal coherence optimisation - if used - requires that all systems are kept in sync, so that no changes in lighting are missed.
Nevertheless, some systems can be updated less frequently than others by using the Freeze functions in place of a solve. FreezeInputLightingBuffer marks an input lighting buffer as frozen. Other systems reading this buffer then recognise that the input hasn't changed. (Neglecting to freeze buffers won't cause visual artefacts, but will result in performing more recalculations than necessary.)
Parameters
[in] | lightingBuffer | The input lighting buffer to mark as frozen. |
bool GEO_CALL Enlighten::FreezeIrradianceTask
public: bool GEO_CALL FreezeIrradianceTask
(
const Enlighten::RadIrradianceTask * task,
void * workspace,
Geo::u32 & timeUs,
Geo::u32 & numSolvedPixels
)
The temporal coherence optimization - if used - requires that all systems are kept in sync, so that no changes in lighting are missed.
Nevertheless, some systems can be updated less frequently than others by using the Freeze functions in place of a solve. FreezeIrradianceTask performs the minimal housekeeping required to keep track of light changes for the temporal optimization - no output textures are updated. The input parameters are exactly the same as for SolveIrradianceTask.
Parameters
[in] | task | A valid pointer to the irradiance task structure to freeze. |
[in] | workspace | A valid pointer to a block of memory to use as a workspace which must be at least as big as m_RequiredWorkspaceSize in the core meta data. |
[out] | timeUs | Number of microseconds it took to freeze the task. |
[out] | numSolvedPixels | Number of output pixels solved in the task. This will always be 0. |
const char* GEO_CALL Enlighten::GetEnlightenFormatFriendlyName
public: const char *GEO_CALL GetEnlightenFormatFriendlyName
(
Geo::u32 format
)
Helper function for getting irradiance output format friendly name.
GEO_FORCE_INLINE Geo::s32 GEO_CALL Enlighten::GetEnlightenOutputFormatBytesPerPixel
public: GEO_FORCE_INLINEGeo::s32GEO_CALL GetEnlightenOutputFormatBytesPerPixel
(
Geo::u32 outputFormat
)
Helper function to get the number of bytes/pixel per texture for a given output format.
bool GEO_CALL Enlighten::GetForceDisableFma4
public: bool GEO_CALL GetForceDisableFma4()
Get the state of the force disable FMA4 support flag.
Geo::GeoGuid GEO_CALL Enlighten::GetInputWorkspaceGUID
public: Geo::GeoGuidGEO_CALL GetInputWorkspaceGUID
(
const Enlighten::RadCubeMapCore * coreData,
Geo::s32 index
)
Returns the GUID of a specific entry in the expected input lighting buffer list.
Parameters
[in] | coreData | The core data to query. |
[in] | index | The index of the system to query. Must be >= 0 and less than the length returned by GetInputWorkspaceListLength. |
Geo::GeoGuid GEO_CALL Enlighten::GetInputWorkspaceGUID
public: Geo::GeoGuidGEO_CALL GetInputWorkspaceGUID
(
const Enlighten::RadProbeSetCore * coreData,
Geo::s32 index
)
Returns the GUID of a specific entry in the expected input lighting buffer list.
Parameters
[in] | coreData | The core data to query. |
[in] | index | The index of the system to query. Must be >= 0 and less than the length returned by GetInputWorkspaceListLength. |
Geo::GeoGuid GEO_CALL Enlighten::GetInputWorkspaceGUID
public: Geo::GeoGuidGEO_CALL GetInputWorkspaceGUID
(
const Enlighten::RadSystemCore * coreData,
Geo::s32 index
)
Returns the GUID of a specific entry in the expected input lighting buffer list.
Parameters
[in] | coreData | The core data to query. |
[in] | index | The index of the system to query. Must be >= 0 and less than the length returned by GetInputWorkspaceListLength. |
Geo::GeoGuid GEO_CALL Enlighten::GetInputWorkspaceGUID
public: Geo::GeoGuidGEO_CALL GetInputWorkspaceGUID
(
const Enlighten::RadDataBlock * dataBlock,
Geo::s32 index
)
Returns the GUID of a specific entry in the expected input lighting buffer list.
Parameters
[in] | dataBlock | The precomputed data block for the task. This should be RadSystemCore::m_RadiosityPrecomp (for RadIrradianceTask); RadProbeSetCore::m_ProbeSetPrecomp (for RadProbeTask); RadProbeSetCore::m_EntireProbeSetPrecomp (for EntireProbeSetTask; or RadCubeMapCore::m_ClusterCubeMapPrecomp (for RadCubeMapTask). |
[in] | index | The index of the system to query. Must be >= 0 and less than the length returned by GetInputWorkspaceListLength. |
Returns
The GUID of the entry, or GeoGuid::Invalid if out of range, or input invaild.
Geo::s32 GEO_CALL Enlighten::GetInputWorkspaceListLength
public: Geo::s32GEO_CALL GetInputWorkspaceListLength
(
const Enlighten::RadDataBlock * dataBlock
)
Returns the length of the input lighting buffer list expected when solving radiosity using this core data.
E.g. the number of pointers in m_InputLighting in RadIrradianceTask, RadProbeTask, EntireProbeSetTask or RadCubeMapTask.
Parameters
[in] | dataBlock | The precomputed data block for the task. This should be RadSystemCore::m_RadiosityPrecomp (for RadIrradianceTask); RadProbeSetCore::m_ProbeSetPrecomp (for RadProbeTask); RadProbeSetCore::m_EntireProbeSetPrecomp (for EntireProbeSetTask; or RadCubeMapCore::m_ClusterCubeMapPrecomp (for RadCubeMapTask). |
Returns
The length of the input lighting buffer list, or -1 if the input is invalid.
Geo::s32 GEO_CALL Enlighten::GetInputWorkspaceListLength
public: Geo::s32GEO_CALL GetInputWorkspaceListLength
(
const Enlighten::RadSystemCore * coreSystem
)
Returns the length of the input lighting buffer list expected when solving radiosity using this core data.
E.g. the number of pointers in m_InputLighting in RadIrradianceTask, or RadProbeTask. (In older versions of the API, the input lighting data was part of the input workspace object, which has resulted in some confusing terminology.)
Geo::s32 GEO_CALL Enlighten::GetInputWorkspaceListLength
public: Geo::s32GEO_CALL GetInputWorkspaceListLength
(
const Enlighten::RadCubeMapCore * coreCubeMap
)
Returns the length of the input lighting buffer list expected when solving radiosity using this core data.
E.g. the number of pointers in m_InputLighting in RadIrradianceTask, or RadProbeTask. (In older versions of the API, the input lighting data was part of the input workspace object, which has resulted in some confusing terminology.)
Geo::s32 GEO_CALL Enlighten::GetInputWorkspaceListLength
public: Geo::s32GEO_CALL GetInputWorkspaceListLength
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns the length of the input lighting buffer list expected when solving radiosity using this core data.
E.g. the number of pointers in m_InputLighting in RadIrradianceTask, or RadProbeTask. (In older versions of the API, the input lighting data was part of the input workspace object, which has resulted in some confusing terminology.)
Geo::s32 GEO_CALL Enlighten::GetNumOctreeNodes
public: Geo::s32GEO_CALL GetNumOctreeNodes
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns the number of octree nodes within the specified octree probe set.
Geo::s32 GEO_CALL Enlighten::GetNumVirtualProbes
public: Geo::s32GEO_CALL GetNumVirtualProbes
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns the number of virtual probes within the specified probe set.
const Enlighten::ProbeSetOctreeNode* GEO_CALL Enlighten::GetOctreeNodes
public: const Enlighten::ProbeSetOctreeNode *GEO_CALL GetOctreeNodes
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns a pointer to the array of octree nodes within the specified octree probe set.
Geo::u32 GEO_CALL Enlighten::GetOctreeNumLods
public: Geo::u32GEO_CALL GetOctreeNumLods
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns the number of LODs for the specified octree probe set.
Geo::u32 GEO_CALL Enlighten::GetOctreeNumProbesLod
public: Geo::u32GEO_CALL GetOctreeNumProbesLod
(
const Enlighten::RadProbeSetCore * probeSetCore,
Geo::u32 Lod
)
Returns the number of probes within the specified LOD for the specified octree probe set.
Geo::u32 GEO_CALL Enlighten::GetOctreeNumVirtualProbesLod
public: Geo::u32GEO_CALL GetOctreeNumVirtualProbesLod
(
const Enlighten::RadProbeSetCore * probeSetCore,
Geo::u32 Lod
)
Returns the number of virtual probes within the specified LOD for the specified octree probe set.
Geo::u32 GEO_CALL Enlighten::GetOctreePppiInstanceCount
public: Geo::u32GEO_CALL GetOctreePppiInstanceCount
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns the number of PPPI instances within the specified octree probe set.
Geo::u32 GEO_CALL Enlighten::GetOctreePppiInstanceCount
public: Geo::u32GEO_CALL GetOctreePppiInstanceCount
(
const Enlighten::RadProbeSetCore * probeSetCore,
Geo::u32 lod
)
Returns the number of PPPI instances within the specified octree probe set at the specified lod.
const Geo::u16* GEO_CALL Enlighten::GetOctreePppiInstanceProbeIds
public: const Geo::u16 *GEO_CALL GetOctreePppiInstanceProbeIds
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns a pointer to the array of PPPI instance probe ids within the specified octree probe set.
const Geo::u16* GEO_CALL Enlighten::GetOctreePppiNodes
public: const Geo::u16 *GEO_CALL GetOctreePppiNodes
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns a pointer to the array of PPPI nodes within the specified octree probe set.
const Geo::u32* GEO_CALL Enlighten::GetOctreePppiProbeInstances
public: const Geo::u32 *GEO_CALL GetOctreePppiProbeInstances
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns a pointer to the array of PPPI probe instances within the specified octree probe set.
Geo::u32 GEO_CALL Enlighten::GetOctreePppiTargetCount
public: Geo::u32GEO_CALL GetOctreePppiTargetCount
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns the number of PPPI targets within the specified octree probe set.
const Geo::u16* GEO_CALL Enlighten::GetOctreePppiTargets
public: const Geo::u16 *GEO_CALL GetOctreePppiTargets
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns a pointer to the array of PPPI targets within the specified octree probe set.
const Geo::u32* GEO_CALL Enlighten::GetOctreeRootProbes
public: const Geo::u32 *GEO_CALL GetOctreeRootProbes
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns a pointer to the root probes in the specified octree probe set.
The lower 2x2x2 entries of the flattened 3x3x3 array contain the 8 corner probes.
eSolverType Enlighten::GetOptimisedSolverForPlatform
public: eSolverType GetOptimisedSolverForPlatform
(
Geo::ePlatform platform
)
Function returning the correct optimised solver based on the compilation environment.
Geo::GeoPoint2D Enlighten::GetOutputTextureSize
public: Geo::GeoPoint2D GetOutputTextureSize
(
const RadSystemCore & core
)
Returns the size of the output texture required for this radiosity data.
Geo::s32 Enlighten::GetOutputTextureSize
public: Geo::s32 GetOutputTextureSize
(
const RadCubeMapCore & core
)
Returns the size of the output texture required for this radiosity data.
const float* GEO_CALL Enlighten::GetProbeEnvironmentVisibility
public: const float *GEO_CALL GetProbeEnvironmentVisibility
(
Geo::s32 probeId,
const Enlighten::RadProbeSetCore * probeSetCore
)
Retrieves the light probe environment visibility for the given probe in the volume probe data.
The visibility data is encoded as a spherical harmonic with a number of coefficients depending on the precompute settings used to create the probe set. The number of coefficients can be retrieved from the probeSetCore metadata. The visibility pointer must point to a buffer that is large enough to accommodate the coefficients. Returns a pointer to the visibility data, this pointer will be NULL if the environment visibility is disabled or the probe has been culled by the precompute.
Parameters
[in] | probeId | The volumetric probe to query. |
[in] | probeSetCore | The volumetric probe data to query. |
bool GEO_CALL Enlighten::GetProbeVisibility
public: bool GEO_CALL GetProbeVisibility
(
Geo::s32 probeId,
const Enlighten::RadProbeSetCore * probeSetCore,
float * visibility
)
Retrieves the light probe visibility for the given probe in the volume probe data.
Returns TRUE on success.
Parameters
[in] | probeId | The volumetric probe to query. |
[in] | probeSetCore | The volumetric probe data to query. |
[out] | visibility | The volumetric probe visibility. |
const Enlighten::ProbeSetVirtualProbe* GEO_CALL Enlighten::GetVirtualProbes
public: const Enlighten::ProbeSetVirtualProbe *GEO_CALL GetVirtualProbes
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns a pointer to the array of virtual probes within the specified probe set.
This data can be used to produce the output for virtual probe indices in a single pass. A probe index is virtual when it is greater than the number of probes in the probe set. To find the corresponding index within the virtual probe array, subtract the number of probes in the probe set. The first entry in the array always refers to a pair of real probes. Later entries may be virtual probe indices which refer to virtual probes that appear earlier in the same array.
Geo::u32 GEO_CALL Enlighten::HashInputLightingElements
public: Geo::u32GEO_CALL HashInputLightingElements
(
const InputLightingBuffer ** inputLightingArray,
Geo::s32 numBuffers
)
Hash the guids and pointers of the InputLightingBuffer array.
Parameters
[in] | inputLightingArray | An array of InputLightingBuffers to hash. This hash included the pointer values. |
[in] | numBuffers | The number of InputLightingBuffers in the array. |
Returns
The hash of the inputs.
GEO_FORCE_INLINE bool GEO_CALL Enlighten::IsFixedPointFormat
public: GEO_FORCE_INLINE bool GEO_CALL IsFixedPointFormat
(
eOutputFormat format
)
Returns true for formats with a fixed range (0-1).
To retain HDR output the user should set the irradiance scale to a value < 1.0, and scale the output back up in the shader code.
bool GEO_CALL Enlighten::IsInputLightingBufferStatic
public: bool GEO_CALL IsInputLightingBufferStatic
(
const InputLightingBuffer * lightingBuffer
)
Returns true if the given light input buffer did not change the last time it was updated.
Parameters
[in] | lightingBuffer | The lighting buffer to check for changes. |
Returns
Returns TRUE if the lighting buffer is static; FALSE if it has changed.
bool GEO_CALL Enlighten::IsProbeCulled
public: bool GEO_CALL IsProbeCulled
(
Geo::s32 probeId,
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns TRUE if the probe was culled during precompute.
Parameters
[in] | probeId | The volumetric probe to query. |
[in] | probeSetCore | The volumetric probe data to query. |
GEO_FORCE_INLINE bool GEO_CALL Enlighten::IsValidOutputFormat
public: GEO_FORCE_INLINE bool GEO_CALL IsValidOutputFormat
(
Geo::u32 outputFormat
)
Checks if the given output format enumeration is valid.
bool GEO_CALL Enlighten::PrepareInputLightingList
public: bool GEO_CALL PrepareInputLightingList
(
const Enlighten::RadDataBlock * dataBlock,
const Enlighten::InputLightingBuffer ** inputLightingBuffers,
Geo::s32 numLightingBuffers,
const Enlighten::InputLightingBuffer ** listILBOut
)
Places the unordered list of lighting buffers into the correct order for the solver.
RadIrradianceTask, RadProbeTask, EntireProbeSetTask and RadCubeMapTask all expect a pointer to an ordered
list of input lighting buffers. This saves the overhead of sorting and searching for systems inside each call. In most situations, it will be possible to call this function once and cache the results for repeated use over many frames. A new list will be required only when systems are allocated (loaded) or deallocated (unloaded).
Parameters
[in] | dataBlock | The precomputed data block for the task. This should be RadSystemCore::m_RadiosityPrecomp (for RadIrradianceTask); RadProbeSetCore::m_ProbeSetPrecomp (for RadProbeTask); RadProbeSetCore::m_EntireProbeSetPrecomp (for EntireProbeSetTask; or RadCubeMapCore::m_ClusterCubeMapPrecomp (for RadCubeMapTask). |
[in] | inputLightingBuffers | The unordered list of lighting buffers. |
[in] | numLightingBuffers | The number of lighting buffers provided. |
[in] | listILBOut | The location to write the new list to. This array of pointers must be the length returned by GetInputWorkspaceListLength(). |
bool GEO_CALL Enlighten::PrepareInputLightingList
public: bool GEO_CALL PrepareInputLightingList
(
const Enlighten::RadProbeSetCore * coreData,
const Enlighten::InputLightingBuffer ** inputLightingBuffers,
Geo::s32 numLightingBuffers,
const Enlighten::InputLightingBuffer ** listILBOut
)
Places the unordered list of lighting buffers into the correct order for the solver.
RadIrradianceTask, RadProbeTask and RadCubeMapTask all expect a pointer to an ordered
list of input lighting buffers. This saves the overhead of sorting and searching for systems inside each call. In most situations, it will be possible to call this function once and cache the results for repeated use over many frames. A new list will be required only when systems are allocated (loaded) or deallocated (unloaded).
Parameters
[in] | coreData | The core data to prepare the input list for. |
[in] | inputLightingBuffers | The unordered list of lighting buffers. |
[in] | numLightingBuffers | The number of lighting buffers provided. |
[in] | listILBOut | The location to write the new list to. This array of pointers must be the length returned by GetInputWorkspaceListLength(). |
bool GEO_CALL Enlighten::PrepareInputLightingList
public: bool GEO_CALL PrepareInputLightingList
(
const Enlighten::RadCubeMapCore * coreData,
const Enlighten::InputLightingBuffer ** inputLightingBuffers,
Geo::s32 numLightingBuffers,
const Enlighten::InputLightingBuffer ** listILBOut
)
Places the unordered list of lighting buffers into the correct order for the solver.
RadIrradianceTask, RadProbeTask and RadCubeMapTask all expect a pointer to an ordered
list of input lighting buffers. This saves the overhead of sorting and searching for systems inside each call. In most situations, it will be possible to call this function once and cache the results for repeated use over many frames. A new list will be required only when systems are allocated (loaded) or deallocated (unloaded).
Parameters
[in] | coreData | The core data to prepare the input list for. |
[in] | inputLightingBuffers | The unordered list of lighting buffers. |
[in] | numLightingBuffers | The number of lighting buffers provided. |
[in] | listILBOut | The location to write the new list to. This array of pointers must be the length returned by GetInputWorkspaceListLength(). |
bool GEO_CALL Enlighten::PrepareInputLightingList
public: bool GEO_CALL PrepareInputLightingList
(
const Enlighten::RadSystemCore * coreData,
const Enlighten::InputLightingBuffer ** inputLightingBuffers,
Geo::s32 numLightingBuffers,
const Enlighten::InputLightingBuffer ** listILBOut
)
Places the unordered list of lighting buffers into the correct order for the solver.
RadIrradianceTask, RadProbeTask and RadCubeMapTask all expect a pointer to an ordered
list of input lighting buffers. This saves the overhead of sorting and searching for systems inside each call. In most situations, it will be possible to call this function once and cache the results for repeated use over many frames. A new list will be required only when systems are allocated (loaded) or deallocated (unloaded).
Parameters
[in] | coreData | The core data to prepare the input list for. |
[in] | inputLightingBuffers | The unordered list of lighting buffers. |
[in] | numLightingBuffers | The number of lighting buffers provided. |
[in] | listILBOut | The location to write the new list to. This array of pointers must be the length returned by GetInputWorkspaceListLength(). |
bool GEO_CALL Enlighten::ResampleBounce
public: bool GEO_CALL ResampleBounce
(
const Enlighten::ResampleBounceParameters & params,
Geo::u32 & timeUs
)
After SolveIrradianceTask is run, the ResampleBounce() function populates an Enlighten::BounceBuffer with bounce data.
This BounceBuffer is then used as input to the IndirectInputLighting stage for the next solve iteration.
Parameters
[in] | params | A complete and valid ResampleBounceParameters |
[out] | timeUs | Number of microseconds it took to Resample the bounce |
void GEO_CALL Enlighten::SetForceDisableFma4
public: void GEO_CALL SetForceDisableFma4
(
bool disableFma4
)
Set whether to force disable FMA4 support.
This only affects the SSE solver, and has no effect on other architectures. By default, if FMA4 support is detected in the hardware and OS it will be used by the solver. This function allows you to override the automatic detection and force FMA4 support off. There is no way to force it on if Enlighten cannot detect it.
bool GEO_CALL Enlighten::SolveBounceBufferTask
public: bool GEO_CALL SolveBounceBufferTask
(
const Enlighten::SolveBounceTask * task,
void * workspace,
Geo::u32 & timeUs,
Geo::u32 & numSolvedClusters
)
Solve the radiosity directly to a bounce buffer only.
This does not update the lightmap. All parameters must be valid non-null objects.
Parameters
[in] | task | A valid pointer to the RadIrradianceTaskLod structure to complete. |
[in] | workspace | A valid pointer to a block of memory to use as a workspace which must be at least as big as m_RequiredWorkspaceSize in the core meta data. |
[out] | timeUs | Number of microseconds it took to solve the task. |
[out] | numSolvedClusters | Number of output pixels solved in the task. |
bool GEO_CALL Enlighten::SolveCubeMapTask
public: bool GEO_CALL SolveCubeMapTask
(
const Enlighten::RadCubeMapTask * task,
void * workspace,
Geo::u32 & timeUs,
Geo::u32 & numSolvedPixels
)
Solve the specified cube map task using a given workspace.
Returns TRUE on success. All parameters must be valid non-null objects.
Parameters
[in] | task | A valid pointer to the cube map task structure to complete. |
[in] | workspace | A valid pointer to a block of memory to use as a workspace which must be at least as big as the amount returned from CalcRequiredWorkspaceMemory(). |
[out] | timeUs | Number of microseconds it took to solve the task. |
[out] | numSolvedPixels | Number of output pixels solved in the task. |
bool GEO_CALL Enlighten::SolveEntireProbeSetTask
public: bool GEO_CALL SolveEntireProbeSetTask
(
const Enlighten::EntireProbeSetTask * task,
void * workspace,
Geo::u32 & timeUs,
Geo::u32 & numSolvedProbes
)
Solve the specified EntireProbeSetTask.
bool GEO_CALL Enlighten::SolveIrradianceTask
public: bool GEO_CALL SolveIrradianceTask
(
const Enlighten::RadIrradianceTask * task,
void * workspace,
Geo::u32 & timeUs,
Geo::u32 & numSolvedPixels
)
Solve the specified irradiance task using a given workspace.
Returns TRUE on success. All parameters must be valid non-null objects.
Parameters
[in] | task | A valid pointer to the irradiance task structure to complete. |
[in] | workspace | A valid pointer to a block of memory to use as a workspace which must be at least as big as m_RequiredWorkspaceSize in the core meta data. |
[out] | timeUs | Number of microseconds it took to solve the task. |
[out] | numSolvedPixels | Number of output pixels solved in the task. |
bool GEO_CALL Enlighten::SolveProbeTaskL1
public: bool GEO_CALL SolveProbeTaskL1
(
const Enlighten::RadProbeTask * task,
Geo::u32 & timeUs
)
Solve the specified L1 probe task.
Returns TRUE on success. Returns FALSE if the input task is precomputed as L2.
Parameters
[in] | task | A valid pointer to the probe task structure to complete. |
[out] | timeUs | Returns the number of microseconds taken to perform the compute |
bool GEO_CALL Enlighten::SolveProbeTaskL2
public: bool GEO_CALL SolveProbeTaskL2
(
const Enlighten::RadProbeTask * task,
Geo::u32 & timeUs
)
Solve the specified L2 probe task.
Returns TRUE on success. Returns FALSE if the input task is precomputed as L1.
Parameters
[in] | task | A valid pointer to the probe task structure to complete. |
[out] | timeUs | Returns the number of microseconds taken to perform the compute |
eOutputFormat
public: enum eOutputFormat
{
OUTPUT_FORMAT_FP16 = 0,
OUTPUT_FORMAT_LRB = 2,
OUTPUT_FORMAT_R11G11B10 = 4,
OUTPUT_FORMAT_R9G9B9E5 = 5,
OUTPUT_FORMAT_RGBM = 6,
OUTPUT_FORMAT_DIRECT_TO_BOUNCE = 7,
NUM_OUTPUT_FORMATS
}
Output formats.
enumerators
OUTPUT_FORMAT_FP16 | 16-bits-per-pixel-per-channel floating point (D3DFMT_A16B16G16R16F; 8 byte per pixel). |
OUTPUT_FORMAT_LRB | 16 bit fixed point luminance; 8 bit red and blue (D3DFMT_A8R8G8B8; 4 byte per pixel). |
OUTPUT_FORMAT_R11G11B10 | Floating point, 11 bits per channel R and G, with 10 bit B. Identical to DX11 format DXGI_FORMAT_R11G11B10_FLOAT (http://msdn.microsoft.com/en-gb/library/windows/desktop/bb173059(v=vs.85).aspx) |
OUTPUT_FORMAT_R9G9B9E5 | Floating point, 9 bits per channel mantissa with shared 5 bit exponent. Identical to DX11 format DXGI_FORMAT_R9G9B9E5_SHAREDEXP (http://msdn.microsoft.com/en-gb/library/windows/desktop/bb173059(v=vs.85).aspx) |
OUTPUT_FORMAT_RGBM | 8 bit fixed point red, green and blue, with an 8 bit multiplier. |
OUTPUT_FORMAT_DIRECT_TO_BOUNCE | Format used internally for solving direct to the bounce buffer. |
NUM_OUTPUT_FORMATS |
eOutputFormatByteOrder
public: enum eOutputFormatByteOrder
{
OUTPUT_FORMAT_BYTE_ORDER_BGRA = 0,
OUTPUT_FORMAT_BYTE_ORDER_RGBA = 1
}
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.
This applies to the directional output texture and to irradiance or cube map textures in LRB format. This enum only affects the SSE, NEON and reference solvers.
enumerators
OUTPUT_FORMAT_BYTE_ORDER_BGRA | Write 8-bit-per-pixel textures in BGRA (DX9) byte order. |
OUTPUT_FORMAT_BYTE_ORDER_RGBA | Write 8-bit-per-pixel textures in RGBA (DX11) byte order. |
eProbeOutputFormat
public: enum eProbeOutputFormat
{
PROBE_OUTPUT_FORMAT_FP16 = 0,
PROBE_OUTPUT_FORMAT_FP32 = 1,
NUM_PROBE_OUTPUT_FORMATS = 2
}
Probe Interpolation output formats.
enumerators
PROBE_OUTPUT_FORMAT_FP16 | 16-bits-per-pixel-per-channel floating point. |
PROBE_OUTPUT_FORMAT_FP32 | 32-bits-per-pixel-per-channel floating point. |
NUM_PROBE_OUTPUT_FORMATS | Number of available output formats. |
eRadDataType
public: enum eRadDataType
{
RDT_INVALID = 0,
RDT_RAD_CORE = 1,
RDT_RAD_PROJECTION_DATA = 2,
RDT_INPUT_WORKSPACE = 4,
RDT_PROBE_SET_CORE = 5,
RDT_CAW_CLUSTER_MATERIALS = 6,
RDT_TAW_MATERIAL_RUNS = 7,
RDT_AW_MATERIAL_GUIDS = 8,
RDT_INPUT_LIGHTING_BUFFER = 9,
RDT_RAD_CUBE_MAP_CORE = 10,
RDT_INPUT_PROJECTED_POINTS = 15,
RDT_INPUT_SOURCE_MESH_DATA = 16,
RDT_PROBE_SET_OCTREE = 17,
RDT_PROBE_SET_INTERPOLATION = 18,
RDT_PROBE_SET_VISIBILITY = 19,
RDT_PROBE_SET_OCTREE_VISIBILITY = 20,
RDT_INPUT_HQ_BOUNCE_COORDINATES = 21,
RDT_INPUT_CLUSTER_PROBE_OFFSETS = 22,
RDT_INPUT_CLUSTER_PROBE_BOUNCE_DATA = 23,
RDT_ENTIRE_PROBE_SET_CORE = 24,
RDT_CLUSTER_ALBEDO_WORKSPACE = 25,
RDT_PROBE_SET_DEBUG_DATA = 26,
RDT_RAD_RESAMPLING_DATA = 27,
RDT_ALBEDO_BUFFER = 28,
RDT_EMISSIVE_BUFFER = 29,
RDT_INCIDENT_LIGHTING_BUFFER = 30,
RDT_DYNAMIC_MATERIAL_WORKSPACE = 31,
RDT_TRANSPARENCY_BUFFER = 32,
RDT_RAD_CORE_BOUNCE = 33
}
Valid data types for use with the RadDataBlock class.
enumerators
RDT_INVALID | |
RDT_RAD_CORE | |
RDT_RAD_PROJECTION_DATA | |
RDT_INPUT_WORKSPACE | |
RDT_PROBE_SET_CORE | |
RDT_CAW_CLUSTER_MATERIALS | |
RDT_TAW_MATERIAL_RUNS | |
RDT_AW_MATERIAL_GUIDS | |
RDT_INPUT_LIGHTING_BUFFER | |
RDT_RAD_CUBE_MAP_CORE | |
RDT_INPUT_PROJECTED_POINTS | |
RDT_INPUT_SOURCE_MESH_DATA | |
RDT_PROBE_SET_OCTREE | |
RDT_PROBE_SET_INTERPOLATION | |
RDT_PROBE_SET_VISIBILITY | |
RDT_PROBE_SET_OCTREE_VISIBILITY | |
RDT_INPUT_HQ_BOUNCE_COORDINATES | |
RDT_INPUT_CLUSTER_PROBE_OFFSETS | |
RDT_INPUT_CLUSTER_PROBE_BOUNCE_DATA | |
RDT_ENTIRE_PROBE_SET_CORE | |
RDT_CLUSTER_ALBEDO_WORKSPACE | |
RDT_PROBE_SET_DEBUG_DATA | |
RDT_RAD_RESAMPLING_DATA | |
RDT_ALBEDO_BUFFER | |
RDT_EMISSIVE_BUFFER | |
RDT_INCIDENT_LIGHTING_BUFFER | |
RDT_DYNAMIC_MATERIAL_WORKSPACE | |
RDT_TRANSPARENCY_BUFFER | |
RDT_RAD_CORE_BOUNCE |
eSHOrder
public: enum eSHOrder
{
SH_ORDER_DISABLED = 0,
SH_ORDER_L0 = 1,
SH_ORDER_L1 = 4,
SH_ORDER_L2 = 9
}
Supported Spherical Harmonic types.
enumerators
SH_ORDER_DISABLED | disabled spherical harmonic |
SH_ORDER_L0 | L=0 spherical harmonics (DC component only) |
SH_ORDER_L1 | L=1 spherical harmonics. |
SH_ORDER_L2 | L=2 spherical harmonics. |
eSolverType
public: enum eSolverType
{
SOLVER_REFERENCE = 0,
SOLVER_SSE = 1,
SOLVER_NEON = 5
}
Valid solver types for use with the RadDataBlock class.
enumerators
SOLVER_REFERENCE | All reference solvers. |
SOLVER_SSE | SSE2+ compatible architecture (usually a Windows PC) |
SOLVER_NEON | ARM NEON (most iOS and Android) |