Classic Monte Carlo Pathtracing algorithm for real global illumination. More...

#include <SLPathtracer.h>

Inheritance diagram for SLPathtracer:

Public Member Functions
	SLPathtracer ()

	~SLPathtracer ()

SLbool	render (SLSceneView *sv)

void	renderSlices (bool isMainThread, SLint currentSample, SLuint threadNum)

SLCol4f	trace (SLRay *ray, SLfloat bsdfPdf)
	Traces one ray. bsdfPdf is the solid angle density with which the. More...

SLCol4f	shade (SLRay ray, SLCol4f mat)

void	saveImage ()
	Saves the current PT image as PNG image. More...

void	computeNoise ()

void	calcDirect (SLbool di)

void	calcIndirect (SLbool ii)

void	sampleClamp (SLfloat max)

SLbool	calcDirect () const

SLbool	calcIndirect () const

SLfloat	sampleClamp () const

SLfloat	noiseRSE () const
	Mean relative standard error of the pixels of the last render. More...

SLfloat	noiseRSE999 () const
	Relative standard error of the noisiest 0.1% of the pixels. More...

SLfloat	efficiency () const
	Monte Carlo efficiency, the inverse of variance times time. More...

Public Member Functions inherited from SLRaytracer
	SLRaytracer ()

	~SLRaytracer () override

SLbool	renderClassic (SLSceneView *sv)

SLbool	renderDistrib (SLSceneView *sv)

void	renderSlices (bool isMainThread, SLuint threadNum)

void	renderSlicesMS (bool isMainThread, SLuint threadNum)

SLCol4f	trace (SLRay *ray)

SLCol4f	shade (SLRay *ray)

void	sampleAAPixels (bool isMainThread, SLuint threadNum)

void	renderUIBeforeUpdate ()
	Must be called before an inbetween frame updateRec. More...

void	setPrimaryRay (SLfloat x, SLfloat y, SLRay *primaryRay)
	Set the parameters of a primary ray for a pixel position at x, y. More...

void	getAAPixels ()

SLCol4f	fogBlend (SLfloat z, SLCol4f color)

virtual void	printStats (SLfloat sec)

virtual void	initStats (SLint depth)

void	state (SLRTState state)

void	maxDepth (SLint depth)

void	resolutionFactor (SLfloat rf)

void	doDistributed (SLbool distrib)

void	doContinuous (SLbool cont)

void	doFresnel (SLbool fresnel)

void	aaSamples (SLint samples)

void	gamma (SLfloat g)

SLRTState	state () const

SLint	maxDepth () const

SLbool	doDistributed () const

SLbool	doContinuous () const

SLbool	doFresnel () const

SLint	aaSamples () const

SLint	progressPC () const

SLfloat	aaThreshold () const

SLfloat	renderSec () const

SLfloat	gamma () const

SLfloat	oneOverGamma () const

SLfloat	resolutionFactor () const

SLint	resolutionFactorPC () const

SLfloat	raysPerMS ()
	Rays per ms of the last completed render, for comparing machines. More...

virtual void	prepareImage ()

virtual void	renderImage (bool updateTextureGL)

Public Member Functions inherited from SLGLTexture
	SLGLTexture ()
	Default ctor for all stack instances (not created with new) More...

	SLGLTexture (SLAssetManager *assetMgr, const SLVCol4f &colors, SLint min_filter=GL_LINEAR, SLint mag_filter=GL_LINEAR, SLint wrapS=GL_REPEAT, const SLstring &name="2D-Texture")
	ctor for 1D texture with internal image allocation More...

	SLGLTexture (SLAssetManager *assetMgr, SLint min_filter, SLint mag_filter, SLint wrapS, SLint wrapT, SLenum target=GL_TEXTURE_2D)
	ctor for empty 2D textures More...

	SLGLTexture (SLAssetManager assetMgr, unsigned char data, int width, int height, int cvtype, SLint min_filter, SLint mag_filter, SLTextureType type, SLint wrapS, SLint wrapT)
	ctor for 2D textures from byte pointer More...

	SLGLTexture (SLAssetManager *assetMgr, const SLstring &imageFilename, SLint min_filter=GL_LINEAR_MIPMAP_LINEAR, SLint mag_filter=GL_LINEAR, SLTextureType type=TT_unknown, SLint wrapS=GL_REPEAT, SLint wrapT=GL_REPEAT)
	ctor for 2D textures with internal image allocation More...

	SLGLTexture (SLAssetManager *assetMgr, const SLVstring &imageFilenames, SLint min_filter=GL_LINEAR, SLint mag_filter=GL_LINEAR, SLint wrapS=GL_REPEAT, SLint wrapT=GL_REPEAT, const SLstring &name="3D-Texture", SLbool loadGrayscaleIntoAlpha=false)
	ctor for 3D texture with internal image allocation More...

	SLGLTexture (SLAssetManager *assetMgr, SLint depth, const SLstring &imageFilename, SLint min_filter=GL_LINEAR, SLint mag_filter=GL_LINEAR, SLint wrapS=GL_REPEAT, SLint wrapT=GL_REPEAT, const SLstring &name="3D-Texture", SLbool loadGrayscaleIntoAlpha=false)
	ctor for 3D texture from a single file with depth as 3rd dimension More...

	SLGLTexture (SLAssetManager *assetMgr, const SLstring &imageFilenameXPos, const SLstring &imageFilenameXNeg, const SLstring &imageFilenameYPos, const SLstring &imageFilenameYNeg, const SLstring &imageFilenameZPos, const SLstring &imageFilenameZNeg, SLint min_filter=GL_LINEAR, SLint mag_filter=GL_LINEAR, SLTextureType type=TT_unknown)
	ctor for cube mapping with internal image allocation More...

	~SLGLTexture () override

virtual void	build (SLint texUnit)

void	deleteData (SLbool deleteAlsoOnGPU)
	Delete all data (CVImages and GPU textures) More...

void	deleteDataGpu ()
	Deletes the OpenGL texture objects and releases the memory on the GPU. More...

void	deleteImages ()
	Deletes the CVImages in _images. No more texture mapping in ray tracing. More...

void	bindActive (SLuint texUnit=0)

void	fullUpdate ()

void	drawSprite (SLbool doUpdate, SLfloat x, SLfloat y, SLfloat w, SLfloat h)
	Draws the texture as 2D sprite with OpenGL buffers. More...

