SLRaytracer hold all the methods for Whitted style Ray Tracing. More...

#include <SLRaytracer.h>

Inheritance diagram for SLRaytracer:

Public Member Functions
	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)

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

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

Static Public Member Functions
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...

Protected Attributes
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...

Additional Inherited Members
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...

Detailed Description

SLRaytracer hold all the methods for Whitted style Ray Tracing.

SLRaytracer implements the methods render, eyeToPixel, trace and shade for classic Whitted style Ray Tracing. This class is a friend class of SLScene and can access via the pointer _s all members of SLScene. The scene traversal for the ray intersection tests is done within the intersection method of all nodes. The result is written into an image of an SLGLTexture and that then is rendered with OpenGL in a orthographic projection.

Definition at line 57 of file SLRaytracer.h.

Constructor & Destructor Documentation

◆ SLRaytracer()

SLRaytracer::SLRaytracer ( )

Definition at line 22 of file SLRaytracer.cpp.

 {
     name("myCoolRaytracer");
  
     _sv               = nullptr;
     _state            = rtReady;
     _doDistributed    = true;
     _doContinuous     = false;
     _doFresnel        = true;
     _maxDepth         = 5;
     _aaThreshold      = 0.3f; // = 10% color difference
     _aaSamples        = 3;
     _resolutionFactor = 0.5f;
     gamma(1.0f);
     // A window of 1, i.e. no averaging. Unlike the frame, cull and draw timers
     // of SLSceneView, which are set every frame and fill their window within a
     // second, this is set exactly once per completed render. With a window of
     // 60 the reported value was the sum of the renders done so far divided by
     // 60, so it showed k/60 of the truth after k renders and only became
     // correct after 60 of them. That made it useless for its actual purpose,
     // comparing the multi core throughput of different machines: the number
     // depended on how often the user had pressed render since starting the app.
     _raysPerMS.init(1, 0.0f);
  
     // set texture properties
     _min_filter   = GL_NEAREST;
     _mag_filter   = GL_NEAREST;
     _wrap_s       = GL_CLAMP_TO_EDGE;
     _wrap_t       = GL_CLAMP_TO_EDGE;
     _resizeToPow2 = false;
 }

◆ ~SLRaytracer()

SLRaytracer::~SLRaytracer ( )

override

Definition at line 54 of file SLRaytracer.cpp.

 {
     SL_LOG("Destructor       : ~SLRaytracer");
 }

Member Function Documentation

◆ aaSamples() [1/2]

SLint SLRaytracer::aaSamples ( ) const

inline

Definition at line 119 of file SLRaytracer.h.

119 { return _aaSamples; }

◆ aaSamples() [2/2]

void SLRaytracer::aaSamples ( SLint samples )

inline

Definition at line 102 of file SLRaytracer.h.

     {
         _aaSamples = samples;
         state(rtReady);
     }

◆ aaThreshold()

SLfloat SLRaytracer::aaThreshold ( ) const

inline

Definition at line 122 of file SLRaytracer.h.

122 { return _aaThreshold; }

◆ doContinuous() [1/2]

SLbool SLRaytracer::doContinuous ( ) const

inline

Definition at line 117 of file SLRaytracer.h.

117 { return _doContinuous; }

◆ doContinuous() [2/2]

void SLRaytracer::doContinuous ( SLbool cont )

inline

Definition at line 92 of file SLRaytracer.h.

     {
         _doContinuous = cont;
         state(rtReady);
     }

◆ doDistributed() [1/2]

SLbool SLRaytracer::doDistributed ( ) const

inline

Definition at line 116 of file SLRaytracer.h.

116 { return _doDistributed; }

◆ doDistributed() [2/2]

void SLRaytracer::doDistributed ( SLbool distrib )

inline

Definition at line 91 of file SLRaytracer.h.

91 { _doDistributed = distrib; }

◆ doFresnel() [1/2]

SLbool SLRaytracer::doFresnel ( ) const

inline

Definition at line 118 of file SLRaytracer.h.

118 { return _doFresnel; }

◆ doFresnel() [2/2]

void SLRaytracer::doFresnel ( SLbool fresnel )

inline

Definition at line 97 of file SLRaytracer.h.

     {
         _doFresnel = fresnel;
         state(rtReady);
     }

◆ fogBlend()

SLCol4f SLRaytracer::fogBlend	(	SLfloat	z,
		SLCol4f	color
	)

fogBlend: Blends the a fog color to the passed color according to to OpenGL fog calculation. See OpenGL docs for more information on fog properties.

Definition at line 765 of file SLRaytracer.cpp.

 {
     SLfloat f;
  
     if (z > _sv->_camera->clipFar())
         z = _sv->_camera->clipFar();
  
     switch (_cam->fogMode())
     {
         case 0:
             f = (_cam->fogDistEnd() - z) /
                 (_cam->fogDistEnd() - _cam->fogDistStart());
             break;
         case 1:
             f = exp(-_cam->fogDensity() * z);
             break;
         default:
             f = exp(-_cam->fogDensity() * z * _cam->fogDensity() * z);
             break;
     }
     color = f * color + (1 - f) * _cam->fogColor();
     color.clampMinMax(0, 1);
     return color;
 }

◆ gamma() [1/2]

SLfloat SLRaytracer::gamma ( ) const

inline

Definition at line 124 of file SLRaytracer.h.

124 { return _gamma; }

SLRaytracer::_gamma

SLfloat _gamma

gamma correction value

Definition: SLRaytracer.h:162

◆ gamma() [2/2]

void SLRaytracer::gamma ( SLfloat g )

inline

Definition at line 107 of file SLRaytracer.h.

     {
         _gamma        = g;
         _oneOverGamma = 1.0f / g;
     }

◆ getAAPixels()

void SLRaytracer::getAAPixels ( )

This method fills the pixels into the vector pix that need to be sub-sampled because the contrast to its left and/or above neighbor is above a threshold.

