class Enlighten::IPrecompute

    └>Geo::IGeoReleasable

The Low Level Enlighten Precompute API.

Enums

Functions

EMinimumCompatibleVersion

public: enum EMinimumCompatibleVersion
{
    emcvEnlighten3
}

Controls if Precompute should generate data that can be used by older Enlighten run time APIs.

enumerators

EStateDump

public: enum EStateDump
{
    esdNone,
    esdInputsOnly,
    esdAll
}

Controls the amount of reproduction data saved by the IPrecompute tasks.

enumerators

virtual Geo::s32 Enlighten::IPrecompute::AssembleSystemGeometry

public: Geo::s32 AssembleSystemGeometry
(
    const IPrecompInputSystem * pSystem,
    const IPrecompInputGeometry *const * ppInputGeometry,
    Geo::s32 numGeometries,
    Geo::IGeoProgressProxy * progress,
    IPrecompPackedSystem *& oSystem
)

Assemble system geometry.

If a system is going to be used as probe radiosity, then the input processing is greatly reduced (there is no need to pack the geometry and create the UV chart mappings).

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CalculateCubeMapSystemDependencies

public: Geo::s32 CalculateCubeMapSystemDependencies
(
    const IPrecompInputCubeMap * pCubeMap,
    const IPrecompPackedSystem *const * ppSystems,
    Geo::s32 numSystems,
    Geo::IGeoProgressProxy * progress,
    IPrecompSystemDependencies *& oDependencies
)

Calculate system dependencies for a cube map.

