This is the documentation for Enlighten.
namespace Enlighten
- geosw (Unlicensed)
Enlighten
Classes
| Name | Description |
|---|---|
| Enlighten::A8CpuTextureSampler | A8 texture sampler. |
| Enlighten::AllFilter | Return all light types. |
| Enlighten::Alpha8Normalised | Class to store a normalised single channel value in 1 byte. |
| Enlighten::AsyncTaskThreadGroup | 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. |
| Enlighten::BakedProbeOutputInfo | 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. |
| Enlighten::BakeInputLight | The input light type for baking. |
| Enlighten::BakeInputMeshInfo | Data about a mesh, used as a parameter to IBakeInputSystem::AddMesh. |
| Enlighten::BakeInputTexture | Texture object for the Baking. |
| Enlighten::BakeMaterialInfo | The material description for baking. |
| Enlighten::BaseAlbedoHandler | Base Albedo Handler. |
| Enlighten::BaseCubeMap | Base class used by the update manager to hold all of the resources for a cube map (regardless of where the solving happens). |
| Enlighten::BaseDynamicObject | Base class which holds everything a dynamic object must have (regardless of where the solving happens). |
| Enlighten::BaseEnvironment | Trivial base class used to lend a base type to environment maps. |
| Enlighten::BaseProbeSet | Class used by the update manager to hold all of the resources for a probe set together. |
| Enlighten::BaseSystem | Base class which holds everything a system must have (regardless of where the solving happens). |
| Enlighten::BaseSystemSolutionSpace | Base implementation of ISystemSolutionSpace. |
| Enlighten::BaseWorker | Base implementation of the worker class, containing functionality common to all platforms. |
| Enlighten::BoundingBox2D | Bounding box in 2D. |
| Enlighten::BoxSpotlight | BoxSpotlight class used by extended input lighting. |
| Enlighten::BoxVolume | Box volume primitive. |
| Enlighten::CachedLightSelector | Selects the Cached type for the input light. |
| Enlighten::CachedLightWriter | Cached Lights writer. |
| Enlighten::CallableEnqueueFunctorCommand | An object that can be called to enqueue a command. |
| Enlighten::CanQuickShade | By default, light types do not support quickshade. |
| Enlighten::CanQuickShade< LIGHT_TYPE_DIRECTIONAL_LIGHT > | Specialization to enable QuickShade on this light type. |
| Enlighten::ClusterAlbedoWorkspaceMaterialData | Constitutes the precomputed material data for a system. |
| Enlighten::ClusterMaterialComponent | Enlighten internal class for per material dynamic updates. |
| Enlighten::ClusterMaterials | Enlighten internal implementation for cluster albedo materials. |
| Enlighten::ClusterProbeTransparencySampleData | Precompute data block detailing probe transparency sample data (internal). |
| Enlighten::ClusterRange | The ClusterRange describes a range of leaf clusters that belong to a certain cluster in the tree. |
| Enlighten::Command | Basic interface for commands to be executed on the worker thread. |
| Enlighten::ConstLightValueIterator | Const LightValue iterator. This contains the logic for iterating over LightValue64 or LightValue128 arrays. |
| Enlighten::CopyAlbedoBufferInfo | Parameters to be enqueued for a CopyInputLightingBuffer() command. |
| Enlighten::CopyBounceBufferInfo | Parameters to be enqueued for a CopyInputLightingBuffer() command. |
| Enlighten::CopyEmissiveBufferInfo | Parameters to be enqueued for a CopyInputLightingBuffer() command. |
| Enlighten::CopyEmissiveEnvironmentInfo | Parameters to be enqueued for the CopyEmissiveEnvironment() command. |
| Enlighten::CopyInputLightingBufferInfo | Parameters to be enqueued for a CopyInputLightingBuffer() command. |
| Enlighten::CopyProbeOutputInfo | Parameters to be enqueued for a CopyProbeOutputInfo() command. |
| Enlighten::CopyRawOutputInfo | Parameters to be enqueued for a CopyRawOutput() command. |
| Enlighten::CopyTransparencyBufferInfo | Parameters to be enqueued for a CopyMaterialTransparencyBuffer() or CopyGeometryTransparencyBuffer() command. |
| Enlighten::CopyVisibilityBufferInfo | Parameters to be enqueued for a CopyVisibilityBuffer() command. |
| Enlighten::CountLightSizeVisitor | Count light size. |
| Enlighten::CpuAlbedoHandler | Implementation of BaseAlbedoHandler for the CPU solver. |
| Enlighten::CpuCubeMap | Derived class of BaseCubeMap used by the CPU and console update managers. |
| Enlighten::CpuDynamicObject | Implementation of BaseDynamicObject for Cpu Solving. |
| Enlighten::CpuEnvironment | Class used by the CPU and console update managers to represent an environment map. |
| Enlighten::CpuSystem | System for the CPU solver. |
| Enlighten::CpuSystemSolutionSpace | System solution space for the CPU solver. |
| Enlighten::CpuTextureSamplerBase | CPU texture sampler base class. |
| Enlighten::CpuWorker | Implementation of the worker class, containing functionality common to all platforms which solve radiosity on a CPU or SPU. |
| Enlighten::CullCluster | A class used to apply cluster-light level culling. |
| Enlighten::CullClusterGroup | A class used to apply clustergroup-light level culling. |
| Enlighten::CullingIterator | Struct to iterate over the lights of a particular type, applying the culling operation. |
| Enlighten::CullingIterator< LIGHT_TYPE_INVALID, Culler > | Terminator for CullingIterator. |
| Enlighten::CullSystem | A class used to apply system-light level culling. |
| Enlighten::DefaultGeometryTransparencySampler | The default transparency sampler. |
| Enlighten::DefaultThreadGroup | Default implementation of IThreadGroup which executes tasks serially on the calling thread (the worker thread). |
| Enlighten::DirectInputLightingParameters | A class containing the parameters to be used as input to the direct input lighting stage. |
| Enlighten::DirectionalLight | DirectionalLight class used by extended input lighting. |
| Enlighten::Dx11TextureUpdater | Implementation for managing solver output and Dx11 GPU textures. |
| Enlighten::Dx9TextureUpdater | Implementation for managing solver output and Dx9 GPU textures. |
| Enlighten::DynamicMaterialWorkspace | Enlighten object used for dynamic material updates at runtime. |
| Enlighten::DynamicObject | 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. |
| Enlighten::EnlightenProfile | A container for Enlighten runtime profile statistics. |
| Enlighten::EnlightenTask | A task to be executed by a TaskProcessor. It consists of a task type and an object pointer. |
| Enlighten::EntireProbeSetTask | An EntireProbeSetTask solves an entire set of probes as an atomic block. |
| Enlighten::ExcludeQuickShadeFilter | Return all types except quick shade lights. |
| Enlighten::FitModel | This is a model class, which can currently only be a plane or a cylinder. |
| Enlighten::FixedTimeLimiter | Simple implementation of ILimiter which prevents new tasks from starting after a fixed time has elapsed from the start of UpdateRadiosity(). |
| Enlighten::Fp16CpuTextureSampler | FP16 texture sampler. |
| Enlighten::FrustumLight | FrustumLight class used by extended input lighting. |
| Enlighten::FunctorCommand | Callable object (incl. lambda expressions) commands. |
| Enlighten::GenericColourBuffer | Generic class to store an array of values for a given system. |
| Enlighten::GeoClusterNode | Debugging output representation of a value in the clustering metric. |
| Enlighten::GeoClusterNodeForest | Debugging output representation of a set of clustering metric hierarchies. |
| Enlighten::GeoClusterNodeTree | Debugging output representation of a hierarchy of clustering metrics. |
| Enlighten::GeoDirectionalPoint | Debugging output representation of a point with a normal. |
| Enlighten::GeoRayOrigin | Debugging output representation of a ray origin. |
| Enlighten::GlTextureUpdater | Implementation for managing solver output and OpenGL GPU textures. |
| Enlighten::GpuTextureWrapper | Concrete implementation of IGpuTexture. |
| Enlighten::HashLightVisitor | Hash lights functor. |
| Enlighten::IAsyncTask | Async task interface. |
| Enlighten::IBake | The Low Level Enlighten Baking API. |
| Enlighten::IBakeInputGeometryLightingNormals | Interface for providing lighting normals for the geometry. |
| Enlighten::IBakeInputGeometryTangents | Interface for providing tangents for the geometry. |
| Enlighten::IBakeInputGeometryUvs | Interface for providing tangents for the geometry. |
| Enlighten::IBakeInputLighting | Input lighting for the offline baking; mainly a collection of EnlightenLight structures. |
| Enlighten::IBakeInputMaterial | 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. |
| Enlighten::IBakeInputMeshLightingNormals | Interface for providing lighting normals for the mesh. |
| Enlighten::IBakeInputMeshTangents | Interface for providing tangents for the mesh. |
| Enlighten::IBakeInputMeshUvs | Interface for providing tangents for the mesh. |
| Enlighten::IBakeInputProperties | Bake properties class, used by calculation tasks to hold global and task specific data. |
| Enlighten::IBakeInputRayOriginPositions | The ray origin positions for all systems. |
| Enlighten::IBakeInputRuntime | The Enlighten runtime objects; RadDataCore, InputWorkspace, et al. |
| Enlighten::IBakeInputSystem | A triangle list and GBuffer of the incoming system. |
| Enlighten::IBakeOutputProbeSet | Baking output for a probe set. |
| Enlighten::IBakeOutputProbeSetVisibility | Baking output for per light visibility. |
| Enlighten::IBakeOutputSystemAO | Baking output for ambient occlusion. |
| Enlighten::IBakeOutputSystemDirect | Baking output for direct lighting. |
| Enlighten::IBakeOutputSystemFinalGather | Baking output for indirect lighting from Final Gather. |
| Enlighten::IBakeOutputSystemIndirect | Baking output for indirect lighting. |
| Enlighten::IBakeOutputSystemRadiosityNormal | Baking output for radiosity normal texture. |
| Enlighten::IBakeOutputSystemVisibility | Baking output for per light visibility. |
| Enlighten::IBakeRuntimeLighting | Material textures for the albedo and emissive channels, in Enlighten UV space. |
| Enlighten::IBakeSolvedRuntime | Interface for providing radiosity output for systems and probesets for baking. |
| Enlighten::IBakeSystemResource | System data for baking. |
| Enlighten::IBakeTextureManager | Interface for providing and caching textures. |
| Enlighten::IBakeVisibilityBuffer | Visibility information for a light map. |
| Enlighten::IClusteringOutput | An interface for diagnosing the quality and any issues with the clustering process in EnlightenPrecomp2. |
| Enlighten::IGpuTexture | IGpuTexture is the main interface used by the HLRT to keep track of output textures. |
| Enlighten::IGpuTextureAllocator | Interface which enables Enlighten to allocate GPU textures to hold the solved output. |
| Enlighten::IGpuTextureUpdater | IGpuTextureUpdater is the interface used by the HLRT to manage Enlighten solver output and associated GPU texture resources. |
| Enlighten::ILightTransportOutput | An interface for diagnosing the quality and any issues with the light transport process in EnlightenPrecomp2. |
| Enlighten::ILimiter | Interface which can prevent Enlighten tasks from starting in the current call to UpdateRadiosity. |
| Enlighten::IMeshSimpOutput | An interface for diagnosing the quality and any issues with the mesh simplification process in EnlightenPrecomp2. |
| Enlighten::IncidentLightingBuffer | A buffer containing the incident lighting for a system's input sample points (internal). |
| Enlighten::IndirectInputLightingInternalParameters | A class containing the parameters to be used as input to the internal indirect input lighting stage. |
| Enlighten::IndirectInputLightingParameters | A class containing the parameters to be used as input to the indirect input lighting stage. |
| Enlighten::IndirectionTextureRegions | A set of regions of the indirection texture, one per clipmap level. |
| Enlighten::InputLightBase | A base class all light types must derive from to work with any input lighting API. |
| Enlighten::InputLightFalloffTable | Class encapsulating the description of a light falloff curve. |
| Enlighten::InputLightingBuffer | A single frame of the InputWorkspace lighting (internal). |
| 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::InputWorkspaceDebugIterator | This class is used to iterate through the duster samples in order to get a InputWorkspaceDebugPoint. |
| Enlighten::InputWorkspaceDebugPoint | A structure for receiving the data held internally about a duster point for debugging visualisation purposes. |
| Enlighten::InputWorkspaceDynamicInternal | Runtime data about the quad approximations to clusters used for radiosity computations for dynamic systems (internal). |
| Enlighten::InputWorkspaceInternal | Runtime data about the dusters (internal). |
| Enlighten::InputWorkspaceMetaData | A data block that describes essential properties of an input workspace. |
| Enlighten::InstanceDescMinimal | Minimal description of an instance. |
| Enlighten::InternalLightFalloffTable | The light table stores the falloff model of a light. |
| Enlighten::InterpolatedPoint | Data structure describing a point in space to receive interpolated probe output. |
| Enlighten::InterpolationInputSet | Data structure describing the inputs and outputs of a probe set to be used as input data for interpolation. |
| Enlighten::IPppiComputeUpdateHandler | User callbacks to handle updates to pppi textures using a compute shader. |
| Enlighten::IPppiProbeSetStateHandler | User callback to handle changes to probe set state. |
| Enlighten::IPppiTextureUpdateHandler | User callbacks to handle updates to pppi textures. |
| Enlighten::IPrecompBuildParameters | A class containing various parameters and dials for the system level precompute process. |
| Enlighten::IPrecompCubeMapBuildParameters | Precompute parameters for cube maps. |
| Enlighten::IPrecompCubeMapCore | A class containing a data block that is used by the run-time to generate cube maps. |
| Enlighten::IPrecompDepthCubeMap | Handle to the depth cube map data. |
| Enlighten::IPrecompGeneratedSystems | Result of the the IPrecompute::CreateSystemsByVoxelisation() call. |
| Enlighten::IPrecompInputCubeMap | A class representing a cube map object which the run-time can generate dynamically. |
| Enlighten::IPrecompInputGeometry | Handle to the InputGeometry. |
| Enlighten::IPrecompInputItemDependencies | A collection of item dependencies. |
| Enlighten::IPrecompInputMesh | The standard precompute mesh input class. |
| Enlighten::IPrecompInputProbeOctree | Represents a region of 3D space within which sets of probe positions are adaptively generated. |
| Enlighten::IPrecompInputProbeRegion | Represents a region of 3D space voxelized at various resolutions. |
| Enlighten::IPrecompInputProbeSet | 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. |
| Enlighten::IPrecompInputSystem | Handle to the InputSystem. |
| Enlighten::IPrecompMeshValidation | An interface containing methods for analyzing meshes. |
| Enlighten::IPrecompOutputCubeMap | Handle to the precompute output data for cube maps. |
| Enlighten::IPrecompOutputProbeOctree | An octree of probe positions grouped into probe sets. |
| Enlighten::IPrecompOutputProbeSet | Handle to the LightTransport data for probesets. |
| Enlighten::IPrecompPackedGeometry | Handle to the PackedGeometry. |
| Enlighten::IPrecompPackedInstance | Handle to the PackedInstance. |
| Enlighten::IPrecompPackedSystem | Class encapsulating the geometry and additional data for a system, light-mapped or otherwise. |
| Enlighten::IPrecompProbeAtlasMaxima | Maximum values across the entire world, used to determine the resources required at runtime. |
| Enlighten::IPrecompProbeOctree | A class representing an octree which defines sets of probe positions within a volume. |
| Enlighten::IPrecompProbeOctreeLayout | The layout of an octree. |
| Enlighten::IPrecompProbeSetBuildParameters | A class defining parameters for SH sample probe building. |
| Enlighten::IPrecompProbeSetRadiosity | A class containing a set of data blocks that are used by the run-time to generate SH representations for the related IPrecompInputProbeSet. |
| Enlighten::IPrecompRadiosityNormalTexture | Handle to the radiosity normal texture. |
| Enlighten::IPrecompSystemClustering | Handle to the SystemClustering. |
| Enlighten::IPrecompSystemCompressedLightTransport | Handle to a compressed SystemLightTransport. |
| Enlighten::IPrecompSystemDependencies | Handle to the SystemDependencies. |
| Enlighten::IPrecompSystemDuster | Handle to the platform-agnostic input sample points (dusters). |
| Enlighten::IPrecompSystemLightTransport | Handle to the SystemLightTransport. |
| Enlighten::IPrecompSystemPreClustering | Handle to the SystemPreClustering. |
| Enlighten::IPrecompSystemRadiosity | Handle to the SystemRadiosity. |
| Enlighten::IPrecompSystemsDependencies | Holds IPrecompSystemDependencies for multiple systems. |
| Enlighten::IPrecompute | The Low Level Enlighten Precompute API. |
| Enlighten::IPrecompVolumeQuery | A class representing a region of 3D space which can be tested for intersection against an axis-aligned box. |
| Enlighten::IProbeSetManager | Probe Set Manager interface class. |
| Enlighten::IrradianceOutputDesc | Irradiance and directional irradiance output capture. |
| Enlighten::ISystemSolutionSpace | A solution space for a system. |
| Enlighten::IThreadGroup | Interface through which MultithreadCpuWorker runs tasks on multiple threads in parallel. |
| Enlighten::IUpdateManager | 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. |
| Enlighten::IUpdateManagerWorker | Interface of the update manager worker. |
| Enlighten::IViewVolumeIntersector | A view volume implemented by the application. |
| Enlighten::LightMethodSelector | Light Method Selector. |
| Enlighten::LightSelector | Selects the input light type. |
| Enlighten::LightTransportPixel | Debugging output representation of an output pixel. |
| Enlighten::LightTypeInfo | A class which represents a group of a particular type of lights. |
| Enlighten::LightValue64 | Convenience value type for a half precision lighting value. |
| Enlighten::LightValueIterator | LightValue iterator. This contains the logic for iterating over LightValue64 or LightValue128 arrays. |
| Enlighten::Line2D | A line in 2D defined by two points. |
| Enlighten::LrbCpuTextureSampler | LRB texture sampler. |
| Enlighten::MaterialAlbedoSampler | Albedo sampler read the cluster albedo after all the quads have been sampled. |
| Enlighten::MaterialComponentBuffer | MaterialComponentBuffer type interface. |
| Enlighten::MaterialEmissiveSampler | Emissive sampler reads the emissive for the cluster. |
| Enlighten::MaterialGuids | Storage of mappings between "old" u64 material IDs and "new" instance, mesh and material GUIDs. |
| Enlighten::MaterialSampler | Material sampler reads albedo, emissive and transparency for the cluster. |
| Enlighten::MaterialTransparencySampler | Transparency sampler reads the transparency for the cluster. |
| Enlighten::MergeGeometry | This is the very basic geometry description we operate on. |
| Enlighten::MergeGeometryCache | This is a cache of some various group-related data for use while merging charts. |
| Enlighten::MergeMap | Details of how the old groups have been merged into new groups. |
| Enlighten::MergeProcessParams | Parameters controlling the model fitting. |
| Enlighten::MergeStats | Stats from the result of the merge. |
| Enlighten::MergeTriGroupParams | Parameters controlling the merge behaviour of a particular tri group. |
| Enlighten::MultithreadCpuUpdateManager | An update manager for Enlighten that does CPU updates. |
| Enlighten::MultithreadCpuWorker | Worker for the mulithreaded CPU update manager. |
| Enlighten::MultithreadCpuWorkerCommon | Implementation of the worker class, containing functionality for platforms which run tasks on a multithreaded CPU. |
| Enlighten::NullGeometryTransparencySampler | A transparency sampler which samples the transparency as opaque. |
| Enlighten::NullMaterialEmissiveSampler | An emissive material sampler which returns black. |
| Enlighten::NullMaterialTransparencySampler | A transparency sampler which samples the transparency as opaque. |
| Enlighten::NullSampler | A base implementation for a sampler that does nothing. |
| Enlighten::NullSurroundingsSampler | Surroundings sampler that always returns zero. |
| Enlighten::OctreeSearchResult | Result of an octree search. |
| Enlighten::PackedDusterPoint | This class contains the positions and normals of 4 duster points (internal). |
| Enlighten::PipelineBoxSetProbeRegion | A probe region object, corresponding to a <probeRegion> element in the .scene file. |
| Enlighten::PipelineCubemap | A cubemap object, corresponding to a <cubeMap> element in the .scene file. |
| Enlighten::PipelineError | An exception thrown to indicate a violation of the API contract, such as: |
| Enlighten::PipelineExcludedInstance | An instance object, corresponding to an <instance> element in the .scene file. |
| Enlighten::PipelineGeom | A geometry object, corresponding to a single .geom file. |
| Enlighten::PipelineGeometryProperties | The properties of a .geom that are relevant to the precompute. |
| Enlighten::PipelineGlobalParameters | The parameters that affect the precompute for all instances in the scene. |
| Enlighten::PipelineInstanceParameters | Recommended default values for parameters that affect the precompute for a subset of instances in the scene. |
| Enlighten::PipelineMaterial | The properties of an Enlighten material that are relevant to radiosity. |
| Enlighten::PipelineMesh | A mesh object, corresponding to a single <mesh> element within the .geom file. |
| Enlighten::PipelinePaths | The paths to the Enlighten scene and runtime data generated by the pipeline. |
| Enlighten::PipelinePointSetProbeRegion | A probe region object, corresponding to a <probeRegion> element in the .scene file. |
| Enlighten::PipelineProbeVolume | A probe volume object, corresponding to a <probeVolume> element in the .scene file. |
| Enlighten::PipelineProgressBase | Implements Geo::IGeoProgressProxy::ReportError. |
| Enlighten::PipelineRadiosityInstance | An instance object, corresponding to an <instance> element in the .scene file. |
| Enlighten::PipelineRadiosityProperties | The properties of a radiosity instance that are relevant to the precompute. |
| Enlighten::PipelineScene | The scene to be precomputed. |
| Enlighten::PipelineTransform | The transform used by each instance object. |
| Enlighten::PipelineVolumeProbeRegion | A probe region object, corresponding to a <probeRegion> element in the .scene file. |
| Enlighten::PipelineWorldAxes | 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. |
| Enlighten::PixelBarycentricWeights | Data about a given pixel in the lightmap. |
| Enlighten::PixelCoord | Enlighten internal class for storing a pixel index within an albedo or emissive texture. |
| Enlighten::PointLight | PointLight class used by extended input lighting. |
| Enlighten::PointProjection | Utility class for projecting points into a triangle surface, and optionally 'pushing up'. |
| Enlighten::PointProjectionOptions | Projection options for the point projection functionality. |
| Enlighten::PointProjectionScratchMem | Reusable search scratch memory while projecting points. |
| Enlighten::PointProjectionSurface | A surface we can project points onto. |
| Enlighten::PointProjectionVersion | Description of the point projection of one instance to a set of surfaces. |
| Enlighten::PointProjectionVertex | Simple position & normal structure. |
| Enlighten::PppiAtlasFootprint | A measure of the space required in the PPPI atlas. |
| Enlighten::PppiAtlasMaxima | The maximum number of atlas tiles and probes that may be concurrently allocated for the given combination of probe sets. |
| Enlighten::PppiAtlasOutputWorkspace | The output texture data for the atlas texture. |
| Enlighten::PppiAtlasUpdateData | The required size of the atlas update buffers. |
| Enlighten::PppiAtlasUpdateRequirements | The required size of the atlas update buffers. |
| Enlighten::PppiClipmapUpdateData | The data that must be copied into the clipmap update buffers. |
| Enlighten::PppiClipmapUpdateRequirements | The required size of the clipmap update buffers. |
| Enlighten::PppiClipmapVolumeTextureInfo | 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. |
| Enlighten::PppiConfiguration | |
| Enlighten::PppiIndirectionOutputWorkspace | The output texture data for the indirection texture. |
| Enlighten::PppiIrradiance | L1 SH RGB representation of irradiance. |
| Enlighten::PppiIrradiance16 | L1 SH RGB representation of irradiance. |
| Enlighten::PppiOutputTextureRequirements | The size and format of the required output textures. |
| Enlighten::PppiOutputWorkspace | The output texture data for the atlas and indirection textures. |
| Enlighten::PppiProbeSetState | The state of a probe set. |
| Enlighten::PppiShaderParameters | The shader parameters required to sample per pixel probe lighting. |
| Enlighten::PppiUpdateData | A sequence of data blocks that map to a single target buffer. |
| Enlighten::PppiVolumeTextureInfo | Description of a volume texture written to by the per-pixel probe interpolation runtime. |
| Enlighten::PppiWorld | Updates output textures for all probe sets in the world. |
| Enlighten::PrecisionHint | Enumeration for the precision hint. The hint is used depending on whether the option is supported on the platform. |
| Enlighten::PrecompInputFace | A face (triangle) in EnlightenPrecomp input geometry. |
| Enlighten::PrecompInputInstance | A simple class housing the data required with each stand-alone instance of some geometry. |
| Enlighten::PrecompInputVertex | A vertex in EnlightenPrecomp input geometry. |
| Enlighten::PrecompMaterialInfo | Material precompute properties. Assign these to specific instance, mesh and material GUIDs using SetMaterialInfo on an IPrecompInputSystem object. |
| Enlighten::PrecompMeshIdentifier | Simple struct to identify an IPrecompInputMesh with the name and GUID of the geom and the index and GUID of the mesh. |
| Enlighten::PrecompMeshProperties | Properties of input meshes. |
| Enlighten::PrecompOctreeNode | A serialisable representation of an octree node. |
| Enlighten::PrecompOctreeProbeKey | Provides an ordering of probe voxel positions by their depth within the octree. |
| Enlighten::PrecomputedVisibilityData | Runtime data storing precomputed visibility information (eg, for directional lights) |
| Enlighten::PrecomputedVisibilityWorkspace | Runtime data allocated by end user that stores uncompressed precomputed visibility data. |
| Enlighten::PrecomputeParameters | The arguments to the HLBS precompute process. |
| Enlighten::PrecomputePipeline | Exports the scene and runs the precompute process. |
| Enlighten::PrecompVolumeQueryBox | An example implementation of IPrecompVolumeQuery which defines a region of 3D space as a set of boxes. |
| Enlighten::PrecompVoxelId | Unique ID of a voxel. |
| Enlighten::PrecompVoxelOctree | A voxel in an octree. |
| Enlighten::PrecompVoxelOctreePath | A path to a voxel. |
| Enlighten::PrecompVoxelOctreeVolume | A volume voxel in an octree. |
| Enlighten::ProbeInterpolant | Data structure identifying a probe and associated weight (influence) which forms part of a set to be interpolated. |
| Enlighten::ProbeInterpolationTask | Task describing a set of probe sets to be used as inputs for interpolation, and a set of points which require interpolated outputs. |
| Enlighten::ProbeSetManagerOctree | An implementation of IProbeSetManager with a fast path for scenes which contain only octree probe sets. |
| 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::ProfileHistory | A simple class for recording a history of double valued stats. |
| Enlighten::QuadIterator | Quad iterator class applies the samplers to a set of quads for a given cluster. |
| Enlighten::QuadShader | 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. |
| Enlighten::QuickFlatClusterShader | 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. |
| Enlighten::QuickQuadShader | 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. |
| Enlighten::QuickShadeOnlyFilter | Return only quick shade light types. |
| Enlighten::R11G11B10CpuTextureSampler | R11G11B10 texture sampler. |
| Enlighten::R9G9B9E5CpuTextureSampler | R9G9B9E5 texture sampler. |
| 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::RadDebugBucketSelectionTask | Structure describing an internal debugging task to colour output pixels according to debug data. |
| Enlighten::RadDebugColouringTask | Structure describing a task to colour output pixels according to debug data. |
| Enlighten::RadDebugPixelInfo | Extended information about a pixel in the Enlighten output for internal debugging purposes. |
| Enlighten::RadiosityInputTree | Compressed description of the input cluster tree. |
| 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::RawBuffer | A range of bytes. |
| Enlighten::ReadInputLightingBufferInfo | Parameters to be enqueued for a ReadInputLightingBufferInfo() command. |
| Enlighten::RectangleLight | RectangleLight class used by extended input lighting. |
| Enlighten::RefTextureAllocator | Texture allocator for creating CPU solution spaces for Enlighten without any associated GPU resources. |
| Enlighten::RefTextureUpdater | Reference texture updater. |
| Enlighten::ReleaseSystemSolutionSpacesInfo | Parameters to be enqueued for a ReleaseSystemSolutionSpaces() command. |
| Enlighten::RemoveInfo | Parameters to be enqueued for a RemoveSystem(), RemoveProbeSet(), RemoveCubeMap() or RemoveDynamicObject() command. |
| 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::Rgba32Gamma | Class to store 32-bit colour values in gamma space. |
| Enlighten::Rgba64Linear | Class to store a HDR value using FP16 precision. |
| Enlighten::RgbaCpuTextureSampler | RGBA texture sampler. |
| Enlighten::RgbmCpuTextureSampler | RGBM texture sampler. |
| Enlighten::SelectAll | Selector which selects all lights. |
| Enlighten::SelectCulled | Selector which selects culled lights. |
| Enlighten::SelectUnculled | Selector which selects unculled lights. |
| Enlighten::SetLightBankUpdateCounterInfo | Parameters to be enqueued for a SetLightBankUpdateCounter() command. |
| Enlighten::SetParameterCommand | Command to set a parameter on an object. |
| Enlighten::SetProbeSetTransformInfo | Parameters to be enqueued for a SetProbeSetTransform() command. |
| Enlighten::SetSystemSolutionSpacesCommand | Command to set solutions spaces for given system. |
| Enlighten::SetTransparencySamplePositionOffsetInfo | Parameters to be enqueued for a SetTransparencySamplePositionOffset() command. |
| Enlighten::SetVisibilityBitsInfo | Parameters to be enqueued for a SetVisibilityBits() command. |
| Enlighten::ShadeFourSamplesOperator | Visitor operator used to shade four samples for each light type. |
| Enlighten::ShadeQuadOperator | Visitor operator used to shade the quad for each light type. |
| Enlighten::SolveBounceTask | Structure describing a task which solves directly to the bounce buffer and does not update any textures. |
| Enlighten::SortedLights | A class used to produce a sorted, culled list of lights. |
| Enlighten::SortedLightsOperator | Sorted lights operator interface. |
| Enlighten::SortedLightsVisibilityIdxWriter | Sorted lights visibility index writer. |
| Enlighten::SortedLightsVisitor | Visitor construct to apply each operator to the relevant light types. |
| Enlighten::SortedLightsVisitor< LIGHT_TYPE_INVALID, Op, LightTypeFilter > | Terminator condition for light visitor. |
| Enlighten::SphereVolume | Sphere volume primitive. |
| Enlighten::Spotlight | Spotlight class used by extended input lighting. |
| Enlighten::SurfaceColourDynamicity | A set of initialisers for the dynamicity of surface colours. |
| Enlighten::SystemAlbedoData | Class representing the albedo data for a system (or dynamic object which contributes to radiosity). |
| Enlighten::SystemDependencies | A list of system dependencies. |
| Enlighten::SystemGrouping | A groupings of instances into systems. |
| Enlighten::TaskProcessor | 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. |
| Enlighten::TextureResolutionScale | Specify the albedo/emissive texture resolution relative to the light map resolution. |
| Enlighten::TextureSubSection | Defines a sub-section of a texture, specified in texels. |
| Enlighten::TransformedBounds | A struct used to apply a transform to a bounding box. |
| Enlighten::TransparencySurroundingsSampler | Surroundings sampler for transparency. |
| Enlighten::TransparencyVolumeBase | Base class for transparency volumes. |
| Enlighten::TransparencyWorkspace | Workspace used for authored destruction of lightmapped geometry (internal). |
| Enlighten::Triangle2D | A triangle in 2D defined by three points. |
| Enlighten::TriggerVolumeTransparencyGeneric | Command to trigger a transprency volume. |
| Enlighten::TypeIdToType | Convert from type enum to concrete type Put this above the light type includes so the specialisations can go in the same file. |
| Enlighten::TypeIdToType< LIGHT_TYPE_BOXSPOT_LIGHT > | Specialization to convert Light type enumeration to concrete type. |
| Enlighten::TypeIdToType< LIGHT_TYPE_DIRECTIONAL_LIGHT > | Specialization to convert Light type enumeration to concrete type. |
| Enlighten::TypeIdToType< LIGHT_TYPE_FRUSTUM_LIGHT > | Specialization to convert Light type enumeration to concrete type. |
| Enlighten::TypeIdToType< LIGHT_TYPE_POINT_LIGHT > | Specialization to convert Light type enumeration to concrete type. |
| Enlighten::TypeIdToType< LIGHT_TYPE_RECTANGLE_LIGHT > | Specialization to convert Light type enumeration to concrete type. |
| Enlighten::TypeIdToType< LIGHT_TYPE_SPOT_LIGHT > | Specialization to convert Light type enumeration to concrete type. |
| Enlighten::TypeIdToType< LIGHT_TYPE_UE4_DIRECTIONAL_LIGHT > | Specialization to convert Light type enumeration to concrete type. |
| Enlighten::TypeIdToType< LIGHT_TYPE_UE4_ISFALLOFF > | Specialization to convert Light type enumeration to concrete type. |
| Enlighten::TypeIdToType< LIGHT_TYPE_UE4_RECTLIGHT > | Specialization to convert Light type enumeration to concrete type. |
| Enlighten::TypeIdToType< LIGHT_TYPE_UE4_UNREALFALLOFF > | Specialization to convert Light type enumeration to concrete type. |
| Enlighten::UpdateEnvironmentInfo | Parameters to be enqueued for the UpdateEmissiveEnvironment() command. |
| Enlighten::UpdateLightCommandGeneric | Command to update a light. |
| Enlighten::UpdateLightInfo | Parameters to be enqueued for the UpdateLight() command. |
| Enlighten::UpdateLightOptions | Optional parameters to the UpdateLight() command. |
| Enlighten::UpdateManagerLight | Class which extends the Enlighten input light class with extra data used only by the high level runtime, and not by Enlighten itself. |
| Enlighten::UpdateManagerProperties | This class contains the properties of an Update Manager which must be supplied on creation and can't be changed. |
| Enlighten::UpdateManagerWorkerProperties | Class representing the global state of the update manager worker. |
| Enlighten::UpdatePppiAtlasStats | Statistics reported by the atlas texture update. |
| Enlighten::UpdatePppiIndirectionStats | Statistics reported by the indirection texture update. |
| Enlighten::UpdatePppiStats | Stats reported by PppiWorld::Update(). |
| Enlighten::Vertex2D | Vertex in 2D. |
| Enlighten::VisibilityBuffer | Encapsulation of light visibility information. |
| Enlighten::VisibilityFormat | Supported formats for visibility data. |
| Enlighten::VisitLightsGeneric | Visit the lights of a particular type. Do this recursively. |
| Enlighten::VisitLightsGeneric< TypeSelector, Visitor, LIGHT_TYPE_INVALID > | Visitor terminator. |
| Enlighten::VisitSelectedLightsGeneric | Visitor for selected lights. |
| Enlighten::VisitSelectedLightsGeneric< TypeSelector, Visitor, LightSelector, LIGHT_TYPE_INVALID > | Visitor for selected lights. |
| Enlighten::VolumeTextureRegion | A region of a volume texture defined by two corners. |
| Enlighten::WorkerFunctionCommand | Command to execute a function in the IUpdaetManagerWorker interface with no input arguments. |
| Enlighten::WorkerFunctionParameterCommand | Command to execute a function in the IUpdateManagerWorker interface with one input argument. |
| Enlighten::WorkerFunctionTwoParametersCommand | Command to execute a function in the IUpdateManagerWorker interface with two parameters. |
| Enlighten::WorkerFunctorCommand | Callable object (incl. lambda expressions) worker commands. |
| Enlighten::WorkerObjectFunctionCommand | Command to execute paramless method on an an object specified by the guid. |
| Enlighten::WorkerThreadData | Helper class for holding per-thread working data. |
| Enlighten::WorkspaceAllocator | A specialised circular/stack allocator hybrid for allocating solve workspace memory. |
Typedefs
| Name | Description |
|---|---|
| MaterialComponentBuffer< Rgba32Gamma > AlbedoBuffer | Albedo buffer type used as input to the IndirectInputLighting stage of the runtime. |
| Geo::GeoUniquePtr< Enlighten::AlbedoBuffer, Geo::GeoAlignedFreeDestructor > AlbedoBufferPtr | A unique pointer which controls the lifetime of the object. |
| void(GEO_CALL * AsyncTaskCallback)(IAsyncTask *Task, const char *Name) | Function pointer type for the callback for executing tasks asynchronously. |
| Geo::GeoPair< double, double > BaryCoords | Barycentric coordinates. |
| IncidentLightingBuffer BounceBuffer | BounceBuffer type used for re-sampling the bounce for feedback into the input lighting. |
| Geo::GeoUniqueDelegatePtr< ClusterAlbedoWorkspaceMaterialData, DeleteClusterAlbedoWorkspaceMaterialData > CAWMaterialDataPtr | A unique pointer which controls the lifetime of the object. |
| Geo::GeoMap< Geo::s32, const GeoClusterNodeTree * > ClusterIdLookup | Lookup from linear cluster ID to node. |
| Geo::GeoArray< ClusterRange > ClusterRangeArray | Collection of cluster ranges. |
| void(* CommandCompletedCallback)(void *) | Callback signature for when a command is completed. |
| Geo::GeoRGBXTextureElement CpuTextureElement | Structure defining the memory layout of CPU texture data used by Enlighten for texture albedo and emissive. |
| Geo::GeoUniquePtr< Enlighten::DynamicMaterialWorkspace, Geo::GeoAlignedFreeDestructor > DynamicMaterialWorkspacePtr | A unique pointer which controls the lifetime of the object. |
| MaterialComponentBuffer< Rgba64Linear > EmissiveBuffer | Emissive buffer type used as input to the IndirectInputLighting stage of the runtime. |
| Geo::GeoUniquePtr< Enlighten::EmissiveBuffer, Geo::GeoAlignedFreeDestructor > EmissiveBufferPtr | A unique pointer which controls the lifetime of the object. |
| ProfileHistory< NUM_AGGREGATE_PROFILE_ITEMS > EnlightenAggregateProfile | History profile for aggregate stats. |
| ProfileHistory< NUM_CUBE_MAP_PROFILE_ITEMS > EnlightenCubeMapProfile | History profile for cube maps. |
| ProfileHistory< NUM_PROBE_SET_PROFILE_ITEMS > EnlightenProbeSetProfile | History profile for probesets. |
| ProfileHistory< NUM_SYSTEM_PROFILE_ITEMS > EnlightenSystemProfile | History profile for systems. |
| Geo::GeoUniqueReleasePtr< IPrecompGeneratedSystems > GeneratedSystemsPtr | A unique pointer which controls the lifetime of the object. |
| Geo::GeoArray< GeoDirectionalPoint > GeoDirectionalPointList | Collection of points with normals for debugging. |
| Geo::GeoArray< GeoRayOrigin > GeoRayOriginList | Collection of ray origins for debugging. |
| Geo::GeoArray< GeoRayOrigin * > GeoRayOriginListPtr | Collection of ray origins for debugging. |
| Geo::GeoFileString GeoTextureString | Texture filename string. |
| Geo::GeoArray< Geo::GeoTriangle > GeoTriangleList | Collection of triangles for debugging. |
| Geo::GeoUniqueReleasePtr< IPrecompInputProbeSet > InputProbeSetPtr | A unique pointer which controls the lifetime of the object. |
| Geo::GeoUniqueDelegatePtr< InputWorkspace, DeleteInputWorkspace > InputWorkspacePtr | A unique pointer which controls the lifetime of the object. |
| Geo::s32 LightTypeId | LightTypeIds type. |
| Geo::v128 LightValue128 | Convenience value type for a full precision lighting value. |
| ClusterMaterialComponent< AlbedoBuffer::ColourType > MaterialAlbedoComponent | Material component for albedo. |
| ClusterMaterialComponent< EmissiveBuffer::ColourType > MaterialEmissiveComponent | Material component for emissive. |
| Geo::GeoPair< Geo::GeoGuid, Geo::u32 > MaterialGuidMapping | A mapping between a material GUID and a 32-bit material ID. |
| ClusterMaterialComponent< TransparencyBuffer::ColourType > MaterialTransparencyComponent | Material component for transparency. |
| Geo::GeoUniqueReleasePtr< IPrecompOutputProbeOctree > OutputProbeOctreePtr | A unique pointer which controls the lifetime of the object. |
| Geo::GeoUniqueReleasePtr< IPrecompPackedGeometry > PackedGeometryPtr | A unique pointer which controls the lifetime of the object. |
| Geo::GeoUniqueReleasePtr< IPrecompPackedSystem > PackedSystemPtr | A unique pointer which controls the lifetime of the object. |
| Geo::u16 PppiProbeSetHandle | A handle which uniquely identifies a probe set. |
| Geo::FixedSizeArray< Geo::s32, 3 > PrecompIndex3 | An array of three indices. |
| Geo::u64 PrecompOctreeCode | Identifies a block within the octree. |
| Geo::GeoUniqueDelegatePtr< PrecomputedVisibilityData, DeletePrecomputedVisibilityData > PrecompVisDataPtr | A unique pointer which controls the lifetime of the object. |
| Geo::GeoUniqueReleasePtr< IPrecompProbeAtlasMaxima > ProbeAtlasMaximaPtr | A unique pointer which controls the lifetime of the object. |
| Geo::GeoString< char > ProfileDescription | String for describing a profile, used by EnlightenProfile. |
| Geo::GeoUniqueDelegatePtr< RadCubeMapCore, DeleteRadCubeMapCore > RadCubeMapCorePtr | A unique pointer which controls the lifetime of the object. |
| Geo::GeoUniqueDelegatePtr< RadProbeSetCore, DeleteRadProbeSetCore > RadProbeSetCorePtr | A unique pointer which controls the lifetime of the object. |
| Geo::GeoUniqueDelegatePtr< RadSystemCore, DeleteRadSystemCore > RadSystemCorePtr | A unique pointer which controls the lifetime of the object. |
| Geo::GeoUniqueReleasePtr< Geo::GeoRGBXTexture > RGBXTexturePtr | A unique pointer which controls the lifetime of the object. |
| Geo::u64 SurfaceSelection | Selects a set of surfaces within a system. |
| Geo::GeoUniqueReleasePtr< IPrecompSystemDuster > SystemDusterPtr | A unique pointer which controls the lifetime of the object. |
| Geo::GeoMap< Geo::GeoGuid, Geo::s32 > TGuidIndexMap | GeoGuid-to-s32 map used by EnlightenProfile. |
| MaterialComponentBuffer< Alpha8Normalised > TransparencyBuffer | Transparency buffer type used as input to the IndirectInputLighting stage of the runtime. |
| Vertex2D Vector2D | Vector in 2D. |
Variables
| Name | Description |
|---|---|
| const Geo::u64 DEFAULT_WORKER_THREAD_AFFINITY = Geo::g_MaxU64 | Constant defining the default affinity for the worker thread of a MultithreadCpuWorker. |
| const float g_DependencyVisibilityThresholdDefault = 1.f / (1 << 8) | By default, do not consider a system as a dependency if its visibility is smaller than this threshold. |
| const Geo::s32 g_MaxLightDataStackDepth = 6 | This is the number of copies of lightcount pointers we have in the LightDataStack member of InputWorkspaceData in the lighting internals. |
| const Geo::u32 g_OctreeProbeBorder = 0xfffffffe | This probe index refers to a border probe. |
| const Geo::u32 g_OctreeProbeCulled = 0xffffffff | This probe index refers to a culled probe. |
| const Geo::u32 g_OctreeProbeIndexMask = 0x7fffffff | Mask the bits which contain an index into the probe set. |
| const Geo::u32 g_RadMagicNumber = 0xAD105174 | Arbitrary number that is used to check that the object is of correct type (and endian-ness). |
| const Geo::v128 g_VFalloffInvSamples = Geo::VBroadcast(1.0f / (InputLightFalloffTable::g_SampleCount - 2.0f)) | Light falloff constants for the function: index = (((samples - 1.0) / (samples - 2.0)) / (1.0 / (samples - 2.0) + d * d);. |
| const Geo::v128 g_VFalloffNumSamples = Geo::VBroadcast(float(InputLightFalloffTable::g_SampleCount)) | Light falloff constants for the function: index = (((samples - 1.0) / (samples - 2.0)) / (1.0 / (samples - 2.0) + d * d);. |
| const Geo::v128 g_VFalloffSampleFraction = Geo::VBroadcast((InputLightFalloffTable::g_SampleCount - 1.0f) / (InputLightFalloffTable::g_SampleCount - 2.0f)) | Light falloff constants for the function: index = (((samples - 1.0) / (samples - 2.0)) / (1.0 / (samples - 2.0) + d * d);. |
| const Geo::s32 INFINITE_UPDATES = -1 | Set the update counter for a system to this value to request continuous updates. |
| void *const LIGHT_VISIBILITY_DISABLED = (void*)1 | Equivalent to light visibility data with all bits set to 0. |
| const PppiProbeSetHandle PppiProbeSetHandleInvalid = PppiProbeSetHandle(-1) | A special handle value indicating an invalid handle. |
| const WorldAxis WorldAxisInvalid = WorldAxis(6) | A special value indicating an invalid world axis. |
Functions
Enums
| Name | Description |
|---|---|
| AggregateProfileItem | Items we record for totals. |
| CubeMapProfileItem | Items we record against cube maps. |
| eAutoSimpMode | The UV auto generation / simplification mode for a mesh. |
| eBakeLightType | Different types of baking input lights. |
| EBakeType | Bake output format. |
| eLightType | Different types of Enlighten input lights. |
| eMeshClassificationLightingType | Enumeration for reporting results of the first step of Mesh Classification (lightmap-lit or probe-lit). |
| EnlightenTaskType | The MultithreadCpuWorker works by putting tasks in a list, and then executing TaskProcessors on several threads in parallel. |
| 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. |
| ePppiVolumeTextureFormat | Volume texture formats used by the per-pixel probe interpolation runtime. |
| ePrecompCubeMapQuality | Quality levels for the raytracing in the cube map precompute. |
| ePrecompMaterialBackfaceBehaviourType | Determines how to treat back faces when precomputing light transport. |
| ePrecompMaterialShadowfaceBehaviourType | Determines which faces cast shadows when precomputing directional visibility. |
| ePrecompQuality | Quality levels for majority of raytracing in the precompute, except cube maps. |
| 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. |
| GeometryBuildResult | Enumeration for reporting geometry build success/fail. |
| OutputTextureType | Enumeration of the different output textures produced by the Enlighten solvers. |
| PipelineEnvironmentResolution | The allowed values for Environment resolution. |
| PipelineFormFactorBudget | The recommended values for Irradiance Budget. |
| PipelineRadiosityGroupType | Whether the instance group can be automatically split by the precompute. |
| PipelineRadiosityLightingType | The way a radiosity instance is lit by Enlighten indirect lighting. |
| PipelineRadiosityShadowType | Whether an instance casts an indirect shadow. |
| PipelineWorldAxis | The direction in which a world axis points. |
| PrecomputeDistribute | The way the precompute process should be distributed. |
| PrecomputeResult | The result of the precompute process. |
| ProbeOctreeResolution | The resolution at which probes should be placed. |
| ProbeSetProfileItem | Items we record against probe sets. |
| ProbeVolumeOutputTextureType | Enumeration of the different probe volume output textures. |
| SolveType | Enumeration of the different types of solve. |
| SystemProfileItem | Items we record against systems. |
| TextureFormat | Enumeration of output texture formats used by the high level run-time. |
| VolumeQueryResult | The result of a volume query. |
| WorldAxis | An unit vector aligned with one of vectors of the 3D standard basis, encoded in the range [0, 6). |
bool GEO_CALL Enlighten::AddCachedValuesToInputWorkspace
public: bool GEO_CALL AddCachedValuesToInputWorkspace
(
const InputWorkspace * workspaceMemory,
InputLightingBuffer * output,
const InputLightingBuffer * cachedValues
)
Adds light values from one input lighting buffer to another.
Parameters
| [in] | workspaceMemory | The input workspace memory block used in the two buffers. |
| [in] | output | The input lighting that is added to. |
| [in] | cachedValues | The input lighting to add. |
bool GEO_CALL Enlighten::AddDusterValuesToInputWorkspace
public: bool GEO_CALL AddDusterValuesToInputWorkspace
(
const InputWorkspace * workspaceMemory,
InputLightingBuffer * output,
const Geo::v128 * dusterValues
)
Adds light values laid out in a duster block to an Enlighten input workspace.
Parameters
| [in] | workspaceMemory | The input workspace memory block. |
| [in] | output | The lighting buffer to fill with data. |
| [in] | dusterValues | 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. |
bool GEO_CALL Enlighten::AddDusterValuesToInputWorkspace
public: bool GEO_CALL AddDusterValuesToInputWorkspace
(
const InputWorkspace * workspaceMemory,
Enlighten::IncidentLightingBuffer * output,
const Geo::v128 * dusterValues
)
Adds light values laid out in a duster block to an Enlighten input workspace.
Parameters
| [in] | workspaceMemory | The input workspace memory block. |
| [in] | output | The incident lighting buffer to fill with data. |
| [in] | dusterValues | 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. |
Geo::s32 GEO_CALL Enlighten::AllLightingInputsStatic
public: Geo::s32GEO_CALL AllLightingInputsStatic
(
const InputLightingBuffer ** lightingBuffers,
Geo::s32 numLightingBuffers,
const InputLightingBuffer * emissiveEnvironment
)
Returns the number of frames since the last update that changed any of the given light inputs.
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 the number of updates since the last change to any input.
void Enlighten::AllocateDataBlockContents
public: void AllocateDataBlockContents
(
RadDataBlock * block
)
Allocate memory for a RadDataBlock based on the block's m_Length member and required alignment.
void GEO_CALL Enlighten::ApplyVolumeTransparency
public: void GEO_CALL ApplyVolumeTransparency
(
const InputWorkspace * inputWorkspace,
TransparencyWorkspace * transparencyWorkspace,
const BoxVolume & volume
)
Mark the quads transparency value using a box volume.
Parameters
| [in] | inputWorkspace | The input workspace for the system |
| [out] | transparencyWorkspace | The TransparencyWorkspace for the system |
| [in] | volume | The volume primitive to use to mark the quads |
void GEO_CALL Enlighten::ApplyVolumeTransparency
public: void GEO_CALL ApplyVolumeTransparency
(
const InputWorkspace * inputWorkspace,
TransparencyWorkspace * transparencyWorkspace,
const SphereVolume & volume
)
Mark the quads transparency value using a sphere volume.
Parameters
| [in] | inputWorkspace | The input workspace for the system |
| [out] | transparencyWorkspace | The TransparencyWorkspace for the system |
| [in] | volume | The volume primitive to use to mark the quads |
double GEO_CALL Enlighten::Area
public: double GEO_CALL Area
(
const Vertex2D & a,
const Vertex2D & b,
const Vertex2D & c
)
Computes the unsigned area of a triangle defined by three Vertex2D.
Geo::s32 GEO_CALL Enlighten::AreaSign
public: Geo::s32GEO_CALL AreaSign
(
const Vertex2D & a,
const Vertex2D & b,
const Vertex2D & c
)
Determines the sign of the area of a triangle defined by three Vertex2D.
Returns
-1 if the vertices are given in clockwise order, otherwise 1.
double GEO_CALL Enlighten::AreaTimesTwo
public: double GEO_CALL AreaTimesTwo
(
const Vertex2D & a,
const Vertex2D & b,
const Vertex2D & c
)
Computes the unsigned area of a triangle defined by three Vertex2D multiplied by two.
Geo::u32 GEO_CALL Enlighten::CalcAlbedoBufferSize
public: Geo::u32GEO_CALL CalcAlbedoBufferSize
(
const Enlighten::InputWorkspace * inputWorkspace
)
Calculate the size of the AlbedoBuffer for a system.
Parameters
| [in] | inputWorkspace | A valid InputWorkspace for a system |
Returns
The size in bytes of the AlbedoBuffer. Return 0xFFFFFFFF if an error occurred.
Geo::u32 GEO_CALL Enlighten::CalcBounceBufferSize
public: Geo::u32GEO_CALL CalcBounceBufferSize
(
const Enlighten::InputWorkspace * inputWorkspace,
PrecisionHint::Value precision
)
Tells you the amount of memory required to hold bounce lighting for a given system.
Parameters
| [in] | inputWorkspace | The InputWorkspace for the system. |
| [in] | precision | The hint to what floating point precision to use. |
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
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::CalcDynamicMaterialWorkspaceSize
public: Geo::u32GEO_CALL CalcDynamicMaterialWorkspaceSize
(
const ClusterAlbedoWorkspaceMaterialData * materialData
)
Calculate the size of the DynamicMaterialWorkspace.
Parameters
| [in] | materialData | Pointer to the precompute material data. |
Returns
The size of the DynamicMaterialWorkspace in bytes. Returns 0xFFFFFFFF if an error occurred.
Geo::u32 GEO_CALL Enlighten::CalcEmissiveBufferSize
public: Geo::u32GEO_CALL CalcEmissiveBufferSize
(
const Enlighten::InputWorkspace * inputWorkspace
)
Calculate the size of the EmissiveBuffer for a system.
Parameters
| [in] | inputWorkspace | A valid InputWorkspace for a system |
Returns
The size in bytes of the EmissiveBuffer. Return 0xFFFFFFFF if an error occurred.
Geo::u32 GEO_CALL Enlighten::CalcEnvironmentInputLightingBufferSize
public: Geo::u32GEO_CALL CalcEnvironmentInputLightingBufferSize
(
Geo::s32 environmentResolution,
PrecisionHint::Value precisionHint
)
Tells you the amount of memory required to hold input lighting for a given environment resolution.
Parameters
| [in] | environmentResolution | The resolution of the emissive environment. |
| [in] | precisionHint | A hint as to the preferred precision, if available on the platform. |
Geo::u32 GEO_CALL Enlighten::CalcIncidentLightingBufferSize
public: Geo::u32GEO_CALL CalcIncidentLightingBufferSize
(
const Enlighten::InputWorkspace * inputWorkspace,
PrecisionHint::Value precision
)
Tells you the amount of memory required to hold incident lighting for a given system.
Parameters
| [in] | inputWorkspace | The InputWorkspace for the system. |
| [in] | precision | The hint to what floating point precision to use. |
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
Geo::u32 GEO_CALL Enlighten::CalcInputLightingBufferSize
public: Geo::u32GEO_CALL CalcInputLightingBufferSize
(
const InputWorkspace * inputWorkspace,
PrecisionHint::Value precisionHint
)
Tells you the amount of memory required to hold input lighting for a given system.
Parameters
| [in] | inputWorkspace | The InputWorkspace for the system. |
| [in] | precisionHint | The hint to what floating point precision to use. |
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 Enlighten::CalcLightTableMem
public: Geo::u32 CalcLightTableMem
(
Geo::u32 numLights
)
Calculate the maximum memory required to hold the lights table.
Parameters
| [in] | numLights | Number of lights in the world |
Geo::u32 GEO_CALL Enlighten::CalcLightValueSize
public: Geo::u32GEO_CALL CalcLightValueSize
(
PrecisionHint::Value precision
)
Return the size of the light value given the precision hint.
Parameters
| [in] | precision | The hint to what floating point precision to use. |
Geo::u32 GEO_CALL Enlighten::CalcLightVisibilitySize
public: Geo::u32GEO_CALL CalcLightVisibilitySize
(
const InputWorkspace * workspaceMemory,
Enlighten::VisibilityFormat::Type visibilityType
)
Determine how much memory is required for a light visibility block.
Directional lights store a byte per cluster, all other lights store a bit per input sample (duster).
Parameters
| [in] | workspaceMemory | The input workspace memory block. |
| [in] | visibilityType | Format of the visibility. Must be one of the types defined in VisibilityFormat |
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
Geo::u32 GEO_CALL Enlighten::CalcLightVisibilitySize
public: Geo::u32GEO_CALL CalcLightVisibilitySize
(
const InputWorkspace * workspaceMemory,
eLightType lightType
)
Determine how much memory is required for a light visibility block.
Directional lights store a byte per cluster, all other lights store a bit per input sample (duster).
Parameters
| [in] | workspaceMemory | The input workspace memory block. |
| [in] | lightType | Type of light; one of the Enlighten light type constants, e.g. LIGHT_TYPE_DIRECTIONAL_LIGHT |
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
Geo::s32 GEO_CALL Enlighten::CalcNumEnvironmentLightValues
public: Geo::s32GEO_CALL CalcNumEnvironmentLightValues
(
Geo::s32 environmentResolution
)
Returns the total number of values in the emissive environment cluster tree.
The cluster tree is formed by one root node plus six faces with a perfect tree of 4 children per node. A perfect tree is a tree where each node has the same number of children, and all leaf nodes are on the same level. The formula for the number of nodes per face for a perfect tree is: (number_of_children_per_node * num_leaf_nodes - 1) / (number_of_children_per_node - 1);
Geo::u32 GEO_CALL Enlighten::CalcPrecomputedVisibilityWorkspaceSize
public: Geo::u32GEO_CALL CalcPrecomputedVisibilityWorkspaceSize
(
const InputWorkspace * workspaceMemory,
const PrecomputedVisibilityData * precomputedVisibilityData
)
Determine how much memory is required for a precomputed visibility workspace.
Parameters
| [in] | workspaceMemory | The input workspace memory block. |
| [in] | precomputedVisibilityData | The block of precomputed visibilty data. |
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.
float GEO_CALL Enlighten::CalcRectangleLightAreaNormalisation
public: float GEO_CALL CalcRectangleLightAreaNormalisation
(
float initialWidth,
float initialHeight,
float unitScale
)
Returns an intensity normalisation factor for area lights.
By default, the apparent brightness of rectangular lights changes with their size - larger rectangles emit more light. It can be convenient to instead adjust the brightness so that changing the lights size does not affect the brightness by normalising the light intensity. This function computes a factor that normalises to a 100x100 unit light source (1m^2 in Enlighten units).
Returns
Will return -1 for invalid input (nans, infs, and tiny unitScales) and 0 for zero area lights.
See Also
InputLight
float GEO_CALL Enlighten::CalcRectangleLightMinEdgeLength
public: float GEO_CALL CalcRectangleLightMinEdgeLength
(
float unitScale
)
Returns a minimum edge length for rectangular lights that should minimise noise from float precision.
The default unitScale for a scene is 1.
Returns
Will return -1 for invalid input (nans, infs, and tiny unitScales)
See Also
InputLight
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.
size_t Enlighten::CalcRequiredScratchSpaceMemory
public: size_t CalcRequiredScratchSpaceMemory
(
InputLightBase ** lights,
Geo::u32 numLights
)
Calculate how much scratchspace memory will be required by the DoDirectInputLighting() function given the lights to be shaded.
Parameters
| [in] | lights | An array of pointers to input lights. |
| [in] | numLights | The number of light pointers in the array. |
Returns
Required memory in bytes
size_t Enlighten::CalcRequiredScratchSpaceMemoryInternal
public: size_t CalcRequiredScratchSpaceMemoryInternal
(
InputLightBase ** lights,
Geo::u32 numLights,
Geo::s32 numLevelsOfCulling
)
Calculate how much scratchspace memory will be required by the DoDirectInputLighting() function given the lights to be shaded.
Parameters
| [in] | lights | An array of pointers to input lights. |
| [in] | numLights | The number of light pointers in the array. |
| [in] | numLevelsOfCulling | each level of culling requires an additional copy of the SortedLights structure. |
Returns
Required memory in bytes
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.
Geo::u32 GEO_CALL Enlighten::CalcTransparencyBufferSize
public: Geo::u32GEO_CALL CalcTransparencyBufferSize
(
const Enlighten::InputWorkspace * inputWorkspace
)
Calculate the size of the TransparencyBuffer for a system.
Parameters
| [in] | inputWorkspace | A valid InputWorkspace for a system |
Returns
The size in bytes of the TransparencyBuffer. Return 0xFFFFFFFF if an error occurred.
Geo::u32 GEO_CALL Enlighten::CalcTransparencyWorkspaceSize
public: Geo::u32GEO_CALL CalcTransparencyWorkspaceSize
(
const InputWorkspace * inputWorkspace,
Geo::s32 numInterpolants,
PrecisionHint::Value precision
)
Tells you the amount of memory required for the transparency workspace for a given system.
Parameters
| [in] | inputWorkspace | The InputWorkspace for the system. |
| [in] | numInterpolants | The maximum number of interpolants to use. |
| [in] | precision | The floating point precision for intermediate values. |
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
Geo::u32 GEO_CALL Enlighten::CalcTransparencyWorkspaceSize
public: Geo::u32GEO_CALL CalcTransparencyWorkspaceSize
(
const InputWorkspace * inputWorkspace,
Geo::s32 numInterpolants,
Geo::s32 numLods,
PrecisionHint::Value precision
)
Tells you the amount of memory required for the transparency workspace for a given system.
Parameters
| [in] | inputWorkspace | The InputWorkspace for the system. |
| [in] | numInterpolants | The maximum number of interpolants to use. |
| [in] | precision | The floating point precision for intermediate values. |
| [in] | numLods | The number of LODs to use. |
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
GEO_CONTROLLED_INLINE void Enlighten::CalculateCoordLinearShiftedByHalfPixel
public: GEO_CONTROLLED_INLINE void CalculateCoordLinearShiftedByHalfPixel
(
float u,
float v,
Geo::s32 width,
Geo::s32 height,
Geo::s32 & xi,
Geo::s32 & yi,
float & fracX,
float & fracY
)
Shift by half pixel is needed so that the interpolation code (SampleBilinear) interpolates between correct pixels.
size_t Enlighten::CalculateLightsCachedDataSize
public: size_t CalculateLightsCachedDataSize
(
InputLightBase ** lights,
Geo::u32 numLights
)
Calculate the size of the cached lighting data.
double GEO_CALL Enlighten::CalculateUvMappingError
public: double GEO_CALL CalculateUvMappingError
(
Geo::s32 newGroupIndex,
const Geo::GeoPoint2 * uVs,
const Enlighten::MergeMap * mergeMap,
const Enlighten::MergeGeometry * mergeGeometry
)
Calculate an error of the UV mapping for a given group.
Error is based on angle distortion caused to each triangle by UV mapping The uVs array contains UVs per vertex index
void GEO_CALL Enlighten::CalculateUvOverlap
public: void GEO_CALL CalculateUvOverlap
(
Geo::s32 newGroupIndex,
const Geo::GeoPoint2 * uVs,
const Enlighten::MergeMap * mergeMap,
const Enlighten::MergeGeometry * mergeGeometry,
Geo::s32 rasterisationTextureSize,
float & totalArea,
float & totalOverlappingArea,
float & ratioOverlaps,
float & ratioEmpty
)
Calculate an overlap of the UV mapping for a given group.
Overlap is calculated by rasterising the triangles
void GEO_CALL Enlighten::CalculateUvScaleAndWorldOutputPixelSize
public: void GEO_CALL CalculateUvScaleAndWorldOutputPixelSize
(
float geomOutputPixelSize,
const Geo::Matrix & instanceTransform,
bool scaleUvsWithInstanceSize,
float instanceAdditionalUvScale,
Geo::s32 & outUvScale,
float & outWorldOutputPixelSize
)
Utility to calculate the correct UV scaling and world-space output pixel size for a given instance of a given geometry.
This depends on the instance transform, the "ScaleUvsWithInstanceSize" flag on the instance, the "AdditionalUvScale" value on the instance and the output pixel size on the geom.
Parameters
| [in] | geomOutputPixelSize | The unscaled pixel size |
| [in] | instanceTransform | The transform matrix for the instance |
| [in] | scaleUvsWithInstanceSize | 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)) |
| [in] | instanceAdditionalUvScale | 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. |
| [out] | outUvScale | The UV scale for that instance |
| [out] | outWorldOutputPixelSize | The pixel size after instance UV scaling is applied |
const Geo::GeoPoint2* GEO_CALL Enlighten::ChooseUVSet
public: const Geo::GeoPoint2 *GEO_CALL ChooseUVSet
(
const Geo::GeoPoint2 * uVSet1,
const Geo::GeoPoint2 * uVSet2,
Geo::s32 newGroupIndex,
const Enlighten::MergeMap * mergeMap,
const Enlighten::MergeGeometry * mergeGeometry
)
Use the above functions to determine which set of uv is better.
bool GEO_CALL Enlighten::ClearInputWorkspace
public: bool GEO_CALL ClearInputWorkspace
(
const InputWorkspace * workspaceMemory,
InputLightingBuffer * buffer
)
Clear the input lighting to black.
This wipes out all bounced light for all previous iterations. Used when "starting over".
Parameters
| [in] | workspaceMemory | The input workspace this buffer is used in. |
| [in] | buffer | The lighting buffer to clear. |
bool GEO_CALL Enlighten::CombineGroups
public: bool GEO_CALL CombineGroups
(
MergeMap * mergeMap,
MergeStats * mergeStats,
const MergeGeometry * mergeGeometry,
const MergeProcessParams * mergeParams,
Geo::GeoProgress & progress
)
The tri group merge finding algorithm.
This is a ransac-like algorithm that builds a merge map indicating where and how charts could be merged together. The merge itself is not performed by this call. All pointers except the progress object must be non-null. The progress proxy is optional.
bool GEO_CALL Enlighten::CompareBounceBuffers
public: bool GEO_CALL CompareBounceBuffers
(
Geo::Statistics & res,
const Enlighten::BounceBuffer * bufA,
const Enlighten::BounceBuffer * bufB
)
Compares Returns true if the bounce buffers could be compared.
Parameters
| [inout] | res | - The result of the comparison. Only written if the function succeeded. |
| [in] | bufA | - The first BounceBuffer to compare. |
| [in] | bufB | - The second BounceBuffer to compare. |
bool GEO_CALL Enlighten::CompareIncidentLightingBuffers
public: bool GEO_CALL CompareIncidentLightingBuffers
(
Geo::Statistics & res,
const Enlighten::IncidentLightingBuffer * bufA,
const Enlighten::IncidentLightingBuffer * bufB
)
Compares Returns true if the lighting buffers could be compared.
Parameters
| [inout] | res | - The result of the comparison. Only written if the function succeeded. |
| [in] | bufA | - The first IncidentLightingBuffer to compare. |
| [in] | bufB | - The second IncidentLightingBuffer to compare. |
bool GEO_CALL Enlighten::CompareInputLightingBuffers
public: bool GEO_CALL CompareInputLightingBuffers
(
Geo::Statistics & res,
const InputLightingBuffer * bufA,
const InputLightingBuffer * bufB
)
Compares Returns true if the lighting buffers could be compared.
Parameters
| [inout] | res | - The result of the comparison. Only written if the function succeeded. |
| [in] | bufA | - The first InputLightingBuffer to compare. |
| [in] | bufB | - The second InputLightingBuffer to compare. |
bool GEO_CALL Enlighten::CompareIrradianceOutputBuffers
public: bool GEO_CALL CompareIrradianceOutputBuffers
(
Geo::Statistics & irrResult,
Geo::Statistics & dirResult,
const Enlighten::IrradianceOutputDesc & descA,
const Enlighten::IrradianceOutputDesc & descB
)
Compares a pair of Enlighten irradiance outputs.
Returns true if the output buffers could be compared.
Parameters
| [inout] | irrResult | - The result of comparing irradiance. Only written if the function succeeded. |
| [inout] | dirResult | - The result of comparing directional element. Only written if the function succeeded. |
| [in] | descA | - The first irradiance output to compare. |
| [in] | descB | - The second irradiance output to compare. |
PppiAtlasMaxima GEO_CALL Enlighten::ComputePppiAtlasMaxima
public: PppiAtlasMaximaGEO_CALL ComputePppiAtlasMaxima
(
Geo::u32 probeSetCount,
const PrecompOctreeCode * octreeCodes,
const PppiAtlasFootprint * footprints
)
Return the maximum number of atlas tiles and probes that may be concurrently allocated for the given combination of probe sets.
Parameters
| [in] | probeSetCount | The number of probe sets in the world. |
| [in] | octreeCodes | The octree code associated with each probe set. |
| [in] | footprints | The result of GetOctreePppiAtlasFootprint for each probe set. |
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::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::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.
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::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::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::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::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::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::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::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::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 Enlighten::ConvertEndianDataBlock
public: void ConvertEndianDataBlock
(
Geo::EConvertEndianMode mode,
RadDataBlock & block
)
Byte-swap the members of RadDataBlock depending on the specified endian mode.
Geo::s32 GEO_CALL Enlighten::ConvertInputSystemToIPrecompGeneratedSystem
public: Geo::s32GEO_CALL ConvertInputSystemToIPrecompGeneratedSystem
(
Enlighten::IPrecompInputSystem * inputSystem,
const IPrecompInputGeometry *const * pInputGeoms,
Geo::s32 numGeoms,
Enlighten::IPrecompGeneratedSystems *& generatedSystem
)
Create an IPrecompGeneratedSystems object from inputSystem.
The generatedSystem object will have only one system in it (inputSystem) Note that the output object (generatedSystem) owns the input system, e.g. inputSystem will be destroyed when generatedSystem is destroyed.
Parameters
| [in] | inputSystem | InputSystem to be converted to PrecompGeneratedSystem |
| [in] | pInputGeoms | array of geoms referenced by inputsystem |
| [in] | numGeoms | num of geoms in pInputGeoms |
| [out] | generatedSystem | IPrecompGeneratedSystems with one system in it. |
Returns
0 if successful, otherwise a non-zero value.
D3DFORMAT Enlighten::ConvertToDx9Format
public: D3DFORMAT ConvertToDx9Format
(
TextureFormat format
)
Helper function to convert from platform independent Enlighten::TextureFormat to Dx9 texture format.
DXGI_FORMAT Enlighten::ConvertToDxgiFormat
public: DXGI_FORMAT ConvertToDxgiFormat
(
TextureFormat format
)
Helper function to convert from platform independent Enlighten::TextureFormat to DXGI texture format.
Enlighten::AlbedoBuffer *GEO_CALL Enlighten::CopyAlbedoBufferBuffer
public: Enlighten::AlbedoBuffer *GEO_CALL CopyAlbedoBufferBuffer
(
const Enlighten::InputWorkspace * inputWorkspace,
const Enlighten::AlbedoBuffer * sourceAlbedoBuffer
)
Copy an InputLightingBuffer object.
Parameters
| [in] | inputWorkspace | - The Inputworkspace to use to create the input lighting buffer. |
| [in] | sourceAlbedoBuffer | - The AlbedoBuffer to copy from. |
void GEO_CALL Enlighten::CopyDataBlock
public: void GEO_CALL CopyDataBlock
(
const RadDataBlock * from,
RadDataBlock * to
)
Copy contents of a RadDataBlock.
Enlighten::DynamicMaterialWorkspace *GEO_CALL Enlighten::CopyDynamicMaterialWorkspaceBuffer
public: Enlighten::DynamicMaterialWorkspace *GEO_CALL CopyDynamicMaterialWorkspaceBuffer
(
const Enlighten::InputWorkspace * inputWorkspace,
const Enlighten::DynamicMaterialWorkspace * materialWorkspace
)
Copy an DynamicMaterialWorkspace object.
Parameters
| [in] | inputWorkspace | - The Inputworkspace to use to create the input lighting buffer. |
| [in] | materialWorkspace | - The DynamicMaterialWorkspace to copy from. |
Enlighten::EmissiveBuffer *GEO_CALL Enlighten::CopyEmissiveBuffer
public: Enlighten::EmissiveBuffer *GEO_CALL CopyEmissiveBuffer
(
const Enlighten::InputWorkspace * inputWorkspace,
const Enlighten::EmissiveBuffer * sourceEmissiveBuffer
)
Copy an InputLightingBuffer object.
Parameters
| [in] | inputWorkspace | - The InputWorkspace to use to create the input lighting buffer. |
| [in] | sourceEmissiveBuffer | - The EmissiveBuffer to copy from. |
Enlighten::IncidentLightingBuffer *GEO_CALL Enlighten::CopyIncidentLightingBuffer
public: Enlighten::IncidentLightingBuffer *GEO_CALL CopyIncidentLightingBuffer
(
const Enlighten::InputWorkspace * inputWorkspace,
const Enlighten::IncidentLightingBuffer * sourceIncidentLightingBuffer
)
Copy an IncidentLightingBuffer object.
Parameters
| [in] | inputWorkspace | - The Inputworkspace to use to create the input lighting buffer. |
| [in] | sourceIncidentLightingBuffer | - TheIncidentLightingBuffer to copy from. |
Enlighten::InputLightingBuffer *GEO_CALL Enlighten::CopyInputLightingBuffer
public: Enlighten::InputLightingBuffer *GEO_CALL CopyInputLightingBuffer
(
const Enlighten::InputWorkspace * inputWorkspace,
const Enlighten::InputLightingBuffer * sourceInputLightingBuffer
)
Copy an InputLightingBuffer object.
Parameters
| [in] | inputWorkspace | - The Inputworkspace to use to create the input lighting buffer. |
| [in] | sourceInputLightingBuffer | - The InputLightingBuffer to copy from. |
void GEO_CALL Enlighten::CopyRadCubeMapCore
public: void GEO_CALL CopyRadCubeMapCore
(
const Enlighten::RadCubeMapCore * from,
Enlighten::RadCubeMapCore * to
)
Copies a RadCubeMapCore.
Parameters
| [in] | from | - The core to copy from. |
| [in] | to | - The core to copy to. |
void GEO_CALL Enlighten::CopyRadSystemCore
public: void GEO_CALL CopyRadSystemCore
(
const Enlighten::RadSystemCore * from,
Enlighten::RadSystemCore * to
)
Copies a RadSystemCore.
Parameters
| [in] | from | - The core to copy from. |
| [in] | to | - The core to copy to. |
Enlighten::AlbedoBuffer* GEO_CALL Enlighten::CreateAlbedoBuffer
public: Enlighten::AlbedoBuffer *GEO_CALL CreateAlbedoBuffer
(
const Enlighten::InputWorkspace * inputWorkspace,
void * mem
)
Create an AlbedoBuffer for a system.
This AlbedoBuffer is used as input to the IndirectInputLightingStage.
Parameters
| [in] | inputWorkspace | A valid InputWorkspace for a system |
| [in] | mem | A pointer to 16 byte aligned memory of size returned by CalcAlbedoBufferSize() |
Returns
The complete and valid AlbedoBuffer object. Returns NULL if an error occurred.
IBake* Enlighten::CreateBake
public: IBake * CreateBake()
Create an instance of Enlighten Bake interface.
Enlighten::BounceBuffer* GEO_CALL Enlighten::CreateBounceBuffer
public: Enlighten::BounceBuffer *GEO_CALL CreateBounceBuffer
(
void * memory,
const Enlighten::InputWorkspace * inputWorkspace,
PrecisionHint::Value precision
)
Construct a BounceBuffer inside the memory provided.
Parameters
| [in] | memory | A block of memory (size determined by CalcBounceBufferSize) to store the bounce buffer |
| [in] | inputWorkspace | The InputWorkspace for the system. |
| [in] | precision | The hint to what floating point precision to use. |
Geo::u64 Enlighten::CreateCompositeMaterialId
public: Geo::u64 CreateCompositeMaterialId
(
Geo::u16 instanceId,
Geo::u16 meshIdx,
Geo::u32 baseMaterialId
)
Determine the specific material ID for a given instance, mesh and 32-bit material ID.
See the Material IDs & GUIDs page in the User Guide for further details.
Enlighten::IClusteringOutput* GEO_CALL Enlighten::CreateDebugEnvironmentClustering
public: Enlighten::IClusteringOutput *GEO_CALL CreateDebugEnvironmentClustering
(
Geo::s32 environmentResolution
)
Creates a debug IClusteringOutput interface representing the clustering of an environment at the given resolution.
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.
DynamicMaterialWorkspace* GEO_CALL Enlighten::CreateDynamicMaterialWorkspace
public: DynamicMaterialWorkspace *GEO_CALL CreateDynamicMaterialWorkspace
(
const ClusterAlbedoWorkspaceMaterialData * materialData,
void * mem
)
Create a DynamicMaterialWorkspace which is used for dynamic updates of material colours at runtime.
Each system with dynamic materials will require one of these objects.
Parameters
| [in] | materialData | A pointer to the precompute material data. |
| [in] | mem | A pointer to the memory where the DynamicAlbedoWorkspace will be constructed. This block of memory must be at least CalcDynamicMaterialWorkspaceSize() bytes. |
Returns
A valid DynamicMaterialWorkspace object. Returns NULL if an error occurred.
Enlighten::EmissiveBuffer* GEO_CALL Enlighten::CreateEmissiveBuffer
public: Enlighten::EmissiveBuffer *GEO_CALL CreateEmissiveBuffer
(
const Enlighten::InputWorkspace * inputWorkspace,
void * mem
)
Create an EmissiveBuffer for a system.
This EmissiveBuffer is used as input to the IndirectInputLightingStage.
Parameters
| [in] | inputWorkspace | A valid InputWorkspace for a system |
| [in] | mem | A pointer to 16 byte aligned memory of size returned by CalcEmissiveBufferSize() |
Returns
The complete and valid EmissiveBuffer object. Returns NULL if an error occurred.
InputLightingBuffer* GEO_CALL Enlighten::CreateEnvironmentInputLightingBuffer
public: InputLightingBuffer *GEO_CALL CreateEnvironmentInputLightingBuffer
(
void * memory,
Geo::s32 environmentResolution,
PrecisionHint::Value precisionHint
)
Construct an InputLightingBuffer inside the memory provided.
Parameters
| [in] | memory | A block of memory (size determined by CalcInputLightingBufferSize) to store the lighting buffer |
| [in] | environmentResolution | The resolution of the emissive environment. |
| [in] | precisionHint | A hint as to the preferred precision, if available on the platform. |
Enlighten::IncidentLightingBuffer* GEO_CALL Enlighten::CreateIncidentLightingBuffer
public: Enlighten::IncidentLightingBuffer *GEO_CALL CreateIncidentLightingBuffer
(
void * memory,
const Enlighten::InputWorkspace * inputWorkspace,
PrecisionHint::Value precision
)
Construct an IncidentLightingBuffer inside the memory provided.
Parameters
| [in] | memory | A block of memory (size determined by CalcIncidentLightingBufferSize) to store the lighting buffer |
| [in] | inputWorkspace | The InputWorkspace for the system. |
| [in] | precision | The hint to what floating point precision to use. |
InputLightingBuffer* GEO_CALL Enlighten::CreateInputLightingBuffer
public: InputLightingBuffer *GEO_CALL CreateInputLightingBuffer
(
void * memory,
const InputWorkspace * inputWorkspace,
PrecisionHint::Value precisionHint
)
Construct an InputLightingBuffer inside the memory provided.
Parameters
| [in] | memory | A block of memory (size determined by CalcInputLightingBufferSize) to store the lighting buffer |
| [in] | inputWorkspace | The InputWorkspace for the system. |
| [in] | precisionHint | The hint to what floating point precision to use. |
IPrecompute* Enlighten::CreatePrecompute
public: IPrecompute * CreatePrecompute()
Create an instance of the Precompute.
PrecomputedVisibilityWorkspace* GEO_CALL Enlighten::CreatePrecomputedVisibilityWorkspace
public: PrecomputedVisibilityWorkspace *GEO_CALL CreatePrecomputedVisibilityWorkspace
(
void * memory,
const InputWorkspace * workspaceMemory,
const PrecomputedVisibilityData * precomputedVisibilityData
)
Construct an PrecomputedVisibilityWorkspace inside the memory provided.
Parameters
| [in] | memory | A block of memory (size determined by CalcPrecomputedVisibilityWorkspaceSize) to store the visibility workspace |
| [in] | workspaceMemory | The input workspace memory block. |
| [in] | precomputedVisibilityData | The block of precomputed visibilty data. |
SortedLights* Enlighten::CreateSortedLights
public: SortedLights * CreateSortedLights
(
InputLightBase ** lights,
void ** visibilityPointers,
Geo::s32 numTotalLights,
void * bankScratchspace,
size_t bankScratchspaceSize,
Geo::u32 & requiredLightsBufferSize
)
Create the buffer of lights sorted by type.
Lights banks are controlled through the visibilityPointers parameter.
Parameters
| [in] | lights | An unsorted array of pointers to lights |
| [in] | visibilityPointers | An unsorted array of pointers to visbility buffers. The pointers must correspond to their respective lights in the lights array. |
| [in] | numTotalLights | The number of entries in the lights and visibilityPointers arrays. |
| [in] | bankScratchspace | A pointer to memory where the SortedLights buffer will be constructed. |
| [in] | bankScratchspaceSize | The size of the bankScratchspace memory. (Reserved for future use) |
| [out] | requiredLightsBufferSize | The size of the buffer required to hold the CachedData objects for the given array of lights. |
Enlighten::TransparencyBuffer* GEO_CALL Enlighten::CreateTransparencyBuffer
public: Enlighten::TransparencyBuffer *GEO_CALL CreateTransparencyBuffer
(
const Enlighten::InputWorkspace * inputWorkspace,
void * mem
)
Create a TransparencyBuffer for a system.
This TransparencyBuffer is used as input to the IndirectInputLightingStage.
Parameters
| [in] | inputWorkspace | A valid InputWorkspace for a system |
| [in] | mem | A pointer to 16 byte aligned memory of size returned by CalcTransparencyBufferSize() |
Returns
The complete and valid TransparencyBuffer object. Returns NULL if an error occurred.
TransparencyWorkspace* GEO_CALL Enlighten::CreateTransparencyWorkspace
public: TransparencyWorkspace *GEO_CALL CreateTransparencyWorkspace
(
void * memory,
const InputWorkspace * inputWorkspace,
Geo::s32 numInterpolants,
Geo::s32 numLods,
PrecisionHint::Value precision
)
Construct an TransparencyWorkspace inside the memory provided.
Parameters
| [in] | memory | A block of memory (size determined by CalcTransparencyWorkspaceSize) to store the workspace for pre-authored static destruction/transparency |
| [in] | inputWorkspace | The InputWorkspace for the system. |
| [in] | numInterpolants | The maximum number of interpolants to use. |
| [in] | precision | The floating point precision for intermediate values. |
| [in] | numLods | The number of LODs to use. |
TransparencyWorkspace* GEO_CALL Enlighten::CreateTransparencyWorkspace
public: TransparencyWorkspace *GEO_CALL CreateTransparencyWorkspace
(
void * memory,
const InputWorkspace * inputWorkspace,
Geo::s32 numInterpolants,
PrecisionHint::Value precision
)
Construct an TransparencyWorkspace inside the memory provided.
Parameters
| [in] | memory | A block of memory (size determined by CalcTransparencyWorkspaceSize) to store the workspace for pre-authored static destruction/transparency |
| [in] | inputWorkspace | The InputWorkspace for the system. |
| [in] | numInterpolants | The maximum number of interpolants to use. |
| [in] | precision | The floating point precision for intermediate values. |
Geo::TriGroupSelection* GEO_CALL Enlighten::CreateTriGroupsForPrecompInputMesh
public: Geo::TriGroupSelection *GEO_CALL CreateTriGroupsForPrecompInputMesh
(
const IPrecompInputMesh * inputMesh
)
Utility to create the tri group structure defined by the input mesh.
This can be used to generate the same tri groups the precompute will generate when given this mesh. The tri groups are determined by the connectivity in the index buffer (ie. shared vertices) and the links (Geo::IdxLink) specified or generated by the user.
Parameters
| [in] | inputMesh | The input mesh. |
Returns
A valid tri group if successful, else null.
double Enlighten::CyclesToMillisecond
public: double CyclesToMillisecond
(
Geo::s64 cycles
)
Helper function to convert CPU cycles to milliseconds.
double Enlighten::CyclesToSeconds
public: double CyclesToSeconds
(
Geo::s64 cycles
)
Helper function to convert CPU cycles to seconds.
constexpr Geo::Dimension3 Enlighten::DecodeWorldAxisDimension
public: constexpr Geo::Dimension3 DecodeWorldAxisDimension
(
WorldAxis direction
)
Return the index of the axis to which the specified axis aligned unit vector is oriented.
constexpr Geo::Sign Enlighten::DecodeWorldAxisSign
public: constexpr Geo::Sign DecodeWorldAxisSign
(
WorldAxis direction
)
Return the sign of the axis to which the specified axis aligned unit vector is oriented.
void GEO_CALL Enlighten::DeleteAlbedoBuffer
public: void GEO_CALL DeleteAlbedoBuffer
(
Enlighten::AlbedoBuffer *& albedoBuffer
)
Free an AlbedoBuffer object, and all the memory it owns.
Parameters
| [in] | albedoBuffer | - The AlbedoBuffer to free. |
void GEO_CALL Enlighten::DeleteClusterAlbedoWorkspaceMaterialData
public: void GEO_CALL DeleteClusterAlbedoWorkspaceMaterialData
(
Enlighten::ClusterAlbedoWorkspaceMaterialData *& materialData
)
Free an ClusterAlbedoWorkspaceMaterialData object, and all the memory (RadDataBlocks) it owns.
This is intended to be used to delete objects created with one of the ReadCluster* functions.
Parameters
| [in] | materialData | - The ClusterAlbedoWorkspaceMaterialData to free. |
void GEO_CALL Enlighten::DeleteDynamicMaterialWorkspace
public: void GEO_CALL DeleteDynamicMaterialWorkspace
(
Enlighten::DynamicMaterialWorkspace *& materialWorkspace
)
Free an DynamicMaterialWorkspace object, and all the memory it owns.
Parameters
| [in] | materialWorkspace | - The DynamicMaterialWorkspace to free. |
void GEO_CALL Enlighten::DeleteEmissiveBuffer
public: void GEO_CALL DeleteEmissiveBuffer
(
Enlighten::EmissiveBuffer *& emissiveBuffer
)
Free an EmissiveBuffer object, and all the memory it owns.
Parameters
| [in] | emissiveBuffer | - The EmissiveBuffer to free. |
void GEO_CALL Enlighten::DeleteIncidentLightingBuffer
public: void GEO_CALL DeleteIncidentLightingBuffer
(
Enlighten::IncidentLightingBuffer *& incidentLightingBuffer
)
Free an IncidentLightingBuffer object, and all the memory it owns.
Parameters
| [in] | incidentLightingBuffer | - The IncidentLightingBuffer to free. |
void GEO_CALL Enlighten::DeleteInputLightingBuffer
public: void GEO_CALL DeleteInputLightingBuffer
(
Enlighten::InputLightingBuffer *& inputLightingBuffer
)
Free an InputLightingBuffer object, and all the memory it owns.
Parameters
| [in] | inputLightingBuffer | - The InputLightingBuffer to free. |
void GEO_CALL Enlighten::DeleteInputWorkspace
public: void GEO_CALL DeleteInputWorkspace
(
Enlighten::InputWorkspace *& inputWorkspace
)
Free an InputWorkspace object, and all the memory (RadDataBlocks) it owns.
Parameters
| [in] | inputWorkspace | - The InputWorkspace to free. |
void GEO_CALL Enlighten::DeletePrecomputedVisibilityData
public: void GEO_CALL DeletePrecomputedVisibilityData
(
Enlighten::PrecomputedVisibilityData *& visibilityData
)
Free a PrecomputedVisibilityData object, and all the memory (RadDataBlocks) it owns.
Parameters
| [in] | visibilityData | - The PrecomputedVisibilityData to free. |
void GEO_CALL Enlighten::DeleteRadCubeMapCore
public: void GEO_CALL DeleteRadCubeMapCore
(
Enlighten::RadCubeMapCore *& cubeMapCore
)
Free a RadCubeMapCore object, and all the memory (RadDataBlocks) it owns.
Parameters
| [in] | cubeMapCore | - The RadCubeMapCore to free. |
void GEO_CALL Enlighten::DeleteRadProbeSetCore
public: void GEO_CALL DeleteRadProbeSetCore
(
Enlighten::RadProbeSetCore *& probeSet
)
Free a RadProbeSetCore object, and all the memory (RadDataBlocks) it owns.
Parameters
| [in] | probeSet | - The RadProbeSetCore to free. |
void GEO_CALL Enlighten::DeleteRadSystemCore
public: void GEO_CALL DeleteRadSystemCore
(
Enlighten::RadSystemCore *& system
)
Free a RadSystemCore object, and all the memory (RadDataBlocks) it owns.
Parameters
| [in] | system | - The RadSystemCore to free. |
void GEO_CALL Enlighten::DeleteTransparencyBuffer
public: void GEO_CALL DeleteTransparencyBuffer
(
Enlighten::TransparencyBuffer *& transparencyBuffer
)
Free a TransparencyBuffer object, and all the memory it owns.
Parameters
| [in] | transparencyBuffer | - The TransparencyBuffer to free. |
double GEO_CALL Enlighten::Distance
public: double GEO_CALL Distance
(
const Vertex2D & a,
const Vertex2D & b
)
Computes the distance between two Vertex2D.
double GEO_CALL Enlighten::DistanceSquare
public: double GEO_CALL DistanceSquare
(
const Vertex2D & a,
const Vertex2D & b
)
Computes the squared distance between two Vertex2D.
bool GEO_CALL Enlighten::DoDebugColouring
public: bool GEO_CALL DoDebugColouring
(
const Enlighten::RadDebugColouringTask * task
)
Write debugging colours to an output texture.
The default is to colour naughty pixels in red, and wings in blue in an irradiance output. To use this function with SH-style output, call it three times (once for each output texture), with appropriate debugging values. Or to say if differently: If you clear the texture to zero (including alpha) in advance you could render with the results as an additive overlay, but it will also work just as well if you want to add the results on top of the usual radiosity output.
Parameters
| [in] | task | A valid pointer to a RadDebugColouringTask to perform. |
bool Enlighten::DoDirectInputLighting
public: bool DoDirectInputLighting
(
DirectInputLightingParameters * params,
void * scratchspace,
size_t scratchspacSize,
Geo::u32 & timeUs
)
Do the Direct input lighting stage.
Parameters
| [in] | params | A pointer to a complete DirectInputLightingParams object. |
| [in] | scratchspace | A pointer to allocated scratchspace memory. This memory is only used for the duration of the call to this function. |
| [in] | scratchspacSize | The size of the scratchspace memory calculated with CalcRequiredScratchSpaceMemory function. |
| [out] | timeUs | Duration taken to solve the indirect input lighting phase. |
Returns
The number of light affecting the system after culling.
Geo::u32 Enlighten::DoDirectInputLightingInternal
public: Geo::u32 DoDirectInputLightingInternal
(
DirectInputLightingParameters * params,
void * scratchspace,
size_t scratchspaceSize,
TransformOp transform
)
Do the internal direct input lighting stage.
Called from DoDirectInputLighting() function.
Parameters
| [in] | params | A pointer to a complete DirectInputLightingParameters object. |
| [in] | scratchspace | A pointer to allocated scratchspace memory. |
| [in] | scratchspaceSize | The size of the scratchspace memory calculated with CalcRequiredScratchSpaceMemory function. |
| [in] | transform | An internal transformation operand. |
Returns
The number of lights that affect the system after culling.
bool GEO_CALL Enlighten::DoesInputWorkspaceHaveProjectionData
public: bool GEO_CALL DoesInputWorkspaceHaveProjectionData
(
const InputWorkspace * inputWorkspace
)
Simple test to see if projection data is available.
Returns true if the inputWorkspace has data in its point projection RadDataBlock, otherwise false. This does quick and simple checks only and assumes that if the data exists it is well formed. Note that it can still have a valid RadDataBlock, but that block can be empty. You can test whether GetInputWorkspaceMaxProjectedPointsInAnyInstance() == 0 to check if the block is empty.
Parameters
| [in] | inputWorkspace | The input workspace to use. |
bool Enlighten::DoIndirectInputLighting
public: bool DoIndirectInputLighting
(
IndirectInputLightingParameters * params,
Geo::u32 & timeUs
)
Do the indirect input lighting stage.
Parameters
| [in] | params | A pointer to a complete IndirectInputLightingParameters object. |
| [out] | timeUs | Duration taken to solve the indirect input lighting phase. |
Returns
true on success
bool Enlighten::DoIndirectInputLightingInternal
public: bool DoIndirectInputLightingInternal
(
IndirectInputLightingInternalParameters< MaterialSamplerType, InputLightingSurroundingsType, GeometryTransparencySamplerType > * params
)
Do the internal indirect input lighting stage.
Called from DoIndirectInputLighting() function.
Parameters
| [in] | params | A pointer to a complete IndirectInputLightingParameters object. |
Returns
true on success
CpuTextureElement GEO_CALL Enlighten::EncodeRGBM
public: CpuTextureElementGEO_CALL EncodeRGBM
(
float * rgb,
float MaxRange
)
Utility function for converting floating point values to the RGBM format.
constexpr WorldAxis Enlighten::EncodeWorldAxis
public: constexpr WorldAxis EncodeWorldAxis
(
Geo::Dimension3 axis,
Geo::Sign sign
)
Return the axis aligned unit vector oriented with the specified axis and sign.
void Enlighten::EnqueueCommand
public: void EnqueueCommand
(
IUpdateManager * updateManager,
CommandType && command
)
Enqueues a command.
The command will be executed on the worker thread if one exists, otherwise it will be executed immediately on the calling thread. CommandType is expected to be derived from the Command class - see Command.h
void Enlighten::EnqueueFunctorCommand
public: void EnqueueFunctorCommand
(
IUpdateManager * updateManager,
Functor && functor
)
Enqueue a functor object or lambda expression as a command with no arguments.
void Enlighten::EnqueueSetObjectParameter
public: void EnqueueSetObjectParameter
(
IUpdateManager * updateManager,
Geo::GeoGuid objectId,
void(ObjectType::*)(const ParamType &) function,
ArgType && value
)
Enqueues a command to set a parameter on an object on the worker thread.
ObjectType may be BaseSystem, BaseDynamicObject, BaseCubeMap or Probes.
void Enlighten::EnqueueSetObjectParameter
public: void EnqueueSetObjectParameter
(
IUpdateManager * updateManager,
ObjectType * object,
void(ObjectType::*)(ParamType) function,
ArgType && value
)
Enqueues a command to set a parameter on an object on the worker thread.
ObjectType may be BaseSystem, BaseDynamicObject, BaseCubeMap or Probes.
void Enlighten::EnqueueSetObjectParameter
public: void EnqueueSetObjectParameter
(
IUpdateManager * updateManager,
Geo::GeoGuid objectId,
void(ObjectType::*)(ParamType) function,
ArgType && value
)
Enqueues a command to set a parameter on an object on the worker thread.
ObjectType may be BaseSystem, BaseDynamicObject, BaseCubeMap or Probes.
void Enlighten::EnqueueSetObjectParameter
public: void EnqueueSetObjectParameter
(
IUpdateManager * updateManager,
ObjectType * object,
void(ObjectType::*)(const ParamType &) function,
ArgType && value
)
Enqueues a command to set a parameter on an object on the worker thread.
ObjectType may be BaseSystem, BaseDynamicObject, BaseCubeMap or Probes.
void Enlighten::EnqueueWorkerCommand
public: void EnqueueWorkerCommand
(
IUpdateManager * updateManager,
typename FunctionPointer2< Param1Type, Param2Type >::CallbackType callback,
Param1Type input1,
Param2Type input2
)
Enqueue function pointer 2 param.
void Enlighten::EnqueueWorkerCommand
public: void EnqueueWorkerCommand
(
IUpdateManager * updateManager,
typename FunctionPointer1< Param1Type >::CallbackType callback,
Param1Type input1
)
Enqueue function pointer 1 param.
void Enlighten::EnqueueWorkerCommand
public: void EnqueueWorkerCommand
(
IUpdateManager * updateManager,
FunctionPointer0::CallbackType callback
)
A command that holds a reference to its movable parameter.
Enqueue function pointer 0 param
void Enlighten::EnqueueWorkerCommand
public: void EnqueueWorkerCommand
(
IUpdateManager * updateManager,
typename FunctionPointer5< Param1Type, Param2Type, Param3Type, Param4Type, Param5Type >::CallbackType callback,
Param1Type input1,
Param2Type input2,
Param3Type input3,
Param4Type input4,
Param5Type input5
)
Enqueue function pointer 5 param.
void Enlighten::EnqueueWorkerCommand
public: void EnqueueWorkerCommand
(
IUpdateManager * updateManager,
typename FunctionPointer3< Param1Type, Param2Type, Param3Type >::CallbackType callback,
Param1Type input1,
Param2Type input2,
Param3Type input3
)
Enqueue function pointer 3 param.
void Enlighten::EnqueueWorkerCommand
public: void EnqueueWorkerCommand
(
IUpdateManager * updateManager,
typename FunctionPointer4< Param1Type, Param2Type, Param3Type, Param4Type >::CallbackType callback,
Param1Type input1,
Param2Type input2,
Param3Type input3,
Param4Type input4
)
Enqueue function pointer 4 param.
void Enlighten::EnqueueWorkerFunctorCommand
public: void EnqueueWorkerFunctorCommand
(
IUpdateManager * updateManager,
Functor && functor
)
Enqueue a functor object or lambda expression as a worker command.
Geo::s32 GEO_CALL Enlighten::EstimateSystemDependencies
public: Geo::s32GEO_CALL EstimateSystemDependencies
(
const Enlighten::InstanceDescMinimal< IPrecompInputGeometry > * instances,
Geo::s32 numInstances,
const Enlighten::SystemGrouping * iSystemGrouping,
Enlighten::SystemDependencies *& oSystemDependencies
)
Estimate the dependencies between a set of systems.
Uses the instance bounding boxes to determine the system bounding boxes, and a collection of bounding box/sphere intersection tests to determine the dependencies. The function can be given either IPrecompInputGeometry or IPrecompPackedGeometry. Results will be identical.
Parameters
| [in] | instances | The instances in the systems. |
| [in] | numInstances | The number of instances. |
| [in] | iSystemGrouping | A list of system groups. Each group contains indices into the input array of instances. |
| [out] | oSystemDependencies | The system dependencies. |
Returns
0 if successful, otherwise a non-zero value.
Geo::s32 GEO_CALL Enlighten::EstimateSystemDependencies
public: Geo::s32GEO_CALL EstimateSystemDependencies
(
const Enlighten::InstanceDescMinimal< IPrecompPackedGeometry > * instances,
Geo::s32 numInstances,
const Enlighten::SystemGrouping * iSystemGrouping,
Enlighten::SystemDependencies *& oSystemDependencies
)
Estimate the dependencies between a set of systems.
Uses the instance bounding boxes to determine the system bounding boxes, and a collection of bounding box/sphere intersection tests to determine the dependencies. The function can be given either IPrecompInputGeometry or IPrecompPackedGeometry. Results will be identical.
Parameters
| [in] | instances | The instances in the systems. |
| [in] | numInstances | The number of instances. |
| [in] | iSystemGrouping | A list of system groups. Each group contains indices into the input array of instances. |
| [out] | oSystemDependencies | The system dependencies. |
Returns
0 if successful, otherwise a non-zero value.
bool GEO_CALL Enlighten::ExtractOctreeProbePositions
public: bool GEO_CALL ExtractOctreeProbePositions
(
const RadProbeSetCore * core,
Geo::v128 * positions,
Geo::u32 count
)
Extract the first n probe positions within the specified RadProbeSetCore.
For debugging only. Use GetOctreeProbePositionCount to obtain the total number of probe positions that can be extracted. Real probes appear first in the array, followed by virtual probes, followed by nonexistent probes. The W coordinate of a nonexistent probe indicates its type:
The position of a culled probe has W == -1
The position of a border probe has W == -2
The position of a referenced probe stores the index of the real or virtual probe to which it refers.
Parameters
[in] core A RadProbeSetCore containing a probe set created by automatic probe placement.
[in] positions An array large enough to store the desired subset of probes.
[in] count The number of entries in the positions array.
bool GEO_CALL Enlighten::FindDebugClusterInfo
public: bool GEO_CALL FindDebugClusterInfo
(
RadDebugPixelInfo * infoOut,
Geo::s32 clusterIndex,
const RadSystemCore * radCore
)
Fill in a RadDebugPixelInfo for a specified leaf cluster index (for internal debugging purposes).
Given a cluster index, find the pixel and related indices that the cluster index corresponds to. Returns false if nothing was found at the location.
bool GEO_CALL Enlighten::FindDebugPixelInfo
public: bool GEO_CALL FindDebugPixelInfo
(
RadDebugPixelInfo * infoOut,
float u,
float v,
const RadSystemCore * radCore,
const ILightTransportOutput * ltOutput
)
Fill in a RadDebugPixelInfo for a specified UV coordinate (for internal debugging purposes).
Given a UV coordinate find the pixel and related indices that the UV coordinate corresponds to. The ltOutput parameter is optional, but the other arguments are not. Returns false if nothing was found at the location.
OctreeSearchResult GEO_CALL Enlighten::FindProbeSetOctreeNode
public: OctreeSearchResultGEO_CALL FindProbeSetOctreeNode
(
const RadProbeSetCore * core,
Geo::v128 point,
Geo::u32 lod
)
Returns a search result containing information about the node containing the specified point.
Parameters
| [in] | core | A RadProbeSetCore containing a probeset created by automatic probe placement. |
| [in] | point | The world space location at which to search. |
| [in] | lod | LOD to use when searching the octree nodes. |
void GEO_CALL Enlighten::FreeDataBlockContents
public: void GEO_CALL FreeDataBlockContents
(
RadDataBlock * block
)
Free a RadDataBlock object, and all the memory it owns.
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,
const InputLightingBuffer * environmentOnly
)
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. |
| [out] | environmentOnly | Use in combination with environment only bounce solve. |
void* Enlighten::GenerateCachedData
public: void * GenerateCachedData
(
SortedLights * sortedLights,
InputLightBase * cachedLightMemory,
void ** unsortedVisibilityPointers
)
Go through all the sorted lights generating the CachedData for each. Also modifies sortedLights to point to the cached data.
void* Enlighten::GenerateCachedDataGeneric
public: void * GenerateCachedDataGeneric
(
SortedLights * sortedLights,
InputLightBase * cachedLightMemory,
void ** unsortedVisibilityPointers
)
Generate the CacheData for a specific light type.
void* Enlighten::GenerateCachedDataGeneric< LIGHT_TYPE_INVALID >
public: void * GenerateCachedDataGeneric< LIGHT_TYPE_INVALID >
(
SortedLights * sortedLights,
InputLightBase * cachedLightMemory,
void ** unsortedVisibilityPointers
)
Specialisation for invalid light types - does nothing.
bool GEO_CALL Enlighten::GenerateInverseSquaredLightFalloffTable
public: bool GEO_CALL GenerateInverseSquaredLightFalloffTable
(
InputLightFalloffTable * lightTable,
float lightFalloffDistance,
float lightRadius
)
Helper function that generates a Falloff Table using an inverse squared light falloff function, closely approximating real world light falloff.
Light falloff is smoothly biased to zero as it approaches the cutoff.
Parameters
| [out] | lightTable | The Input Light Falloff Table to write to. |
| [in] | lightFalloffDistance | The falloff distance the light table will represent, typically (m_Cutoff - m_Radius), must be > 0. |
| [in] | lightRadius | The radius of the simulated light source, typically m_Radius or 1.0, must be > 0. |
bool GEO_CALL Enlighten::GenerateUnityCompatibleLightFalloffTable
public: bool GEO_CALL GenerateUnityCompatibleLightFalloffTable
(
InputLightFalloffTable * lightTable
)
Helper function that generates a falloff table compatible with the Unity light falloff model.
Parameters
| [out] | lightTable | The input light falloff table to write to. |
bool GEO_CALL Enlighten::GenerateUnrealCompatibleLightFalloffTable
public: bool GEO_CALL GenerateUnrealCompatibleLightFalloffTable
(
InputLightFalloffTable * lightTable,
float falloffExponent
)
Helper function that generates a Falloff Table compatible with the Unreal light falloff model.
Parameters
| [out] | lightTable | The Input Light Falloff Table to write to. |
| [in] | falloffExponent | The falloff exponent of the light, must be > 0. |
bool GEO_CALL Enlighten::GenerateUvsFromMergeMap
public: bool GEO_CALL GenerateUvsFromMergeMap
(
Geo::GeoPoint2 * outUvs,
const Enlighten::MergeMap * mergeMap,
const Enlighten::MergeGeometry * mergeGeometry
)
Generate UVs for merged geometry.
Takes the MergeMap (which includes the models that were fitted) and the original geometry and writes the generated uvs to the outUvs array. This uv array should have the same number of vertices as the geometry.
Geo::u32 GEO_CALL Enlighten::GetBounceBufferSize
public: Geo::u32GEO_CALL GetBounceBufferSize
(
const Enlighten::BounceBuffer * bounceBuffer,
PrecisionHint::Value precision
)
Returns the size of the specified BounceBuffer object.
Parameters
| [in] | bounceBuffer | The BounceBuffer to query. |
| [in] | precision | The hint to what floating point precision to use. |
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
Geo::GeoGuid GEO_CALL Enlighten::GetBounceBufferSystemId
public: Geo::GeoGuidGEO_CALL GetBounceBufferSystemId
(
const Enlighten::BounceBuffer * bounceBuffer
)
Get system id from BounceBuffer.
Parameters
| [in] | bounceBuffer | The BounceBuffer to query. |
Geo::u32 GEO_CALL Enlighten::GetClusterAlbedoWorkspaceMaterialDataSize
public: Geo::u32GEO_CALL GetClusterAlbedoWorkspaceMaterialDataSize
(
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData
)
Returns the size of the specified ClusterAlbedoWorkspaceMaterialData object.
Note that this includes the size of the two child RadDataBlocks.
Returns
Memory used in bytes, 0xFFFFFFFF upon error.
const Geo::u64* GEO_CALL Enlighten::GetClusterAlbedoWorkspaceMaterialIds
public: const Geo::u64 *GEO_CALL GetClusterAlbedoWorkspaceMaterialIds
(
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData
)
Returns a list of all material Ids referenced by this albedo workspace.
The length of the returned array can be found using GetClusterAlbedoWorkspaceNumMaterials().
Parameters
| [in] | materialData | The albedo workspace material data to query. |
Geo::s32 GEO_CALL Enlighten::GetClusterAlbedoWorkspaceNumMaterials
public: Geo::s32GEO_CALL GetClusterAlbedoWorkspaceNumMaterials
(
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData
)
Returns the number of material Ids referenced by this albedo workspace.
Parameters
| [in] | materialData | The albedo workspace material data to query. |
Returns
The number of materials referenced, -1 upon error.
bool GEO_CALL Enlighten::GetDebugAlbedoValue
public: bool GEO_CALL GetDebugAlbedoValue
(
const Geo::u32 debugClusterIdx,
const AlbedoBuffer * albedoBuffer,
Geo::v128 & outValue
)
Get the cluster albedo value of a debug point from an AlbedoBuffer.
Parameters
| [in] | debugClusterIdx | Index of the cluster |
| [in] | albedoBuffer | The input AlbedoBuffer to query. |
| [out] | outValue | The value in the buffer for the given debug point. returns true on success or false if an error occured. |
bool GEO_CALL Enlighten::GetDebugEmissiveValue
public: bool GEO_CALL GetDebugEmissiveValue
(
const Geo::u32 debugClusterIdx,
const EmissiveBuffer * emissiveBuffer,
Geo::v128 & outValue
)
Get the cluster emissive value of a debug point from an EmissiveBuffer.
Parameters
| [in] | debugClusterIdx | Index of the cluster |
| [in] | emissiveBuffer | The input EmissiveBuffer to query. |
| [out] | outValue | The value in the buffer for the given debug point. returns true on success or false if an error occured. |
bool GEO_CALL Enlighten::GetDebugTransparencyValue
public: bool GEO_CALL GetDebugTransparencyValue
(
const Geo::u32 debugClusterIdx,
const TransparencyBuffer * transparencyBuffer,
float & outValue
)
Get the cluster transparency value of a debug point from an TransparencyBuffer.
Parameters
| [in] | debugClusterIdx | Index of the cluster |
| [in] | transparencyBuffer | The input TransparencyBuffer to query. |
| [out] | outValue | The value in the buffer for the given debug point. returns true on success or false if an error occured. |
Geo::s32 Enlighten::GetDxgiFormatBytesPerPixel
public: Geo::s32 GetDxgiFormatBytesPerPixel
(
DXGI_FORMAT format
)
Helper function to calculate the number of texture bytes per pixel for DXGI texture formats supported by Enlighten.
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::u32 GEO_CALL Enlighten::GetIncidentLightingBufferSize
public: Geo::u32GEO_CALL GetIncidentLightingBufferSize
(
const Enlighten::IncidentLightingBuffer * incidentLightingBuffer,
PrecisionHint::Value precision
)
Returns the size of the specified IncidentLightingBuffer object.
Parameters
| [in] | incidentLightingBuffer | The IncidentLightingBuffer to query. |
| [in] | precision | The hint to what floating point precision to use. |
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
Geo::GeoGuid GEO_CALL Enlighten::GetIncidentLightingBufferSystemId
public: Geo::GeoGuidGEO_CALL GetIncidentLightingBufferSystemId
(
const Enlighten::IncidentLightingBuffer * incidentLightingBuffer
)
Get system id from IncidentLightingBuffer.
Parameters
| [in] | incidentLightingBuffer | The IncidentLightingBuffer to query. |
bool GEO_CALL Enlighten::GetInputLightingBufferLightValue
public: bool GEO_CALL GetInputLightingBufferLightValue
(
const InputLightingBuffer * inputLightingBuffer,
float lightValue,
Geo::s32 clusterIdx
)
Fill the specified array with the current light value for the given cluster index.
Geo::u32 GEO_CALL Enlighten::GetInputLightingBufferSize
public: Geo::u32GEO_CALL GetInputLightingBufferSize
(
const InputLightingBuffer * inputLightingBuffer
)
Returns the size of the specified InputLightingBuffer object.
Parameters
| [in] | inputLightingBuffer | The InputLightingBuffer to query. |
Returns
Required memory in bytes, 0xFFFFFFFF upon error.
Geo::GeoGuid GEO_CALL Enlighten::GetInputLightingBufferSystemId
public: Geo::GeoGuidGEO_CALL GetInputLightingBufferSystemId
(
const Enlighten::InputLightingBuffer * inputLightingBuffer
)
Get system id from InputLightingBuffer.
Parameters
| [in] | inputLightingBuffer | The InputLightingBuffer to query. |
bool GEO_CALL Enlighten::GetInputWorkspaceDebugIterator
public: bool GEO_CALL GetInputWorkspaceDebugIterator
(
const InputWorkspace * inputWorkspace,
Enlighten::InputWorkspaceDebugIterator & debugIterator
)
Return a debug iterator object in {debugIterator} which can be used to iterate through the systems debug points.
bool GEO_CALL Enlighten::GetInputWorkspaceDebugPoint
public: bool GEO_CALL GetInputWorkspaceDebugPoint
(
const InputWorkspace * inputWorkspace,
InputWorkspaceDebugPoint * debugPoint,
Geo::s32 index
)
Fill the specified debug data structure with the current values for the given input workspace sample point.
Does not include lighting.
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::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::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. |
bool GEO_CALL Enlighten::GetInputWorkspaceInstanceGuids
public: bool GEO_CALL GetInputWorkspaceInstanceGuids
(
const InputWorkspace * inputWorkspace,
Geo::GeoGuid * instanceIdsOut
)
Get all the instance GUIDs in this system.
This reports all the instance GUIDs this system saw and recorded during the precompute. You must pass an array that is at least as large as the number reported by GetInputWorkspaceInstanceGuids(). Note that it can succeed not have written anything out if there is a valid projection block, but it's empty. If there is no valid data (the block or input workspace is missing or corrupt) this call will return false, otherwise true.
Parameters
| [in] | inputWorkspace | The input workspace to use. |
| [out] | instanceIdsOut | A pointer to an array of GeoGuid to receive the instance GUIDs. Must not be null and at least as long as GetInputWorkspaceNumInstanceGuids(). |
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::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::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.
bool GEO_CALL Enlighten::GetInputWorkspaceLitDebugPoint
public: bool GEO_CALL GetInputWorkspaceLitDebugPoint
(
const InputWorkspace * inputWorkspace,
InputWorkspaceDebugPoint * debugPoint,
Geo::s32 index,
const InputLightingBuffer * lightValues
)
Fill the specified debug data structure with the current values for the given input workspace sample point.
Does not include albedo information, as this is part of the various albedo workspaces.
bool GEO_CALL Enlighten::GetInputWorkspaceMaxProjectedPointsInAnyInstance
public: bool GEO_CALL GetInputWorkspaceMaxProjectedPointsInAnyInstance
(
const InputWorkspace * inputWorkspace,
Geo::s32 * maxPointsOut
)
Get the maximum number of projected points associated with any instance.
This is effectively the largest number that can be returned by GetInputWorkspaceNumProjectedPointsInInstance() Useful if you want to allocate one buffer up front that will always be large enough to accept results. Note that it can succeed and return 0 if there is a valid projection block, but it's empty. If there is no valid data (the block or input workspace is missing or corrupt) this call will return false, otherwise true.
Parameters
| [in] | inputWorkspace | The input workspace to use. |
| [out] | maxPointsOut | A pointer to an s32 to receive the number of points. Must not be null. |
bool GEO_CALL Enlighten::GetInputWorkspaceMaxVersionsInAnyInstance
public: bool GEO_CALL GetInputWorkspaceMaxVersionsInAnyInstance
(
const InputWorkspace * inputWorkspace,
Geo::s32 * maxVersionsOut
)
Get the maximum number of versions of projected points associated with any instance.
This is effectively the largest number that can be returned by GetInputWorkspaceNumVersionsInInstance() Useful if you want to allocate one buffer up front that will always be large enough to accept results. Note that it can succeed and return 0 if there is a valid projection block, but it's empty. If there is no valid data (the block or input workspace is missing or corrupt) this call will return false, otherwise true.
Parameters
| [in] | inputWorkspace | The input workspace to use. |
| [out] | maxVersionsOut | A pointer to an s32 to receive the number of versions. Must not be null. |
bool GEO_CALL Enlighten::GetInputWorkspaceNormalArray
public: bool GEO_CALL GetInputWorkspaceNormalArray
(
const InputWorkspace * inputWorkspace,
Geo::v128 * normalsOut
)
Fills an array with the normals of all of the input points in an input workspace.
The array should be big enough to hold one vector for each point in the input workspace. The number of points is returned by GetNumberOfPointsInInputWorkspace().
Parameters
| [in] | inputWorkspace | The input workspace to use. |
| [out] | normalsOut | Pointer to an array of vectors to write the normals to. |
bool GEO_CALL Enlighten::GetInputWorkspaceNumInstanceGuids
public: bool GEO_CALL GetInputWorkspaceNumInstanceGuids
(
const InputWorkspace * inputWorkspace,
Geo::s32 * numInstanceGuidsOut
)
Get the number of instance GUIDs in this system.
This is a record of all the instance GUIDs this system saw and recorded during the precompute. It's also the length of the array required by GetInputWorkspaceInstanceGuids() Note that it can succeed and set numInstanceGuidsOut to 0 if there is a valid projection block, but it's empty. If there is no valid data (the block or input workspace is missing or corrupt) this call will return false, otherwise true.
Parameters
| [in] | inputWorkspace | The input workspace to use. |
| [out] | numInstanceGuidsOut | A pointer to an s32 to receive the number of instance GUIDs. Must not be null. |
bool GEO_CALL Enlighten::GetInputWorkspaceNumPointsPerClusterArray
public: bool GEO_CALL GetInputWorkspaceNumPointsPerClusterArray
(
const InputWorkspace * inputWorkspace,
Geo::s32 * numPointsPerClusterArray
)
Fills the array with the number of points per cluster.
The points inside an input workspace are ordered and grouped by cluster, so you can identify which point belongs it which cluster from this information. You can also produce this information from GetInputWorkspaceDebugPoint() and GetInputWorkspaceLitDebugPoint(), but this implementation would be more efficient.
Parameters
| [in] | inputWorkspace | A valid input workspace. |
| [in] | numPointsPerClusterArray | The array to fill. Must be at least as long as that returned by GetNumberOfClustersInInputWorkspace() |
Returns
False on error, true otherwise.
bool GEO_CALL Enlighten::GetInputWorkspaceNumProjectedPointsInInstance
public: bool GEO_CALL GetInputWorkspaceNumProjectedPointsInInstance
(
const InputWorkspace * inputWorkspace,
Geo::GeoGuid instanceGuid,
Geo::s32 * numPointsOut
)
Get the number of points associated with the specified instance.
If the instanceGuid is recognised (i.e. it was seen by the precompute), and versions exist for it, then numPointsOut will be set to the number of points associated with this instance. Note numPointsOut can be zero if there were no associated points. If the instanceGuid is recognised, but no versions exist for it, then numPointsOut will be set to 0. If the instanceGuid is not recognised or invalid, then numPointsOut will be set to -1, but the function still returns true. If there is no valid data (the block or input workspace is missing or corrupt) this call will return false, otherwise true.
Parameters
| [in] | inputWorkspace | The input workspace to use. |
| [in] | instanceGuid | The instance GUID to lookup. |
| [out] | numPointsOut | A pointer to an s32 to receive the number of points. Must not be null. |
bool GEO_CALL Enlighten::GetInputWorkspaceNumVersionsInInstance
public: bool GEO_CALL GetInputWorkspaceNumVersionsInInstance
(
const InputWorkspace * inputWorkspace,
Geo::GeoGuid instanceGuid,
Geo::s32 * numVersionsOut
)
Get the number of versions associated with the specified instance.
If the instanceGuid is recognised (i.e. it was seen by the precompute), then numVersionsOut will be the number of versions associated with this instance. Note that it is valid for an instance to have no versions associated with it, in which case numVersionsOut will be 0. If the instanceGuid is not recognised or invalid, then numVersionsOut will be set to -1, but the function still returns true. If there is no valid data (the block or input workspace is missing or corrupt) this call will return false, otherwise true.
Parameters
| [in] | inputWorkspace | The input workspace to use. |
| [in] | instanceGuid | The instance GUID to lookup. |
| [out] | numVersionsOut | A pointer to an s32 to receive the number of versions. Must not be null. |
bool GEO_CALL Enlighten::GetInputWorkspacePositionAndNormalArray
public: bool GEO_CALL GetInputWorkspacePositionAndNormalArray
(
const InputWorkspace * inputWorkspace,
Geo::v128 * positionsOut,
Geo::v128 * normalsOut
)
Fills arrays with the positions and normals of all of the input points in an input workspace.
This array can then be used for visibility computations (eg on the GPU).
Parameters
| [in] | inputWorkspace | The input workspace to use. |
| [out] | positionsOut | Pointer to an array of vectors to write the positions to. |
| [out] | normalsOut | Pointer to an array of vectors to write the normals to. Both arrays should be big enough to hold one vector for each point in the input workspace. The number of points is returned by GetNumberOfPointsInInputWorkspace(). |
See Also
bool GEO_CALL Enlighten::GetInputWorkspacePositionArray
public: bool GEO_CALL GetInputWorkspacePositionArray
(
const InputWorkspace * inputWorkspace,
Geo::v128 * positionsOut
)
Fills an array with the positions of all of the input points in an input workspace.
This array can then be used for visibility computations (eg on the GPU). The array should be big enough to hold one vector for each point in the input workspace. The number of points is returned by GetNumberOfPointsInInputWorkspace().
Parameters
| [in] | inputWorkspace | The input workspace to use. |
| [out] | positionsOut | Pointer to an array of vectors to write the positions to. |
bool GEO_CALL Enlighten::GetInputWorkspaceProjectedPointVersion
public: bool GEO_CALL GetInputWorkspaceProjectedPointVersion
(
const InputWorkspace * inputWorkspace,
Geo::GeoGuid instanceGuid,
Geo::s32 versionId,
Geo::s32 * pointIdxArrayOut,
Geo::v128 * pointPosArrayOut,
Geo::s32 * numProjectedPointsOut
)
Get the projected points for a specified version and instance.
pointIdxArrayOut and pointPosArrayOut should each point to arrays and will be filled with corresponding pairs of indices and positions associated with the specified instance and version. The values of pointIdxArrayOut are the indices into the duster point position array. The values of pointPosArrayOut are the corresponding projected positions of the point at that index.
numProjectedPointsOut should point to a single s32 and will be set to the same value as returned through GetInputWorkspaceNumProjectedPointsInInstance() if both the instanceId and versionId are recognised.
If both the instanceGuid and versionId are recognised, then numProjectedPointsOut will be the number of items written to each array. If the instanceGuid is not recognised or is invalid, numProjectedPointsOut will be -1, and no values will be written to the arrays. If the instanceGuid is recognised by versionId is not, numProjectedPointsOut will be 0, and no values will be written to the arrays.
The arrays should be at least as large as the maximum value that may be written, which can be found by calling GetInputWorkspaceNumProjectedPointsInInstance() in advance, or by using the system-wide num points maximum returned by GetInputWorkspaceMaxProjectedPointsInAnyInstance(). The system wide maximum may be helpful if you wish to allocate a single block of memory and re-use it for other instances. If there is no valid data (the block or input workspace is missing or corrupt) this call will return false, otherwise true.
Parameters
| [in] | inputWorkspace | The input workspace to use. |
| [in] | instanceGuid | The instance GUID to lookup. |
| [in] | versionId | The version ID to lookup. |
| [out] | pointIdxArrayOut | A pointer to an array of s32 to receive the point indices. Must not be null and at least as long as GetInputWorkspaceNumProjectedPointsInInstance(). |
| [out] | pointPosArrayOut | A pointer to an array of v128 to receive the point positions. Must not be null and at least as long as GetInputWorkspaceNumProjectedPointsInInstance(). |
| [out] | numProjectedPointsOut | A pointer to an s32 to receive the number of points written. Must not be null. |
Geo::u32 GEO_CALL Enlighten::GetInputWorkspaceSize
public: Geo::u32GEO_CALL GetInputWorkspaceSize
(
const InputWorkspace * inputWorkspace
)
Returns the size of the specified InputWorkspace object.
Returns
Memory used in bytes, 0xFFFFFFFF upon error.
bool GEO_CALL Enlighten::GetInputWorkspaceVersionsInInstance
public: bool GEO_CALL GetInputWorkspaceVersionsInInstance
(
const InputWorkspace * inputWorkspace,
Geo::GeoGuid instanceId,
Geo::s32 * versionIdsOut,
Geo::s32 * numVersionsOut
)
Get the list of version ids stored for a specified instance.
numVersionsOut should point to a single s32 and will be set to the same value as returned through GetInputWorkspaceNumVersionsInInstance(). versionIdsOut should point to an array of s32s and will be filled with the version ids associated with instanceGuid.
If the instanceGuid is recognised, then numVersionsOut will be the number of items written to versionIdsOut. If the instanceGuid is not recognised or is invalid, numVersionsOut will be -1, and no values will be written to versionIdsOut. The versionIdsOut array should be at least as large as the maximum value that may be written, which can be found by calling GetInputWorkspaceNumVersionsInInstance() in advance, or by using the system-wide num versions maximum returned by GetInputWorkspaceMaxVersionsInAnyInstance(). The system wide maximum may be helpful if you wish to allocate a single block of memory and re-use it for other instances. If there is no valid data (the block or input workspace is missing or corrupt) this call will return false, otherwise true.
Parameters
| [in] | inputWorkspace | The input workspace to use. |
| [in] | instanceId | The instance GUID to lookup. |
| [out] | versionIdsOut | A pointer to an array of s32 to receive the version IDs. Must not be null and at least as long as GetInputWorkspaceNumVersionsInInstance(). |
| [out] | numVersionsOut | A pointer to an s32 to receive the number of versions. Must not be null. |
bool GEO_CALL Enlighten::GetLineIntersection
public: bool GEO_CALL GetLineIntersection
(
Vertex2D & intersection,
const Line2D & p,
const Line2D & q
)
Computes the intersection between two Line2D.
Parameters
| [out] | intersection | The intersection point of the two lines. |
| [in] | p | One line. |
| [in] | q | Other line. |
Returns
true if the lines intersect, and false if they are parallel
Geo::s32 GEO_CALL Enlighten::GetNumberOfClustersInInputWorkspace
public: Geo::s32GEO_CALL GetNumberOfClustersInInputWorkspace
(
const InputWorkspace * inputWorkspace
)
Returns the total number of clusters in an input workspace.
Returns
Number of clusters, -1 upon error.
Geo::s32 GEO_CALL Enlighten::GetNumberOfOutputBuckets
public: Geo::s32GEO_CALL GetNumberOfOutputBuckets
(
const RadSystemCore * radCore
)
Returns the total number of output buckets.
Returns
Number of buckets, -1 upon error.
Geo::s32 GEO_CALL Enlighten::GetNumberOfOutputPixels
public: Geo::s32GEO_CALL GetNumberOfOutputPixels
(
const RadSystemCore * radCore
)
Returns the total number of output pixels being lit.
Returns
Number of pixels, -1 upon error.
Geo::s32 GEO_CALL Enlighten::GetNumberOfOutputPixelsInBucket
public: Geo::s32GEO_CALL GetNumberOfOutputPixelsInBucket
(
const RadSystemCore * radSysCore,
const Geo::s32 & bucketIdx
)
Returns the total number of output pixels in the given bucket.
Returns
Number of pixels in bucket, -1 upon error.
Geo::s32 GEO_CALL Enlighten::GetNumberOfPointsInInputWorkspace
public: Geo::s32GEO_CALL GetNumberOfPointsInInputWorkspace
(
const InputWorkspace * inputWorkspace
)
Returns the total number of sample duster points in an input workspace.
Returns
Number of points, -1 upon error.
Geo::s32 GEO_CALL Enlighten::GetNumberOfTreeClustersInInputWorkspace
public: Geo::s32GEO_CALL GetNumberOfTreeClustersInInputWorkspace
(
const InputWorkspace * inputWorkspace
)
Returns the total number of tree clusters in an input workspace.
Returns
Number of tree clusters, -1 upon error.
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.
Geo::v128 GEO_CALL Enlighten::GetOctreeCodeWorldPositionAndSize
public: Geo::v128GEO_CALL GetOctreeCodeWorldPositionAndSize
(
PrecompOctreeCode octreeCode,
float voxelSize
)
Return the world space position (xyz) and size (w) of the octree block identified by the specified octree code with the specified voxel size.
Geo::u32 GEO_CALL Enlighten::GetOctreeLevel
public: Geo::u32GEO_CALL GetOctreeLevel
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns the level with the probe set hierarchy of this octree 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::GetOctreeNumVirtualProbes
public: Geo::u32GEO_CALL GetOctreeNumVirtualProbes
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns the number of virtual probes within the specified octree probe set.
PppiAtlasFootprint GEO_CALL Enlighten::GetOctreePppiAtlasFootprint
public: PppiAtlasFootprintGEO_CALL GetOctreePppiAtlasFootprint
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns the PPPI atlas footprint of 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.
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::GetOctreeProbePositionCount
public: Geo::u32GEO_CALL GetOctreeProbePositionCount
(
const RadProbeSetCore * core
)
Return the total number of probe positions within the specified RadProbeSetCore.
For debugging only. The total includes virtual and nonexistent probes.
Parameters
| [in] | core | A RadProbeSetCore containing a probe set created by automatic probe placement. |
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.
float GEO_CALL Enlighten::GetOctreeVoxelSize
public: float GEO_CALL GetOctreeVoxelSize
(
const Enlighten::RadProbeSetCore * probeSetCore
)
Returns the voxel size used when the specified octree probe set was precomputed.
eSolverType Enlighten::GetOptimisedSolverForPlatform
public: eSolverType GetOptimisedSolverForPlatform
(
Geo::ePlatform platform
)
Function returning the correct optimised solver based on the compilation environment.
OutputTextureType Enlighten::GetOutputTextureRangeEnd
public: OutputTextureType GetOutputTextureRangeEnd
(
const RadSystemCore & core,
SolveType solveType
)
Return the end of the range of output texture types that can be updated for this combination of solve type and radiosity core.
Geo::s32 Enlighten::GetOutputTextureSize
public: Geo::s32 GetOutputTextureSize
(
const RadCubeMapCore & core
)
Returns the size of the output texture required for this radiosity data.
Geo::GeoPoint2D Enlighten::GetOutputTextureSize
public: Geo::GeoPoint2D GetOutputTextureSize
(
const RadSystemCore & core
)
Returns the size of the output texture required for this radiosity data.
PppiAtlasUpdateRequirements Enlighten::GetPppiMaximumAtlasUpdateRequirements
public: PppiAtlasUpdateRequirements GetPppiMaximumAtlasUpdateRequirements
(
PppiAtlasFootprint atlasMaxima
)
Return the maximum required size of the atlas update workspace for the atlas footprint determined by the precompute.
PppiClipmapUpdateRequirements Enlighten::GetPppiMaximumClipmapUpdateRequirements
public: PppiClipmapUpdateRequirements GetPppiMaximumClipmapUpdateRequirements
(
PppiAtlasFootprint atlasMaxima
)
Return the maximum required size of the clipmap update workspace for the atlas footprint determined by the precompute.
PppiOutputTextureRequirements GEO_CALL Enlighten::GetPppiRequiredOutputTextures
public: PppiOutputTextureRequirementsGEO_CALL GetPppiRequiredOutputTextures
(
PppiConfiguration configuration
)
Returns the required output textures for the specified configuration.
Geo::u32 GEO_CALL Enlighten::GetPrecomputedVisibilityDataSize
public: Geo::u32GEO_CALL GetPrecomputedVisibilityDataSize
(
const PrecomputedVisibilityData * visibilityData
)
Returns the size of the specified PrecomputedVisibilityData object.
Returns
Memory used in bytes, 0xFFFFFFFF upon error.
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 char* Enlighten::GetSolverSuffix
public: const char * GetSolverSuffix
(
eSolverType solverType
)
Defines a platform specific extension for some files, such as the InputWorkspace, that differ in content between platforms.
bool GEO_CALL Enlighten::GetSystemBoundingBox
public: bool GEO_CALL GetSystemBoundingBox
(
const InputWorkspace * inputWorkspace,
Geo::GeoBoundingBox & bb
)
Returns the axis-aligned bounding box of the set of input points in the input workspace.
Parameters
| [in] | inputWorkspace | The input workspace to compute the bounding box for. |
| [out] | bb | The bounding box object to receive the system bounds. |
bool GEO_CALL Enlighten::GetSystemBounds
public: bool GEO_CALL GetSystemBounds
(
const InputWorkspace * inputWorkspace,
Geo::GeoBoundingBox & boundingBox
)
Retrieve the bounding volume of the system.
Parameters
| [in] | inputWorkspace | The input workspace for the system |
| [out] | boundingBox | The bounding box for the system |
Geo::s32 Enlighten::GetTextureBytesPerPixel
public: Geo::s32 GetTextureBytesPerPixel
(
D3DFORMAT format
)
Returns the size of a pixel in bytes for the specified format, if supported.
Geo::s32 Enlighten::GetTextureBytesPerPixel
public: Geo::s32 GetTextureBytesPerPixel
(
TextureFormat format
)
Gets the number of bytes required for each pixel of the given texture format.
Geo::s32 Enlighten::GetTextureBytesPerPixel
public: Geo::s32 GetTextureBytesPerPixel
(
GLint format,
GLenum type
)
Returns the size of a pixel in bytes for the specified format and type, if supported.
bool GEO_CALL Enlighten::GetTextureSize
public: bool GEO_CALL GetTextureSize
(
const Enlighten::RadSystemCore * radSystemCoreIn,
const TextureResolutionScale::Value scale,
Geo::s32 & widthOut,
Geo::s32 & heightOut
)
Returns the required dimensions of the albedo and emissive textures for a given radiosity core.
This is a replacement for GetTextureAlbedoSize()
Parameters
| [in] | radSystemCoreIn | The radiosity core to compute the texture dimensions for. |
| [in] | scale | The desired texture resolution scale. |
| [out] | widthOut | The width of the albedo and emissive textures, -1 upon error. |
| [out] | heightOut | The height of the albedo and emissive textures, -1 upon error. returns true on success or false if an error occurred. |
void Enlighten::GetTextureSize
public: void GetTextureSize
(
const TextureResolutionScale::Value scale,
Geo::s32 widthIn,
Geo::s32 heightIn,
Geo::s32 & widthOut,
Geo::s32 & heightOut
)
Inline function that returns the required dimensions of the albedo and emissive textures for a given a texture width and height.
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.
ValueType Enlighten::GetZeroValue
public: ValueType GetZeroValue()
Helper template to get the zero value of different types.
float Enlighten::GetZeroValue< float >
public: float GetZeroValue< float >()
Helper template to get the zero value of floats.
Geo::v128 Enlighten::GetZeroValue< Geo::v128 >
public: Geo::v128 GetZeroValue< Geo::v128 >()
Helper template to get the zero value of v128s.
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.
bool GEO_CALL Enlighten::InitialiseAlbedoBufferFromColoursPerPoint
public: bool GEO_CALL InitialiseAlbedoBufferFromColoursPerPoint
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const InputWorkspace * inputWorkspace,
const Geo::v128 * pointAlbedoColours,
const Geo::s32 numPoints,
AlbedoBuffer * albedoBuffer
)
Sets the albedo colours for an AlbedoBuffer based on the individual sample points.
You can use Enlighten::GetNumberOfPointsInInputWorkspace() to get the number of points in a system, and Enlighten::GetInputWorkspacePositionAndNormalArray() to get their positions and normals.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | inputWorkspace | The input workspace for the system. |
| [in] | pointAlbedoColours | The albedo colours to set for the points. Each colour component should be between [0..1]. Values outside this range will be clamped internally. The size of this array must be equal to or larger than the value in numPoints. These values are expected in linear colour space. |
| [in] | numPoints | Number of sample points provided. It must match the number of points in the input workspace. |
| [in] | albedoBuffer | The AlbedoBuffer which is being initialised. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::InitialiseAlbedoBufferFromMaterialWorkspace
public: bool GEO_CALL InitialiseAlbedoBufferFromMaterialWorkspace
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
AlbedoBuffer * albedoBuffer
)
Sets the albedo colours for an AlbedoBuffer from a materialWorkspace.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | albedoBuffer | The AlbedoBuffer which is being initialised. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::InitialiseAlbedoBufferFromTexture
public: bool GEO_CALL InitialiseAlbedoBufferFromTexture
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const Enlighten::InputTextureSamplerParameters * textureParams,
const TextureResolutionScale::Value resolutionScale,
AlbedoBuffer * albedoBuffer
)
Sets the albedo colours for an AlbedoBuffer from an albedo texture expected in RGBA format in gamma-2 colour space.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | textureParams | Parameters used for sampling the albedo texture on the CPU. |
| [in] | resolutionScale | An enumeration representing the size of the albedo texture relative to the lightmap resolution. Can be FullResolutionScale or HalfResolutionScale. |
| [in] | albedoBuffer | The AlbedoBuffer which is being initialised. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::InitialiseEmissiveBufferFromColoursPerPoint
public: bool GEO_CALL InitialiseEmissiveBufferFromColoursPerPoint
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const InputWorkspace * inputWorkspace,
const Geo::v128 * pointEmissiveColours,
const Geo::s32 numPoints,
EmissiveBuffer * emissiveBuffer
)
Sets the emissive colours for an EmissiveBuffer based on the individual sample points.
You can use Enlighten::GetNumberOfPointsInInputWorkspace() to get the number of points in a system, and Enlighten::GetInputWorkspacePositionAndNormalArray() to get their positions and normals.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | inputWorkspace | The input workspace for the system. |
| [in] | pointEmissiveColours | The albedo colours to set for the points. Each colour component should be between [0..1]. Values outside this range will be clamped internally. The size of this array must be equal to or larger than the value in numPoints. These values are expected in linear colour space. |
| [in] | numPoints | Number of sample points provided. It must match the number of points in the input workspace. |
| [in] | emissiveBuffer | The EmissiveBuffer which is being initialised. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::InitialiseEmissiveBufferFromMaterialWorkspace
public: bool GEO_CALL InitialiseEmissiveBufferFromMaterialWorkspace
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
EmissiveBuffer * emissiveBuffer
)
Sets the emissive colours for an EmissiveBuffer from a materialWorkspace.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | emissiveBuffer | The EmissiveBuffer which is being initialised. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::InitialiseEmissiveBufferFromTexture
public: bool GEO_CALL InitialiseEmissiveBufferFromTexture
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const Enlighten::InputTextureSamplerParameters * textureParams,
float fixedPointMaximum,
const TextureResolutionScale::Value resolutionScale,
EmissiveBuffer * emissiveBuffer
)
Sets the emissive colours for an EmissiveBuffer from an emissive texture expected in RGBM format in linear colour space.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | textureParams | Parameters used for sampling the albedo texture on the CPU. |
| [in] | fixedPointMaximum | The maximum value representable by the fixed point RGBM format. |
| [in] | resolutionScale | An enumeration representing the size of the albedo texture relative to the lightmap resolution. Can be FullResolutionScale or HalfResolutionScale. |
| [in] | emissiveBuffer | The EmissiveBuffer which is being initialised. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::InitialiseEmissiveBufferFromTextureFp16
public: bool GEO_CALL InitialiseEmissiveBufferFromTextureFp16
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const Enlighten::InputTextureSamplerParameters * textureParams,
const TextureResolutionScale::Value resolutionScale,
EmissiveBuffer * emissiveBuffer
)
Sets the emissive colours for an EmissiveBuffer from an emissive texture expected in FP16 format in linear colour space.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | textureParams | Parameters used for sampling the albedo texture on the CPU. |
| [in] | resolutionScale | An enumeration representing the size of the albedo texture relative to the lightmap resolution. Can be FullResolutionScale or HalfResolutionScale. |
| [in] | emissiveBuffer | The EmissiveBuffer which is being initialised. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::InitialiseInstanceEmissiveAsDynamic
public: bool GEO_CALL InitialiseInstanceEmissiveAsDynamic
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const Geo::u16 instanceId
)
Initialise all the materials of an instance in the DynamicMaterialWorkspace as dynamic.
This is used to distinguish dynamic material values from static values when initialising or reconstructing the EmissiveBuffer. If a material albedo component is not initialised as dynamic, any calls to SetMaterialEmissiveColour() will require the EmissiveBuffer to be re-initialised.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | instanceId | The instance ID to set the emissive for. |
Returns
True on success or false if an error occurred. This does not imply whether or not the instance was found.
bool GEO_CALL Enlighten::InitialiseIntelGPA
public: bool GEO_CALL InitialiseIntelGPA()
If you are using the Intel Graphical Performance Analyzer, call this function at application startup.
There is a function of the same name in the Geo namespace that loads the Dll, this function also creates domains, registers string handles and creates group ids for tasks.
bool GEO_CALL Enlighten::InitialiseMaterialDynamicity
public: bool GEO_CALL InitialiseMaterialDynamicity
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const SurfaceSelection & selection,
SurfaceColourDynamicity dynamicity
)
Initialise a material component in the DynamicMaterialWorkspace as static or dynamic.
This is used to distinguish dynamic material values from static values when initialising or reconstructing the AlbedoBuffer. If a material component is not initialised as dynamic albedo, any calls to SetMaterialAlbedoColour() will require the AlbedoBuffer to be re-initialised. If a material component is not initialised as dynamic emissive, any calls to SetMaterialEmissiveColour() will require the EmissiveBuffer to be re-initialised. If a material component is not initialised as dynamic transparency, any calls to SetMaterialTransparency() will require the TransparencyBuffer to be re-initialised.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | selection | The selection of surfaces to set the state for. |
| [in] | dynamicity | The dynamicity to initialise the material component with. |
Returns
True on success or false if an error occurred. This does not imply whether or not the material was found.
bool GEO_CALL Enlighten::InitialiseMaterialEmissiveAsDynamic
public: bool GEO_CALL InitialiseMaterialEmissiveAsDynamic
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const Geo::u64 & materialId
)
Initialise a material emissive component in the DynamicMaterialWorkspace as dynamic.
This is used to distinguish dynamic material values from static values when initialising or reconstructing the EmissiveBuffer. If a material emissive component is not initialised as dynamic, any calls to SetMaterialEmissiveColour() will require the EmissiveBuffer to be re-initialised.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | materialId | The material 64 bit material ID to set the emissive for. |
Returns
True on success or false if an error occurred. This does not imply whether or not the material was found.
bool GEO_CALL Enlighten::InitialiseSystemEmissiveAsDynamic
public: bool GEO_CALL InitialiseSystemEmissiveAsDynamic
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData
)
Initialise all the materials in the DynamicMaterialWorkspace as dynamic.
This is used to distinguish dynamic material values from static values when initialising or reconstructing the EmissiveBuffer. If a material albedo component is not initialised as dynamic, any calls to SetMaterialEmissiveColour() will require the EmissiveBuffer to be re-initialised.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::InitialiseTransparencyBufferFromColoursPerPoint
public: bool GEO_CALL InitialiseTransparencyBufferFromColoursPerPoint
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const InputWorkspace * inputWorkspace,
const float * pointTransparencyValues,
const Geo::s32 numPoints,
TransparencyBuffer * transparencyBuffer
)
Sets the transparency for a TransparencyBuffer based on the individual sample points.
You can use Enlighten::GetNumberOfPointsInInputWorkspace() to get the number of points in a system, and Enlighten::GetInputWorkspacePositionAndNormalArray() to get their positions and normals.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | inputWorkspace | The input workspace for the system. |
| [in] | pointTransparencyValues | The transparency values to set for the points. Each value should be between [0..1]. Values outside this range will be clamped internally. The size of this array must be equal to or larger than the value in numPoints. These values are expected in linear colour space. |
| [in] | numPoints | Number of sample points provided. It must match the number of pointsg in the input workspace. |
| [in] | transparencyBuffer | The TransparencyBuffer which is being initialised. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::InitialiseTransparencyBufferFromMaterialWorkspace
public: bool GEO_CALL InitialiseTransparencyBufferFromMaterialWorkspace
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
TransparencyBuffer * transparencyBuffer
)
Sets the values for a TransparencyBuffer from a materialWorkspace.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | transparencyBuffer | The TransparencyBuffer which is being initialised. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::InitialiseTransparencyBufferFromTexture
public: bool GEO_CALL InitialiseTransparencyBufferFromTexture
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const Enlighten::InputTextureSamplerParameters * textureParams,
const Geo::s32 pixelStrideInBytes,
const Geo::s32 alphaOffsetInBytes,
const TextureResolutionScale::Value resolutionScale,
TransparencyBuffer * transparencyBuffer
)
Sets the values for a TransparencyBuffer from a the alpha channel in the albedo texture in RGBA format.
In the alpha channel 0 represents fully transparent and 255 represents fully opaque in linear space.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | textureParams | Parameters used for sampling the albedo texture on the CPU. |
| [in] | pixelStrideInBytes | The stride between pixels in the texture. |
| [in] | alphaOffsetInBytes | The byte offset to the first alpha element. |
| [in] | resolutionScale | An enumeration representing the size of the albedo texture relative to the lightmap resolution. Can be FullResolutionScale or HalfResolutionScale. |
| [in] | transparencyBuffer | The TransparencyBuffer which is being initialised. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::InsideAABBExclusive
public: bool GEO_CALL InsideAABBExclusive
(
const Vertex2D & v,
const Vertex2D & min,
const Vertex2D & max
)
Tests if a Vertex2D is within a bounding box defined by two Vertex2D.
Parameters
| [in] | v | Vertex that gets tested |
| [in] | min | Vertex that defines the bounding box minimum |
| [in] | max | Vertex that defines the bounding box maximum |
Returns
true if the vertex is truly inside the bounding box excluding the bounding box walls
bool GEO_CALL Enlighten::InsideAABBInclusive
public: bool GEO_CALL InsideAABBInclusive
(
const Vertex2D & v,
const Vertex2D & min,
const Vertex2D & max
)
Tests if a Vertex2D is within a bounding box defined by two Vertex2D.
Parameters
| [in] | v | Vertex that gets tested |
| [in] | min | Vertex that defines the bounding box minimum |
| [in] | max | Vertex that defines the bounding box maximum |
Returns
true if the vertex is truly inside the bounding box or coincides with the bounding box walls
bool GEO_CALL Enlighten::IsAlbedoBufferInitialiseRequired
public: bool GEO_CALL IsAlbedoBufferInitialiseRequired
(
const DynamicMaterialWorkspace * materialWorkspace
)
Determine if the buffer needs to be initialised.
An initialised buffer can require re-initialisation if a static colour changes or the dynamic-ness of a material changes.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
Returns
True if the buffer needs to be initialised.
bool Enlighten::IsClosedMesh
public: bool IsClosedMesh
(
Geo::StridedArrayView< PrecompIndex3 > faces
)
Return true if the mesh is closed.
bool GEO_CALL Enlighten::IsEmissiveBufferInitialiseRequired
public: bool GEO_CALL IsEmissiveBufferInitialiseRequired
(
const DynamicMaterialWorkspace * materialWorkspace
)
Determine if the buffer needs to be initialised.
An initialised buffer can require re-initialisation if a static colour changes or the dynamic-ness of a material changes.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
Returns
True if the buffer needs to be initialised.
bool Enlighten::IsFinite
public: bool IsFinite
(
const BaryCoords & c
)
Tests if barycentric coordinates are valid.
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.
Geo::s32 GEO_CALL Enlighten::IsInputLightingBufferStatic
public: Geo::s32GEO_CALL IsInputLightingBufferStatic
(
const InputLightingBuffer * lightingBuffer
)
Returns the number of frames since the last update that changed the given input lighting buffer.
Parameters
| [in] | lightingBuffer | The lighting buffer to check for changes. |
Returns
Returns the number of updates since the last change.
bool Enlighten::IsInsideInclusive
public: bool IsInsideInclusive
(
const BaryCoords & c
)
Tests if a set of barycentric coordinates define a point within a triangle.
Here, 'within' includes the edges of the triangle.
bool GEO_CALL Enlighten::IsOctreeProbeSet
public: bool GEO_CALL IsOctreeProbeSet
(
const RadProbeSetCore * core
)
Returns true if the specified probe set core is a ProbeOctree.
Parameters
| [in] | core | A valid RadProbeSetCore object |
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. |
bool GEO_CALL Enlighten::IsTransparencyBufferInitialiseRequired
public: bool GEO_CALL IsTransparencyBufferInitialiseRequired
(
const DynamicMaterialWorkspace * materialWorkspace
)
Determine if the buffer needs to be initialised.
An initialised buffer can require re-initialisation if a static colour changes or the dynamic-ness of a material changes.
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
Returns
True if the buffer needs to be initialised.
bool GEO_CALL Enlighten::IsValid
public: bool GEO_CALL IsValid
(
const InputWorkspace * inputWorkspace,
const char * functionName,
bool requireProjectedPoints
)
Function that tests if the data object provided is valid (pointer checks, metadata, etc).
bool GEO_CALL Enlighten::IsValid
public: bool GEO_CALL IsValid
(
const ResamplingData * resamplingData,
const char * functionName
)
Function that tests if the data object provided is valid (pointer checks, metadata, etc).
bool GEO_CALL Enlighten::IsValid
public: bool GEO_CALL IsValid
(
const InterpolationInputSet * inputSet,
const char * functionName
)
Function that tests if the data object provided is valid (pointer checks, metadata, etc).
bool GEO_CALL Enlighten::IsValid
public: bool GEO_CALL IsValid
(
const PrecomputedVisibilityWorkspace * visWorkspace,
const char * functionName
)
Function that tests if the data object provided is valid (pointer checks, metadata, etc).
bool GEO_CALL Enlighten::IsValid
public: bool GEO_CALL IsValid
(
const PrecomputedVisibilityData * visData,
const char * functionName
)
Function that tests if the data object provided is valid (pointer checks, metadata, etc).
bool GEO_CALL Enlighten::IsValid
public: bool GEO_CALL IsValid
(
const ClusterAlbedoWorkspaceMaterialData * cawData,
const char * functionName,
bool requireMaterialGuids
)
Function that tests if the data object provided is valid (pointer checks, metadata, etc).
bool GEO_CALL Enlighten::IsValid
public: bool GEO_CALL IsValid
(
const RadSystemCore * radCore,
const char * functionName
)
Function that tests if the data object provided is valid (pointer checks, metadata, etc).
bool GEO_CALL Enlighten::IsValid
public: bool GEO_CALL IsValid
(
const RadProbeSetCore * probeSetCore,
Geo::u32 sectionMask,
const char * functionName
)
Function that tests if the data object provided is valid (pointer checks, metadata, etc).
bool GEO_CALL Enlighten::IsValid
public: bool GEO_CALL IsValid
(
const RadProbeSetCore * probeSetCore,
const char * functionName
)
Function that tests if the data object provided is valid (pointer checks, metadata, etc).
bool GEO_CALL Enlighten::IsValid
public: bool GEO_CALL IsValid
(
const RadCubeMapCore * cubeMapCore,
const char * functionName
)
Function that tests if the data object provided is valid (pointer checks, metadata, etc).
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.
Geo::v128 Enlighten::LightFalloffFunction
public: Geo::v128 LightFalloffFunction
(
const InternalLightFalloffTable & light,
const Geo::v128 & lightRadius,
const Geo::v128 & lightDistances
)
common light falloff function used by spot and point lights, computes four lights at a time
void Enlighten::MakeEnvironmentConstants
public: void MakeEnvironmentConstants
(
Geo::u32 faceSize,
float * areas,
float * normals
)
Compute the area and directional normalization factors for each texel of a single environment cubemap face.
faceSize The number of texels in x and y for the cubemap face. areas An array of size faceSize^2 to which the areas are output. normals An array of size faceSize^2 to which the directional normalization factors are output.
SurfaceSelection Enlighten::MakeInstanceSurfaceSelection
public: SurfaceSelection MakeInstanceSurfaceSelection
(
Geo::u16 instanceId
)
All surfaces matching the specified instance.
PppiIrradiance16 Enlighten::MakePppiIrradiance16
public: PppiIrradiance16 MakePppiIrradiance16
(
const PppiIrradiance & irradiance
)
Return the specified irradiance value converted to 16-bit floating point.
SurfaceSelection Enlighten::MakeSingleSurfaceSelection
public: SurfaceSelection MakeSingleSurfaceSelection
(
Geo::u16 instanceId,
Geo::u16 meshIndex,
Geo::u32 materialId
)
The surface matching the instanceId, meshIndex and materialId combination.
SurfaceSelection Enlighten::MakeSystemSurfaceSelection
public: SurfaceSelection MakeSystemSurfaceSelection()
All surfaces in the system.
WorldAxis Enlighten::MakeWorldAxis
public: WorldAxis MakeWorldAxis
(
PipelineWorldAxis worldAxis
)
The world space axis in which a given axis points.
Vertex2D GEO_CALL Enlighten::MaxVertex
public: Vertex2DGEO_CALL MaxVertex
(
const Vertex2D & a,
const Vertex2D & b
)
Returns a Vertex2D as the componentwise minimum of two Vertex2D.
Vertex2D GEO_CALL Enlighten::MinVertex
public: Vertex2DGEO_CALL MinVertex
(
const Vertex2D & a,
const Vertex2D & b
)
Returns a Vertex2D as the componentwise minimum of two Vertex2D.
Vector2D GEO_CALL Enlighten::Normalise
public: Vector2DGEO_CALL Normalise
(
const Vector2D & v
)
Normalises a Vector2D to a length of one.
Vertex2D GEO_CALL Enlighten::operator-
public: Vertex2DGEO_CALL operator-
(
const Vertex2D & lhs,
const Vertex2D & rhs
)
Componentwise subtraction operator for two Vertex2D.
bool Enlighten::operator!=
public: bool operator!=
(
const PrecompVoxelId & l,
const PrecompVoxelId & r
)
Returns true if the arguments are not equal.
bool Enlighten::operator!=
public: bool operator!=
(
const PrecompVoxelOctreePath & l,
const PrecompVoxelOctreePath & r
)
Returns true if the paths are not equal.
bool Enlighten::operator!=
public: bool operator!=
(
const PrecompOctreeNode & l,
const PrecompOctreeNode & r
)
Returns true if the nodes are not equal.
DynamicMaterialWorkspace::Status Enlighten::operator&
public: DynamicMaterialWorkspace::Status operator&
(
DynamicMaterialWorkspace::Status a,
DynamicMaterialWorkspace::Status b
)
Bitwise AND of two dynamic material workspace statuses.
Vertex2D GEO_CALL Enlighten::operator*
public: Vertex2DGEO_CALL operator*
(
const Vertex2D & lhs,
const double & rhs
)
Componentwise multiplication by scalar for Vertex2D.
Vertex2D GEO_CALL Enlighten::operator*
public: Vertex2DGEO_CALL operator*
(
const double & lhs,
const Vertex2D & rhs
)
Componentwise multiplication by scalar for Vertex2D.
DynamicMaterialWorkspace::Status Enlighten::operator|
public: DynamicMaterialWorkspace::Status operator|
(
DynamicMaterialWorkspace::Status a,
DynamicMaterialWorkspace::Status b
)
Bitwise OR of two dynamic material workspace statuses.
DynamicMaterialWorkspace::Status Enlighten::operator~
public: DynamicMaterialWorkspace::Status operator~
(
DynamicMaterialWorkspace::Status a
)
Bitwise NOT of a dynamic material workspace status.
Vertex2D GEO_CALL Enlighten::operator+
public: Vertex2DGEO_CALL operator+
(
const Vertex2D & lhs,
const Vertex2D & rhs
)
Componentwise addition operator for two Vertex2D.
Triangle2D& GEO_CALL Enlighten::operator+=
public: Triangle2D &GEO_CALL operator+=
(
Triangle2D & t,
Vector2D v
)
Moves a triangle by a given Vector2D.
bool Enlighten::operator<
public: bool operator<
(
const PrecompVoxelId & l,
const PrecompVoxelId & r
)
Returns true if the left argument is ordered before the right argument.
Triangle2D& GEO_CALL Enlighten::operator-=
public: Triangle2D &GEO_CALL operator-=
(
Triangle2D & t,
Vector2D v
)
Moves a triangle by a given Vector2D into it's opposite direction.
Vertex2D& GEO_CALL Enlighten::operator-=
public: Vertex2D &GEO_CALL operator-=
(
Vertex2D & lhs,
Vertex2D rhs
)
Componentwise subtraction and assignment operator for two Vertex2D.
bool Enlighten::operator==
public: bool operator==
(
const PrecompVoxelId & l,
const PrecompVoxelId & r
)
Returns true if the arguments are equal.
bool Enlighten::operator==
public: bool operator==
(
const PrecompVoxelOctreePath & l,
const PrecompVoxelOctreePath & r
)
Returns true if the paths are equal.
bool Enlighten::operator==
public: bool operator==
(
const PrecompOctreeNode & l,
const PrecompOctreeNode & r
)
Returns true if the nodes are equal.
WorldAxis Enlighten::ParseWorldAxis
public: WorldAxis ParseWorldAxis
(
const char * s
)
Return the axis aligned unit vector matching one of the following input strings: +x, +X, +y, +Y, +z, +Z, -x, -X, -y, -Y, -z, -Z.
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::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::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::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(). |
PppiIrradiance Enlighten::ProjectEnvironmentProbeL1
public: PppiIrradiance ProjectEnvironmentProbeL1
(
Geo::u32 faceSize,
const Geo::v128 * texels,
const float * areas,
const float * normals
)
Project the environment cubemap irradiance values to L1 SH coefficients.
faceSize The number of texels in x and y for each cubemap face. texels An array of size faceSize^2 * 6 containing the environment cubemap irradiance RGB values. areas An array of size faceSize^2 to which the areas are output. normals An array of size faceSize^2 to which the directional normalization factors are output.
Enlighten::AlbedoBuffer *GEO_CALL Enlighten::ReadAlbedoBuffer
public: Enlighten::AlbedoBuffer *GEO_CALL ReadAlbedoBuffer
(
Geo::IGeoInputStream & stream
)
Read an AlbedoBuffer from a stream.
Parameters
| [in] | stream | - The Geo::IGeoStream to read. |
Enlighten::AlbedoBuffer *GEO_CALL Enlighten::ReadAlbedoBufferInPlace
public: AlbedoBuffer *GEO_CALL ReadAlbedoBufferInPlace
(
char * data,
size_t size
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
Enlighten::ClusterAlbedoWorkspaceMaterialData *GEO_CALL Enlighten::ReadClusterAlbedoWorkspaceMaterialData
public: Enlighten::ClusterAlbedoWorkspaceMaterialData *GEO_CALL ReadClusterAlbedoWorkspaceMaterialData
(
Geo::IGeoInputStream & stream,
Geo::u32 sections
)
Read an ClusterAlbedoWorkspaceMaterialData from a stream.
Parameters
| [in] | stream | - The Geo::IGeoStream to read. |
| [in] | sections | - Which of the optional data blocks to allocate and read. Pass 0 to load no optional data, or Enlighten::Iff::ClusterAlbedoWorkspaceMaterialGuidsSection to load the optional material guids data |
Returns
Non-null if successful - remember to delete the pointer using DeleteClusterAlbedoWorkspaceMaterialData.
Enlighten::ClusterAlbedoWorkspaceMaterialData *GEO_CALL Enlighten::ReadClusterAlbedoWorkspaceMaterialDataFromFile
public: Enlighten::ClusterAlbedoWorkspaceMaterialData *GEO_CALL ReadClusterAlbedoWorkspaceMaterialDataFromFile
(
const char * filename,
Geo::u32 sections
)
Read an ClusterAlbedoWorkspaceMaterialData from file.
Parameters
| [in] | filename | - The name of the file to read. |
| [in] | sections | - Which of the optional data blocks to allocate and read. Pass 0 to load no optional data, or Enlighten::Iff::ClusterAlbedoWorkspaceMaterialGuidsSection to load the optional material guids data |
Returns
Non-null if successful - remember to delete the pointer using DeleteClusterAlbedoWorkspaceMaterialData.
ClusterAlbedoWorkspaceMaterialData *GEO_CALL Enlighten::ReadClusterAlbedoWorkspaceMaterialDataInPlace
public: ClusterAlbedoWorkspaceMaterialData *GEO_CALL ReadClusterAlbedoWorkspaceMaterialDataInPlace
(
char * data,
size_t size
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
void GEO_CALL Enlighten::ReadDataBlock
public: void GEO_CALL ReadDataBlock
(
RadDataBlock * block,
Geo::IGeoInputStream & stream
)
Read a RadDataBlock from a Geo::IGeoInputStream. Will return an object that should be released with FreeDataBlockContents().
Always returns a relocatable data block.
void Enlighten::ReadDataBlockInPlace
public: void ReadDataBlockInPlace
(
RadDataBlock & block,
char *& ptr
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
Enlighten::DynamicMaterialWorkspace *GEO_CALL Enlighten::ReadDynamicMaterialWorkspace
public: Enlighten::DynamicMaterialWorkspace *GEO_CALL ReadDynamicMaterialWorkspace
(
Geo::IGeoInputStream & stream
)
Read an DynamicMaterialWorkspace from a stream.
Parameters
| [in] | stream | - The Geo::IGeoStream to read. |
Enlighten::DynamicMaterialWorkspace *GEO_CALL Enlighten::ReadDynamicMaterialWorkspaceInPlace
public: DynamicMaterialWorkspace *GEO_CALL ReadDynamicMaterialWorkspaceInPlace
(
char * data,
size_t size
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
Enlighten::EmissiveBuffer *GEO_CALL Enlighten::ReadEmissiveBuffer
public: Enlighten::EmissiveBuffer *GEO_CALL ReadEmissiveBuffer
(
Geo::IGeoInputStream & stream
)
Read an EmissiveBuffer from a stream.
Parameters
| [in] | stream | - The Geo::IGeoStream to read. |
Enlighten::EmissiveBuffer *GEO_CALL Enlighten::ReadEmissiveBufferInPlace
public: EmissiveBuffer *GEO_CALL ReadEmissiveBufferInPlace
(
char * data,
size_t size
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
Enlighten::IncidentLightingBuffer *GEO_CALL Enlighten::ReadIncidentLightingBuffer
public: Enlighten::IncidentLightingBuffer *GEO_CALL ReadIncidentLightingBuffer
(
Geo::IGeoInputStream & stream
)
Read an IncidentLightingBuffer from a stream.
Parameters
| [in] | stream | - The Geo::IGeoStream to read. |
Enlighten::IncidentLightingBuffer *GEO_CALL Enlighten::ReadIncidentLightingBufferInPlace
public: IncidentLightingBuffer *GEO_CALL ReadIncidentLightingBufferInPlace
(
char * data,
size_t size
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
Enlighten::InputLightingBuffer *GEO_CALL Enlighten::ReadInputLightingBuffer
public: Enlighten::InputLightingBuffer *GEO_CALL ReadInputLightingBuffer
(
Geo::IGeoInputStream & stream
)
Read an InputLightingBuffer from a stream.
Parameters
| [in] | stream | - The Geo::IGeoStream to read. |
Enlighten::InputLightingBuffer *GEO_CALL Enlighten::ReadInputLightingBufferInPlace
public: InputLightingBuffer *GEO_CALL ReadInputLightingBufferInPlace
(
char * data,
size_t size
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
Enlighten::InputWorkspace *GEO_CALL Enlighten::ReadInputWorkspace
public: Enlighten::InputWorkspace *GEO_CALL ReadInputWorkspace
(
Geo::IGeoInputStream & stream,
Geo::u32 sections
)
Read an InputWorkspace from a stream.
Parameters
| [in] | stream | - The Geo::IGeoStream to read. |
| [in] | sections | - Which of the optional data blocks to allocate and read. Pass 0 to load no optional data, or Enlighten::Iff::DynamicInputWorkspaceDataSection to load the optional dynamic data and/or Enlighten::Iff::ProjectedPointsInputWorkspaceDataSection to load the optional duster projection data and/or Enlighten::Iff::HighQualityBounceCoordinateDataSection to load the optional high quality bounce data |
Returns
Non-null if successful - you must delete the pointer using DeleteInputWorkspace.
Enlighten::InputWorkspace *GEO_CALL Enlighten::ReadInputWorkspaceFromFile
public: Enlighten::InputWorkspace *GEO_CALL ReadInputWorkspaceFromFile
(
const char * filename,
Geo::u32 sections
)
Read an InputWorkspace from file.
Parameters
| [in] | filename | - The name of the file to read. |
| [in] | sections | - Which of the optional data blocks to allocate and read. Pass 0 to load no optional data, or Enlighten::Iff::DynamicInputWorkspaceDataSection to load the optional dynamic data and/or Enlighten::Iff::ProjectedPointsInputWorkspaceDataSection to load the optional duster projection data and/or Enlighten::Iff::HighQualityBounceCoordinateDataSection to load the optional high quality bounce data |
InputWorkspace *GEO_CALL Enlighten::ReadInputWorkspaceInPlace
public: InputWorkspace *GEO_CALL ReadInputWorkspaceInPlace
(
char * data,
size_t size
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
void GEO_CALL Enlighten::ReadOptionalDataBlock
public: void GEO_CALL ReadOptionalDataBlock
(
RadDataBlock * dataBlock,
Geo::IGeoInputStream & stream,
Geo::u32 sections,
Geo::u32 optionalBlock
)
Read or skip a RadDataBlock in a Geo::IGeoInputStream, depending on the sections requested and the id of the block.
Enlighten::PrecomputedVisibilityData *GEO_CALL Enlighten::ReadPrecomputedVisibilityData
public: Enlighten::PrecomputedVisibilityData *GEO_CALL ReadPrecomputedVisibilityData
(
Geo::IGeoInputStream & stream
)
Read a PrecomputedVisibilityData struct from a stream.
Parameters
| [in] | stream | - The Geo::IGeoStream to read |
Enlighten::PrecomputedVisibilityData *GEO_CALL Enlighten::ReadPrecomputedVisibilityDataFromFile
public: Enlighten::PrecomputedVisibilityData *GEO_CALL ReadPrecomputedVisibilityDataFromFile
(
const char * filename
)
Read a PrecomputedVisibilityData struct from a file.
Parameters
| [in] | filename | - The name of the file to read |
PrecomputedVisibilityData *GEO_CALL Enlighten::ReadPrecomputedVisibilityDataInPlace
public: PrecomputedVisibilityData *GEO_CALL ReadPrecomputedVisibilityDataInPlace
(
char * data,
size_t size
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::ReadProbeTaskOutput
public: bool GEO_CALL ReadProbeTaskOutput
(
Enlighten::RadProbeTask * probeTask,
Geo::IGeoInputStream & stream
)
Read the RadProbeTask results data from a file/stream.
Note
The caller takes ownership of the loaded data, which includes deleting m_NumIndexesToSolve, m_OutputPointers and m_OutputPointers[0] (which is the main block of floats)
bool GEO_CALL Enlighten::ReadProbeTaskOutputFromFile
public: bool GEO_CALL ReadProbeTaskOutputFromFile
(
Enlighten::RadProbeTask * probeTask,
const char * filename
)
Read the RadProbeTask results data from a file/stream.
Note
The caller takes ownership of the loaded data, which includes deleting m_NumIndexesToSolve, m_OutputPointers and m_OutputPointers[0] (which is the main block of floats)
Enlighten::RadCubeMapCore *GEO_CALL Enlighten::ReadRadCubeMapCore
public: Enlighten::RadCubeMapCore *GEO_CALL ReadRadCubeMapCore
(
Geo::IGeoInputStream & stream
)
Read a RadCubeMapCore from a stream.
The data is written in little-endian format, so the loading code must handle this.
Parameters
| [in] | stream | - The Geo::IGeoStream to read. |
Returns
Non-null if successful - you must delete the pointer using DeleteRadCubeMapCore.
Note
the RadDataBlock contained within the returned RadCubeMapCore is always relocatable after load.
Enlighten::RadCubeMapCore *GEO_CALL Enlighten::ReadRadCubeMapCoreFromFile
public: Enlighten::RadCubeMapCore *GEO_CALL ReadRadCubeMapCoreFromFile
(
const char * filename
)
Read a RadCubeMapCore from file.
The files are written in target-endian format, so the same loading code works for all platforms.
Parameters
| [in] | filename | - The name of the file to read. |
Returns
Non-null if successful - you must delete the pointer using DeleteRadCubeMapCore.
Note
the RadDataBlock contained within the returned RadCubeMapCore is always relocatable after load.
RadCubeMapCore *GEO_CALL Enlighten::ReadRadCubeMapCoreInPlace
public: RadCubeMapCore *GEO_CALL ReadRadCubeMapCoreInPlace
(
char * data,
size_t size
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
RadProbeSetCore *GEO_CALL Enlighten::ReadRadProbeSetCore
public: Enlighten::RadProbeSetCore *GEO_CALL ReadRadProbeSetCore
(
Geo::IGeoInputStream & stream,
Geo::u32 sections
)
Read run-time probeset data from a file.
The files are written in target-endian format, so the same loading code works for all platforms.
Parameters
| [in] | stream | - The Geo::IGeoStream to read |
| [in] | sections | - Pass 0 to load no optional data or any combination of the following: Enlighten::Iff::ProbeSetPrecompSection Enlighten::Iff::EntireProbeSetPrecompSection Enlighten::Iff::ProbeSetInterpolationDataSection Enlighten::Iff::ProbeSetVisibilityDataSection Enlighten::Iff::ProbeSetDebugDataSection |
Returns
Non-null if successful - you must delete the pointer using DeleteRadProbeSetCore.
Note
the returned RadDataBlock is always relocatable.
RadProbeSetCore *GEO_CALL Enlighten::ReadRadProbeSetCoreFromFile
public: Enlighten::RadProbeSetCore *GEO_CALL ReadRadProbeSetCoreFromFile
(
const char * filename,
Geo::u32 sections
)
Read run-time probe set data from a file.
The files are written in target-endian format, so the same loading code works for all platforms. Note this doesn't do any endian swapping. It assumes you are reading/writing the file on the same platform.
Parameters
| [in] | filename | - The name of the file to read |
| [in] | sections | - Pass 0 to load no optional data or any combination of the following: Enlighten::Iff::ProbeSetPrecompSection Enlighten::Iff::EntireProbeSetPrecompSection Enlighten::Iff::ProbeSetInterpolationDataSection Enlighten::Iff::ProbeSetVisibilityDataSection Enlighten::Iff::ProbeSetDebugDataSection |
Returns
Non-null if successful - you must delete the pointer using DeleteRadProbeSetCore.
Note
the returned RadDataBlock is always relocatable.
RadProbeSetCore *GEO_CALL Enlighten::ReadRadProbeSetCoreInPlace
public: RadProbeSetCore *GEO_CALL ReadRadProbeSetCoreInPlace
(
char * data,
size_t size
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
RadSystemCore *GEO_CALL Enlighten::ReadRadSystemCore
public: Enlighten::RadSystemCore *GEO_CALL ReadRadSystemCore
(
Geo::IGeoInputStream & stream,
Geo::u32 sections
)
Read a RadSystemCore from a stream.
The data is written in little-endian format, so the loading code must handle this.
Parameters
| [in] | stream | - The Geo::IGeoInputStream to read. |
| [in] | sections | - Which of the optional data blocks to allocate and read. Pass 0 to load no optional data, or a combination of Enlighten::Iff::ProjectionDataSection and/or Enlighten::Iff::DynamicRadiosityDataSection |
Returns
Non-null if successful - you must delete the pointer using DeleteRadSystemCore.
Note
the RadDataBlock contained within the returned RadSystemCore is always relocatable after load.
RadSystemCore *GEO_CALL Enlighten::ReadRadSystemCoreFromFile
public: Enlighten::RadSystemCore *GEO_CALL ReadRadSystemCoreFromFile
(
const char * filename,
Geo::u32 sections
)
Read a RadSystemCore from file.
The files are written in target-endian format, so the same loading code works for all platforms.
Parameters
| [in] | filename | - The name of the file to read. |
| [in] | sections | - Which of the optional data blocks to allocate and read. Pass 0 to load no optional data, or a combination of Enlighten::Iff::ProjectionDataSection and/or Enlighten::Iff::DynamicRadiosityDataSection |
Returns
Non-null if successful - you must delete the pointer using DeleteRadSystemCore.
Note
the RadDataBlock contained within the returned RadSystemCore is always relocatable after load.
RadSystemCore *GEO_CALL Enlighten::ReadRadSystemCoreInPlace
public: RadSystemCore *GEO_CALL ReadRadSystemCoreInPlace
(
char * data,
size_t Size
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::ReadRadTaskOutput
public: bool GEO_CALL ReadRadTaskOutput
(
Geo::s32 & outputWidth,
Geo::s32 & outputHeight,
eOutputFormat & outputFormat,
eOutputFormatByteOrder & outputFormatByteOrder,
void * irradianceOutput64,
void * irradianceOutput32,
void * directionalOutput,
Geo::IGeoInputStream & stream
)
Read the RadIrradianceTask results data from a file/stream.
Note
If the output width or height are set to zero, then only the header of the file is read, and the width, height outputFormat and outputFormatByteOrder are filled in. The function then returns true. If the output size is non-zero, the function assumes that the various output pointers are large enough to hold the incoming data. In general, users should not have to call these functions in their integration.
Parameters
| [out] | outputWidth | - The width of the output texture |
| [out] | outputHeight | - The height of the output texture |
| [out] | outputFormat | - The format of the output texture |
| [out] | outputFormatByteOrder | - The byte order of the LRB irradiance/directional output texture |
| [in] | irradianceOutput64 | - pointer large enough to hold 64-bit-per-pixel output data (e.g. FP16). Pass NULL if not required |
| [in] | irradianceOutput32 | - pointer large enough to hold 32-bit-per-pixel output data (e.g. LRB). Pass NULL if not required |
| [in] | directionalOutput | - pointer large enough to hold directional output data. Pass NULL if not required |
| [in] | stream | - The file stream from which to read the rad task data from |
bool GEO_CALL Enlighten::ReadRadTaskOutputFromFile
public: bool GEO_CALL ReadRadTaskOutputFromFile
(
Geo::s32 & outputWidth,
Geo::s32 & outputHeight,
eOutputFormat & outputFormat,
eOutputFormatByteOrder & outputFormatByteOrder,
void * irradianceOutput64,
void * irradianceOutput32,
void * directionalOutput,
const char * filename
)
Read the RadIrradianceTask results data from a file.
Please see ReadRadTaskOutput for details.
Parameters
| [out] | outputWidth | - The width of the output texture |
| [out] | outputHeight | - The height of the output texture |
| [out] | outputFormat | - The format of the output texture |
| [out] | outputFormatByteOrder | - The byte order of the LRB irradiance/directional output texture |
| [in] | irradianceOutput64 | - pointer large enough to hold 64-bit-per-pixel output data (e.g. FP16). Pass NULL if not required |
| [in] | irradianceOutput32 | - pointer large enough to hold 32-bit-per-pixel output data (e.g. LRB). Pass NULL if not required |
| [in] | directionalOutput | - pointer large enough to hold directional output data. Pass NULL if not required |
| [in] | filename | - The name of the rad task output file to read data from |
Enlighten::TransparencyBuffer *GEO_CALL Enlighten::ReadTransparencyBufferInPlace
public: TransparencyBuffer *GEO_CALL ReadTransparencyBufferInPlace
(
char * data,
size_t size
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
Geo::GeoArray<PrecompIndex3> Enlighten::RepairHoles
public: Geo::GeoArray< PrecompIndex3 > RepairHoles
(
Geo::StridedArrayView< PrecompIndex3 > faces
)
Return the faces which must be added to the mesh to repair holes.
Each hole is filled with a triangle fan. The mesh cannot be repaired if any two holes share a common vertex.
bool Enlighten::ReportPipelineError
public: bool ReportPipelineError
(
Geo::GeoUIString message
)
Report a fatal PipelineError.
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 |
bool GEO_CALL Enlighten::RunDebugBucketSelectionTask
public: bool GEO_CALL RunDebugBucketSelectionTask
(
const Enlighten::RadDebugBucketSelectionTask * task
)
Generate a texture that highlights the information specified in the task object.
Parameters
| [in] | task | A valid pointer to a RadDebugBucketSelectionTask to perform. |
GEO_CONTROLLED_INLINE Geo::v128 Enlighten::SampleBilinear
public: GEO_CONTROLLED_INLINEGeo::v128 SampleBilinear
(
const tIrradianceTexture * texture,
float u,
float v
)
Samples the given texture at the given co-ordinates, using bilinear filtering.
GEO_CONTROLLED_INLINE bool Enlighten::SelectAlbedoEmissiveTransparencyAndSurroundings
public: GEO_CONTROLLED_INLINE bool SelectAlbedoEmissiveTransparencyAndSurroundings
(
const IndirectInputLightingParameters * params,
const InputWorkspaceInternal * inputWorkspace
)
Selects albedo, emissive, transparency and surroundings.
GEO_CONTROLLED_INLINE bool Enlighten::SelectEmissiveTransparencyAndSurroundings
public: GEO_CONTROLLED_INLINE bool SelectEmissiveTransparencyAndSurroundings
(
const IndirectInputLightingParameters * params,
const InputWorkspaceInternal * inputWorkspace
)
Selects emissive, transparency and surroundings.
GEO_CONTROLLED_INLINE bool Enlighten::SelectSamplersAndDoIndirectInputLighting
public: GEO_CONTROLLED_INLINE bool SelectSamplersAndDoIndirectInputLighting
(
const IndirectInputLightingParameters * params,
const InputWorkspaceInternal * inputWorkspace
)
Selects samplers and does indirect input lighting.
GEO_CONTROLLED_INLINE bool Enlighten::SelectSurroundings
public: GEO_CONTROLLED_INLINE bool SelectSurroundings
(
const IndirectInputLightingParameters * params,
const InputWorkspaceInternal * inputWorkspace
)
Selects surroundings.
GEO_CONTROLLED_INLINE bool Enlighten::SelectTransparencyAndSurroundings
public: GEO_CONTROLLED_INLINE bool SelectTransparencyAndSurroundings
(
const IndirectInputLightingParameters * params,
const InputWorkspaceInternal * inputWorkspace
)
Selects transparency and surroundings.
bool GEO_CALL Enlighten::SetDirectionalVisibility
public: bool GEO_CALL SetDirectionalVisibility
(
const InputWorkspace * workspaceMemory,
const PrecomputedVisibilityData * precomputedVisibilityData,
PrecomputedVisibilityWorkspace * visibilityWorkspace,
void * visibilityData,
Geo::v128 lightDirection
)
Set visibility in an input workspace for a directional light, using precomputed visibility data.
Parameters
| [in] | workspaceMemory | The input workspace memory block. |
| [in] | precomputedVisibilityData | The block of precomputed visibility data. |
| [in] | visibilityWorkspace | The visibility workspace memory block. |
| [in] | visibilityData | The visibility data to set, one bit per duster. |
| [in] | lightDirection | The direction of the light source. |
bool GEO_CALL Enlighten::SetEnvironmentLightValues
public: bool GEO_CALL SetEnvironmentLightValues
(
Enlighten::InputLightingBuffer * env,
const Geo::v128 * values,
Geo::s32 resolution
)
Sets the environment light values.
The required input is an N x N cube map of environment light values where N is the resolution. The values are laid out in the standard D3D cube map ordering, in v128 format (ie 4 x 32-bit float per value). More explicitly, this means the input buffer should contain 6 * N * N base values with 16 bytes each. The remaining values in the buffer are hierarchical averages for each face and an overall average for the entire cube map. These averages are computed internally by the SetValues function. All light values are in linear space.
Direct3D DDS cube maps use the following face order and XYZ to UV transformation:
face major axis uc vc ma ---------- ---------- --- --- --- POSITIVE_X +rx -rz -ry rx NEGATIVE_X -rx +rz -ry rx POSITIVE_Y +ry +rx +rz ry NEGATIVE_Y -ry +rx -rz ry POSITIVE_Z +rz +rx -ry rz NEGATIVE_Z -rz -rx -ry rz u = (uc/|ma| + 1) / 2 v = (vc/|ma| + 1) / 2
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::SetMaterialAlbedoColour
public: bool GEO_CALL SetMaterialAlbedoColour
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const SurfaceSelection & selection,
const Geo::v128 & newAlbedoColour
)
Set the colour of a material selection within the DynamicMaterialWorkspace.
If the selection has been previously setup as dynamic (using InitialiseMaterialAlbedoAsDynamic()), the AlbedoBuffer will need updating using UpdateAlbedoBuffer(). If the selection is static however, the AlbedoBuffer will need re-initialising using InitialiseAlbedoBufferFromMaterialWorkspace().
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | selection | The selection of surfaces to set the albedo for. |
| [in] | newAlbedoColour | The colour to set the material to. This is expected to be in linear colour space. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::SetMaterialEmissiveColour
public: bool GEO_CALL SetMaterialEmissiveColour
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const SurfaceSelection & selection,
const Geo::v128 & newEmissiveColour
)
Set the emissive colour of a material selection within the DynamicMaterialWorkspace.
If the selection has been previously setup as dynamic (using InitialiseMaterialEmissiveAsDynamic()), the EmissiveBuffer will need updating using UpdateEmissiveBuffer(). If the selection is static however, the EmissiveBuffer will need re-initialising using InitialiseEmissiveBufferFromMaterialWorkspace().
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | selection | The selection of surfaces to set the emissive for. |
| [in] | newEmissiveColour | The colour to set to the emissive component of the material. This is expected to be in linear colour space. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::SetMaterialTransparency
public: bool GEO_CALL SetMaterialTransparency
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const SurfaceSelection & selection,
float newTransparency
)
Set the transparency of a material selection within the DynamicMaterialWorkspace.
If the selection has been previously setup as dynamic (using InitialiseMaterialTransparencyAsDynamic()), the TransparencyBuffer will need updating using UpdateTransparencyBuffer(). If the selection is static however, the TransparencyBuffer will need re-initialising using InitialiseTransparencyBufferFromMaterialWorkspace().
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | selection | The selection of surfaces to set the transparency for. |
| [in] | newTransparency | The transparency to set the material to. This is expected to be in linear space. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::SetTransparency
public: bool GEO_CALL SetTransparency
(
const InputWorkspace * inputWorkspace,
TransparencyWorkspace * transparencyWorkspace,
float transparencyValue
)
Set all transparency values of transparencyWorkspace to the given value.
Parameters
| [in] | inputWorkspace | The input workspace for the system |
| [out] | transparencyWorkspace | The TransparencyWorkspace for the system |
| [in] | transparencyValue | The value to reset all the quads in this system to |
void GEO_CALL Enlighten::SkipDataBlock
public: void GEO_CALL SkipDataBlock
(
Geo::IGeoInputStream & stream
)
Skip a RadDataBlock in a Geo::IGeoStream. Will advance the stream past a RadDataBlock without reading the contents.
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 |
void GEO_CALL Enlighten::StoreTemporaryScaleAndTranslation
public: void GEO_CALL StoreTemporaryScaleAndTranslation
(
Enlighten::PrecompOutputInstance * outputInstance,
Geo::s32 uvScale,
Geo::s32 precompBlockSize
)
Utility to temporarily pack scale and translation into the PrecompOutputInstance object.
This later gets overridden
Parameters
| [in] | outputInstance | The output instance |
| [in] | uvScale | The UV scaling to apply to the instance chart |
| [in] | precompBlockSize | The block size used when testing charts in the packing |
bool GEO_CALL Enlighten::UpdateAlbedoBuffer
public: bool GEO_CALL UpdateAlbedoBuffer
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
Enlighten::AlbedoBuffer * albedoBuffer
)
Update an AlbedoBuffer from the DynamicMaterialWorkspace.
This will preserve values that were initialised with static data (ie ColourPerPoint or Texture).
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | albedoBuffer | A valid AlbedoBuffer where the results will be written to. This buffer is used as input to the IndirectInputLighting stage. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::UpdateEmissiveBuffer
public: bool GEO_CALL UpdateEmissiveBuffer
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
Enlighten::EmissiveBuffer * emissiveBuffer
)
Update an EmissiveBuffer from the DynamicMaterialWorkspace.
This will preserve values that were initialised with static data (ie ColourPerPoint or Texture).
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | emissiveBuffer | A valid EmissiveBuffer where the results will be written to. This buffer is used as input to the IndirectInputLighting stage. |
Returns
True on success or false if an error occurred.
bool GEO_CALL Enlighten::UpdateTransparencyBuffer
public: bool GEO_CALL UpdateTransparencyBuffer
(
DynamicMaterialWorkspace * materialWorkspace,
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
Enlighten::TransparencyBuffer * transparencyBuffer
)
Update a TransparencyBuffer from the DynamicMaterialWorkspace.
This will preserve values that were initialised with static data (ie ColourPerPoint or Texture).
Parameters
| [in] | materialWorkspace | A pointer to the DynamicMaterialWorkspace for the system. |
| [in] | materialData | A pointer to the precompute material data. |
| [in] | transparencyBuffer | A valid TransparencyBuffer where the results will be written to. This buffer is used as input to the IndirectInputLighting stage. |
Returns
True on success or false if an error occurred.
void GEO_CALL Enlighten::UpdateTransparencyWorkspace
public: void GEO_CALL UpdateTransparencyWorkspace
(
const InputWorkspace * inputWorkspace,
TransparencyWorkspace * transparencyWorkspace,
const InterpolationInputSet * interpolationInputs,
Geo::s32 numInterpolationInputs,
bool recomputeInterpolants
)
Update the transparency workspace with values calculated from interpolated probes.
Parameters
| [in] | inputWorkspace | The input workspace for the system |
| [out] | transparencyWorkspace | The workspace where intermediate probe results and other calculation results are stored |
| [in] | interpolationInputs | An array of probesets to interpolate from |
| [in] | numInterpolationInputs | The number of probesets in the array |
| [in] | recomputeInterpolants | Whether or not to recompute the interpolants |
void GEO_CALL Enlighten::UpdateTransparencyWorkspace
public: void GEO_CALL UpdateTransparencyWorkspace
(
const InputWorkspace * inputWorkspace,
TransparencyWorkspace * transparencyWorkspace,
Enlighten::IProbeSetManager * probeSetManager,
bool recomputeInterpolants
)
Update the transparency workspace with values calculated from interpolated probes.
Parameters
| [in] | inputWorkspace | The input workspace for the system |
| [out] | transparencyWorkspace | The workspace where intermediate probe results and other calculation results are stored |
| [in] | probeSetManager | The Probe Set Manager object that provides interface for probe interpolation |
| [in] | recomputeInterpolants | Whether or not to recompute the interpolants |
bool GEO_CALL Enlighten::VerifyBounceBufferData
public: bool GEO_CALL VerifyBounceBufferData
(
const Enlighten::BounceBuffer * bounceBuffer
)
Returns true if there are no NaN's or non-finite numbers in the specified BounceBuffer object.
Parameters
| [in] | bounceBuffer | The BounceBuffer to query. |
bool GEO_CALL Enlighten::VerifyIncidentLightingBufferData
public: bool GEO_CALL VerifyIncidentLightingBufferData
(
const Enlighten::IncidentLightingBuffer * incidentLightingBuffer
)
Returns true if there are no NaN's or non-finite numbers in the specified InputLightingBuffer object.
Parameters
| [in] | incidentLightingBuffer | The IncidentLightingBuffer to query. |
bool GEO_CALL Enlighten::VerifyInputLightingBufferData
public: bool GEO_CALL VerifyInputLightingBufferData
(
const InputLightingBuffer * inputLightingBuffer
)
Returns true if there are no NaN's or non-finite numbers in the specified InputLightingBuffer object.
Parameters
| [in] | inputLightingBuffer | The InputLightingBuffer to query. |
void Enlighten::VisitLights
public: void VisitLights
(
SortedLights * sortedLights,
Visitor & visitor
)
Visitor function to apply the visitor functor to each light.
void Enlighten::VisitSelectedLights
public: void VisitSelectedLights
(
const SortedLights * sortedLights,
Visitor & visitor,
LightSelector & lightSelector,
SortedLightsOperator * optionalSortedLightsOperator
)
Visits the selected lights with the given visitor.
const char* Enlighten::WorldAxisToString
public: const char * WorldAxisToString
(
WorldAxis direction
)
Return the string representation of the specified axis aligned unit vector.
bool GEO_CALL Enlighten::WriteAlbedoBuffer
public: bool GEO_CALL WriteAlbedoBuffer
(
const Enlighten::AlbedoBuffer * albedoBuffer,
Geo::IGeoStream & stream
)
Write an AlbedoBuffer to a stream.
Parameters
| [in] | albedoBuffer | - The AlbedoBuffer to write. |
| [in] | stream | - The Geo::IGeoStream to write. |
bool GEO_CALL Enlighten::WriteAlbedoBufferForInPlace
public: bool GEO_CALL WriteAlbedoBufferForInPlace
(
const AlbedoBuffer * albedoBuffer,
Geo::IGeoStream & stream,
Geo::EConvertEndianMode endianMode
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::WriteClusterAlbedoWorkspaceMaterialData
public: bool GEO_CALL WriteClusterAlbedoWorkspaceMaterialData
(
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
Geo::IGeoStream & stream
)
Write an ClusterAlbedoWorkspaceMaterialData to a stream, ready to be loaded on the target platform.
Parameters
| [in] | materialData | - The ClusterAlbedoWorkspaceMaterialData to write. |
| [in] | stream | - The Geo::IGeoStream to write to. |
bool GEO_CALL Enlighten::WriteClusterAlbedoWorkspaceMaterialDataForInPlace
public: bool GEO_CALL WriteClusterAlbedoWorkspaceMaterialDataForInPlace
(
const ClusterAlbedoWorkspaceMaterialData * materialData,
Geo::IGeoStream & stream,
Geo::EConvertEndianMode endianMode
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::WriteClusterAlbedoWorkspaceMaterialDataToFile
public: bool GEO_CALL WriteClusterAlbedoWorkspaceMaterialDataToFile
(
const Enlighten::ClusterAlbedoWorkspaceMaterialData * materialData,
const char * filename
)
Write an ClusterAlbedoWorkspaceMaterialData to file, ready to be loaded on the target platform.
Parameters
| [in] | materialData | - The ClusterAlbedoWorkspaceMaterialData to write. |
| [in] | filename | - The name of the file to write. |
bool GEO_CALL Enlighten::WriteDataBlock
public: bool GEO_CALL WriteDataBlock
(
const RadDataBlock & data,
Geo::IGeoStream & stream
)
Write a RadDataBlock to a Geo::IGeoStream.
void * Enlighten::WriteDataBlockForInPlace
public: void * WriteDataBlockForInPlace
(
const RadDataBlock & block,
char *& ptr
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::WriteDynamicMaterialWorkspace
public: bool GEO_CALL WriteDynamicMaterialWorkspace
(
const Enlighten::DynamicMaterialWorkspace * materialWorkspace,
Geo::IGeoStream & stream
)
Write an DynamicMaterialWorkspace to a stream.
Parameters
| [in] | materialWorkspace | - The DynamicMaterialWorkspace to write. |
| [in] | stream | - The Geo::IGeoStream to write. |
bool GEO_CALL Enlighten::WriteDynamicMaterialWorkspaceForInPlace
public: bool GEO_CALL WriteDynamicMaterialWorkspaceForInPlace
(
const DynamicMaterialWorkspace * workspace,
Geo::IGeoStream & stream,
Geo::EConvertEndianMode endianMode
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::WriteEmissiveBuffer
public: bool GEO_CALL WriteEmissiveBuffer
(
const Enlighten::EmissiveBuffer * emissiveBuffer,
Geo::IGeoStream & stream
)
Write an EmissiveBuffer to a stream.
Parameters
| [in] | emissiveBuffer | - The EmissiveBuffer to write. |
| [in] | stream | - The Geo::IGeoStream to write. |
bool GEO_CALL Enlighten::WriteEmissiveBufferForInPlace
public: bool GEO_CALL WriteEmissiveBufferForInPlace
(
const EmissiveBuffer * emissiveBuffer,
Geo::IGeoStream & stream,
Geo::EConvertEndianMode endianMode
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::WriteIncidentLightingBuffer
public: bool GEO_CALL WriteIncidentLightingBuffer
(
const Enlighten::IncidentLightingBuffer * incidentLightingBuffer,
Geo::IGeoStream & stream
)
Write an IncidentLightingBuffer to a stream.
Parameters
| [in] | incidentLightingBuffer | - The IncidentLightingBuffer to write. |
| [in] | stream | - The Geo::IGeoStream to write. |
bool GEO_CALL Enlighten::WriteIncidentLightingBufferForInPlace
public: bool GEO_CALL WriteIncidentLightingBufferForInPlace
(
const IncidentLightingBuffer * incidentLightingBuffer,
Geo::IGeoStream & stream,
Geo::EConvertEndianMode endianMode
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::WriteInputLightingBuffer
public: bool GEO_CALL WriteInputLightingBuffer
(
const Enlighten::InputLightingBuffer * source,
Enlighten::InputLightingBuffer * destination
)
Overwrite an InputLightingBuffer with another InputLightingBuffer.
Fails if the system ids or sample counts do not match.
Parameters
| [in] | source | - The InputLightingBuffer to read. |
| [inout] | destination | - The InputLightingBuffer to write. |
bool GEO_CALL Enlighten::WriteInputLightingBuffer
public: bool GEO_CALL WriteInputLightingBuffer
(
const Enlighten::InputLightingBuffer * inputLightingBuffer,
Geo::IGeoStream & stream
)
Write an InputLightingBuffer to a stream.
Parameters
| [in] | inputLightingBuffer | - The InputLightingBuffer to write. |
| [in] | stream | - The Geo::IGeoStream to write. |
bool GEO_CALL Enlighten::WriteInputLightingBufferForInPlace
public: bool GEO_CALL WriteInputLightingBufferForInPlace
(
const InputLightingBuffer * inputLightingBuffer,
Geo::IGeoStream & stream,
Geo::EConvertEndianMode endianMode
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::WriteInputLightingBufferToFile
public: bool GEO_CALL WriteInputLightingBufferToFile
(
const Enlighten::InputLightingBuffer * inputLightingBuffer,
const char * filename
)
Write an InputLightingBuffer to file.
Parameters
| [in] | inputLightingBuffer | - The InputLightingBuffer to write. |
| [in] | filename | - The name of the file to write. |
bool GEO_CALL Enlighten::WriteInputWorkspace
public: bool GEO_CALL WriteInputWorkspace
(
const Enlighten::InputWorkspace * inputWorkspace,
Geo::IGeoStream & stream
)
Write an InputWorkspace to a stream, ready to be loaded on the target platform.
Parameters
| [in] | inputWorkspace | - The InputWorkspace to write. |
| [in] | stream | - The Geo::IGeoStream to write to. |
bool GEO_CALL Enlighten::WriteInputWorkspaceForInPlace
public: bool GEO_CALL WriteInputWorkspaceForInPlace
(
const InputWorkspace * inputWorkspace,
Geo::IGeoStream & stream,
Geo::EConvertEndianMode endianMode
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::WriteInputWorkspaceToFile
public: bool GEO_CALL WriteInputWorkspaceToFile
(
const Enlighten::InputWorkspace * inputWorkspace,
const char * filename
)
Write an InputWorkspace to file, ready to be loaded on the target platform.
Parameters
| [in] | inputWorkspace | - The InputWorkspace to write. |
| [in] | filename | - The name of the file to write. |
bool GEO_CALL Enlighten::WritePrecomputedVisibilityData
public: bool GEO_CALL WritePrecomputedVisibilityData
(
const Enlighten::PrecomputedVisibilityData * visibilityData,
Geo::IGeoStream & stream
)
Write a PrecomputedVisibilityData structure to a stream.
Parameters
| [in] | visibilityData | - The PrecomputedVisibilityData structure data to write. |
| [in] | stream | - The Geo::IGeoStream to write. |
bool GEO_CALL Enlighten::WritePrecomputedVisibilityDataForInPlace
public: bool GEO_CALL WritePrecomputedVisibilityDataForInPlace
(
const PrecomputedVisibilityData * visibilityData,
Geo::IGeoStream & stream,
Geo::EConvertEndianMode endianMode
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::WritePrecomputedVisibilityDataToFile
public: bool GEO_CALL WritePrecomputedVisibilityDataToFile
(
const Enlighten::PrecomputedVisibilityData * visibilityData,
const char * filename
)
Write a PrecomputedVisibilityData structure to a file.
Parameters
| [in] | visibilityData | - The PrecomputedVisibilityData structure data to write. |
| [in] | filename | - The name of the file to write. |
bool GEO_CALL Enlighten::WriteProbeTaskOutput
public: bool GEO_CALL WriteProbeTaskOutput
(
const Enlighten::RadProbeTask * probeTask,
Geo::IGeoStream & stream
)
Write the RadProbeTask results data to a file/stream.
bool GEO_CALL Enlighten::WriteProbeTaskOutputToFile
public: bool GEO_CALL WriteProbeTaskOutputToFile
(
const Enlighten::RadProbeTask * probeTask,
const char * filename
)
Write the RadProbeTask results data to a file/stream.
bool GEO_CALL Enlighten::WriteRadCubeMapCore
public: bool GEO_CALL WriteRadCubeMapCore
(
const Enlighten::RadCubeMapCore * cubeMapCore,
Geo::IGeoStream & stream
)
Write a RadCubeMapCore to a stream, ready to be loaded on the target platform.
Parameters
| [in] | cubeMapCore | - The RadCubeMapCore to write. |
| [in] | stream | - The Geo::IGeoStream to write to. |
Note
the RadDataBlock contained in the RadCubeMapCore must be relocatable for this function to succeed.
bool GEO_CALL Enlighten::WriteRadCubeMapCoreForInPlace
public: bool GEO_CALL WriteRadCubeMapCoreForInPlace
(
const RadCubeMapCore * cubeMap,
Geo::IGeoStream & stream,
Geo::EConvertEndianMode endianMode
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::WriteRadCubeMapCoreToFile
public: bool GEO_CALL WriteRadCubeMapCoreToFile
(
const Enlighten::RadCubeMapCore * cubeMapCore,
const char * filename
)
Write a RadCubeMapCore to file, ready to be loaded on the target platform.
Parameters
| [in] | cubeMapCore | - The RadCubeMapCore to write. |
| [in] | filename | - The name of the file to write. |
Note
the RadDataBlock contained in the RadCubeMapCore must be relocatable for this function to succeed.
bool Enlighten::WriteRadIrradianceTaskOutput
public: bool WriteRadIrradianceTaskOutput
(
const RadIrradianceTask * task,
Geo::IGeoStream & stream
)
Write the RadIrradianceTask results data to a file/stream.
bool Enlighten::WriteRadIrradianceTaskOutputToFile
public: bool WriteRadIrradianceTaskOutputToFile
(
const RadIrradianceTask * task,
const char * filename
)
Write the RadIrradianceTask results data to a file/stream.
bool GEO_CALL Enlighten::WriteRadProbeSetCore
public: bool GEO_CALL WriteRadProbeSetCore
(
const Enlighten::RadProbeSetCore * probeSet,
Geo::IGeoStream & stream
)
Write run-time probeset data to a stream, ready to be loaded on the target platform.
Parameters
| [in] | probeSet | - The probe set data to write. |
| [in] | stream | - The Geo::IGeoStream to write. |
Note
the RadDataBlock must be relocatable for this function to succeed.
bool GEO_CALL Enlighten::WriteRadProbeSetCoreForInPlace
public: bool GEO_CALL WriteRadProbeSetCoreForInPlace
(
const RadProbeSetCore * probeSet,
Geo::IGeoStream & stream,
Geo::EConvertEndianMode endianMode
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::WriteRadProbeSetCoreToFile
public: bool GEO_CALL WriteRadProbeSetCoreToFile
(
const Enlighten::RadProbeSetCore * probeSet,
const char * filename
)
Write run-time probeset data to file, ready to be loaded on the target platform.
The data is written in little-endian format, so the loading code must handle this.
Parameters
| [in] | probeSet | - The probe set data to write. |
| [in] | filename | - The name of the file to write. |
Note
the RadDataBlock must be relocatable for this function to succeed.
bool GEO_CALL Enlighten::WriteRadSystemCore
public: bool GEO_CALL WriteRadSystemCore
(
const Enlighten::RadSystemCore * system,
Geo::IGeoStream & stream
)
Write a RadSystemCore to a stream, ready to be loaded on the target platform.
Parameters
| [in] | system | - The RadSystemCore to write. |
| [in] | stream | - The Geo::IGeoStream to write to. |
Note
the RadDataBlock contained in the RadSystemCore must be relocatable for this function to succeed.
bool GEO_CALL Enlighten::WriteRadSystemCoreForInPlace
public: bool GEO_CALL WriteRadSystemCoreForInPlace
(
const RadSystemCore * system,
Geo::IGeoStream & stream,
Geo::EConvertEndianMode endianMode
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
bool GEO_CALL Enlighten::WriteRadSystemCoreToFile
public: bool GEO_CALL WriteRadSystemCoreToFile
(
const Enlighten::RadSystemCore * system,
const char * filename
)
Write a RadSystemCore to file, ready to be loaded on the target platform.
Parameters
| [in] | system | - The RadSystemCore to write. |
| [in] | filename | - The name of the file to write. |
Note
the RadDataBlock contained in the RadSystemCore must be relocatable for this function to succeed.
void Enlighten::WriteSortedLightsToMem
public: void WriteSortedLightsToMem
(
SortedLights * sortedLights,
void * destMem
)
Write the sorted lights to memory.
This will be the buffer that the GPU uses to read lights from.
Parameters
| [in] | sortedLights | A valid SortedLights buffer created though a call to CreateSortedLights() |
| [in] | destMem | A pointer to memory where the CachedData of the sorted lights will be written to. |
bool GEO_CALL Enlighten::WriteTransparencyBufferForInPlace
public: bool GEO_CALL WriteTransparencyBufferForInPlace
(
const TransparencyBuffer * transparencyBuffer,
Geo::IGeoStream & stream,
Geo::EConvertEndianMode endianMode
)
These utilities perform in-place fixup of the various enlighten data structures.
Make sure any buffers passed to Read*InPlace functions are 16 byte aligned.
AggregateProfileItem
public: enum AggregateProfileItem
{
API_ENLIGHTEN_TOTAL_CPU = 0,
API_ENLIGHTEN_TOTAL_GPU,
API_ENLIGHTEN_TOTAL_PROBES,
API_ENLIGHTEN_TOTAL_PROBE_INTERPOLATION,
API_ENLIGHTEN_TOTAL_CUBEMAPS,
API_ENLIGHTEN_SETUP_WALLCLOCK,
API_ENLIGHTEN_ENVIRONMENT_WALLCLOCK,
API_ENLIGHTEN_INPUTLIGHTING_WALLCLOCK,
API_ENLIGHTEN_SYSTEMS_WALLCLOCK,
API_ENLIGHTEN_PROBES_WALLCLOCK,
API_ENLIGHTEN_CUBEMAPS_WALLCLOCK,
API_ENLIGHTEN_SOLVE_TASKS_WALLCLOCK,
API_ENLIGHTEN_DYNAMICOBJECTS_WALLCLOCK,
API_ENLIGHTEN_TIME_BETWEEN_UPDATES,
API_ENLIGHTEN_OTHER_COMMANDS,
API_ENLIGHTEN_INPUTLIGHTING_GPU_TICKS,
API_ENLIGHTEN_NUM_BLOCKED_BUFFER_WRITES,
API_ENLIGHTEN_BLOCKED_COMMAND_WRITES_DURATION,
API_ENLIGHTEN_PPPI_UPDATE_TIME_US,
API_ENLIGHTEN_PPPI_PROBESET_UPDATE_COUNT,
API_ENLIGHTEN_PPPI_COPIED_PROBE_COUNT,
API_ENLIGHTEN_PPPI_COPY_TIME_US,
API_ENLIGHTEN_PPPI_BUILD_TIME_US,
API_ENLIGHTEN_PPPI_INDIRECTION_UPDATE_TIME_US,
API_ENLIGHTEN_PPPI_ATLAS_TILE_COUNT,
NUM_AGGREGATE_PROFILE_ITEMS
}
Items we record for totals.
enumerators
| API_ENLIGHTEN_TOTAL_CPU | |
| API_ENLIGHTEN_TOTAL_GPU | |
| API_ENLIGHTEN_TOTAL_PROBES | |
| API_ENLIGHTEN_TOTAL_PROBE_INTERPOLATION | |
| API_ENLIGHTEN_TOTAL_CUBEMAPS | |
| API_ENLIGHTEN_SETUP_WALLCLOCK | |
| API_ENLIGHTEN_ENVIRONMENT_WALLCLOCK | |
| API_ENLIGHTEN_INPUTLIGHTING_WALLCLOCK | |
| API_ENLIGHTEN_SYSTEMS_WALLCLOCK | |
| API_ENLIGHTEN_PROBES_WALLCLOCK | |
| API_ENLIGHTEN_CUBEMAPS_WALLCLOCK | |
| API_ENLIGHTEN_SOLVE_TASKS_WALLCLOCK | |
| API_ENLIGHTEN_DYNAMICOBJECTS_WALLCLOCK | |
| API_ENLIGHTEN_TIME_BETWEEN_UPDATES | |
| API_ENLIGHTEN_OTHER_COMMANDS | |
| API_ENLIGHTEN_INPUTLIGHTING_GPU_TICKS | |
| API_ENLIGHTEN_NUM_BLOCKED_BUFFER_WRITES | |
| API_ENLIGHTEN_BLOCKED_COMMAND_WRITES_DURATION | |
| API_ENLIGHTEN_PPPI_UPDATE_TIME_US | |
| API_ENLIGHTEN_PPPI_PROBESET_UPDATE_COUNT | |
| API_ENLIGHTEN_PPPI_COPIED_PROBE_COUNT | |
| API_ENLIGHTEN_PPPI_COPY_TIME_US | |
| API_ENLIGHTEN_PPPI_BUILD_TIME_US | |
| API_ENLIGHTEN_PPPI_INDIRECTION_UPDATE_TIME_US | |
| API_ENLIGHTEN_PPPI_ATLAS_TILE_COUNT | |
| NUM_AGGREGATE_PROFILE_ITEMS |
CubeMapProfileItem
public: enum CubeMapProfileItem
{
CMPI_SOLVE_TIME = 0,
CMPI_SETUP_TIME,
NUM_CUBE_MAP_PROFILE_ITEMS
}
Items we record against cube maps.
enumerators
| CMPI_SOLVE_TIME | |
| CMPI_SETUP_TIME | |
| NUM_CUBE_MAP_PROFILE_ITEMS |
eAutoSimpMode
public: enum eAutoSimpMode
{
ASM_NONE = 0,
ASM_SIMPLIFY_NO_UVS,
ASM_SIMPLIFY_USING_UVS,
NUM_AUTO_SIMP_MODES
}
The UV auto generation / simplification mode for a mesh.
Used as part of PrecompMeshProperties.
enumerators
| ASM_NONE | Switch AutoUV generation off. |
| ASM_SIMPLIFY_NO_UVS | Switch AutoUV generation on and use auto generated UVs for all charts. |
| ASM_SIMPLIFY_USING_UVS | Switch AutoUV generation on, use auto UV generated UVs only if they are better than the input UVs. |
| NUM_AUTO_SIMP_MODES |
eBakeLightType
public: enum eBakeLightType
{
BAKE_LIGHT_TYPE_INVALID = -1,
BAKE_LIGHT_TYPE_SPOT_LIGHT = 0,
BAKE_LIGHT_TYPE_POINT_LIGHT = 1,
BAKE_LIGHT_TYPE_DIRECTIONAL_LIGHT = 2,
BAKE_LIGHT_TYPE_RECTANGULAR_LIGHT = 3
}
Different types of baking input lights.
enumerators
| BAKE_LIGHT_TYPE_INVALID | Invalid light type. |
| BAKE_LIGHT_TYPE_SPOT_LIGHT | Spot light. |
| BAKE_LIGHT_TYPE_POINT_LIGHT | Point light. |
| BAKE_LIGHT_TYPE_DIRECTIONAL_LIGHT | Directional light. |
| BAKE_LIGHT_TYPE_RECTANGULAR_LIGHT | Rectangular area light. |
EBakeType
public: enum EBakeType
{
ebtTexture,
ebtVertex,
ebtProbe
}
Bake output format.
enumerators
| ebtTexture | Use texture bake output. |
| ebtVertex | Use vertex bake output. |
| ebtProbe | Use probe bake output. |
eLightType
public: enum eLightType
{
LIGHT_TYPE_INVALID = -1,
LIGHT_TYPE_SPOT_LIGHT = 0,
LIGHT_TYPE_POINT_LIGHT = 1,
LIGHT_TYPE_DIRECTIONAL_LIGHT = 2,
LIGHT_TYPE_RECTANGLE_LIGHT = 3,
LIGHT_TYPE_FRUSTUM_LIGHT = 4,
LIGHT_TYPE_BOXSPOT_LIGHT = 5,
LIGHT_TYPE_NUM_TYPES
}
Different types of Enlighten input lights.
enumerators
| LIGHT_TYPE_INVALID | Invalid light type. |
| LIGHT_TYPE_SPOT_LIGHT | Spot light. |
| LIGHT_TYPE_POINT_LIGHT | Point light. |
| LIGHT_TYPE_DIRECTIONAL_LIGHT | Directional light. |
| LIGHT_TYPE_RECTANGLE_LIGHT | Rectangular area light (only available on PC) |
| LIGHT_TYPE_FRUSTUM_LIGHT | Frustum light. |
| LIGHT_TYPE_BOXSPOT_LIGHT | BoxSpot light. |
| LIGHT_TYPE_NUM_TYPES |
eMeshClassificationLightingType
public: enum eMeshClassificationLightingType
{
MCLT_LIGHTMAP,
MCLT_PROBE
}
Enumeration for reporting results of the first step of Mesh Classification (lightmap-lit or probe-lit).
enumerators
| MCLT_LIGHTMAP | |
| MCLT_PROBE |
EnlightenTaskType
public: enum EnlightenTaskType
{
ETT_SYSTEM_INPUT_LIGHTING,
ETT_SYSTEM_SOLVE,
ETT_PROBE_SOLVE,
ETT_CUBE_MAP_SOLVE,
ETT_DYNAMIC_OBJECT_INTERPOLATION
}
The MultithreadCpuWorker works by putting tasks in a list, and then executing TaskProcessors on several threads in parallel.
A TaskProcessor pulls tasks off the list one by one, until either the whole list is done, or an ILimiter tells it to stop.
The executing threads are accessed through the IThreadGroup interface. If none is supplied then the MultithreadCpuWorker will create a DefaultThreadGroup which executes tasks in serial on the calling thread (ie the update manager worker thread). When it is destroyed, the MultithreadCpuWorker will call Release() on the IThreadGroup interface it was passed. There is an implementation of IThreadGroup which uses Intel Threaded Building Blocks in the TbbThreadGroup.h header (which does not get compiled in to EnlightenHRLT).
ILimiter is an optional interface which can be implemented by the application. A simple FixedTimeLimiter is included here which times out after a given fixed time. Note that the limiter only controls the point at which new tasks can be started, not the total time taken.
The Enlighten update loop consists of three multithreaded phases: input lighting, solve tasks, and probe interpolation. Within each phase tasks can run in parallel (for instance, a probe set can be solved at the same time as a system), but tasks from different phases cannot run together.
If no limiter is supplied, the MultithreadCpuWorker will complete one full pass through the update loop for each call to UpdateRadiosity(). However, it can remembers where in the udpate loop it previously stopped, so if a limiter tells it to stop part-way through an update it will resume from where it left off. This ensures that the Enlighten data remains in a consistent state at all times. Enumeration of Enlighten task types. These are executed by the TaskProcessors.
enumerators
| ETT_SYSTEM_INPUT_LIGHTING | |
| ETT_SYSTEM_SOLVE | |
| ETT_PROBE_SOLVE | |
| ETT_CUBE_MAP_SOLVE | |
| ETT_DYNAMIC_OBJECT_INTERPOLATION |
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. |
ePppiVolumeTextureFormat
public: enum ePppiVolumeTextureFormat
{
PPPI_VOLUME_TEXTURE_FORMAT_R16G16B16A16F,
PPPI_VOLUME_TEXTURE_FORMAT_R8G8,
PPPI_VOLUME_TEXTURE_FORMAT_R8G8B8A8
}
Volume texture formats used by the per-pixel probe interpolation runtime.
enumerators
| PPPI_VOLUME_TEXTURE_FORMAT_R16G16B16A16F | |
| PPPI_VOLUME_TEXTURE_FORMAT_R8G8 | |
| PPPI_VOLUME_TEXTURE_FORMAT_R8G8B8A8 |
ePrecompCubeMapQuality
public: enum ePrecompCubeMapQuality
{
PCMQ_LOW = 1,
PCMQ_MEDIUM = 4,
PCMQ_HIGH = 16,
PCMQ_VERY_HIGH = 64
}
Quality levels for the raytracing in the cube map precompute.
Each levels correspond to a number of rays that get generated and cast per pixel.
See Also
ePrecompQuality
enumerators
| PCMQ_LOW | |
| PCMQ_MEDIUM | The default. |
| PCMQ_HIGH | |
| PCMQ_VERY_HIGH |
ePrecompMaterialBackfaceBehaviourType
public: enum ePrecompMaterialBackfaceBehaviourType
{
epmbbtInvalid,
epmbbtBlack,
epmbbtTransparent,
epmbbtDoubleSided,
epmbbtNumValues
}
Determines how to treat back faces when precomputing light transport.
enumerators
| epmbbtInvalid | |
| epmbbtBlack | |
| epmbbtTransparent | |
| epmbbtDoubleSided | |
| epmbbtNumValues |
ePrecompMaterialShadowfaceBehaviourType
public: enum ePrecompMaterialShadowfaceBehaviourType
{
epmsfbtFront,
epmsfbtBack,
epmsfbtBoth,
epmsfbtNumValues,
epmsfbtDefault = epmsfbtBoth
}
Determines which faces cast shadows when precomputing directional visibility.
enumerators
| epmsfbtFront | |
| epmsfbtBack | |
| epmsfbtBoth | |
| epmsfbtNumValues | |
| epmsfbtDefault |
ePrecompQuality
public: enum ePrecompQuality
{
PCQ_DEBUG = 16,
PCQ_DRAFT = 512,
PCQ_LOW = 2048,
PCQ_MEDIUM = 8192,
PCQ_HIGH = 32768,
PCQ_VERY_HIGH = 131072
}
Quality levels for majority of raytracing in the precompute, except cube maps.
Each levels correspond to a number of rays that get generated and than cast over the sphere and/or hemisphere. More rays result in a better approximation and therefore higher quality.
See Also
ePrecompCubeMapQuality
enumerators
| PCQ_DEBUG | |
| PCQ_DRAFT | |
| PCQ_LOW | |
| PCQ_MEDIUM | |
| PCQ_HIGH | |
| PCQ_VERY_HIGH |
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_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_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) |
GeometryBuildResult
public: enum GeometryBuildResult
{
GEOM_BUILD_SUCCESS = 0,
GEOM_BUILD_INVALID_MESH_INPUT = -1,
GEOM_BUILD_INVALID_MESH_PROPERTIES = -2,
GEOM_BUILD_PRECOMPUTE_FAILURE = -3,
GEOM_BUILD_EMPTY = -4,
GEOM_BUILD_USER_CANCELLED = -5,
GEOM_BUILD_INVALID_TERRAIN = -6,
GEOM_BUILD_INVALID_GEOM_PROPERTIES = -7
}
Enumeration for reporting geometry build success/fail.
enumerators
| GEOM_BUILD_SUCCESS | The geometry was built successfully. |
| GEOM_BUILD_INVALID_MESH_INPUT | A mesh failed validation, or the geometry's output pixel size or atlas width/height was invalid. |
| GEOM_BUILD_INVALID_MESH_PROPERTIES | The flags and/or parameters of a mesh were invalid, or the geometry contained no input mesh or no output mesh. |
| GEOM_BUILD_PRECOMPUTE_FAILURE | An internal precompute error occurred. Contact Enlighten support. |
| GEOM_BUILD_EMPTY | The geometry contained no meshes. |
| GEOM_BUILD_USER_CANCELLED | The user cancelled the geometry build. |
| GEOM_BUILD_INVALID_TERRAIN | Geometry is marked up as terrain, but has invalid terrain properties. |
| GEOM_BUILD_INVALID_GEOM_PROPERTIES | Geometry has invalid properties. |
OutputTextureType
public: enum OutputTextureType
{
ENLIGHTEN_OUTPUT_IRRADIANCE = 0,
ENLIGHTEN_OUTPUT_DIRECTIONAL = 1,
ENLIGHTEN_OUTPUT_DIRECTIONAL_G = 2,
ENLIGHTEN_OUTPUT_DIRECTIONAL_B = 3,
ENLIGHTEN_NUM_OUTPUT_TEXTURE_TYPES = 4
}
Enumeration of the different output textures produced by the Enlighten solvers.
enumerators
| ENLIGHTEN_OUTPUT_IRRADIANCE | The Irradiance Output data. |
| ENLIGHTEN_OUTPUT_DIRECTIONAL | The luminance/red Directional Irradiance Output data. |
| ENLIGHTEN_OUTPUT_DIRECTIONAL_G | The green Directional Irradiance Output data. |
| ENLIGHTEN_OUTPUT_DIRECTIONAL_B | The blue Directional Irradiance Output data. |
| ENLIGHTEN_NUM_OUTPUT_TEXTURE_TYPES | Total number of output textures per system. |
PipelineEnvironmentResolution
public: enum PipelineEnvironmentResolution{}
The allowed values for Environment resolution.
PipelineFormFactorBudget
public: enum PipelineFormFactorBudget{}
The recommended values for Irradiance Budget.
PipelineRadiosityGroupType
public: enum PipelineRadiosityGroupType{}
Whether the instance group can be automatically split by the precompute.
PipelineRadiosityLightingType
public: enum PipelineRadiosityLightingType{}
The way a radiosity instance is lit by Enlighten indirect lighting.
PipelineRadiosityShadowType
public: enum PipelineRadiosityShadowType{}
Whether an instance casts an indirect shadow.
PipelineWorldAxis
public: enum PipelineWorldAxis{}
The direction in which a world axis points.
PrecomputeDistribute
public: enum PrecomputeDistribute{}
The way the precompute process should be distributed.
PrecomputeResult
public: enum PrecomputeResult{}
The result of the precompute process.
ProbeOctreeResolution
public: enum ProbeOctreeResolution
{
PROBEOCTREERESOLUTION_FULL,
PROBEOCTREERESOLUTION_HALF,
PROBEOCTREERESOLUTION_QUARTER,
PROBEOCTREERESOLUTION_EIGHTH,
PROBEOCTREERESOLUTION_SIXTEENTH,
PROBEOCTREERESOLUTION_1_IN_32,
PROBEOCTREERESOLUTION_1_IN_64,
PROBEOCTREERESOLUTION_1_IN_128,
PROBEOCTREERESOLUTION_1_IN_256,
PROBEOCTREERESOLUTIONCOUNT,
PROBEOCTREERESOLUTION_NONE = PROBEOCTREERESOLUTIONCOUNT
}
The resolution at which probes should be placed.
enumerators
| PROBEOCTREERESOLUTION_FULL | |
| PROBEOCTREERESOLUTION_HALF | |
| PROBEOCTREERESOLUTION_QUARTER | |
| PROBEOCTREERESOLUTION_EIGHTH | |
| PROBEOCTREERESOLUTION_SIXTEENTH | |
| PROBEOCTREERESOLUTION_1_IN_32 | |
| PROBEOCTREERESOLUTION_1_IN_64 | |
| PROBEOCTREERESOLUTION_1_IN_128 | |
| PROBEOCTREERESOLUTION_1_IN_256 | |
| PROBEOCTREERESOLUTIONCOUNT | |
| PROBEOCTREERESOLUTION_NONE |
ProbeSetProfileItem
public: enum ProbeSetProfileItem
{
PSPI_SOLVE_TIME = 0,
PSPI_SETUP_TIME,
PSPI_FREEZE_TIME,
PSPI_NUM_TOTAL_PROBES,
PSPI_NUM_REAL_PROBES,
PSPI_NUM_VIRTUAL_PROBES,
PSPI_NUM_SOLVED_PROBES,
NUM_PROBE_SET_PROFILE_ITEMS
}
Items we record against probe sets.
enumerators
| PSPI_SOLVE_TIME | |
| PSPI_SETUP_TIME | |
| PSPI_FREEZE_TIME | |
| PSPI_NUM_TOTAL_PROBES | |
| PSPI_NUM_REAL_PROBES | |
| PSPI_NUM_VIRTUAL_PROBES | |
| PSPI_NUM_SOLVED_PROBES | |
| NUM_PROBE_SET_PROFILE_ITEMS |
ProbeVolumeOutputTextureType
public: enum ProbeVolumeOutputTextureType
{
ENLIGHTEN_PROBE_VOLUME_R = 0,
ENLIGHTEN_PROBE_VOLUME_G = 1,
ENLIGHTEN_PROBE_VOLUME_B = 2,
ENLIGHTEN_PROBE_VOLUME_ENV_VIS_SH = 3,
ENLIGHTEN_PROBE_VOLUME_NUM_TYPES = 4
}
Enumeration of the different probe volume output textures.
enumerators
| ENLIGHTEN_PROBE_VOLUME_R | The red channel of probe volume data. |
| ENLIGHTEN_PROBE_VOLUME_G | The green channel of probe volume data. |
| ENLIGHTEN_PROBE_VOLUME_B | The blue channel of probe volume data. |
| ENLIGHTEN_PROBE_VOLUME_ENV_VIS_SH | The environment visibility data. |
| ENLIGHTEN_PROBE_VOLUME_NUM_TYPES | Total number of probe volume output textures. |
SolveType
public: enum SolveType
{
ENLIGHTEN_IRRADIANCE_ONLY = 0,
ENLIGHTEN_DIRECTIONAL_IRRADIANCE = 1,
ENLIGHTEN_DIRECTIONAL_IRRADIANCE_RGB = 2
}
Enumeration of the different types of solve.
enumerators
| ENLIGHTEN_IRRADIANCE_ONLY | Computes only the irradiance texture. |
| ENLIGHTEN_DIRECTIONAL_IRRADIANCE | Computes irradiance and the additional directional texture. |
| ENLIGHTEN_DIRECTIONAL_IRRADIANCE_RGB | Computes irradiance and three additional directional textures for R, G and B channels. |
SystemProfileItem
public: enum SystemProfileItem
{
SPI_SOLVE_TIME = 0,
SPI_SOLVE_SETUP_TIME,
SPI_TRANSPARENCY_TIME,
SPI_INPUT_LIGHTING_SETUP_TIME,
SPI_WRITE_INPUT_TIME,
SPI_DIRECT_INPUT_LIGHTING_TIME = SPI_WRITE_INPUT_TIME,
SPI_RESAMPLE_LIGHTMAP_BOUNCE,
SPI_END_INPUT_TIME,
SPI_INDIRECT_INPUT_LIGHTING_TIME = SPI_END_INPUT_TIME,
SPI_FREEZE_TIME,
SPI_SOLVE_PERC,
SPI_DIRECTIONAL_VISIBILITY_TIME,
SPI_UPDATE_RATE,
SPI_NUM_TOTAL_PIXELS,
SPI_NUM_SOLVED_PIXELS,
SPI_NUM_LIGHTS_AFFECTING,
NUM_SYSTEM_PROFILE_ITEMS
}
Items we record against systems.
enumerators
| SPI_SOLVE_TIME | |
| SPI_SOLVE_SETUP_TIME | |
| SPI_TRANSPARENCY_TIME | |
| SPI_INPUT_LIGHTING_SETUP_TIME | |
| SPI_WRITE_INPUT_TIME | |
| SPI_DIRECT_INPUT_LIGHTING_TIME | |
| SPI_RESAMPLE_LIGHTMAP_BOUNCE | |
| SPI_END_INPUT_TIME | |
| SPI_INDIRECT_INPUT_LIGHTING_TIME | |
| SPI_FREEZE_TIME | |
| SPI_SOLVE_PERC | |
| SPI_DIRECTIONAL_VISIBILITY_TIME | |
| SPI_UPDATE_RATE | |
| SPI_NUM_TOTAL_PIXELS | |
| SPI_NUM_SOLVED_PIXELS | |
| SPI_NUM_LIGHTS_AFFECTING | |
| NUM_SYSTEM_PROFILE_ITEMS |
TextureFormat
public: enum TextureFormat
{
TextureFormat_A16B16G16R16F,
TextureFormat_A32B32G32R32F,
GEO_DEPRECATED_ENUMERATOR =(TextureFormat_A16B16G16R16_Deprecated),
TextureFormat_A8R8G8B8,
GEO_DEPRECATED_ENUMERATOR =(TextureFormat_A16B16G16R16_Deprecated),
GEO_DEPRECATED_ENUMERATOR =(TextureFormat_A16B16G16R16_Deprecated),
TextureFormat_R8G8B8A8_UINT,
TextureFormat_R8,
TextureFormat_R32F,
GEO_DEPRECATED_ENUMERATOR =(TextureFormat_A16B16G16R16_Deprecated),
TextureFormat_R11G11B10,
TextureFormat_R9G9B9E5,
TextureFormat_UNKNOWN
}
Enumeration of output texture formats used by the high level run-time.
enumerators
| TextureFormat_A16B16G16R16F | |
| TextureFormat_A32B32G32R32F | |
| GEO_DEPRECATED_ENUMERATOR | |
| TextureFormat_A8R8G8B8 | |
| GEO_DEPRECATED_ENUMERATOR | |
| GEO_DEPRECATED_ENUMERATOR | |
| TextureFormat_R8G8B8A8_UINT | |
| TextureFormat_R8 | |
| TextureFormat_R32F | |
| GEO_DEPRECATED_ENUMERATOR | |
| TextureFormat_R11G11B10 | |
| TextureFormat_R9G9B9E5 | |
| TextureFormat_UNKNOWN |
VolumeQueryResult
public: enum VolumeQueryResult
{
VOLUMEQUERYESULT_OUTSIDE,
VOLUMEQUERYESULT_PARTIAL,
VOLUMEQUERYESULT_INSIDE
}
The result of a volume query.
enumerators
| VOLUMEQUERYESULT_OUTSIDE | Completely outside. |
| VOLUMEQUERYESULT_PARTIAL | Partly inside. |
| VOLUMEQUERYESULT_INSIDE | Completely inside. |
WorldAxis
public: enum WorldAxis{}
An unit vector aligned with one of vectors of the 3D standard basis, encoded in the range [0, 6).