Definition at line 613 of file SLRaytracer.cpp.

 {
     SLCol4f color, colorLeft, colorUp; // pixel colors to be compared
     SLVbool gotSampled;
     gotSampled.resize(_images[0]->width()); // Flags if above pixel got sampled
     SLbool isSubsampled;                    // Flag if pixel got sub-sampled
  
     // Nothing got sampled at beginning
     for (SLuint x = 0; x < _images[0]->width(); ++x)
         gotSampled[x] = false;
  
     // Loop through all pixels & add the pixel that have to be subsampled
     _aaPixels.clear();
     for (SLuint y = 0; y < _images[0]->height(); ++y)
     {
         for (SLuint x = 0; x < _images[0]->width(); ++x)
         {
             CVVec4f c4f = _images[0]->getPixeli((SLint)x, (SLint)y);
             color.set(c4f[0], c4f[1], c4f[2], c4f[3]);
  
             isSubsampled = false;
             if (x > 0)
             {
                 CVVec4f colL = _images[0]->getPixeli((SLint)x - 1, (SLint)y);
                 colorLeft.set(colL[0], colL[1], colL[2], colL[3]);
                 if (color.diffRGB(colorLeft) > _aaThreshold)
                 {
                     if (!gotSampled[x - 1])
                     {
                         _aaPixels.push_back(SLRTAAPixel((SLushort)x - 1, (SLushort)y));
                         gotSampled[x - 1] = true;
                     }
                     _aaPixels.push_back(SLRTAAPixel((SLushort)x, (SLushort)y));
                     isSubsampled = true;
                 }
             }
             if (y > 0)
             {
                 CVVec4f colU = _images[0]->getPixeli((SLint)x, (SLint)y - 1);
                 colorUp.set(colU[0], colU[1], colU[2], colU[3]);
                 if (color.diffRGB(colorUp) > _aaThreshold)
                 {
                     if (!gotSampled[x])
                         _aaPixels.push_back(SLRTAAPixel((SLushort)x, (SLushort)y - 1));
                     if (!isSubsampled)
                     {
                         _aaPixels.push_back(SLRTAAPixel((SLushort)x, (SLushort)y));
                         isSubsampled = true;
                     }
                 }
             }
             gotSampled[x] = isSubsampled;
         }
     }
     SLRay::subsampledPixels = (SLuint)_aaPixels.size();
 }

◆ initStats()

void SLRaytracer::initStats ( SLint depth )

virtual

Initialises the statistic variables in SLRay to zero

Definition at line 793 of file SLRaytracer.cpp.

 {
     SLRay::maxDepth         = (depth) ? depth : SL_MAXTRACE;
     SLRay::primaryRays      = 0;
     SLRay::reflectedRays    = 0;
     SLRay::refractedRays    = 0;
     SLRay::tirRays          = 0;
     SLRay::shadowRays       = 0;
     SLRay::subsampledRays   = 0;
     SLRay::subsampledPixels = 0;
     SLRay::tests            = 0;
     SLRay::intersections    = 0;
     SLRay::maxDepthReached  = 0;
     SLRay::avgDepth         = 0.0f;
 }

◆ maxDepth() [1/2]

SLint SLRaytracer::maxDepth ( ) const

inline

Definition at line 115 of file SLRaytracer.h.

115 { return _maxDepth; }

◆ maxDepth() [2/2]

void SLRaytracer::maxDepth ( SLint depth )

inline

Definition at line 85 of file SLRaytracer.h.

     {
         _maxDepth = depth;
         state(rtReady);
     }

◆ numThreads()

static SLuint SLRaytracer::numThreads ( )

inlinestatic

Definition at line 120 of file SLRaytracer.h.

120 { return Utils::maxThreads(); }

Utils::maxThreads

unsigned int maxThreads()

Returns in release config the max. NO. of threads otherwise 1.

Definition: Utils.cpp:1188

◆ oneOverGamma()

SLfloat SLRaytracer::oneOverGamma ( ) const

inline

Definition at line 125 of file SLRaytracer.h.

125 { return _oneOverGamma; }

◆ prepareImage()

void SLRaytracer::prepareImage ( )

virtual

Creates the inherited image in the texture class. The RT is drawn into a texture map that is displayed with OpenGL in 2D-orthographic projection. Also precalculate as much as possible.

Definition at line 850 of file SLRaytracer.cpp.

 {
     ///////////////////////
     //  PRECALCULATIONS  //
     ///////////////////////
  
     _cam = _sv->_camera; // camera shortcut
  
     // get camera vectors eye, lookAt, lookUp
     _cam->updateAndGetVM().lookAt(&_eye, &_la, &_lu, &_lr);
  
     if (_cam->projType() == P_monoOrthographic)
     {
         /*
         In orthographic projection the bottom-left vector (_bl) points
         from the eye to the center of the bottom-left pixel of a plane that
         parallel to the projection plan at zero distance from the eye.
         */
         SLVec3f pos(_cam->updateAndGetVM().translation());
         SLfloat hh = tan(Utils::DEG2RAD * _cam->fovV() * 0.5f) * pos.length();
         SLfloat hw = hh * _sv->viewportWdivH();
  
         // calculate the size of a pixel in world coords.
         _pxSize = hw * 2 / ((SLint)((SLfloat)_sv->viewportW() * _resolutionFactor));
  
         _bl = _eye - hw * _lr - hh * _lu + _pxSize / 2 * _lr - _pxSize / 2 * _lu;
     }
     else
     {
         /*
         In perspective projection the bottom-left vector (_bl) points
         from the eye to the center of the bottom-left pixel on a projection
         plan in focal distance. See also the computer graphics script about
         primary ray calculation.
         */
         // calculate half window width & height in world coords
         SLfloat hh = tan(Utils::DEG2RAD * _cam->fovV() * 0.5f) * _cam->focalDist();
         SLfloat hw = hh * _sv->viewportWdivH();
  
         // calculate the size of a pixel in world coords.
         _pxSize = hw * 2 / ((SLint)((SLfloat)_sv->viewportW() * _resolutionFactor));
  
         // calculate a vector to the center (C) of the bottom left (BL) pixel
         SLVec3f C = _la * _cam->focalDist();
         _bl       = C - hw * _lr - hh * _lu + _pxSize / 2 * _lr + _pxSize / 2 * _lu;
     }
  
     // Create the image for the first time
     if (_images.empty())
         _images.push_back(new CVImage((SLint)((SLfloat)_sv->viewportW() * _resolutionFactor),
                                       (SLint)((SLfloat)_sv->viewportH() * _resolutionFactor),
                                       PF_rgb,
                                       "Raytracer"));
  
     // Allocate image of the inherited texture class
     if ((SLint)((SLfloat)_sv->viewportW() * _resolutionFactor) != (SLint)_images[0]->width() ||
         (SLint)((SLfloat)_sv->viewportH() * _resolutionFactor) != (SLint)_images[0]->height())
     {
         // Delete the OpenGL Texture if it already exists
         if (_texID)
         {
             glDeleteTextures(1, &_texID);
             _texID = 0;
         }
  
         _vaoSprite.clearAttribs();
         _images[0]->allocate((SLint)((SLfloat)_sv->viewportW() * _resolutionFactor),
                              (SLint)((SLfloat)_sv->viewportH() * _resolutionFactor),
                              PF_rgb);
  
         _width  = (SLint)_images[0]->width();
         _height = (SLint)_images[0]->height();
         _depth  = (SLint)_images.size();
     }
  
     // Fill image black for single RT
     if (!_doContinuous) _images[0]->fill(0, 0, 0);
 }