Each IPrecompInputCubeMap may have dependencies calculated by calling this function on it. All packed systems which are fully loaded will have their geometry fully represented in the visibility tests. Packed systems which only have a header (ie whose geometry isn't loaded) will be represented by their bounding boxes in the visibility tests. (In the HLBS these sets of systems are controlled by the "expansionDistance" parameter.)

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CalculateProbeSetSystemDependencies

public: Geo::s32 CalculateProbeSetSystemDependencies
(
    const IPrecompInputProbeSet * pProbeInput,
    const IPrecompPackedSystem *const * ppSystems,
    Geo::s32 numSystems,
    Geo::IGeoProgressProxy * progress,
    IPrecompSystemDependencies *& oDependencies
)

Calculate system dependencies for a probe set.

Each IPrecompInputProbeSet may have dependencies calculated by calling this function on it. The collection of systems passed in determines the connectivity between them, so completely isolated systems have a numSystems of 1. All packed systems which are fully loaded will have their geometry fully represented in the visibility tests. Packed systems which only have a header (ie whose geometry isn't loaded) will be represented by their bounding boxes in the visibility tests. (In the HLBS these sets of systems are controlled by the "expansionDistance" parameter.)

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CalculateSystemDependencies

public: Geo::s32 CalculateSystemDependencies
(
    const IPrecompPackedSystem * pSystem,
    const IPrecompPackedSystem *const * ppSystems,
    Geo::s32 numSystems,
    float rayOriginsPerPixelArea,
    Geo::IGeoProgressProxy * progress,
    IPrecompSystemDependencies *& oDependencies
)

Calculate system dependencies for a system.

Each IPrecompInputSystem may have dependencies calculated by calling this function on it. The collection of systems passed in determines the connectivity between them, so completely isolated systems have a numSystems of 1. All packed systems which are fully loaded will have their geometry fully represented in the visibility tests. Packed systems which only have a header (ie whose geometry isn't loaded) will be represented by their bounding boxes in the visibility tests. (In the HLBS these sets of systems are controlled by the "expansionDistance" parameter.)

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CalculateSystemDependenciesByDistance

public: Geo::s32 CalculateSystemDependenciesByDistance
(
    const IPrecompInputSystem *const * pInputSystems,
    Geo::s32 numSystems,
    const IPrecompInputGeometry *const * pInputGeoms,
    Geo::s32 numGeoms,
    float maxDistanceInPixelSizeUnits,
    bool estimateFromCentre,
    Geo::IGeoProgressProxy * progress,
    IPrecompSystemsDependencies *& oDependencies
)

Calculate dependencies for the input systems.

System A is dependent on system B if the centres of A and B are at a distance equal or smaller than the maxDistanceInPixelSizeUnits multiplied by the minimum pixel size of the instances in system B.

Parameters

virtual bool Enlighten::IPrecompute::ClassifyInstanceAsLightmapOrProbeLit

public: bool ClassifyInstanceAsLightmapOrProbeLit
(
    const Geo::Matrix & instanceTransform,
    const IPrecompInputGeometry * pPrecompInputGeometry,
    float outputPixelSize,
    bool considerUserUvs,
    float autoUvMaxDistanceFactor,
    double autoUvTotalErrorThreshold,
    eMeshClassificationLightingType & result
)

Decides whether a given geometry instance should be probe-lit or lightmap-lit based on how good its generated Auto UVs are.

This is used as part of Mesh Classification.

Parameters

virtual bool Enlighten::IPrecompute::ClassifyInstancesAsContributingProbeLit

public: bool ClassifyInstancesAsContributingProbeLit
(
    const Geo::Matrix * pInstanceTransforms,
    const IPrecompInputGeometry *const * ppInstanceGeoms,
    const float * pClusterSizes,
    Geo::s32 numInstances,
    float densityWindowSizeFactor,
    bool * pResults
)

Decides which probe-lit instances should be contributing ("Probe Radiosity") and which should not ("Fully Dynamic") based on how much light each instance and its neighbours could block.

This is used as part of Mesh Classification.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CompileClusteringOutput

public: Geo::s32 CompileClusteringOutput
(
    const IPrecompSystemPreClustering * pPreClustering,
    const IPrecompSystemClustering * pClustering,
    Geo::IGeoProgressProxy * progress,
    IClusteringOutput *& oClusteringOutput
)

Extract some data about the clustering process.

An optional step that gives you some information for debugging.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CompileCubeMap

public: Geo::s32 CompileCubeMap
(
    const IPrecompOutputCubeMap * cubeMapOutput,
    Enlighten::eSolverType targetSolver,
    Geo::IGeoProgressProxy * progress,
    IPrecompCubeMapCore *& oCubeMapCore
)

Compile the data from the cube map output object into runtime format.

Each IPrecompOutputCubeMap must have this function called on it per-platform

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CompileDepthCubeMap

public: Geo::s32 CompileDepthCubeMap
(
    const IPrecompOutputCubeMap * cubeMapOutput,
    IPrecompDepthCubeMap *& oDepthCubeMap
)

Compile the depth data from the cube map output object.

Each IPrecompOutputCubeMap must have this function called on it per-platform

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CompileInputWorkspace

public: Geo::s32 CompileInputWorkspace
(
    const IPrecompSystemDuster * pDusters,
    Enlighten::eSolverType targetSolver,
    bool includeProjectedPointData,
    Geo::IGeoProgressProxy * progress,
    InputWorkspace *& oInputWorkspace
)

Compile the data from the dusters and radiosity cores into an InputWorkspace.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CompileLightTransportOutput

public: Geo::s32 CompileLightTransportOutput
(
    const IPrecompSystemLightTransport * pLightTransport,
    Geo::IGeoProgressProxy * progress,
    ILightTransportOutput *& oLightTransportOutput
)

Extract some data about the light transport process.

An optional step that gives you some information for debugging.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CompileMaterialData

public: Geo::s32 CompileMaterialData
(
    const IPrecompSystemDuster * pDusters,
    Geo::IGeoProgressProxy * progress,
    ClusterAlbedoWorkspaceMaterialData *& oMaterialData
)

Compile the data from the dusters into a ClusterAlbedoWorkspaceMaterialData.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CompileProbeSet

public: Geo::s32 CompileProbeSet
(
    const IPrecompOutputProbeSet * pProbeSetOutput,
    Enlighten::eSolverType targetSolver,
    Geo::IGeoProgressProxy * progress,
    IPrecompProbeSetRadiosity *& oRadiosity
)

Compile the data from the probeset light transport into runtime format.

Each IPrecompOutputProbeSet must have this function called on it per-platform

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CompileRadiosity

public: Geo::s32 CompileRadiosity
(
    const IPrecompSystemCompressedLightTransport * pLightTransport,
    Enlighten::eSolverType targetSolver,
    Geo::IGeoProgressProxy * progress,
    IPrecompSystemRadiosity *& oRadiosity
)

Compile the data from the light transport into runtime format.

Each IPrecompSystemLightTransport must have this function called on it per-platform

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CompileRadiosityNormalTexture

public: Geo::s32 CompileRadiosityNormalTexture
(
    const IPrecompSystemCompressedLightTransport * pLightTransport,
    IPrecompRadiosityNormalTexture *& oRadiosityNormalTexture
)

Compile the radiosity normal texture from the light transport data.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CompressLightTransport

public: Geo::s32 CompressLightTransport
(
    const IPrecompSystemLightTransport * pLightTransport,
    const IPrecompSystemDuster * pDusters,
    Geo::IGeoProgressProxy * progress,
    IPrecompSystemCompressedLightTransport *& oCompiledLightTransport
)

Compress the data from the light transport into a tighter format.

Each IPrecompSystemLightTransport must have this function called on it to reduce the data down to runtime-compatible levels.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CreateClustering

public: Geo::s32 CreateClustering
(
    const IPrecompSystemPreClustering * pSystemPreClustering,
    const IPrecompPackedSystem *const * ppOtherPackedSystems,
    Geo::s32 numOtherSystems,
    Geo::IGeoProgressProxy * progress,
    IPrecompSystemClustering *& oClustering
)

Create clustering for a system.

Each IPrecompInputSystem must have clustering created by calling this function on it. The collection of other packed systems passed in is used for visibility determination, so any system whose geometry could affect rays cast with the system should be supplied. Typically the safest and simplest thing is to pass the same dependencies used by light transport.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CreateCubeMap

public: Geo::s32 CreateCubeMap
(
    const IPrecompInputCubeMap * inputCubeMap,
    const IPrecompSystemClustering *const * ppClusterings,
    Geo::s32 numClusterings,
    const IPrecompSystemPreClustering *const * ppPreClusterings,
    Geo::IGeoProgressProxy * progress,
    IPrecompOutputCubeMap *& oCubeMapOutput
)

Run the precompute for a cube map.

This function takes a description of a cube map as a IPrecompInputCubeMap and runs the precompute to produce an IPrecompOutputCubeMap. The runtime data can then be extracted from this object. This function requires a list of all systems the cube map is allowed to 'see', as an array of IPrecompSystemClustering objects. Removing systems that the cube map cannot see will make this stage faster.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CreateLightTransport

public: Geo::s32 CreateLightTransport
(
    const IPrecompPackedSystem * pSystem,
    const IPrecompPackedSystem *const * ppSystems,
    Geo::s32 numSystems,
    const IPrecompSystemClustering *const * ppClusterings,
    Geo::s32 numClusterings,
    Geo::IGeoProgressProxy * progress,
    IPrecompSystemLightTransport *& oLightTransport
)

Create the light transport for a system.

Each light-mapped system must have a light transport created by calling this function on it. The clustering object for each system to be considered as input (the dependencies), whether light-mapped or not, should be passed in. These are used to determine the bounced light that a given pixel in the system of interest can see. The packed system object of each light-mapped system to be considered as input should be passed in separately. These are used to determine connectivity in light-map space, and ensure boundaries between systems are as smooth as possible.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CreateOutputProbeOctree

public: Geo::s32 CreateOutputProbeOctree
(
    const IPrecompInputProbeOctree * pProbeInput,
    const IPrecompPackedSystem *const * ppSystems,
    Geo::s32 numSystems,
    Geo::IGeoProgressProxy * progress,
    IPrecompOutputProbeOctree *& pProbeOutput
)

Adaptively generate probe positions within a volume, based on distance to geometry.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CreatePreClustering

public: Geo::s32 CreatePreClustering
(
    const IPrecompPackedSystem * pSystem,
    const IPrecompPackedSystem *const * ppSystems,
    Geo::s32 numSystems,
    Geo::IGeoProgressProxy * progress,
    IPrecompSystemPreClustering *& oPreClustering
)

Create pre-clustering for a system.

Each IPrecompInputSystem must have pre-clustering created by calling this function on it. The collection of systems passed in determines the connectivity between them, so completely isolated systems have a numSystems of 1.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CreateProbeSet

public: Geo::s32 CreateProbeSet
(
    const IPrecompInputProbeSet * pProbeSet,
    const IPrecompSystemClustering *const * ppClusterings,
    Geo::s32 numClusterings,
    Geo::IGeoProgressProxy * progress,
    IPrecompOutputProbeSet *& oProbeSetOutput
)

Create the spherical harmonic data for an SH probe set.

Each IPrecompInputProbeSet must have spherical harmonic data created by calling this function on it. The collection of clusters passed in determines the connectivity between them, so completely isolated probe sets have a numClusterings of 1.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CreateSystemDusters

public: Geo::s32 CreateSystemDusters
(
    const IPrecompSystemClustering * pClustering,
    const IPrecompSystemClustering *const * ppClusterings,
    Geo::s32 numClusterings,
    Geo::IGeoProgressProxy * progress,
    IPrecompSystemDuster *& oDuster
)

Create the platform-agnostic runtime input sample points.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CreateSystemDusters

public: Geo::s32 CreateSystemDusters
(
    const IPrecompSystemClustering * pClustering,
    const IPrecompSystemClustering *const * ppClusterings,
    Geo::s32 numClusterings,
    const PointProjectionSurface * surfaceArray,
    Geo::s32 numSurfaces,
    const PointProjectionVersion * versionArray,
    Geo::s32 numVersions,
    const PointProjectionOptions * projectionOptions,
    Geo::IGeoProgressProxy * progress,
    IPrecompSystemDuster *& oDuster
)

Create the platform-agnostic runtime input sample points including versions of projected points.

This function will optionally generate alternative versions of the input sample points (duster points). If created, these will be exported via the m_ProjectedPointData RadDataBlock of the InputWorkspace runtime object when this class is compiled to a specific platform. If you do not want point projection data, you can simply pass NULLs as appropriate. There is a second version of this function which does this for you. In particular, if no versions are specified (numVersions == 0), the call will succeed and will not generate any additional data.

The m_ProjectedPointData RadDataBlock in the InputWorkspace is a collection of per-instance sets of input sample points that have been projected to the meshes provided to this call. The m_ProjectedPointData RadDataBlock is optional and will only be loaded at runtime if you provide the Enlighten::Iff::ProjectedPointsInputWorkspaceDataSection to Enlighten::ReadInputWorkspaceFromFile().

Point projection works well when projecting onto an alternative representation of the same geometry, such as a different LOD level. The geometry to project onto is provided as a set of 'surfaces', each of which consist of an IPrecompInputMesh, a transformation matrix and boolean. This is the PointProjectionSurface class. Note that only the positions and normals of the meshes are used in the projection. The set of surfaces to use is specified per-instance, per-version, with the PointProjectionVersion class.

"Versions" can be thought of as a generalisation of LODs. They are just an alternative representation for an instance, and although version IDs need to be unique per-instance, they can be any value. In particular, they do not need to start at 0, or be contiguous, or positive (e.g. -100,-1,4,5 are all fine). This function will fail and report an error if you specify the same version ID for an instance more than once. It will also fail if the m_TargetSurfaces array is 0 length, or contains invalid indices or refers to null pointers and so on, but we will accept geometry that is empty (no triangles or vertices). In this case, it is not possible to project the points so we keep their original locations and create a version entry with this data. This is redundant (the points are the same), but it allows us to handle this scenario correctly and without creating an edge case in the runtime. In particular, all versions of the points for an instance will have the same number of points in all cases.

Instances that are known by the precompute (and therefore the InputWorkspace), but do not have projected point versions explicitly created for them have zero points in the resulting RadDataBlock. See the runtime API for further details.

The projection code will find the closest position on the specified geometry for each duster point. But it can also attempt to find a better position in front of itself, along its normal, if this helps it sit on top of nearby obscuring geometry. This can help prevent points being hidden under small details. This behaviour is optional and disabled if maxRayIntersectionDistance in the PointProjectionOptions class is 0 or negative. (Default is 0.)

The ppClusterings array of dependent clusterings is used to correctly determine transparency offsets per cluster, it has to contain the pClustering system.

virtual Geo::s32 Enlighten::IPrecompute::CreateSystemsByVoxelisation

public: Geo::s32 CreateSystemsByVoxelisation
(
    const IPrecompInputSystem * pInputSystem,
    const IPrecompInputGeometry *const * pInputGeoms,
    Geo::s32 numGeoms,
    float voxelSizeInPixelSizeUnits,
    Geo::IGeoProgressProxy * progress,
    IPrecompGeneratedSystems *& oSystems
)

Split the input system into automatically generated systems.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CreateSystemsByVoxelisation

public: Geo::s32 CreateSystemsByVoxelisation
(
    const IPrecompInputSystem * pInputSystem,
    const IPrecompPackedGeometry *const * pPackedGeoms,
    Geo::s32 numGeoms,
    float voxelSizeInPixelSizeUnits,
    Geo::IGeoProgressProxy * progress,
    IPrecompGeneratedSystems *& oSystems
)

Split the input system into automatically generated systems.

This version of the function takes a collection of packed geometry objects allowing it to check that each system generated will pack. The instances in a generated system that would fail to pack using the provided voxel size are split into sub-voxels, ensuring valid systems are always generated.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::CreateVisibilityData

public: Geo::s32 CreateVisibilityData
(
    const IPrecompSystemClustering * thisClustering,
    const IPrecompSystemClustering *const * allClusterings,
    Geo::s32 numClusterings,
    Geo::IGeoProgressProxy * progress,
    PrecomputedVisibilityData *& oVisibility
)

Create precomputed visibility data for directional lights for a system.

Parameters

virtual void Enlighten::IPrecompute::DumpInputProbeRegion

public: void DumpInputProbeRegion
(
    const IPrecompInputProbeRegion * pProbeRegion,
    const char * name
)

Dump debug data for a probe region.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::LicenseDaysRemaining

public: Geo::s32 LicenseDaysRemaining()

Number of full days remaining for the set license. Returns -1 if the set license is invalid and/or outdated.

virtual Geo::s32 Enlighten::IPrecompute::PackGeometry

public: Geo::s32 PackGeometry
(
    const IPrecompInputGeometry * pGeometry,
    Geo::IGeoProgressProxy * progress,
    IPrecompPackedGeometry *& oGeometry
)

Simplify and pack geometry meshes.

Each IPrecompInputGeometry must be analysed and packed by calling this function on it.

Parameters

Returns

Returns 0 if successful, otherwise an integer which can be interpreted as a GeometryBuildResult. More detailed error information can be collected by implementing the ReportError() method of the IGeoProgressProxy object.

virtual Geo::s32 Enlighten::IPrecompute::PackSystem

public: Geo::s32 PackSystem
(
    const IPrecompInputSystem * pSystem,
    const IPrecompPackedGeometry *const * ppPackedGeometry,
    Geo::s32 numGeometries,
    Geo::IGeoProgressProxy * progress,
    IPrecompPackedSystem *& oSystem
)

Pack systems.

Each IPrecompInputSystem must be packed by calling this function on it.

Parameters

Returns

Returns zero if successful, non-zero if an error occurred. More detailed error information can be collected by implementing the ReportError() method of the IGeoProgressProxy object.

virtual Geo::s32 Enlighten::IPrecompute::ProjectGeometry

public: Geo::s32 ProjectGeometry
(
    const IPrecompInputGeometry * pInputGeometry,
    const IPrecompPackedGeometry *const * pBaseGeometries,
    Geo::s32 numBaseGeoms,
    Geo::IGeoProgressProxy * progress,
    IPrecompPackedGeometry *& oGeometry
)

Project detail meshes in an pInputGeometry onto target clusters from pBaseGeometries This is guaranteed not to change the pInputGeometry and pBaseGeometries in any way, so can be done after a precompute to get new UVs for a detail mesh that was not known about when the last precompute was run.

Parameters

virtual Geo::s32 Enlighten::IPrecompute::ProjectSystem

public: Geo::s32 ProjectSystem
(
    const IPrecompInputSystem * pProjectedSystem,
    const IPrecompInputGeometry *const * ppProjSysGeoms,
    Geo::s32 numProjSysGeometries,
    const IPrecompInputSystem * pTargetSystem,
    const IPrecompPackedGeometry *const * ppTargetSysGeoms,
    Geo::s32 numTargetSysGeometries,
    const Geo::Geo2DTransform * pTargetUvTransforms,
    Geo::IGeoProgressProxy * progress,
    IPrecompPackedSystem *& oSystem
)

Project a system comprised entirely of detail mesh instances across another system.

Parameters

virtual void Geo::IGeoReleasable::Release

public: void Release()

Free this object that was created within the Enlighten libraries.

Expect this to behave in a similar way to calling 'delete(this)'

virtual void Enlighten::IPrecompute::SetCpuGpuMode

public: void SetCpuGpuMode
(
    Geo::ECpuGpuMode mode
)

Sets the hardware mode for the Enlighten precompute.

virtual void Enlighten::IPrecompute::SetCpuThreadMax

public: void SetCpuThreadMax
(
    Geo::s32 maxThreads
)

Sets the maximum number of threads that the Cpu mode will use.

virtual bool Enlighten::IPrecompute::SetLicense

public: bool SetLicense
(
    const char * licenseData,
    Geo::s32 licenseLength
)

Set the license string. Must set before any precompute action.

virtual void Enlighten::IPrecompute::SetMaxConcurrentRays

public: void SetMaxConcurrentRays
(
    Geo::s32 totalRays
)

Sets the total number of rays that the precompute will generate at one time. Set this only if you are concerned about memory pressure.

virtual void Enlighten::IPrecompute::SetMinimumCompatibleVersion

public: void SetMinimumCompatibleVersion
(
    EMinimumCompatibleVersion minimumVersion
)

Sets the minimum version of Enlighten, precompute should generate data for (default is emcvEnlighten3).

virtual void Enlighten::IPrecompute::SetStateDump

public: void SetStateDump
(
    EStateDump state
)

Sets the level of reproduction data saved by the IPrecompute tasks.

virtual bool Enlighten::IPrecompute::SetStateDumpFolder

public: bool SetStateDumpFolder
(
    const char * folder
)

Sets the folder that shall contain reproduction data for the IPrecompute tasks.

virtual Geo::s32 Enlighten::IPrecompute::ValidateBuildParameters

public: Geo::s32 ValidateBuildParameters
(
    const IPrecompInputSystem * pSystem,
    const IPrecompInputGeometry *const * ppGeometry,
    Geo::s32 numGeometries,
    bool estimateNumOutputPixels,
    bool estimateNumClusters,
    Geo::IGeoProgressProxy * progress
)

Examine the incoming data and determine if the supplied parameters will violate memory or reasonable performance limits.

Parameters

Returns

Returns zero if successful, non-zero if the validation fails. Please refer to the errors reported via the ReportError() method of the IGeoProgressProxy object for details.

virtual Geo::s32 Enlighten::IPrecompute::ValidateGeometryParameters

public: Geo::s32 ValidateGeometryParameters
(
    const IPrecompInputGeometry * pGeometry,
    Geo::s32 * oOutputPixelLowerBound,
    Geo::IGeoProgressProxy * progress
)

Examine the incoming geometry and determine if the supplied parameters violate memory and performance limits.

This function will compute a lower bound on the number of output pixels, based on the surface area of the geometry and its output pixel size. If this lower bound exceeds the maximum size of a system then the function will fail. This is only intended as a sanity check, to catch the case where the output pixel size mismatches the geometry by order(s) of magnitude.

Parameters

Returns

0 on success, non-zero if the validation fails.