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, SLbool em)

SLCol4f	shade (SLRay ray, SLCol4f mat)

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

void	calcDirect (SLbool di)

void	calcIndirect (SLbool ii)

SLbool	calcDirect () const

SLbool	calcIndirect () const

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 ()

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

Public Member Functions inherited from SLEventHandler
	SLEventHandler ()

virtual	~SLEventHandler ()

virtual SLbool	onMouseDown (const SLMouseButton button, const SLint x, const SLint y, const SLKey mod)

virtual SLbool	onMouseUp (const SLMouseButton button, const SLint x, const SLint y, const SLKey mod)

virtual SLbool	onMouseMove (const SLMouseButton button, const SLint x, const SLint y, const SLKey mod)

virtual SLbool	onDoubleClick (const SLMouseButton button, const SLint x, const SLint y, const SLKey mod)

virtual SLbool	onMouseWheel (const SLint delta, const SLKey mod)

virtual SLbool	onTouch2Down (const SLint x1, const SLint y1, const SLint x2, const SLint y2)

virtual SLbool	onTouch2Move (const SLint x1, const SLint y1, const SLint x2, const SLint y2)

virtual SLbool	onTouch2Up (const SLint x1, const SLint y1, const SLint x2, const SLint y2)

virtual SLbool	onTouch3Down (const SLint x1, const SLint y1)

virtual SLbool	onTouch3Move (const SLint x1, const SLint y1)

virtual SLbool	onTouch3Up (const SLint x1, const SLint y1)

virtual SLbool	onKeyPress (const SLKey key, const SLKey mod)

virtual SLbool	onKeyRelease (const SLKey key, const SLKey mod)

virtual SLbool	onRotationPYR (const SLfloat pitchRAD, const SLfloat yawRAD, const SLfloat rollRAD)

void	mouseRotationFactor (SLfloat rf)

SLfloat	mouseRotationFactor ()

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

SLbool	_calcDirect
	flag to calculate direct illumination More...

SLbool	_calcIndirect
	flag to calculate indirect illumination 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
	Averaged rays per ms. 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...

Protected Attributes inherited from SLEventHandler
SLfloat	_mouseRotationFactor
	Mouse rotation sensibility. More...

SLfloat	_keyboardDeltaPos
	Delta dist. for keyboard translation. 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 23 of file SLPathtracer.cpp.

 {
     name("PathTracer");
     _calcDirect   = true;
     _calcIndirect = true;
     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(...)

Definition: SL.h:233

Member Function Documentation

◆ calcDirect() [1/2]

SLbool SLPathtracer::calcDirect ( ) const

inline

Definition at line 37 of file SLPathtracer.h.

37 { return _calcDirect; }

◆ calcDirect() [2/2]

void SLPathtracer::calcDirect ( SLbool di )

inline

Definition at line 33 of file SLPathtracer.h.

33 { _calcDirect = di; }

◆ calcIndirect() [1/2]

SLbool SLPathtracer::calcIndirect ( ) const

inline

Definition at line 38 of file SLPathtracer.h.

38 { return _calcIndirect; }

◆ calcIndirect() [2/2]

void SLPathtracer::calcIndirect ( SLbool ii )

inline

Definition at line 34 of file SLPathtracer.h.

34 { _calcIndirect = ii; }

◆ render()

SLbool SLPathtracer::render ( SLSceneView * sv )

Main render function. The Path Tracing algorithm starts from here

Definition at line 34 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();
  
     // Set second image for render update to the same size
     while (_images.size() > 1)
     {
         delete _images[_images.size() - 1];
         _images.pop_back();
     }
     _images.push_back(new CVImage(_sv->viewportW(),
                                   _sv->viewportH(),
                                   PF_rgb,
                                   "Pathtracer"));
     // 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;
  
     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 97 of file SLPathtracer.cpp.

 {
     if (!isMainThread)
     {
         PROFILE_THREAD(string("PT-Worker-") + std::to_string(threadNum));
     }
  
     PROFILE_FUNCTION();
  
     // Time points
     double t1 = 0;
  
     while (_nextLine < (SLint)_images[0]->width())
     {
         // The next section must be protected
         // Making _nextLine an atomic was not sufficient.
         _mutex.lock();
         SLint minX = _nextLine;
         _nextLine += 4;
         _mutex.unlock();
  
         for (SLint x = minX; x < minX + 4; ++x)
         {
             for (SLuint y = 0; y < _images[0]->height(); ++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, false);
                 ///////////////////////////////////
  
                 // weight old and new color for continuous rendering
                 SLCol4f oldColor;
                 if (currentSample > 1)
                 {
                     CVVec4f c4f = _images[1]->getPixeli(x, (SLint)y);
                     oldColor.set(c4f[0], c4f[1], c4f[2], c4f[3]);
  
                     // weight old color (examp. 3/4, 4/5, 5/6)
                     oldColor /= (SLfloat)currentSample;
                     oldColor *= (SLfloat)(currentSample - 1);
  
                     // weight new color (examp. 1/4, 1/5, 1/6)
                     color /= (SLfloat)currentSample;
  
                     // bring them together (examp. 4/4, 5/5, 6/6)
                     color += oldColor;
                 }
  
                 color.clampMinMax(0.0f, 1.0f);
  
                 // save image without gamma
                 _images[1]->setPixeliRGB(x,
                                          (SLint)y,
                                          CVVec4f(color.r,
                                                  color.g,
                                                  color.b,
                                                  color.a));
  
                 color.gammaCorrect(_oneOverGamma);
  
                 // image to render
                 _images[0]->setPixeliRGB(x,
                                          (SLint)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();
                 }
             }
         }
     }
 }