void	cubeUV2XYZ (SLint index, SLfloat u, SLfloat v, SLfloat &x, SLfloat &y, SLfloat &z)
	Computes the unnormalised vector x,y,z from tex. coords. uv with cubemap index. More...

void	cubeXYZ2UV (SLfloat x, SLfloat y, SLfloat z, SLint &index, SLfloat &u, SLfloat &v)
	Computes the uv and cubemap image index from a unnormalised vector x,y,z. More...

SLstring	filterString (SLint glFilter)
	Returns OpenGL texture filter as string. More...

void	texType (SLTextureType bt)

void	uvIndex (SLbyte i)

void	bumpScale (SLfloat bs)

void	minFiler (SLint minF)

void	magFiler (SLint magF)

void	needsUpdate (SLbool update)

void	textureSize (int width, int height)

void	deleteImageAfterBuild (SLbool delImg)
	If deleteImageAfterBuild is set to true you won't be able to ray trace the scene. More...

SLuint	width ()

SLuint	height ()

SLuint	depth ()

SLbyte	uvIndex ()

SLint	bytesPerPixel ()

SLint	bytesOnGPU ()

SLint	bytesInFile ()

CVVImage &	images ()

SLenum	target () const

SLuint	texID () const

SLTextureType	texType ()

SLfloat	bumpScale () const

SLCol4f	getTexelf (SLfloat u, SLfloat v, SLuint imgIndex=0)
	SLGLTexture::getTexelf returns a pixel color from u & v texture coordinates. More...

SLCol4f	getTexelf (const SLVec3f &cubemapDir)
	SLGLTexture::getTexelf returns a pixel color at the specified cubemap direction. More...

SLbool	hasAlpha ()

SLMat4f	tm ()

SLbool	autoCalcTM3D () const

SLbool	needsUpdate ()

SLstring	typeName ()
	Returns the texture type as string. More...

SLstring	typeShortName ()
	Returns the texture type short. More...

bool	isTexture ()

SLstring	minificationFilterName ()

SLstring	magnificationFilterName ()

void	build2DMipmaps (SLint target, SLuint index)

SLbool	copyVideoImage (SLint camWidth, SLint camHeight, CVPixelFormatGL glFormat, SLuchar *data, SLbool isContinuous, SLbool isTopLeft)
	Copies the image data from a video camera into the current video image. More...

SLbool	copyVideoImage (SLint camWidth, SLint camHeight, CVPixelFormatGL srcFormat, CVPixelFormatGL dstFormat, SLuchar *data, SLbool isContinuous, SLbool isTopLeft)

void	calc3DGradients (SLint sampleRadius, const function< void(int)> &onUpdateProgress=nullptr)

void	smooth3DGradients (SLint smoothRadius, function< void(int)> onUpdateProgress=nullptr)

SLVec2f	dudv (SLfloat u, SLfloat v)

Public Member Functions inherited from SLObject
	SLObject (const SLstring &Name="", const SLstring &url="")

virtual	~SLObject ()

void	name (const SLstring &Name)

void	url (const SLstring &url)

const SLstring &	name () const

const SLstring &	url () const

Private Attributes
function< void(bool, int, SLuint)>	renderSlicesPTAsync

SLbool	_calcDirect
	flag to calculate direct illumination More...

SLbool	_calcIndirect
	flag to calculate indirect illumination More...

SLfloat	_sampleClamp
	Upper limit on the radiance of a single sample, 0 to switch it off. More...

vector< SLCol4f >	_radianceSum
	Linear, unclamped sum of all radiance samples taken so far per pixel. More...

vector< SLdouble >	_lumSum
	Sum and sum of squares of the luminance of every sample, per pixel. More...

vector< SLdouble >	_lumSumSq

SLfloat	_noiseRSE
	mean relative standard error, see noiseRSE() More...

SLfloat	_noiseRSE999
	the same for the worst 0.1%, see noiseRSE999() More...

Additional Inherited Members
Static Public Member Functions inherited from SLRaytracer
static SLuint	numThreads ()

Static Public Member Functions inherited from SLGLTexture
static SLTextureType	detectType (const SLstring &filename)
	Detects the texture type from the filename appendix (See SLTexType def.) More...

static string	internalFormatStr (int internalFormat)
	Returns the internal pixel format from OpenGL. More...

Static Public Attributes inherited from SLGLTexture
static SLfloat	maxAnisotropy = -1.0f
	Returns the derivation as [s,t]. More...

static SLuint	totalNumBytesOnGPU = 0
	Total NO. of bytes used for textures on GPU. More...

Protected Member Functions inherited from SLGLTexture
void	load (const SLstring &filename, SLbool flipVertical=true, SLbool loadGrayscaleIntoAlpha=false)
	Loads the texture, converts color depth & applies vertical mirroring. More...

void	load (const SLVCol4f &colors)
	Loads the 1D color data into an image of height 1. More...

Protected Attributes inherited from SLRaytracer
function< void(bool, SLuint)>	renderSlicesAsync

function< void(bool, SLuint)>	sampleAAPixelsAsync

SLSceneView *	_sv
	Parent sceneview. More...

SLRTState	_state
	RT state;. More...

SLCamera *	_cam
	shortcut to the camera More...

SLfloat	_resolutionFactor
	screen to RT image size factor (default 1.0) More...

SLint	_maxDepth
	Max. allowed recursion depth. More...

SLbool	_doContinuous
	if true state goes into ready again More...

SLbool	_doDistributed
	Flag for parallel distributed RT. More...

SLbool	_doFresnel
	Flag for Fresnel reflection. More...

SLint	_progressPC
	progress in % More...

SLfloat	_renderSec
	Rendering time in seconds. More...

AvgFloat	_raysPerMS
	Rays per ms of the last completed render. More...

SLfloat	_pxSize
	Pixel size. More...

SLVec3f	_eye
	Camera position. More...

SLVec3f	_la

SLVec3f	_lu

SLVec3f	_lr
	Camera lookat, lookup, lookright. More...

SLVec3f	_bl
	Bottom left vector. More...

SLint	_nextLine
	next line index to render RT in a thread More...

SLVPixel	_aaPixels
	Vector for antialiasing pixels. More...

SLfloat	_gamma
	gamma correction value More...

SLfloat	_oneOverGamma
	one over gamma correction value More...

SLfloat	_aaThreshold
	threshold for anti aliasing More...