◆ printStats()

void SLRaytracer::printStats ( SLfloat sec )

virtual

Prints some statistics after the rendering

Definition at line 812 of file SLRaytracer.cpp.

 {
     SL_LOG("\nRender time       : %10.2f sec.", sec);
     SL_LOG("Image size        : %10d x %d", _images[0]->width(), _images[0]->height());
     SL_LOG("Num. Threads      : %10d", Utils::maxThreads());
     SL_LOG("Allowed depth     : %10d", SLRay::maxDepth);
  
     SLuint primarys = (SLuint)(_sv->viewportRect().width * _sv->viewportRect().height);
     SLuint total    = primarys +
                    SLRay::reflectedRays +
                    SLRay::subsampledRays +
                    SLRay::refractedRays +
                    SLRay::shadowRays;
  
     SL_LOG("Maximum depth     : %10d", SLRay::maxDepthReached);
     SL_LOG("Average depth     : %10.6f", SLRay::avgDepth / primarys);
     SL_LOG("AA threshold      : %10.1f", _aaThreshold);
     SL_LOG("AA subsampling    : %8dx%d\n", _aaSamples, _aaSamples);
     SL_LOG("Subsampled pixels : %10u, %4.1f%% of total", SLRay::subsampledPixels, (SLfloat)SLRay::subsampledPixels / primarys * 100.0f);
     SL_LOG("Primary rays      : %10u, %4.1f%% of total", primarys, (SLfloat)primarys / total * 100.0f);
     SL_LOG("Reflected rays    : %10u, %4.1f%% of total", SLRay::reflectedRays, (SLfloat)SLRay::reflectedRays / total * 100.0f);
     SL_LOG("Refracted rays    : %10u, %4.1f%% of total", SLRay::refractedRays, (SLfloat)SLRay::refractedRays / total * 100.0f);
     SL_LOG("Ignored rays      : %10u, %4.1f%% of total", SLRay::ignoredRays, (SLfloat)SLRay::ignoredRays / total * 100.0f);
     SL_LOG("TIR rays          : %10u, %4.1f%% of total", SLRay::tirRays, (SLfloat)SLRay::tirRays / total * 100.0f);
     SL_LOG("Shadow rays       : %10u, %4.1f%% of total", SLRay::shadowRays, (SLfloat)SLRay::shadowRays / total * 100.0f);
     SL_LOG("AA subsampled rays: %10u, %4.1f%% of total", SLRay::subsampledRays, (SLfloat)SLRay::subsampledRays / total * 100.0f);
     SL_LOG("Total rays        : %10u,100.0%%\n", total);
  
     SL_LOG("Rays per second   : %10u", (SLuint)(total / sec));
     SL_LOG("Intersection tests: %10u", SLRay::tests);
     SL_LOG("Intersections     : %10u, %4.1f%%\n", SLRay::intersections, SLRay::intersections / (SLfloat)SLRay::tests * 100.0f);
 }

◆ progressPC()

SLint SLRaytracer::progressPC ( ) const

inline

Definition at line 121 of file SLRaytracer.h.

121 { return _progressPC; }

SLRaytracer::_progressPC

SLint _progressPC

progress in %

Definition: SLRaytracer.h:152

◆ raysPerMS()

SLfloat SLRaytracer::raysPerMS ( )

inline

Rays per ms of the last completed render, for comparing machines.

Measured over the whole render, so it includes the window updates that the main thread does every 500ms and the thread barrier at the end of every sample pass. Both are small, but it means the figure describes this renderer on this machine rather than raw ray throughput.

Definition at line 133 of file SLRaytracer.h.

133 { return _raysPerMS.average(); }

Utils::Averaged::average

T average()

Definition: Averaged.h:74

◆ renderClassic()

SLbool SLRaytracer::renderClassic ( SLSceneView * sv )

This is the main rendering method for the classic ray tracing. It loops over all lines and pixels and determines for each pixel a color with a partly global illumination calculation.

