This is the documentation for Enlighten.
class Enlighten IPrecompute
class Enlighten::IPrecompute
The Low Level Enlighten Precompute API.
Enums
Name | Description |
|---|---|
Controls if Precompute should generate data that can be used by older Enlighten run time APIs. | |
Controls the amount of reproduction data saved by the IPrecompute tasks. |
Functions
Name | Description |
|---|---|
Assemble system geometry. | |
Calculate system dependencies for a cube map. | |
Calculate system dependencies for a probe set. | |
Calculate system dependencies for a system. | |
Calculate dependencies for the input systems. | |
Decides whether a given geometry instance should be probe-lit or lightmap-lit based on how good its generated Auto UVs are. | |
Decides which probe-lit instances should be contributing ("Probe Radiosity") and which should not ("Fully Dynamic") based on how much light each instance and its neighbours could block. | |
Extract some data about the clustering process. | |
Compile the data from the cube map output object into runtime format. | |
CompileDepthCubeMap(const IPrecompOutputCubeMap *, IPrecompDepthCubeMap *&) | Compile the depth data from the cube map output object. |
Compile the data from the dusters and radiosity cores into an InputWorkspace. | |
Extract some data about the light transport process. | |
Compile the data from the dusters into a ClusterAlbedoWorkspaceMaterialData. | |
Compile the data from the probeset light transport into runtime format. | |
Compile the data from the light transport into runtime format. | |
Compile the radiosity normal texture from the light transport data. | |
Compress the data from the light transport into a tighter format. | |
Create clustering for a system. | |
Run the precompute for a cube map. | |
Create the light transport for a system. | |
Automatically place probes within a volume, based on distance to geometry. | |
Create pre-clustering for a system. | |
Automatically place probes within a volume, based on distance to geometry. | |
Create the spherical harmonic data for an SH probe set. | |
Create the platform-agnostic runtime input sample points. | |
Create the platform-agnostic runtime input sample points including versions of projected points. | |
Split the input system into automatically generated systems. | |
Split the input system into automatically generated systems. | |
Create precomputed visibility data for directional lights for a system. | |
DumpInputProbeRegion(const IPrecompInputProbeRegion *, const char *) | Dump debug data for a probe region. |
ExtractOctreeProbeSet(const IPrecompOutputProbeOctree *, Geo::s32, IPrecompInputProbeSet *&) | Extract a probe set containing automatically placed probes from a probe octree. |
Extract a probe set containing automatically placed probes from a probe octree. | |
Number of full days remaining for the set license. Returns -1 if the set license is invalid and/or outdated. | |
PackGeometry(const IPrecompInputGeometry *, Geo::IGeoProgressProxy *, IPrecompPackedGeometry *&) | Simplify and pack geometry meshes. |
Pack systems. | |
Project detail meshes in an pInputGeometry onto target clusters from pBaseGeometries This is guaranteed not to change the pInputGeometry and pBaseGeometries in any way, so can be done after a precompute to get new UVs for a detail mesh that was not known about when the last precompute was run. | |
Project a system comprised entirely of detail mesh instances across another system. | |
Free this object that was created within the Enlighten libraries. | |
Sets the hardware mode for the Enlighten precompute. | |
Sets the maximum number of threads that the Cpu mode will use. | |
Set the license string. Must set before any precompute action. | |
Sets the total number of rays that the precompute will generate at one time. Set this only if you are concerned about memory pressure. | |
Sets the minimum version of Enlighten, precompute should generate data for (default is emcvEnlighten3). | |
Sets the level of reproduction data saved by the IPrecompute tasks. | |
Sets the folder that shall contain reproduction data for the IPrecompute tasks. | |
Stitch one octree with others to produce an output probe octree. | |
Examine the incoming data and determine if the supplied parameters will violate memory or reasonable performance limits. | |
ValidateGeometryParameters(const IPrecompInputGeometry *, Geo::s32 *, Geo::IGeoProgressProxy *) | Examine the incoming geometry and determine if the supplied parameters violate memory and performance limits. |
EMinimumCompatibleVersion
public: enum EMinimumCompatibleVersion
{
emcvEnlighten3
}
Controls if Precompute should generate data that can be used by older Enlighten run time APIs.
enumerators
emcvEnlighten3 | Generate precompute data that can be consumed by Enlighten3 (and later) API. |
EStateDump
public: enum EStateDump
{
esdNone,
esdInputsOnly,
esdAll
}
Controls the amount of reproduction data saved by the IPrecompute tasks.
enumerators
esdNone | Do not save any dump files. |
esdInputsOnly | Save files containing the inputs provided by the user. |
esdAll | Save files at the input to every task, including generated files. |
virtual Geo::s32 Enlighten::IPrecompute::AssembleSystemGeometry
public: Geo::s32 AssembleSystemGeometry
(
const IPrecompInputSystem * pSystem,
const IPrecompInputGeometry *const * ppInputGeometry,
Geo::s32 numGeometries,
Geo::IGeoProgressProxy * progress,
IPrecompPackedSystem *& oSystem
)
Assemble system geometry.
If a system is going to be used as probe radiosity, then the input processing is greatly reduced (there is no need to pack the geometry and create the UV chart mappings).
Parameters
[in] | pSystem | The system to pack |
[in] | ppInputGeometry | The geometry referred to (by Id) in this system's PrecompInputInstances. You may pass more geometry items than are necessary, but all Id's used in the instances must have a packed geometry available. |
[in] | numGeometries | The number of packed geometry classes in the above array |
[in] | progress | This object is updated during this function call to give feedback on progress |
[out] | oSystem | The final packed system |
virtual Geo::s32 Enlighten::IPrecompute::CalculateCubeMapSystemDependencies
public: Geo::s32 CalculateCubeMapSystemDependencies
(
const IPrecompInputCubeMap * pCubeMap,
const IPrecompPackedSystem *const * ppSystems,
Geo::s32 numSystems,
Geo::IGeoProgressProxy * progress,
IPrecompSystemDependencies *& oDependencies
)
Calculate system dependencies for a cube map.
Each IPrecompInputCubeMap may have dependencies calculated by calling this function on it. All packed systems which are fully loaded will have their geometry fully represented in the visibility tests. Packed systems which only have a header (ie whose geometry isn't loaded) will be represented by their bounding boxes in the visibility tests. (In the HLBS these sets of systems are controlled by the "expansionDistance" parameter.)
Parameters
[in] | pCubeMap | The cube map for which to calculate dependencies |
[in] | ppSystems | The list of systems to include in this calculation. |
[in] | numSystems | The number of packed systems in the above array |
[in] | progress | This object is updated during this function call to give feedback on progress |
[out] | oDependencies | The approximate set of system dependencies, which may be fed back into the precompute. |
virtual Geo::s32 Enlighten::IPrecompute::CalculateProbeSetSystemDependencies
public: Geo::s32 CalculateProbeSetSystemDependencies
(
const IPrecompInputProbeSet * pProbeInput,
const IPrecompPackedSystem *const * ppSystems,
Geo::s32 numSystems,
Geo::IGeoProgressProxy * progress,
IPrecompSystemDependencies *& oDependencies
)
Calculate system dependencies for a probe set.
Each IPrecompInputProbeSet may have dependencies calculated by calling this function on it. The collection of systems passed in determines the connectivity between them, so completely isolated systems have a numSystems of 1. All packed systems which are fully loaded will have their geometry fully represented in the visibility tests. Packed systems which only have a header (ie whose geometry isn't loaded) will be represented by their bounding boxes in the visibility tests. (In the HLBS these sets of systems are controlled by the "expansionDistance" parameter.)
Parameters
[in] | pProbeInput | The probe set for which to calculate dependencies |
[in] | ppSystems | The list of systems to include in this calculation. |
[in] | numSystems | The number of packed systems in the above array |
[in] | progress | This object is updated during this function call to give feedback on progress |
[out] | oDependencies | The approximate set of system dependencies, which may be fed back into the precompute. |
virtual Geo::s32 Enlighten::IPrecompute::CalculateSystemDependencies
public: Geo::s32 CalculateSystemDependencies
(
const IPrecompPackedSystem * pSystem,
const IPrecompPackedSystem *const * ppSystems,
Geo::s32 numSystems,
float rayOriginsPerPixelArea,
Geo::IGeoProgressProxy * progress,
IPrecompSystemDependencies *& oDependencies
)
Calculate system dependencies for a system.
Each IPrecompInputSystem may have dependencies calculated by calling this function on it. The collection of systems passed in determines the connectivity between them, so completely isolated systems have a numSystems of 1. All packed systems which are fully loaded will have their geometry fully represented in the visibility tests. Packed systems which only have a header (ie whose geometry isn't loaded) will be represented by their bounding boxes in the visibility tests. (In the HLBS these sets of systems are controlled by the "expansionDistance" parameter.)
Parameters
[in] | pSystem | The system for which to calculate dependencies |
[in] | ppSystems | The list of systems to include in this calculation. It must include at least the system in the previous argument. |
[in] | numSystems | The number of packed systems in the above array |
[in] | rayOriginsPerPixelArea | Density of ray origins - i.e. num of ray origins = rayOriginsPerPixelArea * SystemWorldArea/(minSystemPixelSize^2) |
[in] | progress | This object is updated during this function call to give feedback on progress |
[out] | oDependencies | The approximate set of system dependencies, which may be fed back into the precompute. |
virtual Geo::s32 Enlighten::IPrecompute::CalculateSystemDependenciesByDistance
public: Geo::s32 CalculateSystemDependenciesByDistance
(
const IPrecompInputSystem *const * pInputSystems,
Geo::s32 numSystems,
const IPrecompInputGeometry *const * pInputGeoms,
Geo::s32 numGeoms,
float maxDistanceInPixelSizeUnits,
bool estimateFromCentre,
Geo::IGeoProgressProxy * progress,
IPrecompSystemsDependencies *& oDependencies
)
Calculate dependencies for the input systems.
System A is dependent on system B if the centres of A and B are at a distance equal or smaller than the maxDistanceInPixelSizeUnits multiplied by the minimum pixel size of the instances in system B.
Parameters
[in] | pInputSystems | The input systems that will get their dependencies calculated. |
[in] | numSystems | The number of input systems |
[in] | pInputGeoms | A collection of input geometry objects, referred to by the input systems above. |
[in] | numGeoms | How many entries in the pInputGeometry array. |
[in] | maxDistanceInPixelSizeUnits | If system A's bounding box is closer than maxDistanceInPixelSizeUnits * (minPixelSize of system B) to system's B bounding box, than system A is dependent on system B. minPixelSize of a system is a minimal value of an output pixel size present among input instances making up that system. |
[in] | estimateFromCentre | If true the distance between bounding box centres is evaluated, if false the actual distance between the bounding boxes is considered (i.e. overlapping bounding boxes have a distance of less than zero. |
[in] | progress | This object is updated during this function call to give feedback on progress. |
[out] | oDependencies | Dependencies for the input systems. |