SLint	_aaSamples
	SQRT of uneven num. of AA samples. More...

Protected Attributes inherited from SLGLTexture
CVVImage	_images
	Vector of CVImage pointers. More...

SLuint	_texID
	OpenGL texture ID. More...

SLTextureType	_texType
	See SLTextureType. More...

SLint	_width
	Texture image width in pixels (images exist either in _images or on the GPU or on both) More...

SLint	_height
	Texture image height in pixels (images exist either in _images or on the GPU or on both) More...

SLint	_depth
	3D Texture image depth (images exist either in _images or on the GPU or on both) More...

SLbyte	_uvIndex
	Texture coordinate index in SLMesh (0 = default) More...

SLint	_internalFormat
	Internal OpenGL format. More...

SLint	_bytesPerPixel
	Bytes per texture image pixel (images exist either in _images or on the GPU or on both) More...

SLint	_min_filter
	Minification filter. More...

SLint	_mag_filter
	Magnification filter. More...

SLint	_wrap_s
	Wrapping in s direction. More...

SLint	_wrap_t
	Wrapping in t direction. More...

SLenum	_target
	texture target More...

SLMat4f	_tm
	texture matrix More...

SLuint	_bytesOnGPU
	NO. of bytes on GPU. More...

SLuint	_bytesInFile
	NO. of bytes in file. More...

SLbool	_autoCalcTM3D
	Flag if texture matrix should be calculated from AABB for 3D mapping. More...

SLfloat	_bumpScale
	Bump mapping scale factor. More...

SLbool	_resizeToPow2
	Flag if image should be resized to n^2. More...

SLGLVertexArray	_vaoSprite
	Vertex array object for sprite rendering. More...

std::atomic< bool >	_needsUpdate {}
	Flag if image needs an single update. More...

std::mutex	_mutex
	Mutex to protect parallel access (used in ray tracing) More...

SLbool	_deleteImageAfterBuild
	Flag if images should be deleted after build on GPU. More...

SLbool	_compressedTexture = false
	True for compressed texture format on GPU. More...

Protected Attributes inherited from SLObject
SLstring	_name
	name of an object More...

SLstring	_url
	uniform resource locator More...

Detailed Description

Classic Monte Carlo Pathtracing algorithm for real global illumination.

Definition at line 17 of file SLPathtracer.h.

Constructor & Destructor Documentation

◆ SLPathtracer()

SLPathtracer::SLPathtracer ( )

Definition at line 184 of file SLPathtracer.cpp.

 {
     name("PathTracer");
     _calcDirect   = true;
     _calcIndirect = true;
     _sampleClamp  = 3.0f; // see SLPathtracer.h; 0 switches it off
     _noiseRSE     = 0.0f;
     _noiseRSE999  = 0.0f;
     gamma(2.2f);
 }

◆ ~SLPathtracer()

SLPathtracer::~SLPathtracer ( )

inline

Definition at line 21 of file SLPathtracer.h.

21 { SL_LOG("Destructor : ~SLPathtracer"); }

SL_LOG

#define SL_LOG(...)

Some debugging and error handling macros.

Definition: SL.h:279

Member Function Documentation

◆ calcDirect() [1/2]

SLbool SLPathtracer::calcDirect ( ) const

inline

Definition at line 44 of file SLPathtracer.h.

44 { return _calcDirect; }

◆ calcDirect() [2/2]

void SLPathtracer::calcDirect ( SLbool di )

inline

Definition at line 39 of file SLPathtracer.h.

39 { _calcDirect = di; }

◆ calcIndirect() [1/2]

SLbool SLPathtracer::calcIndirect ( ) const

inline

Definition at line 45 of file SLPathtracer.h.

45 { return _calcIndirect; }

◆ calcIndirect() [2/2]

void SLPathtracer::calcIndirect ( SLbool ii )

inline

Definition at line 40 of file SLPathtracer.h.

40 { _calcIndirect = ii; }

◆ computeNoise()

void SLPathtracer::computeNoise ( )

Turns the two luminance moments that renderSlices accumulated into the noise figures of the Timing panel. Called once, after the last sample pass.

For a pixel that received N samples with luminances x_i, from the sums

S1 = sum(x_i)  and  S2 = sum(x_i^2)

the variance of one sample and the standard error of the pixel, which is the mean of those samples, are

s^2 = (S2 - S1^2 / N) / (N - 1)
SE  = sqrt(s^2 / N)

SE is in the units of the pixel, so it is divided by the pixel to give a relative standard error that can be compared between scenes, exposures and resolutions. noiseRSE is the mean of that over the image, noiseRSE999 the 99.9th percentile, which is the figure fireflies move.

A Monte Carlo estimator converges with 1/sqrt(N), so noiseRSE has to fall by half when the samples per pixel are quadrupled. That makes it a check on the estimators in trace() and shade() as much as a readout: if it does not halve, something upstream is wrong.

Definition at line 822 of file SLPathtracer.cpp.

 {
     const size_t numPixels = _lumSum.size();
  
     // The variance of a sample needs at least two samples to exist.
     if (numPixels == 0 || _aaSamples < 2)
     {
         _noiseRSE    = 0.0f;
         _noiseRSE999 = 0.0f;
         return;
     }
  
     const SLdouble n = (SLdouble)_aaSamples;
  
     // Keeps a black pixel, where mu is 0 and no number of samples is going to
     // change that, from dividing by zero.
     const SLdouble eps = 1e-3;
  
     vector<SLfloat> rse(numPixels);
     SLdouble        sum = 0.0;
  
     for (size_t i = 0; i < numPixels; ++i)
     {
         const SLdouble s1 = _lumSum[i];
         const SLdouble s2 = _lumSumSq[i];
         const SLdouble mu = s1 / n;
  
         SLdouble variance = (s2 - s1 * s1 / n) / (n - 1.0);
  
         // A pixel that got the same value every time, a background pixel for
         // instance, has a true variance of 0 and the subtraction above can land
         // just below it. Without this the sqrt would return a NaN.
         if (variance < 0.0)
             variance = 0.0;
  
         rse[i] = (SLfloat)(sqrt(variance / n) / (mu + eps));
         sum += (SLdouble)rse[i];
     }
  
     _noiseRSE = (SLfloat)(sum / (SLdouble)numPixels);
  
     // nth_element partitions around the wanted rank instead of sorting the
     // whole image, which is O(numPixels) rather than O(numPixels log numPixels)
     // and is all a percentile needs.
     size_t k = (size_t)(0.999 * (SLdouble)numPixels);
     if (k >= numPixels)
         k = numPixels - 1;
     std::nth_element(rse.begin(),
                      rse.begin() + (std::ptrdiff_t)k,
                      rse.end());
     _noiseRSE999 = rse[k];
 }