Definition at line 64 of file SLRaytracer.cpp.

 {
     PROFILE_FUNCTION();
  
     _sv         = sv;
     _state      = rtBusy; // From here we state the RT as busy
     _progressPC = 0;      // % rendered
     _renderSec  = 0.0f;   // reset time
  
     initStats(_maxDepth); // init statistics
     prepareImage();       // Setup image & precalculations
  
     // Measure time
     float t1     = GlobalTimer::timeS();
     float tStart = t1;
  
     for (SLuint y = 0; y < _images[0]->height(); ++y)
     {
         for (SLuint x = 0; x < _images[0]->width(); ++x)
         {
             SLRay primaryRay(_sv);
             setPrimaryRay((SLfloat)x, (SLfloat)y, &primaryRay);
  
             ///////////////////////////////////
             SLCol4f color = trace(&primaryRay);
             ///////////////////////////////////
  
             color.gammaCorrect(_oneOverGamma);
  
             _images[0]->setPixeliRGB((SLint)x,
                                      (SLint)y,
                                      CVVec4f(color.r,
                                              color.g,
                                              color.b,
                                              color.a));
  
             SLRay::avgDepth += (SLfloat)SLRay::depthReached;
             SLRay::maxDepthReached = std::max(SLRay::depthReached,
                                               SLRay::maxDepthReached);
         }
  
         // Update image after 500 ms
         double t2 = GlobalTimer::timeS();
         if (t2 - t1 > 0.5)
         {
             _progressPC = (SLint)((SLfloat)y / (SLfloat)_images[0]->height() * 100);
             renderUIBeforeUpdate();
             _sv->onWndUpdate();
             t1 = GlobalTimer::timeS();
         }
     }
  
     _renderSec = GlobalTimer::timeS() - tStart;
     _raysPerMS.set((SLfloat)SLRay::totalNumRays() / _renderSec / 1000.0f);
     _progressPC = 100;
  
     if (_doContinuous)
         _state = rtReady;
     else
     {
         _state = rtFinished;
         printStats(_renderSec);
     }
     return true;
 }

◆ renderDistrib()

SLbool SLRaytracer::renderDistrib ( SLSceneView * sv )

This is the main rendering method for parallel and distributed ray tracing.

Definition at line 133 of file SLRaytracer.cpp.

 {
     PROFILE_FUNCTION();
  
     _sv         = sv;
     _state      = rtBusy; // From here we state the RT as busy
     _progressPC = 0;      // % rendered
     _renderSec  = 0.0f;   // reset time
  
     initStats(_maxDepth); // init statistics
     prepareImage();       // Setup image & precalculations
  
     // Measure time
     float t1 = GlobalTimer::timeS();
  
     // Lambda function for async AA pixel sampling
     sampleAAPixelsAsync = [this](bool isMainThread, SLuint threadNum)
     {
         sampleAAPixels(isMainThread, threadNum);
     };
  
     // Lambda function for async slice rendering
     if (_cam->lensSamples()->samples() == 1)
     {
         renderSlicesAsync = [this](bool isMainThread, SLuint threadNum)
         {
             renderSlices(isMainThread, threadNum);
         };
     }
     else
     {
         renderSlicesAsync = [this](bool isMainThread, SLuint threadNum)
         {
             renderSlicesMS(isMainThread, threadNum);
         };
     }
  
     // Do multi-threading only in release config
     // Render image without anti-aliasing
     vector<thread> threads1; // vector for additional threads
     _nextLine = 0;           // reset _nextLine=0 be for multithreading starts
  
     // Start additional threads on the renderSlices function
     for (SLuint t = 1; t <= Utils::maxThreads() - 1; t++)
         threads1.emplace_back(renderSlicesAsync, false, t);
  
     // Do the same work in the main thread
     renderSlicesAsync(true, 0);
  
     // Wait for the other threads to finish
     for (auto& thread : threads1)
         thread.join();
  
     // Do anti-aliasing w. contrast compare in a 2nd. pass
     if (_aaSamples > 1 && _cam->lensSamples()->samples() == 1)
     {
         PROFILE_SCOPE("AntiAliasing");
  
         getAAPixels();           // Fills in the AA pixels by contrast
         vector<thread> threads2; // vector for additional threads
         _nextLine = 0;           // reset _nextLine=0 be for multithreading starts
  
         // Start additional threads on the sampleAAPixelFunction function
         for (SLuint t = 1; t <= Utils::maxThreads() - 1; t++)
             threads2.emplace_back(sampleAAPixelsAsync, false, t);
  
         // Do the same work in the main thread
         sampleAAPixelsAsync(true, 0);
  
         // Wait for the other threads to finish
         for (auto& thread : threads2)
             thread.join();
     }
  
     _renderSec = GlobalTimer::timeS() - t1;
     _raysPerMS.set((float)SLRay::totalNumRays() / _renderSec / 1000.0f);
     _progressPC = 100;
  
     if (_doContinuous)
         _state = rtReady;
     else
     {
         _state = rtFinished;
         printStats(_renderSec);
     }
     return true;
 }

◆ renderImage()

void SLRaytracer::renderImage ( bool updateTextureGL )

virtual

Draw the RT-Image as a textured quad in 2D-Orthographic projection

Definition at line 932 of file SLRaytracer.cpp.

 {
     PROFILE_FUNCTION();
  
     SLRecti vpRect = _sv->viewportRect();
     SLfloat w      = (SLfloat)vpRect.width;
     SLfloat h      = (SLfloat)vpRect.height;
  
     // Set orthographic projection with the size of the window
     SLGLState* stateGL = SLGLState::instance();
     stateGL->viewport(vpRect.x, vpRect.y, (SLsizei)w, (SLsizei)h);
     stateGL->projectionMatrix.ortho(0.0f, w, 0.0f, h, -1.0f, 0.0f);
     stateGL->viewMatrix.identity();
     stateGL->modelMatrix.identity();
     stateGL->clearColorBuffer();
     stateGL->depthTest(false);
     stateGL->multiSample(false);
     stateGL->polygonLine(false);
  
     drawSprite(updateTextureGL, 0.0f, 0.0f, w, h);
  
     stateGL->depthTest(true);
     GET_GL_ERROR;
 }

◆ renderSec()

SLfloat SLRaytracer::renderSec ( ) const

inline

Definition at line 123 of file SLRaytracer.h.

123 { return _renderSec; }

◆ renderSlices()

void SLRaytracer::renderSlices	(	bool	isMainThread,
		SLuint	threadNum
	)