◆ saveImage()

void SLPathtracer::saveImage ( )

virtual

Saves the current PT image as PNG image.

Reimplemented from SLRaytracer.

Definition at line 421 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 direct illumination for intersection point of ray

Definition at line 361 of file SLPathtracer.cpp.

 {
     SLCol4f color        = SLCol4f::BLACK;
     SLCol4f diffuseColor = SLCol4f::BLACK;
     SLVec3f L, N;
     SLfloat lightDist, LdN, df, spotEffect, lighted;
  
     // loop over light sources in scene
     for (auto* light : _sv->s()->lights())
     {
         if (light && light->isOn())
         {
             N.set(ray->hitNormal);
             L.sub(light->positionWS().vec3(), ray->hitPoint);
             lightDist = L.length();
             L /= lightDist;
             LdN = L.dot(N);
  
             // check shadow ray if hit point is towards the light
             lighted = (SLfloat)((LdN > 0) ? light->shadowTestMC(ray,
                                                                 L,
                                                                 lightDist,
                                                                 _sv->s()->root3D())
                                           : 0);
  
             // calculate spot effect if light is a spotlight
             if (lighted > 0.0f && 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())
                 {
                     spotEffect = pow(LdS, (SLfloat)light->spotExponent());
                 }
                 else
                 {
                     lighted    = 0.0f;
                     spotEffect = 0.0f;
                 }
             }
             else
                 spotEffect = 1.0f;
  
             if (lighted > 0.0f)
             {
                 df = std::max(LdN, 0.0f); // diffuse factor
  
                 // material color * light emission * LdN * brdf(1/pi) * lighted(for soft shadows)
                 diffuseColor = (*mat & (light->diffuse() * df) * Utils::ONEOVERPI * lighted);
             }
  
             color += light->attenuation(lightDist) * spotEffect * diffuseColor;
         }
     }
  
     return color;
 }

◆ trace()

SLCol4f SLPathtracer::trace	(	SLRay *	ray,
		SLbool	em
	)

Recursively traces ray in scene.

Definition at line 192 of file SLPathtracer.cpp.

 {
     SLCol4f finalColor(ray->backgroundColor);
  
     // 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 - no object hit OR max depth reached
     if (ray->length >= FLT_MAX || 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();
  
     // stop recursion if light source is hit
     if (maxEmission > 0)
     {
         if (ray->depth == 1)
             return mat->emissive() * absorption;
         else
             return mat->emissive() * absorption * em;
     }
  
     // 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;
  
         if (_calcIndirect)
         {
             SLRay scatter;
             ray->diffuseMC(&scatter);
  
             // material emission, material diffuse and recursive indirect illumination
             finalColor += (trace(&scatter, false) & objectColor) * scaleBy;
         }
     }
     else if (ray->hitMatIsReflective())
     {
         // scatter toward perfect specular direction
         SLRay reflected;
         ray->reflect(&reflected);
  
         // scatter around perfect reflected direction only if material not perfect
         if (mat->shininess() < SLMaterial::PERFECT)
         {
             // rotation matrix for glossy
             SLMat3f rotMat;
             SLVec3f rotAxis((SLVec3f(0.0f, 0.0f, 1.0f) ^ reflected.dir).normalize());
             SLfloat rotAngle = acos(reflected.dir.z);
             rotMat.rotation(rotAngle * 180.0f * Utils::ONEOVERPI, rotAxis);
             ray->reflectMC(&reflected, rotMat);
         }
  
         // shininess contribution * recursive indirect illumination and matrial base color
         finalColor += ((mat->shininess() + 2.0f) / (mat->shininess() + 1.0f) *
                        (trace(&reflected, true) & objectColor)) *
                       scaleBy;
     }
     else if (ray->hitMatIsTransparent())
     {
         // 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
         if (mat->translucency() < SLMaterial::PERFECT)
         {
             // rotation matrix for translucency
             SLMat3f rotMat;
             SLVec3f rotAxis((SLVec3f(0.0f, 0.0f, 1.0f) ^ refracted.dir).normalize());
             SLfloat rotAngle = acos(refracted.dir.z);
             rotMat.rotation((SLfloat)(rotAngle * 180.0f * Utils::ONEOVERPI), rotAxis);
             ray->refractMC(&refracted, rotMat);
         }
  
         // probability of reflection
         if (rnd01() > (0.25f + 0.5f * schlick))
             // scatter toward transmissive direction
             finalColor += ((mat->translucency() + 2.0f) /
                            (mat->translucency() + 1.0f) *
                            (trace(&refracted, true) & objectColor) *
                            refractionProbability) *
                           scaleBy;
         else
         {
             // scatter toward perfect specular direction
             SLRay scattered;
             ray->reflect(&scattered);
  
             // shininess contribution * recursive indirect illumination and material basecolor
             finalColor += ((mat->shininess() + 2.0f) /
                            (mat->shininess() + 1.0f) *
                            (trace(&scattered, true) & objectColor) *
                            reflectionProbability) *
                           scaleBy;
         }
     }
  
     return finalColor;
 }

Member Data Documentation

◆ _calcDirect

SLbool SLPathtracer::_calcDirect

private

flag to calculate direct illumination

Definition at line 43 of file SLPathtracer.h.

◆ _calcIndirect

SLbool SLPathtracer::_calcIndirect

private

flag to calculate indirect illumination

Definition at line 44 of file SLPathtracer.h.

◆ renderSlicesPTAsync

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

private

Definition at line 41 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]

◆ render()

◆ renderSlices()

◆ saveImage()

◆ shade()

◆ trace()

Member Data Documentation

◆ _calcDirect

◆ _calcIndirect

◆ renderSlicesPTAsync