◆ efficiency()

SLfloat SLPathtracer::efficiency ( ) const

inline

Monte Carlo efficiency, the inverse of variance times time.

The figure to compare two renderers or two settings with, because it is the only one that stays fair when a change alters what a sample costs, as Russian roulette does. It does not depend on the sample count: the variance of a pixel falls as 1/N while the render time grows as N, so their product is constant in N and two renders at different samples per pixel can be compared directly. Higher is better.

Definition at line 84 of file SLPathtracer.h.

     {
         return _noiseRSE > 0.0f && _renderSec > 0.0f
                  ? 1.0f / (_noiseRSE * _noiseRSE * _renderSec)
                  : 0.0f;
     }

◆ noiseRSE()

SLfloat SLPathtracer::noiseRSE ( ) const

inline

Mean relative standard error of the pixels of the last render.

How far the average pixel is expected to sit from the value this estimator converges to, as a fraction of the pixel itself. It is a measure of the noise only: it says nothing about the bias that sampleClamp adds, and it falls monotonically as the clamp tightens. See computeNoise.

Definition at line 53 of file SLPathtracer.h.

53 { return _noiseRSE; }

◆ noiseRSE999()

SLfloat SLPathtracer::noiseRSE999 ( ) const

inline

Relative standard error of the noisiest 0.1% of the pixels.

The figure to watch for fireflies. A firefly covers a handful of pixels out of hundreds of thousands, so it barely moves noiseRSE, but it dominates this one.

It has a floor that comes straight from its definition: it reports the pixel at rank 99.9%, so it only moves once the fireflies reach more than 0.1% of the image. Measured on synthetic fireflies at 640x360 and 1000 spp, with the outliers 3000 times an ordinary sample:

firefly pixels noiseRSE noiseRSE999 0.010% 0.00320 0.00338 0.100% 0.00370 0.00342 still an ordinary pixel 0.200% 0.00421 0.60547 5.000% 0.02910 0.75061

Below that threshold this figure reads as if the image were clean and only noiseRSE moves, by very little. It is the right figure for the Muttenzer Box, whose fireflies cover about 4% of the far wall (see _sampleClamp), but a scene with rarer ones needs a higher percentile or the maximum.

Definition at line 75 of file SLPathtracer.h.

75 { return _noiseRSE999; }

◆ render()

SLbool SLPathtracer::render ( SLSceneView * sv )

Main render function. The Path Tracing algorithm starts from here

Definition at line 198 of file SLPathtracer.cpp.

 {
     _sv         = sv;
     _state      = rtBusy; // From here we state the PT as busy
     _renderSec  = 0.0f;   // reset time
     _progressPC = 0;      // % rendered
  
     initStats(0); // init statistics
     prepareImage();
  
     // Drop the 8 bit accumulation image that older versions kept here.
     // The path tracer needs only _images[0], which holds the clamped and
     // gamma corrected image for the display. The progressive mean itself is
     // accumulated in _radianceSum (see SLPathtracer.h).
     while (_images.size() > 1)
     {
         delete _images[_images.size() - 1];
         _images.pop_back();
     }
  
     // Allocate and clear the high precision accumulation buffer. Its size is
     // taken from _images[0] and not from the viewport, because prepareImage
     // scales the image with _resolutionFactor.
     const size_t numPixels = (size_t)_images[0]->width() *
                              (size_t)_images[0]->height();
     _radianceSum.assign(numPixels, SLCol4f::BLACK);
  
     // The two moments the noise figure is computed from. See computeNoise.
     _lumSum.assign(numPixels, 0.0);
     _lumSumSq.assign(numPixels, 0.0);
     _noiseRSE    = 0.0f;
     _noiseRSE999 = 0.0f;
  
     // Measure time
     double t1 = GlobalTimer::timeS();
  
     // Lambda function for async slice rendering
     renderSlicesPTAsync = [this](bool isMainThread, SLint curSample, SLuint threadNum)
     {
         SLPathtracer::renderSlices(isMainThread, curSample, threadNum);
     };
  
     // Do multi-threading only in release config
     SL_LOG("\n\nRendering with %d samples", _aaSamples);
     SL_LOG("\nCurrent Sample:       ");
     for (int currentSample = 1; currentSample <= _aaSamples; currentSample++)
     {
         vector<thread> threads; // vector for additional threads
         _nextLine = 0;
  
         // Start additional threads on the renderSlices function
         for (SLuint t = 0; t < Utils::maxThreads() - 1; t++)
             threads.emplace_back(renderSlicesPTAsync, false, currentSample, t);
  
         // Do the same work in the main thread
         renderSlicesPTAsync(true, currentSample, 0);
  
         for (auto& thread : threads)
             thread.join();
  
         _progressPC = (SLint)((SLfloat)currentSample / (SLfloat)_aaSamples * 100.0f);
     }
  
     _renderSec = GlobalTimer::timeS() - (SLfloat)t1;
     _raysPerMS.set((float)SLRay::totalNumRays() / _renderSec / 1000.0f);
     _progressPC = 100;
     computeNoise();
  
     SL_LOG("\nTime to render image: %6.3fsec", _renderSec);
  
     _state = rtFinished;
     return true;
 }

◆ renderSlices()

void SLPathtracer::renderSlices	(	bool	isMainThread,
		SLint	currentSample,
		SLuint	threadNum
	)

Renders a slice of 4px width.