Renders slices of 4 rows until the full width of the image is rendered. This method can be called as a function by multiple threads. The _nextLine index is used and incremented by every thread. So it should be locked or an atomic index. I prefer not protecting it because it's faster. If the increment is not done properly some pixels may get ray traced twice. Only the main thread is allowed to call a repaint of the image.

Definition at line 229 of file SLRaytracer.cpp.

 {
     if (!isMainThread)
     {
         PROFILE_THREAD(string("RT-Worker-") + std::to_string(threadNum));
     }
  
     PROFILE_FUNCTION();
  
     // Time points
     double t1 = 0;
  
     while (_nextLine < (SLint)_images[0]->height())
     {
         // The next section must be protected
         // Making _nextLine an atomic was not sufficient.
         _mutex.lock();
         SLint minY = _nextLine;
         _nextLine += 4;
         _mutex.unlock();
  
         for (SLint y = minY; y < minY + 4; ++y)
         {
             for (SLuint x = 0; x < _images[0]->width(); ++x)
             {
                 SLRay primaryRay(_sv);
                 setPrimaryRay((SLfloat)x, (SLfloat)y, &primaryRay);
  
                 ///////////////////////////////////
                 SLCol4f color = trace(&primaryRay);
                 ///////////////////////////////////
  
                 color.gammaCorrect(_oneOverGamma);
  
                 //_mutex.lock();
                 _images[0]->setPixeliRGB((SLint)x,
                                          (SLint)y,
                                          CVVec4f(color.r,
                                                  color.g,
                                                  color.b,
                                                  color.a));
                 //_mutex.unlock();
  
                 SLRay::avgDepth += (SLfloat)SLRay::depthReached;
                 SLRay::maxDepthReached = std::max(SLRay::depthReached,
                                                   SLRay::maxDepthReached);
             }
  
             // Update image after 500 ms
             if (_sv->onWndUpdate && isMainThread && !_doContinuous)
             {
                 if (GlobalTimer::timeS() - t1 > 0.5)
                 {
                     _progressPC = (SLint)((SLfloat)y /
                                           (SLfloat)_images[0]->height() * 100);
                     if (_aaSamples > 0) _progressPC /= 2;
                     renderUIBeforeUpdate();
                     _sv->onWndUpdate();
                     t1 = GlobalTimer::timeS();
                 }
             }
         }
     }
 }

◆ renderSlicesMS()

void SLRaytracer::renderSlicesMS	(	bool	isMainThread,
		SLuint	threadNum
	)

Renders slices of 4 rows multi-sampled until the full width of the image is rendered. Every pixel is multi-sampled for depth of field lens sampling. This method can be called as a function by multiple threads. The _nextLine index is used and incremented by every thread. So it should be locked or an atomic index. I prefer not protecting it because it's faster. If the increment is not done properly some pixels may get ray traced twice. Only the main thread is allowed to call a repaint of the image.

Definition at line 303 of file SLRaytracer.cpp.

 {
     if (!isMainThread)
     {
         PROFILE_THREAD(string("RT-Worker-") + std::to_string(threadNum));
     }
  
     PROFILE_FUNCTION();
  
     // Time points
     double t1 = 0;
  
     // lens sampling constants
     SLVec3f lensRadiusX = _lr * (_cam->lensDiameter() * 0.5f);
     SLVec3f lensRadiusY = _lu * (_cam->lensDiameter() * 0.5f);
  
     while (_nextLine < (SLint)_images[0]->width())
     {
         // The next section must be protected
         // Making _nextLine an atomic was not sufficient.
         _mutex.lock();
         SLint minY = _nextLine;
         _nextLine += 4;
         _mutex.unlock();
  
         for (SLint y = minY; y < minY + 4; ++y)
         {
             for (SLuint x = 0; x < _images[0]->width(); ++x)
             {
                 // focal point is single shot primary dir
                 SLVec3f primaryDir(_bl + _pxSize * ((SLfloat)x * _lr + (SLfloat)y * _lu));
                 SLVec3f FP = _eye + primaryDir;
                 SLCol4f color(SLCol4f::BLACK);
  
                 // Loop over radius r and angle phi of lens
                 for (SLint iR = (SLint)_cam->lensSamples()->samplesX() - 1; iR >= 0; --iR)
                 {
                     for (SLint iPhi = (SLint)_cam->lensSamples()->samplesY() - 1; iPhi >= 0; --iPhi)
                     {
                         SLVec2f discPos(_cam->lensSamples()->point((SLuint)iR, (SLuint)iPhi));
  
                         // calculate lens position out of disc position
                         SLVec3f lensPos(_eye + discPos.x * lensRadiusX + discPos.y * lensRadiusY);
                         SLVec3f lensToFP(FP - lensPos);
                         lensToFP.normalize();
  
                         SLCol4f backColor;
                         if (_sv->s()->skybox())
                             backColor = _sv->s()->skybox()->colorAtDir(lensToFP);
                         else
                             backColor = _sv->camera()->background().colorAtPos((SLfloat)x,
                                                                                (SLfloat)y,
                                                                                (SLfloat)_images[0]->width(),
                                                                                (SLfloat)_images[0]->height());
  
                         SLRay primaryRay(lensPos, lensToFP, (SLfloat)x, (SLfloat)y, backColor, _sv);
  
                         ////////////////////////////
                         color += trace(&primaryRay);
                         ////////////////////////////
  
                         SLRay::avgDepth += (SLfloat)SLRay::depthReached;
                         SLRay::maxDepthReached = std::max(SLRay::depthReached,
                                                           SLRay::maxDepthReached);
                     }
                 }
                 color /= (SLfloat)_cam->lensSamples()->samples();
  
                 color.gammaCorrect(_oneOverGamma);
  
                 //_mutex.lock();
                 _images[0]->setPixeliRGB((SLint)x, y, CVVec4f(color.r, color.g, color.b, color.a));
                 //_mutex.unlock();
  
                 SLRay::avgDepth += (SLfloat)SLRay::depthReached;
                 SLRay::maxDepthReached = std::max(SLRay::depthReached, SLRay::maxDepthReached);
             }
  
             if (_sv->onWndUpdate && isMainThread && !_doContinuous)
             {
                 if (GlobalTimer::timeS() - t1 > 0.5)
                 {
                     renderUIBeforeUpdate();
                     _sv->onWndUpdate();
                     t1 = GlobalTimer::timeS();
                 }
             }
         }
     }
 }

