Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

►Nph	The root for all renderer implementations
►Nfield_set_op
CNoOpNoticeReceiver
►Nfunction_detail
CTFunction
CTFunction< R(Args...), MIN_SIZE_HINT >	Lightweight callable target wrapper
►Nhalton_detail
CFixedPermuter
COwenScrambledPermuter
CPerDigitPermuter
►Nlta	Light transport algorithms
CPDF	A sample from a Probability Density Function (PDF)
CPtVolumetricEstimator
CRussianRoulette	Russian roulette random termination scheme
CSenseEvent
CSidednessAgreement
CSurfaceHitRefinery	Algorithms for various hit point adjustments. For surface escaping routines, the generated ray is not guaranteed to "actually" avoid the surface. In other words, self-intersection may still happen under different circumstances dpending on the method used
CSurfaceTracer	Common operations for surface tracing. This class also handles many subtle cases for surface tracing. You may take the implementations here as reference if a more fine-grained control is needed for a custom operation
CTDirectLightEstimator	Estimate direct lighting for a surface point. This is a lightweight helper type for estimating direct lighting. Do not think "direct light" as lighting from a directional light source, it means the first-bounce lighting for any surface point, and the surface point can be the N-th one in a path
CTIndirectLightEstimator	Estimate indirect lighting for a surface point
CTMIS	Static helper for Multiple Importance Sampling (MIS). See the paper by Veach et al. [17] for more theoretical background
►Nmath	Math functions and utilities
►Ndetail
►Nbvh
CTFloatN
►Nshuffle
CStandardSwapper
CPcg64UInt128
CTCIEXYZCmfKernel
CTColorSpaceDummy
CTSmitsSPDBasis
CBvhParams
CColorError	Error on the color-related functionalities
CDefaultSpectralSampleProps
CDeterministicSeeder	Convenient thread-safe seed provider for RNGs. Do not use this for cryptography
CDynamicLinearTranslation
CIndexedKdtreeParams
CMathException	General exception thrown on error related to math functionalities
CMurmur3BitMixer32
CPcg32	PCG-32 generator. This is the pcg32 generator in O'Neill's original pcg-cpp implementation. References: [1] https://dotat.at/@/2023-06-21-pcg64-dxsm.html [2] https://github.com/imneme/pcg-c-basic [3] https://github.com/wjakob/pcg32
CPcg64DXSM	PCG-64 DXSM generator. This is the pcg_engines::cm_setseq_dxsm_128_64 generator in O'Neill's original pcg-cpp implementation. References: [1] https://dotat.at/@/2023-06-21-pcg64-dxsm.html [2] NumPy source code (numpy/numpy/random/src/pcg64/*), version: 308b348bb595bc1b86f9e4bc08be2e3ba5d4f18f
CRandom	Get random values from default RNG
CReal
CRigidTransform
CStaticAffineTransform
CStaticRigidTransform
CTAABB2D	A 2-D Axis-Aligned Bounding Box (AABB)
CTAABB3D	A 3-D Axis-Aligned Bounding Box (AABB)
CTAnalyticalIntegrator1D
CTArithmeticArray
CTArithmeticArrayBase
CTBasicTriangle	Basic 3-D triangle functionalities
CTBinaryBvhNode
CTBlackmanHarris2D	Blackman-Harris window function. A window function similar to Gaussian function in shape. It is defined over \( \left[-radius, radius\right] \) and will take on value 0 at boundaries. The peak of the function is at \( (0, 0) \)
CTBvhBuilder
CTBvhInfoNode	General BVH node packed with additional information. This node type is typically used for building other types of BVH or for algorithmic analysis
CTBvhItemInfo
CTBvhSimdComputingContext	A SIMD computing context for BVH. Use isSupported() to check the availability of the required hardware feature
CTChromaticAdaptationDefinition	Sinkhole for undefined chromatic adaptation routines. Specialize the class to provide definitions for the specified adaptation configuration. Must satisfy CChromaticAdaptationDefinition
CTChromaticAdaptationDefinition< EChromaticAdaptation::Bradford, T >
CTChromaticAdaptationDefinition< EChromaticAdaptation::VonKries, T >
CTChromaticAdaptationDefinition< EChromaticAdaptation::XYZScaling, T >	Adapts by simply scale by the corresponding white points–identity CAT matrices are used
CTChromaticAdaptationDefinitionHelper
CTColorSpaceDefinition	Sinkhole for color spaces without definition. Specialize this class to provide definitions for color space. Must satisfy CTristimulusColorSpaceDefinition or CSpectralColorSpaceDefinition
CTColorSpaceDefinition< EColorSpace::ACEScg, T >
CTColorSpaceDefinition< EColorSpace::CIE_xyY, T >
CTColorSpaceDefinition< EColorSpace::CIE_XYZ, T >
CTColorSpaceDefinition< EColorSpace::Linear_sRGB, T >	Linear sRGB color space definitions
CTColorSpaceDefinition< EColorSpace::Spectral_Smits, T >
CTColorSpaceDefinition< EColorSpace::sRGB, T >
CTColorSpaceDefinitionHelper
CTConstant2D
CTDecomposedTransform	Perform affine transformations in decomposed form
CTDisk	A 2-D disk with normal facing up (0, 1, 0)
CTFraction
CTGaussian2D
CTHeavisideStep2D	A step function in 2-D, with a specific normal direction. This is a simplified version of general Heaviside step function in 2-D. This class represents 1-D Heaviside in 2-D, dividing the xy-plane into regions of value 0 & 1 (while a general Heaviside step function in 2-D can have the discontinuity along an arbitarary 2-D contour, this class does not support that). Value along the line of discontinuity is 0.5 (for integer types, this would be 0)
CTHemisphere	A hemisphere in 3-D space
CTIndexedItemEndpoint
CTIndexedKdtree
CTIndexedKdtreeNode	An indexed kD-tree node with compacted memory layout
►CTIndexedPointKdtree
CBuildCache
CTIndexedVector3
CTLinearDepthFirstBinaryBvh
CTLinearDepthFirstWideBvh
CTLinearGradient2D	A linearly increasing/decreasing gradient in a specific direction. Value at (0, 0) is 0
CTLineSegment	Represents a line segment in space
CTMathFunction2D
CTMatrix2	Represents a 2x2 matrix
CTMatrix3	Represents a 3x3 matrix
CTMatrix4	Represents a 4x4 matrix
CTMatrixMxNBase	A base for general M by N row-major matrices
CTMatrixNBase	A base for general N dimensional row-major square matrices
CTMitchellNetravaliCubic2D	Mitchell–Netravali filter function [13]
CTMt19937	Standard Mersenne Twister generator
CTOrthonormalBasis3	Represents a set of orthonormal basis vectors in 3-D space
CTPiecewiseLinear1D
CTPwcDistribution1D	A 1-D piecewise constant distribution of floating-point type T. The sample weights can be seen as a histogram, and samples are drawn according to each column's relative heights. Each generated sample is guaranteed to have a non-zero PDF
CTPwcDistribution2D
CTQuaternion	Represents a quaternion
CTransform
CTSampledSpectrum
CTSpectralColorSpaceDefinitionHelper
CTSpectrumBase	Base for spectrum implementations
CTSphere	A sphere in 3-D space
CTTriangle
CTTristimulusColorSpaceDefinitionHelper
CTTristimulusSpectrum
CTUniformRandomBitGenerator
CTUrbg32x2	Combining two 32-bit RNGs to form a new 64-bit RNG. If any of the input RNG is not a 32-bit type, this generator will treat it as a 32-bit RNG (e.g., by converting its generated bits to 32-bit)
CTVector2	Represents a 2-D vector
CTVector3	Represents a 3-D vector
CTVector4	Represents a 4-D vector
CTVectorN
CTVectorNBase
CTWatertightTriangle
CTWideBvhNode
►Npixel_buffer
CTPixel	Represent a pixel from pixel buffer
►Ntexfunc
CTAbsolute
CTAdd
CTClamp
CTDefaultConversion	Constructs output value from input value
CTDivide
CTMultiply
CTPower
CTScalarToSpectrum	Converts a scalar value to spectrum
CTSubtract
CTUnaryFromBinary	Uses binary operator as a unary one by treating the second input as constant
CTUnaryFromTernary	Uses ternary operator as a unary one by treating the second and third inputs as constants
CAAreaLight
CAbradedOpaque
CAbradedSurface
CAbradedTranslucent
CActor
CActorCookException	General exception thrown on cook error for actors
CAdaptiveSamplingRenderer
CADome	An actor that models the sky of the scene. Model the sky in latitude-longitude format. Effectively a large energy emitting source encompassing the whole scene
CAGeometricLight
CAIesAttenuatedLight
CAImageDome	Model the sky of the scene with an image. Using a background image to represent the energy emitted from far away
CALight
CAMaskedModel
CAModel
CAModelLight
CAnisoTrowbridgeReitz
CAPhantomModel
CApiDatabase
CApiHelper
CAPointLight
CAPreethamDome	Model the sky of the scene with an image
CARectangleLight
CASphereLight
CATransformedInstance
CAttributeRenderer
CAttributeTags
CBfConstant
CBinaryFileInputStream
CBinaryFileOutputStream
CBinaryFileReader
CBinaryMixedImage
CBinaryMixedSurfaceMaterial
CBlackBodyRadiationImage
CBlockFunction
CBNEEPTEstimator
CBruteForceIntersector
CBsdfEvalInput	Input for BsdfEvalQuery
CBsdfEvalOutput	Output for BsdfEvalQuery
CBsdfEvalQuery	Information for obtaining a sample value from BSDF
CBsdfHelper
CBsdfPdfInput	Input for BsdfPdfQuery
CBsdfPdfOutput	Output for BsdfPdfQuery
CBsdfPdfQuery	Information for the probability of generating a specific BSDF sample
CBsdfQueryContext	The environment a BSDF query is performed under
CBsdfSampleInput	Input for BsdfSampleQuery
CBsdfSampleOutput	Output for BsdfSampleQuery
CBsdfSampleQuery	Information for generating a BSDF sample
CBVPTDLEstimator	A direct lighting only estimator using path tracing
CBVPTEstimator	A GI estimator using pure path tracing
CByteBuffer	An auto-resizable byte storage
CByteBufferInputStream	An in-memory byte stream designed for I/O performance
CCheckerboardImage
CConductiveInterfaceInfo	Data describing the effects when light hits an conductive interface
CConductorFresnel	Conductor-dielectric interface Fresnel effect
CConstantImage
CConstantVelocityMotion
CCookedDataStorage
CCookedGeometry
CCookedMotion
CCookedNamedResource
CCookedResourceCollection	Provides thread-safe cooked data creation and storage. All methods are thread-safe to call, however manipulating the created data is not thread-safe unless stated explicitly
CCookedResourceCollectionBase	Provides thread-safe cooked data creation and storage. All methods are thread-safe to call, however manipulating the created data is not thread-safe unless stated explicitly
CCookException	General exception thrown on cook error
CCookingConfig
CCookingContext	Information about the world being cooked
CCookOrder	Controls the order actors are cooked
CCoreCookedUnit
CCoreCookingContext
CCoreResource
CCoreSdlResource	Core SDL resource abstraction. This class does not provide static/dynamic category information. The work is left for derived classes. See SdlResourceBase for more implementation requirements
CCsvFile
CCsvFileRow
►CDammertzDispatcher
CTAnalyzer
CDielectricFresnel	Dielectric-dielectric interface Fresnel effect
CDielectricInterfaceInfo	Data describing the effects when light hits an dielectric interface
CDiffuseSurfaceEmitter	Diffusive surface emitter
CDiffuseSurfaceEmitterBase	Base for diffusive surface emitters
CDirectEnergyPdfInput	Input for DirectEnergyPdfQuery
CDirectEnergyPdfOutput	Output for DirectEnergyPdfQuery
CDirectEnergyPdfQuery	Information for the probability of generating a specific sample for direct energy estimation
CDirectEnergySampleInput	Input for DirectEnergySampleQuery
CDirectEnergySampleOutput	Output for DirectEnergySampleQuery
CDirectEnergySampleQuery	Information for generating a sample for direct energy estimation
CDomeRadianceFunctionInfo
CEmbeddedPrimitiveMetaGetter
CEmitFunction
CEmitter	An electromagnetic energy emitting source. The emitted energy can be captured by a Receiver
CEmitterSampler
CEnergyEmissionSampleInput	Input for EnergyEmissionSampleQuery
CEnergyEmissionSampleOutput	Output for EnergyEmissionSampleQuery
CEnergyEmissionSampleQuery	Information for generating a sample for energy emission
CEngine	The render engine
CEngineInitSettings	Options for initializing core engine. These settings are loaded on engine startup and remains constant till engine exit. Changing the settings will require an engine restart to see the effect
CEqualSamplingRenderer
CESPowerFavoring
CESUniformRandom
CExactConductorFresnel	Conductor-dielectric interface Fresnel effect
CExactDielectricFresnel	Dielectric-dielectric interface Fresnel effect
CExrFileReader
CExrFileWriter
CFilesystem	Filesystem operations for the native operating system
CFilm	A camera film that receives any quantity
CFilteredInputStream
CFixedSizeThreadPool	A thread pool where works are accessed concurrently by blocking other threads. A thread pool that contains fixed number of threads for work processing. It is a blocking pool, i.e., works are enqueued and dequeued concurrently by blocking other threads, in FIFO order. The pool can be used concurrently, namely, it is thread-safe. However, the user must ensure that the pool is properly initialized before subsequent usages
CFormattedTextInputStream	Read text with basic auto formatting applied
CFormattedTextOutputStream	Write text with basic auto formatting applied
CFrameOperator
CFrameProcessingPipeline	Process frames with a series of operations
CFrameProcessor	Manages and executes frame processing pipelines
CFrameVisualizer
CFresnelEffect	Modeling Fresnel effects that occur on interfaces
CFullMaterial
CFullPhoton	This photon type stores all possible photon data without any loss of information. It is unrecommended to use this kind of photon if low memory usage is desired
CFullRay
CFullRayEnergyEstimator
CFullViewpoint	This viewpoint type stores all possible viewpoint data without any loss of information. It is unrecommended to use this kind of viewpoint if low memory usage is desired
CGammaCorrection
CGCuboid
CGEmpty
CGeometry
CGeometrySoup
CGIndexedTriangleMesh
CGMengerSponge
CGPlyPolygonMesh	Mesh stored as a .ply file
CGradientImage
CGRectangle
CGridScheduler
CGroupedDiffuseSurfaceEmitter	Diffusive surface emitter comprised of multiple surface fragments. All surface fragments use the same energy texture
CGSphere
CGTriangle
CGTriangleMesh	Basic triangle mesh
CGWave
CHaltonSampleSource
CHdrOperator
CHdrRgbFilm	A film that records RGB values internally. Although film samples are added as spectral values, they are automatically converted to linear sRGB values for storage
CHdrRgbTexture2D
CHenyeyGreenstein
CHitDetail	Detailed information regarding a ray-primitive intersection
CHitInfo	General information for a ray-primitive intersection
CHitProbe	Lightweight ray intersection testing and reporting object. If an intersection is found, a detailed report can be obtained from the stored information
CIDataStream
CIdealAbsorber
CIdealDielectric
CIdealDielectricTransmitter
CIdealReflector
CIdealSubstance
CIesData
CIesFile
CIInputStream
CImage
CIMoveOnly	Marks the derived class as move only
CIndexedTriangle
CIndexedTriMesh
CIndexedUIntBuffer	A general unsigned integer buffer for integers with any number of bits
►CIndexedVertexBuffer	A general vertex buffer for storing various indexed attributes
CAttributeDeclaration	Info for a declared vertex attribute
CInitiallyPausedThread
CINoCopyAndMove	Marks the derived class as non-copyable and non-movable
CIntegrand
CInterfaceStatistics
CIntersectable	An object in the scene that a ray can intersect with
CIntersector
CIntersectorCommonParams	Common parameters of intersector
CIOutputStream
CIRayEnergyEstimator
CIReceivedRayProcessor
CIResourceIdentifierResolver
CIsBuildable	Check if object conversion can be made
CIsBuildable< Built, From, std::enable_if_t< std::is_convertible_v< From, Built >||std::is_constructible_v< Built, From > > >	Return type if the result is true
CISdlDataPacketGroup	View for a group of named data packets
CISdlInstantiable
CISdlReferenceGroup	View for a group of SDL references
CISdlResource	Interface for all SDL resource
CIsoBeckmann	Isotropic Beckmann distribution. See the paper "Microfacet Models for Refraction through Rough Surfaces" by Walter et al. [18]
CIsoTrowbridgeReitz	Isotropic Trowbridge-Reitz distribution (GGX)
CIsoTrowbridgeReitzConstant
CIsoTrowbridgeReitzTextured
CIUninstantiable	Marks the derived class as uninstantiable
CIWorkDispatcher	A manager that distributes work
CJRToneMapping	Maps HDR values to LDR
CKdtreeAABB
CKdtreeIntersector
CKdtreeNode
CLambertianReflector	Lambertian diffuse model for an opaque surface. This model is double-sided
CLatLongEnvEmitter	Models energy coming from background
CLayeredSurface
CLbLayer
CLbLayeredSurface	Laurent Belcour's layered BSDF model. This is the symmetric model as described in Section 6.2 of the paper [1]. Laurent Belcour's project page: https://belcour.github.io/blog/research/2018/05/05/brdf-realtime-layered.html
CLdrRgbTexture2D
CLerpedSurfaceOptics	Linearly interpolate between two surface optics
CMaskedIntersectable	Carve out some part of an intersectable. This is a masking approach based on intersection routine. Another common approach to shape masking is BSDF-based, where the mask determines whether the incoming light simply passes through (a no-op, perfectly transmitting BSDF). There is a trade-off between these approaches: masking in intersection routine samples the mask texture (usually a slower operation) in the tight loop of acceleration structure traversal, while masking in BSDF will need to re-enter the acceleration structure multiple times (such as when rendering a forest) which can also be slow
CMaterial
CMathImage
CMatteOpaque
CMemoryArena	A general purpose bump allocator
CMetaRecordingProcessor
CMicrofacet
CMicrosurfaceInfo
Cmipmapgen
CModelParser
CMotionCookConfig
CMotionSource
CNaiveReinhardToneMapping
CObject
CObserver
COmniModulatedEmitter
COpaqueMicrofacet	Microfacet based opaque surface model. Microfacet optical behavior modeled using Cook-Torrance BRDF [4]. This model is double-sided
COption
COrenNayar
COrientedRasterObserver
CPartialRayEnergyEstimator
CPath	General path representation. Does not check whether the target actually exists (e.g., on a filesystem). To check target existence, use Filesystem
CPathTracingVisualizer
CPBasicSphere
CPEmpty
CPeriodicSingleThreadExecutor	A single-thread executor that runs specified works periodically. The executor can be used concurrently, namely, it is thread-safe. However, the user must ensure that the pool is properly initialized before subsequent usages
CPfmFile	Writer for Portable FloatMap image format
CPhotonMappingVisualizer
►CPhysicalActor
CSdlRotate
CSdlScale
CSdlTranslate
CPictureData
CPictureMeta
CPinholeCamera
CPixelBuffer2D
CPlateScheduler
CPLatLong01Sphere
CPLatLongEnvSphere	A sphere specifically built for environment lighting. This primitive is for environment map with latitude-longitude format. Unlike regular primitives, transformations are done locally rather than wrapping the primitive by another to allow a wider set of custom operations. Note that the UV for the environment sphere is based on the direction of incident ray
CPlyElement	PLY element storage
CPlyFile
CPlyIOConfig
CPlyProperty	PLY property storage
CPlyPropertyListValues	A convenient PLY list property accessor
CPlyPropertyValues	A convenient PLY property accessor
CPMAtomicStatistics	Thread safe statictics tracking utilities
CPMCommonParams	Common parameters of photon mapping
CPMRendererBase
CPreCookReport
CPreCookResourceCollectionProxy
CPreethamTexture
CPrimitive	A physical shape in the scene
CPrimitiveBuildingMaterial
CPrimitiveChannel
CPrimitiveMetadata	Collection of attached components to a primitive. This type effectively "glues" various components that helps to describe additional properties related to a primitive
CPrimitivePosPdfInput	Input for PrimitivePosPdfOutput
CPrimitivePosPdfOutput	Output for PrimitivePosPdfOutput
CPrimitivePosPdfQuery	Information for the probability of generating a specific sample point on a primitive
CPrimitivePosSampleInput	Input for PrimitivePosSampleQuery
CPrimitivePosSampleOutput	Output for PrimitivePosSampleQuery
CPrimitivePosSampleQuery	Information for generating a sample point on a primitive
CProbabilisticProgressivePMRenderer
CProgressivePMRenderer
CPTriangle	A single triangle. This triangle type is for constructing simple shapes such as a quad or box. For more complex shapes, it is better to use a more space efficient primitive type for them
CRadianceSensor
CRasterFileImage
CRasterImageBase
CRawResourceCollection
CRay	Represents a ray in space
CRayDifferential
CReceiver	A target that can receive any physical quantity, typically electromagnetic energy. The received energy is originated from some Emitters
CReceiverSamplingWork
CRectangularSensorReceiver	A receiver with a rectangular sensor installed
CReferencedPrimitiveMetaGetter
CRegularPicture	Raw representation of common picture types
CRegularPictureFormat	Format of common pictures. Typically closely related to how the picture is stored natively (e.g., on disk)
CRenderer
CRendererProxy
CRenderObservationInfo	Meta information for data related to ongoing render operation
CRenderProgress
CRenderRegionStatus
CRenderSession
CRenderStats
CRenderWork
CRenderWorker
CResourceIdentifier	An general identifier that points to some resource. This is the most general form of a resource identifier, typically refers to as Photon Resource Identifier (PRI) thoughout the engine
CRoughnessToAlphaMapping	Maps roughness value in [0, 1] to the alpha parameter in NDF
CRuntimeSampleSource
CSample
CSampleContext
CSampleFilter	An image reconstruction kernel
CSampleFlow	A sample with arbitrary dimensions with fine-grained sampling control
CSampleGenerator	Generates samples in [0, 1]. Generators of different types produces samples with different properties. Depending on the implementation, the samples can be fully random, quasi random, or even fully deterministic. Sample generators in Photon have their life cycles. Life cycle begins when the sample generator start producing sample batches, and ends when all sample batches are exhausted
CSampleLocation
CSamplesND
CSamplesNDHandle
CSamplesNDStream
CSampleSource
CSampleStage
CSampleStageReviser
CSamplingFilmDimensions
CSamplingRenderer
CSamplingStatistics
CScatterFunction
CScene	A unified interface for accessing cooked content in a visual world
CSceneDescription	Data that describe a scene. Represents the result of running SDL commands
CSchlickApproxConductorFresnel	Conductor-dielectric interface Fresnel effect
CSchlickApproxDielectricFresnel	Dielectric-dielectric interface Fresnel effect
CSdlClass
CSdlCommandGenerator
CSdlCommandParser
CSdlDataPacketCollection
CSdlDataPacketInterface	Parsing & generating a group of SDL clauses
CSdlDependencyResolver	Resolves dependency between SDL resources and provides a valid initialization order. Optionally provide resource name lookup (if user provides resource name during analyzation)
►CSdlEnum	Describes enum in SDL
CTEntry
CSdlException	General exception thrown on error related to SDL
CSdlField
CSdlFunction
CSdlInlinePacketInterface	Supports the case where the packet command stores SDL clauses directly
CSdlInputClause	Carries SDL representation of various data during the input process. Helps to read input data such as command clauses or data packets
CSdlInputClauses	Container for input clauses
CSdlInputContext	Data that SDL input process can rely on
CSdlIOContext	Data that SDL input/output process can rely on
CSdlLoadError	Error on the SDL input process
CSdlNamedOutputClauses
CSdlNativeData
CSdlOutputClause	Carries SDL representation of various data during the output process. Helps to write output data such as command clauses or data packets
CSdlOutputClauses
CSdlOutputContext	Data that SDL output process can rely on
CSdlResourceBase	A convenient ISdlResource with some core requirements implemented. This class does not provide static/dynamic category information. The work is left for derived classes. See ISdlResource for more implementation requirements
CSdlResourceLocator
CSdlSaveError	Error on the SDL output process
CSdlSceneFileReader	Loading utility for renderer scene. Loads .p2 (Photon-v2) file
CSdlSceneFileWriter	Saving utility for renderer scene. Writes .p2 (Photon-v2) file
CSdlStruct
CSdlStructFieldStump
CSemanticVersion	Convenient software version handling routines. See https://semver.org/ for a detailed explaination of the concept
CSGHalton
CSGStratified
CSGUniformRandom
CSGUtil
CShapeInvariantMicrofacet
CSingleFrameRenderSession
CSingleLensObserver
CSphericalMapper
CSpiralGridScheduler
CSpiralScheduler
►CStatistics
CRecord
CStdInputStream
CStdOutputStream
CStochasticProgressivePMRenderer
CStratifiedSampleSource
CStripeScheduler
CSurfaceAttributeEstimator
CSurfaceBehavior
CSurfaceEmitter
CSurfaceHit	General information about a ray-surface intersection event
CSurfaceLayerInfo
CSurfaceMaterial
CSurfaceOptics	Describes how light interacts with a surface
CSwizzledImage	An image whose primary purpose is to swizzle the output of a source image
CTableFGD
CTableTIR
CTAbstractPixelTex2D
CTAnyPtr	A type-safe, lightweight wrapper for any raw pointer type. Using std::any with a raw pointer type could achieve similar functionality. However, this class is dedicated for raw pointers and is guaranteed to have no dynamic allocation
CTAosTriMesh
CTArrayHeap	A fixed size heap backed by an array. The container inherits the properties of a fixed size array of type T. The container keeps all N elements alive until its lifetime ends, even if elements are popped/removed from the stack. It is guaranteed that no dynamic memory allocation takes place
CTArrayStack	A fixed size stack backed by an array. The container inherits the properties of a fixed size array of type T. The container keeps all N elements alive until its lifetime ends, even if elements are popped/removed from the stack. It is guaranteed that no dynamic memory allocation takes place
CTArrayVector	A fixed size vector backed by an array. The container inherits the properties of a fixed size array of type T. The container keeps all N elements alive until its lifetime ends, even if elements are popped/removed from the vector. It is guaranteed that no dynamic memory allocation takes place
CTAtomicQuasiQueue	A multi-producer, multi-consumer, lock-free concurrent queue-like structure. For single-thread uses, it is a FIFO queue. For multi-thread uses, it is mostly a FIFO queue. Specifically, items put in by a given producer will all come out in the same order (FIFO). But there is no coordination between items from other producers–two items put in by two different producers will come out in an undefined order relative to each other (the interleaving between different streams of items from different producers is undefined, even with external synchronization). It is possible some items will starve in the queue if more items are enqueued than dequeued. Guarantees aquire-release semantics for items that are enqueued/dequeued
CTBilinearPixelTex2D
CTBinaryBvhIntersector	Classic binary BVH acceleration structure
CTBinaryTextureOperator
CTBitFlags	Manipulate a value type where each bit is a binary flag
CTBlockableAtomicQuasiQueue	Blockable version of the TAtomicQuasiQueue. For single-thread uses, it is a FIFO queue. For multi-thread uses, it is mostly a FIFO queue. Specifically, items put in by a given producer will all come out in the same order (FIFO). But there is no coordination between items from other producers–two items put in by two different producers will come out in an undefined order relative to each other (the interleaving between different streams of items from different producers is undefined, even with external synchronization). It is possible some items will starve in the queue if more items are enqueued than dequeued. Guarantees aquire-release semantics for items that are enqueued/dequeued
CTCheckerboardTexture	Texture representing checker patterns
CTColorPixelTexture2D
CTConstantSpectralTexture	A constant color texture that can adapt spectral values to spectrum. Converts spectral values to spectrum based on parameters obtained during rendering
CTConstantTexture	Texture storing one single constant of arbitrary type. This texture provides only a constant value. Input color usages are ignored. For color-related constants, consider using TConstantTristimulusTexture or TConstantSpectralTexture; otherwise, it is recommended to bake color-related side effects (e.g., color usages) into the constant
CTConstantTristimulusTexture	A constant color texture that can adapt values in tristimulus color space to spectrum. Converts tristimulus values to spectrum based on parameters obtained during rendering
CTConstIteratorProxy
CTEmbeddedPrimitiveGetter
CTEstimationArray
CTestPoint
CTextFileLoader
CTextureLoader
CTFixedMapBase
CTFixedMapEntry
CTFrame
CTFrameBuffer2D
CThinDielectricFilm
CThinDielectricShell
CThinDielectricSurface
CThinFilm
CThinLensCamera
CTileScheduler
CTime
CTimer	A timer. Measures relative time (not wall clock)
CTIndexedKdtreeIntersector
CTIndexedPolygonBuffer
CTIRayEstimator
CTIteratorProxy
CTLinearGradientTexture
CTMergeableFilmProxy
CTMetaInjectionPrimitive
CTMipmap
CTMRSWResource	A resource wrapper that facilitates Multiple-Readers Single-Writer (MRSW) usages
CTNearestPixelTex2D
CTNonTypeTemplateArgDummy
CTNumericPixelTexture2D
CTokenizer
CToneMapper
CTPhoton
►CTPhotonMap	Default photon map type. Should be adequate for most cases
CPhotonCenterCalculator
CTPhotonMapInfo	Carries common informatiom for a photon map
CTPhotonPathTracingWork
CTPIndexedKdTreeTriangleMesh
CTPixelTex2D
CTPixelTexture2D
CTPPMRadianceEvaluationWork
CTPPMViewpointCollector
CTransformedIntersectable	Applies general transformation to an intersectable
CTransformedPrimitive	Applies rigid transformation to a primitive. A transformed primitive accepts only rigid transformations. This way, properties such as surface area and volume are guaranteed to be the same during transformations
CTransformInfo
CTransientResourceCache	Provides thread-safe cooked data creation and storage. Similar to TransientVisualElement, this cache will be cleared before rendering starts. All methods are thread-safe to call, however manipulating the created data is not thread-safe unless stated explicitly
CTransientVisualElement	A group of cooked data that represent the visible part of the scene at a specific time. This data block do not persist throughout the rendering process. After cooking is done, all cooked data should be properly interlinked and TransientVisualElement will be cleaned up
CTranslucentMicrofacet	Microfacet based translucent surface model. Microfacet optical behavior modeled using the dielectric variant [18] of the Cook-Torrance BRDF [4]. This model is double-sided
CTReceiverMeasurementEstimator
CTReferencedPrimitiveGetter
CTRelaxedAtomic	Wrapper for relaxed atomic read and write. May resort to lock based read/write if atomic read/write for type T is not supported
CTriFace
CTrowbridgeReitz	Trowbridge-Reitz distribution (GGX). See the original paper by Trowbridge et al. [16]. The paper "Microfacet Models for Refraction through Rough Surfaces" by Walter et al. [18] provides a nice explanation, too
CTSampler	Common settings and operations for sampling a texture
CTSamplingFilm	A camera film that receives any quantity, for sampling-based rendering techniques
CTScalarPixelTexture2D
CTSdl
CTSdl< T >	TSdl specialization that accepts static type (T)
CTSdl< void >	TSdl specialization that accepts dynamic type (SdlClass)
CTSdlAbstractValue	General concept of a SDL value type
CTSdlAccessorVariant
CTSdlAnyInstance	References a SDL object. This is a lightweight utility for referencing SDL objects. Following objects are valid targets to be referenced by this type:
CTSdlBool	A field class that binds a bool member variable
CTSdlBruteForceFieldSet	A set of fields, with basic functionalities
CTSdlEnum	A helper for accessing SDL enum properties
CTSdlEnumField
CTSdlGeneralEnum	SDL enum implementation with common features. Enum value and string mapping are done in a brute-force way. This SDL enum type supports enum entries with identical value or name, which is useful for giving the user more tolerance on specifying inputs (e.g., case inconsistency). See getTypedEntry() for more details
CTSdlInteger	A field class that binds a integral member variable
CTSdlMethod	SDL binding type for a canonical SDL method
CTSdlNestedField	A field that lives within an inner object
CTSdlOptionalValue	Abstractions for a SDL value type that can be empty
CTSdlOwnedField	Abstraction for a value that is owned by some owner type. Governs how a field should be initialized on the policy level
CTSdlOwnerClass	SDL binding type for a canonical SDL resource class
CTSdlOwnerStruct	SDL binding type for a typical C++ struct
CTSdlPath	A field class that binds a Path member variable
CTSdlQuaternion
CTSdlReal	A field class that binds a floating point member variable
CTSdlRealArray
CTSdlReference	A value that points to a SDL resource
CTSdlReferenceArray	A value that points to an array of SDL resources
CTSdlResourceBase	A convenient ISdlResource with core requirements implemented. This class is similar to SdlResourceBase, except that it provides a way for derived classes to supply static category information. Dynamic category is directly obtained from it
CTSdlResourceIdentifier	A field class that binds a resource identifier member. Though the member type that is binded by default can handle any types of identifier (the ResourceIdentifier class, which represents a PRI), this class treat it as a SDL Resource Identifier (SRI) which has a more specific form. On some circumstances it may be desirable to accept any identifier, and this can be achieved by specifying IS_SRI=false
CTSdlSpectrum
CTSdlString
CTSdlStructArray
CTSdlValue	Abstractions for a SDL value type
CTSdlVector2
CTSdlVector3
CTSdlVector3Array
CTSdlVector4
CTSortedMap	A sorted container that offers fast value lookup & iteration, while modifications are slow. The container has continuous memory allocation. The values are stored in ascending order according to their keys
CTSortedVector	A sorted container that offers fast value lookup & iteration, while modifications are slow. The container has continuous memory allocation. The values are stored in ascending order
CTSPPMRadianceEvaluator
CTSPSCExecutor	A single-producer, single-consumer worker thread. Ctor and dtor are not thread safe. Most of the methods are either producer thread only, or thread-safe. start() must be called before adding work since it also serves as a mean to determine the producer thread. Setters for function callbacks can only be called before start(). Note that if work processor is not set from ctor, setWorkProcessor() must be called with a valid processor function
►CTSPSCRingBuffer
CConsumerGuard
CProducerGuard
CTStableIndexDenseVector	A container offering stable index and efficient iteration
CTStackSentinel
CTStepperReceiverMeasurementEstimator
CTSwizzledTexture	Swizzle an array-like input type to the other array-like output type. Output type OutputT can have any number of elements (no need to be the same as input type InputT). For any elements in OutputT that is not part of the swizzle, the value will be as if the element is zero-initialized (or default-initialized depending on the actual type)
CTTernaryTextureOperator
CTTexture
CTTrilinearPixelTex2D
CTUnaryTextureOperator
CTUniquePtrVector
CTViewPathHandler	Process and control a view path tracing process. Derived classes need to implement all methods with "impl_" prefixed names and with the exact signature
CTViewPathTracingWork
CTViewpoint
CTVPMRadianceEvaluator
CTWideBvhIntersector	Wide BVH acceleration structure supporting arbitrary branch factor
CUniformRandomSampleSource
CUvwMapper
CVAbsorptionOnly
CVanillaPMRenderer
CVector3Film	A film that records 3-D vectors
CViewPathTracingPolicy	Specifying and querying policies for tracing view path
CViewport
CVisualizer
CVisualWorld	A virtual world for image synthesis
CVoHomoAbsorption
CVolumeBehavior
►CVolumeDistanceSample
CInput
COutput
CVolumeMaterial
CVolumeOptics
►CWorkflow
CWorkHandle	Lightweight handle for an added work
CWorkScheduler	A manager that distributes a fixed amount of work to workers
CWorkUnit	Represents some amount of work
►Nstd
Chash< ph::math::TAABB2D< T > >
Chash< ph::math::TVector2< T > >