Definition at line 275 of file SLPathtracer.cpp.

 {
     if (!isMainThread)
     {
         PROFILE_THREAD(string("PT-Worker-") + std::to_string(threadNum));
     }
  
     PROFILE_FUNCTION();
  
     // Time points
     double t1 = 0;
  
     const SLint imgW = (SLint)_images[0]->width();
     const SLint imgH = (SLint)_images[0]->height();
  
     while (_nextLine < imgW)
     {
         // The next section must be protected
         // Making _nextLine an atomic was not sufficient.
         _mutex.lock();
         SLint minX = _nextLine;
         _nextLine += 4;
         _mutex.unlock();
  
         // The image width is not necessarily a multiple of the slice width of
         // 4px, so the last slice has to be cut off. Without this the loop below
         // would index past the end of _radianceSum.
         SLint maxX = std::min(minX + 4, imgW);
  
         for (SLint x = minX; x < maxX; ++x)
         {
             for (SLint y = 0; y < imgH; ++y)
             {
                 SLCol4f color(SLCol4f::BLACK);
  
                 // calculate direction for primary ray - scatter with random variables for anti aliasing
                 SLRay primaryRay;
                 setPrimaryRay((SLfloat)((SLfloat)x - rnd01() + 0.5f),
                               (SLfloat)((SLfloat)y - rnd01() + 0.5f),
                               &primaryRay);
  
                 ///////////////////////////////////
                 color += trace(&primaryRay, PDF_NO_MIS);
                 ///////////////////////////////////
  
                 // Optional firefly clamp. The brightest channel is brought
                 // down to the limit and the other two are scaled with it, so
                 // that the sample loses energy but keeps its colour. Clamping
                 // each channel on its own would shift the hue of everything it
                 // touches. See _sampleClamp for why this is off by default.
                 if (_sampleClamp > 0.0f)
                 {
                     SLfloat maxChannel = color.maxXYZ();
                     if (maxChannel > _sampleClamp)
                         color *= _sampleClamp / maxChannel;
                 }
  
                 // Add the raw linear radiance of this sample to the running sum.
                 // Nothing is clamped or quantised here on purpose: the estimator
                 // only converges with 1/sqrt(N) if every sample keeps its full
                 // value and its full precision. The correction that one sample
                 // applies to the mean shrinks with 1/currentSample, so rounding
                 // the mean to 8 bit (as the old _images[1] did) would freeze
                 // bright outliers (fireflies) at a wrong value forever.
                 const size_t pixel = (size_t)y * (size_t)imgW + (size_t)x;
  
                 SLCol4f& radianceSum = _radianceSum[pixel];
                 radianceSum += color;
  
                 // The same sample as a single number, for the noise figure of
                 // computeNoise. It is taken here and not from _images[0],
                 // because that image is clamped to [0,1] and gamma corrected
                 // for the display, which flattens every firefly to white and
                 // destroys exactly the signal being measured. Rec. 709
                 // luminance, matching the linear primaries the renderer works
                 // in. When _sampleClamp is on the sample arriving here is
                 // already clamped, so the figure describes the noise of the
                 // clamped estimator, which is the image actually produced.
                 const SLdouble lum = 0.2126 * (SLdouble)color.r +
                                      0.7152 * (SLdouble)color.g +
                                      0.0722 * (SLdouble)color.b;
                 _lumSum[pixel] += lum;
                 _lumSumSq[pixel] += lum * lum;
  
                 // The mean of all samples taken so far for this pixel
                 color = radianceSum / (SLfloat)currentSample;
  
                 // From here on the color is for the display only: clamp it into
                 // the displayable range and apply the gamma correction.
                 color.clampMinMax(0.0f, 1.0f);
                 color.gammaCorrect(_oneOverGamma);
  
                 // image to render
                 _images[0]->setPixeliRGB(x,
                                          y,
                                          CVVec4f(color.r,
                                                  color.g,
                                                  color.b,
                                                  color.a));
             }
  
             // update image after 500 ms
             if (_sv->onWndUpdate && isMainThread)
             {
                 if (GlobalTimer::timeS() - t1 > 0.5f)
                 {
                     renderUIBeforeUpdate();
                     _sv->onWndUpdate(); // update window
                     t1 = GlobalTimer::timeS();
                 }
             }
         }
     }
 }

◆ sampleClamp() [1/2]

SLfloat SLPathtracer::sampleClamp ( ) const

inline

Definition at line 46 of file SLPathtracer.h.

46 { return _sampleClamp; }

◆ sampleClamp() [2/2]

void SLPathtracer::sampleClamp ( SLfloat max )

inline

Definition at line 41 of file SLPathtracer.h.

41 { _sampleClamp = max; }

◆ saveImage()

void SLPathtracer::saveImage ( )

virtual

Saves the current PT image as PNG image.

Reimplemented from SLRaytracer.

Definition at line 876 of file SLPathtracer.cpp.

 {
     static SLint no = 0;
     SLchar       filename[255];
     snprintf(filename,
              sizeof(filename),
              "Pathtraced_%d_%d.png",
              _aaSamples,
              no++);
     _images[0]->savePNG(filename);
 }

◆ shade()

SLCol4f SLPathtracer::shade	(	SLRay *	ray,
		SLCol4f *	mat
	)

Calculates the direct illumination at the hit point of the ray by sampling the light sources explicitly (next event estimation).

A rectangular light is an AREA light and is estimated with a Monte Carlo area estimator: one point is sampled uniformly on the rectangle (pdf = 1/area) and the radiance reflected towards the ray is

Lo = albedo/PI * Le * cosSurface * cosLight / dist^2 * area

with the direction, the distance and both cosines taken at the SAMPLED point.

The previous version took all of them at the light CENTRE while it tested the visibility at a random point, and it replaced the geometric term by the OpenGL attenuation and the spot cone exponent. That is the Blinn-Phong rasteriser model, not an estimator of the area light integral. It missed the area factor completely, which made the direct light 1/area too bright (1.54x for the 1.0 x 0.65 light of the Muttenzer Box), and it broke down for surfaces close to a large light. Above all it put the direct illumination on a different scale than the emissive material of the light mesh that the paths see when they hit the light through the mirror or the glass sphere, so the two estimates of the same illumination did not agree.

All other light types are point or directional (delta) lights without any area. For those the classic attenuation and spot cone model is kept.