◆ renderUIBeforeUpdate()

void SLRaytracer::renderUIBeforeUpdate ( )

Must be called before an inbetween frame updateRec.

Definition at line 976 of file SLRaytracer.cpp.

 {
     _sv->gui()->onPaint(_sv->viewportRect());
     SLGLState::instance()->unbindAnythingAndFlush();
 }

◆ resolutionFactor() [1/2]

SLfloat SLRaytracer::resolutionFactor ( ) const

inline

Definition at line 126 of file SLRaytracer.h.

126 { return _resolutionFactor; }

◆ resolutionFactor() [2/2]

void SLRaytracer::resolutionFactor ( SLfloat rf )

inline

Definition at line 90 of file SLRaytracer.h.

90 { _resolutionFactor = rf; }

◆ resolutionFactorPC()

SLint SLRaytracer::resolutionFactorPC ( ) const

inline

Definition at line 127 of file SLRaytracer.h.

127 { return (SLint)(_resolutionFactor * 100.0f + 0.00001f); }

◆ sampleAAPixels()

void SLRaytracer::sampleAAPixels	(	bool	isMainThread,
		SLuint	threadNum
	)

SLRaytracer::sampleAAPixels does the subsampling of the pixels that need to be antialiased. See also getAAPixels. This routine can be called by multiple threads. The _nextLine index is used and incremented by every thread. So it should be locked or an atomic index. I prefer not protecting it because it's faster. If the increment is not done properly some pixels may get ray traced twice. Only the main thread is allowed to call a repaint of the image.

Definition at line 679 of file SLRaytracer.cpp.

 {
     if (!isMainThread)
     {
         PROFILE_THREAD(string("RT-Worker-") + std::to_string(threadNum));
     }
  
     PROFILE_FUNCTION();
  
     assert(_aaSamples % 2 == 1 && "subSample: maskSize must be uneven");
     double t1 = 0, t2;
  
     while (_nextLine < (SLint)_aaPixels.size())
     {
         // The next section must be protected
         // Making _nextLine an atomic was not sufficient.
         _mutex.lock();
         SLuint mini = (SLuint)_nextLine;
         _nextLine += 4;
         _mutex.unlock();
  
         for (SLuint i = mini; i < mini + 4 && i < _aaPixels.size(); ++i)
         {
             SLuint  x   = _aaPixels[i].x;
             SLuint  y   = _aaPixels[i].y;
             CVVec4f c4f = _images[0]->getPixeli((SLint)x, (SLint)y);
             SLCol4f centerColor(c4f[0], c4f[1], c4f[2], c4f[3]);
             SLint   centerIndex = _aaSamples >> 1;
             SLfloat f           = 1.0f / (SLfloat)_aaSamples;
             SLfloat xpos        = (SLfloat)x - (SLfloat)centerIndex * f;
             SLfloat ypos        = (SLfloat)y - (SLfloat)centerIndex * f;
             SLfloat samples     = (SLfloat)_aaSamples * (SLfloat)_aaSamples;
             SLCol4f color(0, 0, 0);
  
             // Loop regularly over the float pixel
  
             for (SLint sy = 0; sy < _aaSamples; ++sy)
             {
                 for (SLint sx = 0; sx < _aaSamples; ++sx)
                 {
                     if (sx == centerIndex && sy == centerIndex)
                         color += centerColor; // don't shoot for center position
                     else
                     {
                         SLRay primaryRay(_sv);
                         setPrimaryRay(xpos + (SLfloat)sx * f,
                                       ypos + (SLfloat)sy * f,
                                       &primaryRay);
                         color += trace(&primaryRay);
                     }
                 }
                 ypos += f;
             }
             SLRay::subsampledRays += (SLuint)samples;
             color /= samples;
  
             color.gammaCorrect(_oneOverGamma);
  
             //_mutex.lock();
             _images[0]->setPixeliRGB((SLint)x,
                                      (SLint)y,
                                      CVVec4f(color.r,
                                              color.g,
                                              color.b,
                                              color.a));
             //_mutex.unlock();
         }
  
         if (_sv->onWndUpdate && isMainThread && !_doContinuous)
         {
             t2 = GlobalTimer::timeS();
             if (t2 - t1 > 0.5)
             {
                 _progressPC = 50 + (SLint)((SLfloat)_nextLine / (SLfloat)_aaPixels.size() * 50);
                 renderUIBeforeUpdate();
                 _sv->onWndUpdate();
                 t1 = GlobalTimer::timeS();
             }
         }
     }
 }

◆ saveImage()

void SLRaytracer::saveImage ( )

virtual

Saves the current RT image as PNG image.

Reimplemented in SLPathtracer.

Definition at line 958 of file SLRaytracer.cpp.

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

◆ setPrimaryRay()

void SLRaytracer::setPrimaryRay	(	SLfloat	x,
		SLfloat	y,
		SLRay *	primaryRay
	)

Set the parameters of a primary ray for a pixel position at x, y.

Definition at line 472 of file SLRaytracer.cpp.

 {
     primaryRay->x  = x;
     primaryRay->y  = y;
     primaryRay->sv = _sv;
  
     // calculate ray from eye to pixel (See also prepareImage())
     if (_cam->projType() == P_monoOrthographic)
     {
         primaryRay->setDir(_la);
         primaryRay->origin = _bl + _pxSize * ((SLfloat)x * _lr + (SLfloat)y * _lu);
     }
     else
     {
         SLVec3f primaryDir(_bl + _pxSize * ((SLfloat)x * _lr + (SLfloat)y * _lu));
         primaryDir.normalize();
         primaryRay->setDir(primaryDir);
         primaryRay->origin = _eye;
     }
  
     if (_sv->s()->skybox())
         primaryRay->backgroundColor = _sv->s()->skybox()->colorAtDir(primaryRay->dir);
     else
         primaryRay->backgroundColor = _sv->camera()->background().colorAtPos(x,
                                                                              y,
                                                                              (SLfloat)_images[0]->width(),
                                                                              (SLfloat)_images[0]->height());
     SLRay::primaryRays++;
 }

