|
Photon Engine 2.0.0-beta
A physically based renderer.
|
| ►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 > > |
1.11.0 