Definition at line 696 of file SLPathtracer.cpp.

 {
     SLCol4f color  = SLCol4f::BLACK;
     SLNode* root3D = _sv->s()->root3D();
     SLVec3f N(ray->hitNormal);
  
     // loop over light sources in scene
     for (auto* light : _sv->s()->lights())
     {
         if (!light || !light->isOn()) continue;
  
         if (typeid(*light) == typeid(SLLightRect))
         {
             ///////////////////////////////////////////////////////
             // Area light: Monte Carlo estimate over its surface  //
             ///////////////////////////////////////////////////////
  
             auto* rect = (SLLightRect*)light;
  
             // One uniformly distributed sample point on the light (pdf=1/area)
             SLVec3f toLight(rect->samplePointMC() - ray->hitPoint);
             SLfloat distSqr = toLight.lengthSqr();
             if (distSqr < FLT_EPSILON) continue;
             SLfloat dist = sqrt(distSqr);
             toLight /= dist;
  
             // Cosine at the shaded surface and at the sampled light point.
             // spotDirWS is the normal of the light rectangle.
             SLfloat cosSurface = toLight.dot(N);
             SLfloat cosLight   = -toLight.dot(rect->spotDirWS());
  
             // Sample is below the surface or behind the (one sided) light
             if (cosSurface <= 0.0f || cosLight <= 0.0f) continue;
  
             // Visibility of the sampled point. The light mesh itself does not
             // block, see SLLightRect::hitRec which ignores shadow rays.
             SLRay shadowRay(dist, toLight, ray);
             root3D->hitRec(&shadowRay);
             if (shadowRay.length < dist) continue;
  
             // Geometric term of the area formulation
             SLfloat geometry = cosSurface * cosLight / distSqr;
  
             // The cosine weighted scattering in trace() can generate this same
             // path, so weight the two estimates against each other; trace()
             // applies the complementary weight. With the indirect
             // illumination switched off the scattering never runs and this
             // estimate carries the path alone.
             SLfloat weight = 1.0f;
             if (_calcIndirect)
             {
                 // The same conversion of 1/area into a solid angle density
                 // that lightPdfMC does for the hit coming the other way
                 SLfloat lightPdf = distSqr / (cosLight * rect->area());
                 SLfloat bsdfPdf  = cosSurface * Utils::ONEOVERPI;
                 weight           = misWeight(lightPdf, bsdfPdf);
             }
  
             // albedo * brdf(1/PI) * Le * G / pdf, with pdf = 1/area
             color += (*mat & light->diffuse()) *
                      (Utils::ONEOVERPI * geometry * rect->area() * weight);
         }
         else
         {
             ///////////////////////////////////////////////////////
             // Point or directional light: no area, classic model //
             ///////////////////////////////////////////////////////
  
             SLVec3f L(light->positionWS().vec3() - ray->hitPoint);
             SLfloat lightDist = L.length();
             L /= lightDist;
             SLfloat LdN = L.dot(N);
  
             // hit point faces away from the light
             if (LdN <= 0.0f) continue;
  
             SLfloat lighted = light->shadowTestMC(ray, L, lightDist, root3D);
             if (lighted <= 0.0f) continue;
  
             // calculate spot effect if light is a spotlight
             SLfloat spotEffect = 1.0f;
             if (light->spotCutOffDEG() < 180.0f)
             {
                 SLfloat LdS = std::max(-L.dot(light->spotDirWS()), 0.0f);
  
                 // check if point is in spot cone
                 if (LdS <= light->spotCosCut()) continue;
  
                 spotEffect = pow(LdS, (SLfloat)light->spotExponent());
             }
  
             // material color * light emission * LdN * brdf(1/pi) * lighted
             SLCol4f diffuseColor = (*mat & (light->diffuse() * LdN)) *
                                    (Utils::ONEOVERPI * lighted);
  
             color += light->attenuation(lightDist) * spotEffect * diffuseColor;
         }
     }
  
     return color;
 }

◆ trace()

SLCol4f SLPathtracer::trace	(	SLRay *	ray,
		SLfloat	bsdfPdf
	)

Traces one ray. bsdfPdf is the solid angle density with which the.

scattering at the previous vertex produced this ray, or the negative sentinel PDF_NO_MIS if next event estimation cannot generate the same path (the primary ray, and every specular or transmissive bounce). It is what lets a light hit be weighted against the light sampling in shade().

Recursively traces ray in scene.