◆ shade()

SLCol4f SLRaytracer::shade ( SLRay * ray )

This method calculates the local illumination at the rays intersection point. It uses the Blinn-Phong local reflection model where the color is calculated as follows: color = material emission + global ambient light scaled by the material's ambient color + ambient, diffuse, and specular contributions from all lights, properly attenuated

Definition at line 511 of file SLRaytracer.cpp.

 {
     SLMaterial*   mat     = ray->hitMesh->mat();
     SLVGLTexture& texture = mat->textures(TT_diffuse);
     SLVec3f       L, N, H;
     SLfloat       lightDist, LdotN, NdotH, df, sf, spotEffect, att, lighted;
     SLCol4f       ambi, diff, spec;
     SLCol4f       localSpec(0, 0, 0, 1);
     SLScene*      s          = _sv->s();
     SLCol4f       localColor = mat->emissive() + (mat->ambient() & SLLight::globalAmbient);
  
     ray->hitMesh->preShade(ray);
  
     for (auto* light : s->lights())
     {
         if (light && light->isOn())
         {
             // calculate light vector L and distance to light
             N.set(ray->hitNormal);
  
             // Distinguish between point and directional lights
             SLVec4f lightPos = light->positionWS();
  
             // Check if directional light on last component w (0 = light is in infinity)
             if (lightPos.w == 0.0f)
             {
                 // directional light
                 L         = -light->spotDirWS().normalized();
                 lightDist = FLT_MAX; // = infinity
             }
             else
             {
                 // Point light
                 L.sub(lightPos.vec3(), ray->hitPoint);
                 lightDist = L.length();
                 L /= lightDist;
             }
  
             // Cosine between L and N
             LdotN = L.dot(N);
  
             // check shadow ray if hit point is towards the light
             lighted = (LdotN > 0) ? light->shadowTest(ray, L, lightDist, s->root3D()) : 0;
  
             // calculate the ambient part
             ambi = light->ambient() & mat->ambient() * ray->hitAO;
  
             // calculate spot effect if light is a spotlight
             spec.set(0, 0, 0);
             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;
  
             // calculate local illumination only if point is not shaded
             if (lighted > 0.0f)
             {
                 H.sub(L, ray->dir); // half vector between light & eye
                 H.normalize();
                 df    = std::max(LdotN, 0.0f); // diffuse factor
                 NdotH = std::max(N.dot(H), 0.0f);
                 sf    = pow(NdotH, (SLfloat)mat->shininess()); // specular factor
  
                 diff += lighted * df * light->diffuse() & mat->diffuse();
                 spec = lighted * sf * light->specular() & mat->specular();
             }
  
             // apply attenuation and spot effect
             att = light->attenuation(lightDist);
             localColor += att * ambi;
             localColor += att * spotEffect * diff;
             localSpec += att * spotEffect * spec;
         }
     }
  
     if (!texture.empty() || !ray->hitMesh->C.empty())
     {
         localColor &= ray->hitTexColor; // component wise multiply
         localColor += localSpec;        // add afterwards the specular component
     }
     else
         localColor += localSpec;
  
     localColor.clampMinMax(0, 1);
     return localColor;
 }

◆ state() [1/2]

SLRTState SLRaytracer::state ( ) const

inline

Definition at line 114 of file SLRaytracer.h.

114 { return _state; }

◆ state() [2/2]

void SLRaytracer::state ( SLRTState state )

inline

Definition at line 81 of file SLRaytracer.h.

     {
         if (_state != rtBusy) _state = state;
     }

◆ trace()

SLCol4f SLRaytracer::trace ( SLRay * ray )

This method is the classic recursive ray tracing method that checks the scene for intersection. If the ray hits an object the local color is calculated and if the material is reflective and/or transparent new rays are created and passed to this trace method again. If no object got intersected the background color is return.

Definition at line 401 of file SLRaytracer.cpp.

 {
     SLCol4f color(ray->backgroundColor);
  
     // Intersect scene
     SLNode* root = _sv->s()->root3D();
     if (root) root->hitRec(ray);
  
     if (ray->length < FLT_MAX && ray->hitMesh && ray->hitMesh->primitive() == PT_triangles)
     {
         color = shade(ray);
  
         SLfloat kt = ray->hitMesh->mat()->kt();
         SLfloat kr = ray->hitMesh->mat()->kr();
  
         if (ray->depth < SLRay::maxDepth && ray->contrib > SLRay::minContrib)
         {
             if (!_doFresnel)
             {
                 // Do classic refraction and/or reflection
                 if (kt > 0.0f)
                 {
                     SLRay refracted(_sv);
                     ray->refract(&refracted);
                     color += kt * trace(&refracted);
                 }
                 if (kr > 0.0f)
                 {
                     SLRay reflected(_sv);
                     ray->reflect(&reflected);
                     color += kr * trace(&reflected);
                 }
             }
             else
             {
                 // Mix refr. & refl. color w. Fresnel approximation
                 if (kt > 0.0f)
                 {
                     SLRay refracted(_sv), reflected(_sv);
                     ray->refract(&refracted);
                     ray->reflect(&reflected);
                     SLCol4f refrCol = trace(&refracted);
                     SLCol4f reflCol = trace(&reflected);
  
                     // Apply Schlick's Fresnel approximation
                     SLfloat F0      = kr;
                     SLfloat theta   = -(ray->dir * ray->hitNormal);
                     SLfloat F_theta = F0 + (1 - F0) * (SLfloat)pow(1 - theta, 5);
                     color += refrCol * (1 - F_theta) + reflCol * F_theta;
                 }
                 else
                 {
                     if (kr > 0.0f)
                     {
                         SLRay reflected(_sv);
                         ray->reflect(&reflected);
                         color += kr * trace(&reflected);
                     }
                 }
             }
         }
     }
  
     if (_cam->fogIsOn())
         color = fogBlend(ray->length, color);
  
     color.clampMinMax(0, 1);
     return color;
 }