Definition at line 395 of file SLPathtracer.cpp.

 {
     // The radiance gathered at this hit point. It must start at BLACK. It used
     // to start at ray->backgroundColor, which added the background to EVERY
     // surface at EVERY bounce and therefore compounded down the path. That
     // stayed invisible in scenes with a black background and no skybox only.
     SLCol4f finalColor(SLCol4f::BLACK);
  
     // Participating Media init
     SLfloat absorption = 1.0f; // used to calculate absorption along the ray
     SLfloat scaleBy    = 1.0f; // used to scale surface reflectance at the end of random walk
  
     // Intersect scene
     SLNode* root = _sv->s()->root3D();
     if (root) root->hitRec(ray);
  
     // End of recursion: the ray escaped the scene, so it gathers the radiance
     // of the environment (skybox or camera background). This is the only place
     // where the background may contribute.
     if (ray->length >= FLT_MAX)
         return ray->backgroundColor;
  
     // End of recursion: the safety net. Russian roulette below decides how long
     // a path lives, but it cannot terminate a surface that absorbs nothing,
     // such as the perfect mirror and the glass of the Muttenzer Box, so a hard
     // cap is still needed against an endless specular chain. The cap is set
     // high enough (see the startPathtracing call sites) that roulette and not
     // this test ends virtually every path, so the bias it used to cause is now
     // negligible instead of dominant.
     if (ray->depth > maxDepth())
         return SLCol4f::BLACK;
  
     // hit material
     SLMaterial* mat = ray->hitMesh->mat();
     ray->hitMesh->preShade(ray);
  
     // set object color
     SLCol4f objectColor = SLCol4f::BLACK;
     if (ray->hitMatIsDiffuse())
         objectColor = mat->diffuse();
     else if (ray->hitMatIsReflective())
         objectColor = mat->specular();
     else if (ray->hitMatIsTransparent())
         objectColor = mat->transmissive();
  
     // set object emission
     SLCol4f objectEmission = mat->emissive();
     SLfloat maxEmission    = objectEmission.maxXYZ();
  
     // End of recursion: a light source is hit
     if (maxEmission > 0)
     {
         // The primary ray, or a specular or transmissive bounce. shade() only
         // ever samples from a diffuse surface, so it cannot have produced a
         // competing estimate of this path and the emission counts in full.
         // This also covers the camera looking straight at the light.
         if (bsdfPdf < 0.0f)
             return mat->emissive() * absorption;
  
         SLfloat lightPdf = lightPdfMC(ray);
  
         if (lightPdf <= 0.0f)
         {
             // Emissive, but not a light that shade() samples over an area. If
             // it is a light node at all, shade() samples it as a point or
             // directional delta light, whose direction the scattering can
             // never reproduce, so counting it here as well would count it
             // twice. SLLightSpot::hitRec and SLLightDirect::hitRec currently
             // reject every ray that is not primary, so this cannot be reached;
             // the test keeps the invariant here rather than resting on those
             // two overrides. Anything else is an ordinary emissive mesh that
             // shade() ignores, so it counts in full.
             if (dynamic_cast<SLLight*>(ray->hitNode) != nullptr)
                 return SLCol4f::BLACK;
  
             return mat->emissive() * absorption;
         }
  
         // Both shade() and the scattering can generate this path. Weight the
         // two estimates with the power heuristic; shade() applies the
         // complementary weight, so together they count the path exactly once.
         return mat->emissive() * absorption * misWeight(bsdfPdf, lightPdf);
     }
  
     // add absorption to base color from Participating Media
     objectColor = objectColor * absorption;
  
     // diffuse reflection
     if (ray->hitMatIsDiffuse())
     {
         // Add component wise the texture color
         if (mat->numTextures() > 0)
         {
             objectColor &= ray->hitTexColor;
         }
  
         if (_calcDirect)
             finalColor += shade(ray, &objectColor) * scaleBy;
  
         // Russian roulette decides whether the path continues. The direct
         // illumination above is a terminal estimate at this vertex and is
         // always taken; only the continuation is gambled on. The roll is made
         // inside the test so that switching the indirect illumination off does
         // not consume random numbers here.
         SLfloat survival = _calcIndirect ? russianRoulette(ray->depth, objectColor)
                                          : 0.0f;
  
         if (survival > 0.0f)
         {
             SLRay scatter;
             ray->diffuseMC(&scatter);
  
             // diffuseMC draws the direction from the cosine distribution, so
             // its solid angle density is cos(theta)/PI. It is handed down so
             // that a light hit further along the path can be weighted against
             // the light sampling that shade() just did at this same vertex.
             // With the direct illumination switched off shade() never runs,
             // so there is nothing to weight against and the hit counts fully.
             SLfloat scatterPdf = PDF_NO_MIS;
             if (_calcDirect)
                 scatterPdf = std::max(scatter.dir.dot(ray->hitNormal), 0.0f) *
                              Utils::ONEOVERPI;
  
             // material emission, material diffuse and recursive indirect
             // illumination, scaled up by 1/survival for the paths that lived
             finalColor += (trace(&scatter, scatterPdf) & objectColor) *
                           (scaleBy / survival);
         }
     }
     else if (ray->hitMatIsReflective())
     {
         // Russian roulette, as in the diffuse branch. A perfect mirror has an
         // albedo of 1, always survives, and is bounded only by the depth cap.
         SLfloat survival = russianRoulette(ray->depth, objectColor);
         if (survival <= 0.0f) return finalColor;
  
         // scatter toward perfect specular direction
         SLRay reflected;
         ray->reflect(&reflected);
  
         // scatter around perfect reflected direction only if material not perfect
         SLfloat lobeWeight = 1.0f;
         if (mat->shininess() < SLMaterial::PERFECT)
         {
             if (!ray->reflectMC(&reflected, SLRay::lobeToWorld(reflected.dir)))
                 return finalColor; // sample below the horizon, see reflectMC
  
             lobeWeight = phongLobeWeight(mat->shininess(),
                                          reflected.dir,
                                          ray->hitNormal);
         }
  
         // lobe weight * recursive indirect illumination and material base color
         finalColor += (lobeWeight * (trace(&reflected, PDF_NO_MIS) & objectColor)) *
                       (scaleBy / survival);
     }
     else if (ray->hitMatIsTransparent())
     {
         // Russian roulette, as in the diffuse branch. This is independent of
         // the Fresnel choice further down, which picks reflection or
         // transmission but never ends the path.
         SLfloat survival = russianRoulette(ray->depth, objectColor);
         if (survival <= 0.0f) return finalColor;
  
         // scatter toward perfect transmissive direction
         SLRay refracted;
         ray->refract(&refracted);
  
         // init Schlick's approximation
         SLVec3f rayDir = ray->dir;
         rayDir.normalize();
         SLVec3f refrDir = refracted.dir;
         refrDir.normalize();
         SLfloat n, nt;
         SLVec3f hitNormal = ray->hitNormal;
         hitNormal.normalize();
  
         // ray from outside in
         if (ray->isOutside)
         {
             n  = 1.0f;
             nt = mat->kn();
         }
         else // ray from inside out
         {
             n  = mat->kn();
             nt = 1.0f;
         }
  
         // calculate Schlick's approx.
         SLfloat nbig, nsmall;
         nbig            = n > nt ? n : nt;
         nsmall          = n < nt ? n : nt;
         SLfloat R0      = ((nbig - nsmall) / (nbig + nsmall));
         R0              = R0 * R0;
         SLbool  into    = (rayDir * hitNormal) < 0;
         SLfloat c       = 1.0f - (into ? (-rayDir * hitNormal) : (refrDir * hitNormal));
         SLfloat schlick = R0 + (1 - R0) * c * c * c * c * c;
  
         SLfloat P                     = 0.25f + 0.5f * schlick; // probability of reflectance
         SLfloat reflectionProbability = schlick / P;
         SLfloat refractionProbability = (1.0f - schlick) / (1.0f - P);
  
         // scatter around perfect transmissive direction only if material not perfect
         SLfloat lobeWeight     = 1.0f;
         SLbool  refractIsValid = true;
         if (mat->translucency() < SLMaterial::PERFECT)
         {
             refractIsValid = ray->refractMC(&refracted,
                                             SLRay::lobeToWorld(refracted.dir));
  
             if (refractIsValid)
                 lobeWeight = phongLobeWeight(mat->translucency(),
                                              refracted.dir,
                                              ray->hitNormal);
         }
  
         // probability of reflection
         if (rnd01() > (0.25f + 0.5f * schlick))
         {
             // scatter toward transmissive direction. A sample that came back
             // out on the incident side carries no energy, see refractMC.
             if (refractIsValid)
                 finalColor += (lobeWeight *
                                (trace(&refracted, PDF_NO_MIS) & objectColor) *
                                refractionProbability) *
                               (scaleBy / survival);
         }
         else
         {
             // scatter toward perfect specular direction
             SLRay scattered;
             ray->reflect(&scattered);
  
             // Scatter around the perfect specular direction if the surface is
             // not perfectly smooth, exactly as the reflective branch above
             // does. A rough dielectric is rough on both sides of the interface
             // -- the same microscopic slopes that spread the transmitted lobe
             // spread the Fresnel reflected one -- so frosted glass whose
             // transmission is blurred but whose surface still mirrors its
             // surroundings sharply looks wrong. The width of the two lobes is
             // controlled separately here: shininess for this reflection and
             // translucency for the transmission above, so a material can still
             // be given a polished surface over a diffusing interior by leaving
             // its shininess at PERFECT.
             //
             // The lobe weight is the normalisation of the Phong lobe
             // estimator and belongs only where a direction was actually drawn
             // from that lobe, which is why a perfect surface still carries
             // no weight at all: multiplying a mirror ray by
             // (shininess + 2) / (shininess + 1) used to add 1% of energy per
             // bounce at the shininess of 100 of the Muttenzer Box glass.
             SLfloat reflLobeWeight = 1.0f;
             if (mat->shininess() < SLMaterial::PERFECT)
             {
                 if (!ray->reflectMC(&scattered,
                                     SLRay::lobeToWorld(scattered.dir)))
                     return finalColor; // sample below the horizon, see reflectMC
  
                 reflLobeWeight = phongLobeWeight(mat->shininess(),
                                                  scattered.dir,
                                                  ray->hitNormal);
             }
  
             // lobe weight * recursive indirect illumination and material base color
             finalColor += (reflLobeWeight *
                            (trace(&scattered, PDF_NO_MIS) & objectColor) *
                            reflectionProbability) *
                           (scaleBy / survival);
         }
     }
  
     return finalColor;
 }