Member Data Documentation

◆ _aaPixels

SLVPixel SLRaytracer::_aaPixels

protected

Vector for antialiasing pixels.

Definition at line 161 of file SLRaytracer.h.

◆ _aaSamples

SLint SLRaytracer::_aaSamples

protected

SQRT of uneven num. of AA samples.

Definition at line 167 of file SLRaytracer.h.

◆ _aaThreshold

SLfloat SLRaytracer::_aaThreshold

protected

threshold for anti aliasing

Definition at line 166 of file SLRaytracer.h.

◆ _bl

SLVec3f SLRaytracer::_bl

protected

Bottom left vector.

Definition at line 159 of file SLRaytracer.h.

◆ _cam

SLCamera* SLRaytracer::_cam

protected

shortcut to the camera

Definition at line 146 of file SLRaytracer.h.

◆ _doContinuous

SLbool SLRaytracer::_doContinuous

protected

if true state goes into ready again

Definition at line 149 of file SLRaytracer.h.

◆ _doDistributed

SLbool SLRaytracer::_doDistributed

protected

Flag for parallel distributed RT.

Definition at line 150 of file SLRaytracer.h.

◆ _doFresnel

SLbool SLRaytracer::_doFresnel

protected

Flag for Fresnel reflection.

Definition at line 151 of file SLRaytracer.h.

◆ _eye

SLVec3f SLRaytracer::_eye

protected

Camera position.

Definition at line 157 of file SLRaytracer.h.

◆ _gamma

SLfloat SLRaytracer::_gamma

protected

gamma correction value

Definition at line 162 of file SLRaytracer.h.

◆ _la

SLVec3f SLRaytracer::_la

protected

Definition at line 158 of file SLRaytracer.h.

◆ _lr

SLVec3f SLRaytracer::_lr

protected

Camera lookat, lookup, lookright.

Definition at line 158 of file SLRaytracer.h.

◆ _lu

SLVec3f SLRaytracer::_lu

protected

Definition at line 158 of file SLRaytracer.h.

◆ _maxDepth

SLint SLRaytracer::_maxDepth

protected

Max. allowed recursion depth.

Definition at line 148 of file SLRaytracer.h.

◆ _nextLine

SLint SLRaytracer::_nextLine

protected

next line index to render RT in a thread

Definition at line 160 of file SLRaytracer.h.

◆ _oneOverGamma

SLfloat SLRaytracer::_oneOverGamma

protected

one over gamma correction value

Definition at line 163 of file SLRaytracer.h.

◆ _progressPC

SLint SLRaytracer::_progressPC

protected

progress in %

Definition at line 152 of file SLRaytracer.h.

◆ _pxSize

SLfloat SLRaytracer::_pxSize

protected

Pixel size.

Definition at line 156 of file SLRaytracer.h.

◆ _raysPerMS

AvgFloat SLRaytracer::_raysPerMS

protected

Rays per ms of the last completed render.

Definition at line 154 of file SLRaytracer.h.

◆ _renderSec

SLfloat SLRaytracer::_renderSec

protected

Rendering time in seconds.

Definition at line 153 of file SLRaytracer.h.

◆ _resolutionFactor

SLfloat SLRaytracer::_resolutionFactor

protected

screen to RT image size factor (default 1.0)

Definition at line 147 of file SLRaytracer.h.

◆ _state

SLRTState SLRaytracer::_state

protected

RT state;.

Definition at line 145 of file SLRaytracer.h.

◆ _sv

SLSceneView* SLRaytracer::_sv

protected

Parent sceneview.

Definition at line 144 of file SLRaytracer.h.

◆ renderSlicesAsync

function<void(bool, SLuint)> SLRaytracer::renderSlicesAsync

protected

Definition at line 141 of file SLRaytracer.h.

◆ sampleAAPixelsAsync

function<void(bool, SLuint)> SLRaytracer::sampleAAPixelsAsync

protected

Definition at line 142 of file SLRaytracer.h.

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

Public Member Functions

Static Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SLRaytracer()

◆ ~SLRaytracer()

Member Function Documentation

◆ aaSamples() [1/2]

◆ aaSamples() [2/2]

◆ aaThreshold()

◆ doContinuous() [1/2]

◆ doContinuous() [2/2]

◆ doDistributed() [1/2]

◆ doDistributed() [2/2]

◆ doFresnel() [1/2]

◆ doFresnel() [2/2]

◆ fogBlend()

◆ gamma() [1/2]

◆ gamma() [2/2]

◆ getAAPixels()

◆ initStats()

◆ maxDepth() [1/2]

◆ maxDepth() [2/2]

◆ numThreads()

◆ oneOverGamma()

◆ prepareImage()

◆ printStats()

◆ progressPC()

◆ raysPerMS()

◆ renderClassic()

◆ renderDistrib()

◆ renderImage()

◆ renderSec()

◆ renderSlices()

◆ renderSlicesMS()

◆ renderUIBeforeUpdate()

◆ resolutionFactor() [1/2]

◆ resolutionFactor() [2/2]

◆ resolutionFactorPC()

◆ sampleAAPixels()

◆ saveImage()

◆ setPrimaryRay()

◆ shade()

◆ state() [1/2]

◆ state() [2/2]

◆ trace()

Member Data Documentation

◆ _aaPixels

◆ _aaSamples

◆ _aaThreshold

◆ _bl

◆ _cam

◆ _doContinuous

◆ _doDistributed

◆ _doFresnel

◆ _eye

◆ _gamma

◆ _la

◆ _lr

◆ _lu

◆ _maxDepth

◆ _nextLine

◆ _oneOverGamma

◆ _progressPC

◆ _pxSize

◆ _raysPerMS

◆ _renderSec

◆ _resolutionFactor

◆ _state

◆ _sv

◆ renderSlicesAsync

◆ sampleAAPixelsAsync