Member Data Documentation

◆ _calcDirect

SLbool SLPathtracer::_calcDirect

private

flag to calculate direct illumination

Definition at line 94 of file SLPathtracer.h.

◆ _calcIndirect

SLbool SLPathtracer::_calcIndirect

private

flag to calculate indirect illumination

Definition at line 95 of file SLPathtracer.h.

◆ _lumSum

vector<SLdouble> SLPathtracer::_lumSum

private

Sum and sum of squares of the luminance of every sample, per pixel.

The two moments that the variance of a pixel is computed from, in computeNoise. Luminance rather than colour, because the noise of a pixel is one number and not three, and it is linear, so summing the luminance of the samples and taking the luminance of _radianceSum come to the same thing.

They are double and not float, although _radianceSum is float, because the variance is the small difference of two large sums, S2 - S1*S1/N. In a quiet region those two agree to several digits and a float would leave almost none of the result. A firefly makes it worse from the other side: 1e4 squared is 1e8, and adding an ordinary 1e-4 to that is lost entirely in float. Double carries both ends. The cost is 16 bytes per pixel, 3.7 MB at 640x480.

Indexed like _radianceSum, with y * width + x.

Definition at line 152 of file SLPathtracer.h.

◆ _lumSumSq

vector<SLdouble> SLPathtracer::_lumSumSq

private

Definition at line 153 of file SLPathtracer.h.

◆ _noiseRSE

SLfloat SLPathtracer::_noiseRSE

private

mean relative standard error, see noiseRSE()

Definition at line 155 of file SLPathtracer.h.

◆ _noiseRSE999

SLfloat SLPathtracer::_noiseRSE999

private

the same for the worst 0.1%, see noiseRSE999()

Definition at line 156 of file SLPathtracer.h.

◆ _radianceSum

vector<SLCol4f> SLPathtracer::_radianceSum

private

Linear, unclamped sum of all radiance samples taken so far per pixel.

The progressive mean of a path tracer must never be kept in an 8 bit image. Rounding the running mean to 1/255 after every sample stops the convergence as soon as the correction of one sample, which is |sample - mean| / sampleNo, falls below half a quantisation step, i.e. as soon as sampleNo > 510 * |sample - mean|. A bright outlier (a firefly) then freezes at a wrong value and never averages out again, no matter how many samples are rendered. That is why this buffer holds the raw sum in full float precision and is divided by the sample number for the display only. Its size is _images[0]->width() * _images[0]->height() and it is indexed with y * width + x.

Definition at line 136 of file SLPathtracer.h.

◆ _sampleClamp

SLfloat SLPathtracer::_sampleClamp

private

Upper limit on the radiance of a single sample, 0 to switch it off.

A firefly is a path that carries far more energy than the pixel it lands in, most often a caustic: light that reaches a diffuse surface through the mirror or the glass sphere. The estimator is right about it, but such a path is found so seldom that the average is still visibly lumpy after a thousand samples. Capping what one sample may contribute removes it at once.

This is a deliberate bias, and the only one left in the renderer: it discards the part of a caustic above the limit and makes it darker than it is. Measured on the Muttenzer Box at 100 spp, against no clamp:

limit fireflies, far wall mean radiance of the caustic off 4.35% 1.000 30 4.75% 0.985 10 4.08% 0.938 3 0.02% 0.695

The fireflies of this scene sit between 3 and 10, so 30 does nothing and 10 barely helps. 3 removes them almost entirely and costs 2 to 5% on ordinary surfaces, 15% on the ceiling below the light and 30% on the caustic under the glass sphere. That is the trade, and it is why this is a menu item that can be switched off rather than a constant.

Note that it caps the SAMPLE and never the running mean. Clamping the mean is the defect that the float accumulation buffer removed: it froze the fireflies at a wrong value instead of averaging them away.

Definition at line 123 of file SLPathtracer.h.

◆ renderSlicesPTAsync

function<void(bool, int, SLuint)> SLPathtracer::renderSlicesPTAsync

private

Definition at line 92 of file SLPathtracer.h.

The documentation for this class was generated from the following files:

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SLPathtracer()

◆ ~SLPathtracer()

Member Function Documentation

◆ calcDirect() [1/2]

◆ calcDirect() [2/2]

◆ calcIndirect() [1/2]

◆ calcIndirect() [2/2]

◆ computeNoise()

◆ efficiency()

◆ noiseRSE()

◆ noiseRSE999()

◆ render()

◆ renderSlices()

◆ sampleClamp() [1/2]

◆ sampleClamp() [2/2]

◆ saveImage()

◆ shade()

◆ trace()

Member Data Documentation

◆ _calcDirect

◆ _calcIndirect

◆ _lumSum

◆ _lumSumSq

◆ _noiseRSE

◆ _noiseRSE999

◆ _radianceSum

◆ _sampleClamp

◆ renderSlicesPTAsync