Ray class with ray and intersection properties. More...

#include <SLRay.h>

Public Member Functions
	SLRay (SLSceneView *sv=nullptr)
	default ctor More...

	SLRay (const SLVec3f &Origin, const SLVec3f &Dir, SLfloat X, SLfloat Y, const SLCol4f &backColor, SLSceneView *sv)
	ctor for primary rays More...

	SLRay (SLfloat distToLight, const SLVec3f &dirToLight, SLRay *rayFromHitPoint)
	ctor for shadow rays More...

void	reflect (SLRay *reflected) const

void	refract (SLRay *refracted)

bool	reflectMC (SLRay *reflected, const SLMat3f &rotMat) const

bool	refractMC (SLRay *refracted, const SLMat3f &rotMat) const

void	diffuseMC (SLRay *scattered) const

void	print () const

void	setDir (const SLVec3f &Dir)
	Setter for the rays direction in world space also setting the inverse direction. More...

void	setDirOS (const SLVec3f &Dir)
	Setter for the rays direction in object space also setting the inverse direction. More...

void	normalizeNormal ()

SLbool	isShaded () const
	Returns true if a shadow ray hits an object on the ray to the light. More...

SLbool	hitMatIsReflective () const
	Returns true if the hit material specular color is not black. More...

SLbool	hitMatIsTransparent () const
	Returns true if the hit material transmission color is not black. More...

SLbool	hitMatIsDiffuse () const
	Returns true if the hit material diffuse color is not black. More...

Static Public Member Functions
static SLMat3f	lobeToWorld (const SLVec3f &lobeAxis)
	Rotation matrix that maps a sample drawn around +z onto lobeAxis. More...

static SLuint	totalNumRays ()
	Total NO. of rays shot during RT. More...

Public Attributes
SLVec3f	origin
	Vector to the origin of ray in WS. More...

SLVec3f	dir
	Direction vector of ray in WS. More...

SLfloat	length
	length from origin to an intersection More...

SLint	depth
	Recursion depth for ray tracing. More...

SLfloat	contrib
	Current contribution of ray to color. More...

SLVec3f	originOS
	Vector to the origin of ray in OS. More...

SLVec3f	dirOS
	Direction vector of ray in OS. More...

SLRayType	type
	PRIMARY, REFLECTED, REFRACTED, SHADOW. More...

SLfloat	lightDist
	Distance to light for shadow rays. More...

SLfloat	x

SLfloat	y
	Pixel position for primary rays. More...

SLbool	isOutside
	Flag if ray is inside of a material. More...

SLbool	isInsideVolume
	Flag if ray is in Volume. More...

SLNode *	srcNode
	Points to the node at ray origin. More...

SLMesh *	srcMesh
	Points to the mesh at ray origin. More...

SLint	srcTriangle
	Points to the triangle at ray origin. More...

SLCol4f	backgroundColor
	Background color at pixel x,y. More...

SLSceneView *	sv
	Pointer to the sceneview. More...

SLfloat	hitU

SLfloat	hitV
	barycentric coords in hit triangle More...

SLNode *	hitNode
	Points to the intersected node. More...

SLMesh *	hitMesh
	Points to the intersected mesh. More...

SLint	hitTriangle
	Points to the intersected triangle. More...

SLVec3f	hitPoint
	Point of intersection. More...

SLVec3f	hitNormal
	Surface normal at intersection point. More...

SLCol4f	hitTexColor
	Color at intersection for texture or color attributes. More...

SLfloat	hitAO
	Ambient occlusion factor at intersection point. More...

SLVec3f	invDir
	Inverse ray dir for fast AABB hit in WS. More...

SLVec3f	invDirOS
	Inverse ray dir for fast AABB hit in OS. More...

SLint	sign [3]
	Sign of invDir for fast AABB hit in WS. More...

SLint	signOS [3]
	Sign of invDir for fast AABB hit in OS. More...

SLfloat	tmin
	min. dist. of last AABB intersection More...

SLfloat	tmax
	max. dist. of last AABB intersection More...

Static Public Attributes
static SLint	maxDepth = 0
	Max. recursion depth. More...

static SLfloat	minContrib = 1.0 / 256.0
	Min. contibution to color (1/256) More...

static SLuint	primaryRays = 0
	NO. of primary rays shot. More...

static SLuint	reflectedRays = 0
	NO. of reflected rays. More...

static SLuint	refractedRays = 0
	NO. of refracted rays. More...

static SLuint	ignoredRays = 0
	NO. of ignore refraction rays. More...

static SLuint	shadowRays = 0
	NO. of shadow rays. More...

static SLuint	tirRays = 0
	NO. of TIR refraction rays. More...

static SLuint	tests = 0
	NO. of intersection tests. More...

static SLuint	intersections = 0
	NO. of intersection. More...

static SLint	depthReached = 1
	depth reached for a primary ray More...

static SLint	maxDepthReached = 0
	max. depth reached for all rays More...

static SLfloat	avgDepth = 0
	average depth reached More...

static SLuint	subsampledRays = 0
	NO. of of subsampled rays. More...

static SLuint	subsampledPixels = 0
	NO. of of subsampled pixels. More...

Detailed Description

Ray class with ray and intersection properties.

Ray class for Ray Tracing. It not only holds informations about the ray itself but also about the node hit by the ray. With that information the method reflect calculates a reflected ray and the method transmit calculates a REFRACTED ray.

Definition at line 39 of file SLRay.h.

Constructor & Destructor Documentation

◆ SLRay() [1/3]

SLRay::SLRay ( SLSceneView * sceneView = nullptr )

explicit

default ctor

SLRay::SLRay default constructor

Definition at line 65 of file SLRay.cpp.

 {
     origin = SLVec3f::ZERO;
     setDir(SLVec3f::ZERO);
     type           = PRIMARY;
     length         = FLT_MAX;
     depth          = 1;
     hitTriangle    = -1;
     hitPoint       = SLVec3f::ZERO;
     hitNormal      = SLVec3f::ZERO;
     hitTexColor    = SLCol4f::WHITE;
     hitAO          = 1.0f;
     hitNode        = nullptr;
     hitMesh        = nullptr;
     srcNode        = nullptr;
     srcMesh        = nullptr;
     srcTriangle    = -1;
     x              = -1;
     y              = -1;
     contrib        = 1.0f;
     isOutside      = true;
     isInsideVolume = false;
     sv             = sceneView;
 }

◆ SLRay() [2/3]

SLRay::SLRay	(	const SLVec3f &	Origin,
		const SLVec3f &	Dir,
		SLfloat	X,
		SLfloat	Y,
		const SLCol4f &	backColor,
		SLSceneView *	sceneView
	)

ctor for primary rays

SLRay::SLRay constructor for primary rays

Definition at line 93 of file SLRay.cpp.

 {
     origin = Origin;
     setDir(Dir);
     type            = PRIMARY;
     length          = FLT_MAX;
     depth           = 1;
     hitTriangle     = -1;
     hitPoint        = SLVec3f::ZERO;
     hitNormal       = SLVec3f::ZERO;
     hitTexColor     = SLCol4f::WHITE;
     hitAO           = 1.0f;
     hitNode         = nullptr;
     hitMesh         = nullptr;
     srcNode         = nullptr;
     srcMesh         = nullptr;
     srcTriangle     = -1;
     x               = (SLfloat)X;
     y               = (SLfloat)Y;
     contrib         = 1.0f;
     isOutside       = true;
     isInsideVolume  = false;
     backgroundColor = backColor;
     sv              = sceneView;
 }

◆ SLRay() [3/3]

SLRay::SLRay	(	SLfloat	distToLight,
		const SLVec3f &	dirToLight,
		SLRay *	rayFromHitPoint
	)

ctor for shadow rays

SLRay::SLRay constructor for shadow rays

Definition at line 127 of file SLRay.cpp.

 {
     origin = rayFromHitPoint->hitPoint;
     setDir(dirToLight);
     type            = SHADOW;
     length          = distToLight;
     lightDist       = distToLight;
     depth           = rayFromHitPoint->depth;
     hitPoint        = SLVec3f::ZERO;
     hitNormal       = SLVec3f::ZERO;
     hitTexColor     = SLCol4f::WHITE;
     hitAO           = 1.0f;
     hitTriangle     = -1;
     hitNode         = nullptr;
     hitMesh         = nullptr;
     srcNode         = rayFromHitPoint->hitNode;
     srcMesh         = rayFromHitPoint->hitMesh;
     srcTriangle     = rayFromHitPoint->hitTriangle;
     x               = rayFromHitPoint->x;
     y               = rayFromHitPoint->y;
     backgroundColor = rayFromHitPoint->backgroundColor;
     sv              = rayFromHitPoint->sv;
     contrib         = 0.0f;
     isOutside       = rayFromHitPoint->isOutside;
     shadowRays++;
 }

Member Function Documentation

◆ diffuseMC()

void SLRay::diffuseMC ( SLRay * scattered ) const

SLRay::diffuseMC scatters a ray around the hit normal with a cosine distribution, which is the importance sampling of the Lambertian BRDF: the density is cos(theta)/PI, so it cancels the cosine of the rendering equation and every sample carries the same weight. SLPathtracer::trace is its only caller in this repository.

The random direction lies around the z-Axis and is then transformed by a rotation matrix to lie along the normal. The direction is calculated according to MCCABE.

Remarks: The comment here used to read "This is only used for photonmapping(russian roulette)". Both halves were wrong. Cosine distributed scattering is importance sampling and has nothing to do with Russian roulette, which is the unrelated technique that terminates the recursion in SLPathtracer::trace (see plan point 13), and there is no photon mapper in this repository.

Definition at line 542 of file SLRay.cpp.

 {
     SLVec3f randVec;
     SLfloat eta1, eta2, eta1sqrt;
  
     scattered->setDir(hitNormal);
     scattered->origin = hitPoint;
     scattered->depth  = depth + 1;
     depthReached      = scattered->depth;
  
     // for reflectance the start material stays the same
     scattered->srcNode = hitNode;
     scattered->srcMesh = hitMesh;
     scattered->type    = REFLECTED;
  
     // Rotation matrix that takes the +z lobe onto the hit normal. See
     // SLRay::lobeToWorld for why this is not built from an axis and an angle.
     SLMat3f rotMat = lobeToWorld(scattered->dir);
  
     // cosine distribution
     eta1     = rnd01();
     eta2     = Utils::TWOPI * rnd01();
     eta1sqrt = sqrt(1 - eta1);
  
     // transform to cartesian
     randVec.set(eta1sqrt * cos(eta2),
                 eta1sqrt * sin(eta2),
                 sqrt(eta1));
  
     // Apply rotation
     scattered->setDir(rotMat * randVec);
  
     // Set pixel and background
     scattered->x  = x;
     scattered->y  = y;
     scattered->sv = sv;
     if (sv->s()->skybox())
         scattered->backgroundColor = sv->s()->skybox()->colorAtDir(scattered->dir);
     else
         scattered->backgroundColor = backgroundColor;
 }

◆ hitMatIsDiffuse()

SLbool SLRay::hitMatIsDiffuse ( ) const

inline

Returns true if the hit material diffuse color is not black.

Definition at line 219 of file SLRay.h.

 {
     if (!hitMesh) return false;
     SLMaterial* mat = hitMesh->mat();
     return ((mat->diffuse().r > 0.0f) ||
             (mat->diffuse().g > 0.0f) ||
             (mat->diffuse().b > 0.0f));
 }

◆ hitMatIsReflective()

SLbool SLRay::hitMatIsReflective ( ) const

inline

Returns true if the hit material specular color is not black.

Definition at line 197 of file SLRay.h.

 {
     if (!hitMesh) return false;
     SLMaterial* mat = hitMesh->mat();
     return ((mat->specular().r > 0.0f) ||
             (mat->specular().g > 0.0f) ||
             (mat->specular().b > 0.0f));
 }

◆ hitMatIsTransparent()

SLbool SLRay::hitMatIsTransparent ( ) const

inline

Returns true if the hit material transmission color is not black.

Definition at line 208 of file SLRay.h.

 {
     if (!hitMesh) return false;
     SLMaterial* mat = hitMesh->mat();
     return ((mat->transmissive().r > 0.0f) ||
             (mat->transmissive().g > 0.0f) ||
             (mat->transmissive().b > 0.0f));
 }

◆ isShaded()

SLbool SLRay::isShaded ( ) const

inline

Returns true if a shadow ray hits an object on the ray to the light.

Definition at line 190 of file SLRay.h.

 {
     return type == SHADOW && length < lightDist;
 }

◆ lobeToWorld()

SLMat3f SLRay::lobeToWorld ( const SLVec3f & lobeAxis )

static

Rotation matrix that maps a sample drawn around +z onto lobeAxis.

SLRay::lobeToWorld returns the rotation matrix that maps a direction sampled around the +z axis onto lobeAxis. Its columns are an orthonormal basis whose third vector is lobeAxis, so that rotMat * v = v.x*t + v.y*b + v.z*lobeAxis.

This replaces the axis-angle construction that the scattering functions used to do themselves:

SLVec3f rotAxis((SLVec3f(0,0,1) ^ dir).normalize());
rotMat.rotation(acos(dir.z) * 180 * ONEOVERPI, rotAxis);

which fails exactly where it is used most. The cross product is (-dir.y, dir.x, 0) and its length is the sine of the angle, so it vanishes for a lobe axis along +-z. SLVec3::normalize guards with if (L > 0) and therefore returns the zero vector rather than a NaN, and the matrix built from a zero axis is diag(cos a, cos a, cos a) - a uniform scale, not a rotation. It happens to be usable at exactly +-z (identity and -I, and -I is fine for an azimuthally symmetric lobe) but the axis loses its precision continuously as the lobe approaches either pole, and acos(dir.z) additionally returns a NaN as soon as rounding pushes |dir.z| past 1. In the Muttenzer Box the box is axis aligned and the front and back walls face +-z, so this is the common case and not a corner one.

The basis is the branchless construction of Duff et al., "Building an Orthonormal Basis, Revisited", JCGT 6(1), 2017. It is exact and orthonormal for every unit vector including both poles, needs no trigonometry, and has no branch on a tolerance that has to be tuned.

Definition at line 372 of file SLRay.cpp.

 {
     SLVec3f n(lobeAxis);
     n.normalize();
  
     SLfloat sign = std::copysign(1.0f, n.z);
     SLfloat a    = -1.0f / (sign + n.z);
     SLfloat b    = n.x * n.y * a;
  
     SLVec3f t(1.0f + sign * n.x * n.x * a, sign * b, -sign * n.x);
     SLVec3f u(b, sign + n.y * n.y * a, -n.y);
  
     // The SLMat3 constructor takes the components in row order and stores them
     // column wise, so this sets the columns to t, u and n.
     return SLMat3f(t.x, u.x, n.x, t.y, u.y, n.y, t.z, u.z, n.z);
 }

◆ normalizeNormal()

void SLRay::normalizeNormal ( )

inline

SLRay::normalizeNormal does a careful normalization of the normal only when the squared length is > 1.0+FLT_EPSILON or < 1.0-FLT_EPSILON.

Definition at line 178 of file SLRay.h.

 {
     SLfloat nLenSqr = hitNormal.lengthSqr();
     if (nLenSqr > 1.0f + FLT_EPSILON || nLenSqr < 1.0f - FLT_EPSILON)
     {
         SLfloat len = sqrt(nLenSqr);
         hitNormal /= len;
     }
 }

◆ print()

void SLRay::print ( ) const

SLRay::prints prints the rays origin (O), direction (D) and the length to the intersection (L)

Definition at line 160 of file SLRay.cpp.

 {
     SL_LOG("Ray: O(%.2f, %.2f, %.2f), D(%.2f, %.2f, %.2f), L: %.2f",
            origin.x,
            origin.y,
            origin.z,
            dir.x,
            dir.y,
            dir.z,
            length);
 }

◆ reflect()

void SLRay::reflect ( SLRay * reflected ) const

SLRay::reflect calculates a secondary ray reflected at the normal, starting at the intersection point. All vectors must be normalized vectors. R = 2(-I*N) N + I

Definition at line 177 of file SLRay.cpp.

 {
 #ifdef DEBUG_RAY
     for (SLint i = 0; i < depth; ++i)
         cout << " ";
     cout << "Reflect: " << hitMesh->name() << endl;
 #endif
  
     SLVec3f R(dir - 2.0f * (dir * hitNormal) * hitNormal);
  
     reflected->setDir(R);
     reflected->origin.set(hitPoint);
     reflected->depth       = depth + 1;
     reflected->length      = FLT_MAX;
     reflected->contrib     = contrib * hitMesh->mat()->kr();
     reflected->srcNode     = hitNode;
     reflected->srcMesh     = hitMesh;
     reflected->srcTriangle = hitTriangle;
     reflected->type        = REFLECTED;
     reflected->isOutside   = isOutside;
     reflected->x           = x;
     reflected->y           = y;
     reflected->sv          = sv;
     if (sv->s()->skybox())
         reflected->backgroundColor = sv->s()->skybox()->colorAtDir(reflected->dir);
     else
         reflected->backgroundColor = backgroundColor;
  
     depthReached = reflected->depth;
     ++reflectedRays;
 }

◆ reflectMC()

bool SLRay::reflectMC	(	SLRay *	reflected,
		const SLMat3f &	rotMat
	)		const

SLRay::reflectMC scatters a ray around perfect specular direction according to shininess (for higher shininess the ray is less scattered). This is used for path tracing and distributed ray tracing as well as for photon scattering. The direction is calculated according to MCCABE. The created direction is along z-axis and then transformed to lie along specular direction with rotationMatrix rotMat, which SLRay::lobeToWorld builds from the perfect specular direction. The rotation matrix must be precalculated (stays the same for each ray sample, needs to be calculated only once).

reflected->dir must hold the perfect specular direction on entry, i.e. the caller must have run SLRay::reflect first, because it is the reference against which the sampled direction is tested.

Returns: false if the sample landed on the far side of the surface. The Phong lobe is a cone around the mirror direction and is not clipped to the hemisphere, so a wide lobe at a grazing angle puts part of its samples below the horizon. The normalised Phong BRDF is zero there, so such a sample carries no energy and the caller must not trace it. Note that the test is a comparison of signs and not "points along the normal": SLMesh::preShade does not flip the hit normal towards the ray, so a back face hit has a perfect specular direction with a negative dot product and every sample around it would otherwise be rejected.

Definition at line 413 of file SLRay.cpp.

 {
     SLfloat eta1, eta2;
     SLVec3f randVec;
     SLfloat shininess = hitMesh->mat()->shininess();
  
     // The side of the surface the perfect specular direction leaves on
     SLfloat perfectCos = hitNormal.dot(reflected->dir);
  
     // scatter within specular lobe
     eta1       = rnd01();
     eta2       = Utils::TWOPI * rnd01();
     SLfloat f1 = sqrt(1.0f - pow(eta1, 2.0f / (shininess + 1.0f)));
  
     // tranform to cartesian
     randVec.set(f1 * cos(eta2),
                 f1 * sin(eta2),
                 pow(eta1, 1.0f / (shininess + 1.0f)));
  
     // ray needs to be reset if already hit a scene node
     if (reflected->hitNode)
     {
         reflected->length    = FLT_MAX;
         reflected->hitNode   = nullptr;
         reflected->hitMesh   = nullptr;
         reflected->hitPoint  = SLVec3f::ZERO;
         reflected->hitNormal = SLVec3f::ZERO;
     }
  
     // apply rotation
     reflected->setDir(rotMat * randVec);
  
     // Set pixel and background
     reflected->x  = x;
     reflected->y  = y;
     reflected->sv = sv;
     if (sv->s()->skybox())
         reflected->backgroundColor = sv->s()->skybox()->colorAtDir(reflected->dir);
     else
         reflected->backgroundColor = backgroundColor;
  
     // true if the sample stayed on the same side of the surface as the
     // perfect specular direction it was scattered around
     return (perfectCos * hitNormal.dot(reflected->dir) > 0.0f);
 }

◆ refract()

void SLRay::refract ( SLRay * refracted )

SLRay::refract calculates a secondary refracted ray, starting at the intersection point. All vectors must be normalized vectors, so the refracted vector T will be a unit vector too. If total internal refraction occurs a reflected ray is calculated instead. Index of refraction eta = Kn_Source/Kn_Destination (Kn_Air = 1.0) We are using a formula by Xavier Bec that is a little faster: http://www.realtimerendering.com/resources/RTNews/html/rtnv10n1.html#art3

Definition at line 218 of file SLRay.cpp.

 {
     assert(hitMesh && "hitMesh is null");
  
     SLVec3f T;   // refracted direction
     SLfloat eta; // refraction coefficient
  
     SLfloat c1           = hitNormal.dot(-dir);
     SLbool  hitFrontSide = c1 > 0.0f;
  
     SLMaterial* srcMat    = srcMesh ? srcMesh->mat() : nullptr;
     SLMaterial* hitMat    = hitMesh ? hitMesh->mat() : nullptr;
     SLMaterial* hitMatOut = hitMesh ? hitMesh->matOut() : nullptr;
  
 #ifdef DEBUG_RAY
     for (SLint i = 0; i < depth; ++i)
         cout << " ";
     cout << "Refract: ";
 #endif
  
     // Calculate index of refraction eta = Kn_Source/Kn_Destination
     // Case 1: From air into a mesh
     if (isOutside)
     {
         eta = 1.0f / hitMat->kn();
     }
     else
     { // Case 2: From inside the same mesh
         if (hitMesh == srcMesh)
         {
             if (hitMatOut)          // Case 2a: into another material
                 eta = hitMat->kn() / hitMatOut->kn();
             else                    // Case 2b: into air
                 eta = hitMat->kn(); // = hitMat / 1.0
         }
         else
         { // Case 3: We hit inside another material from the front
             if (hitFrontSide)
             {
                 if (hitMatOut)
                     eta = hitMatOut->kn() / hitMat->kn();
                 else
                 { // Mesh hit without outside material before leaving another mesh.
                     // This should not happen, but can due to float inaccuracies
                     eta = srcMat->kn() / hitMat->kn();
                 }
             }
             else                        // Case 4: We hit inside another material from behind
             {
                 if (hitMatOut)          // Case 4a: into another material
                     eta = hitMat->kn() / hitMatOut->kn();
                 else                    // Case 4b: into air
                     eta = hitMat->kn(); // = hitMat / 1.0
             }
         }
     }
  
     // Invert the hit normal if ray hit backside for correct refraction
     if (!hitFrontSide)
     {
         c1 *= -1.0f;
         hitNormal *= -1.0f;
     }
  
     SLfloat w  = eta * c1;
     SLfloat c2 = 1.0f + (w - eta) * (w + eta);
  
     if (c2 >= 0.0f)
     {
         T                  = eta * dir + (w - sqrt(c2)) * hitNormal;
         refracted->contrib = contrib * hitMat->kt();
         refracted->type    = REFRACTED;
  
         if (isOutside)
             refracted->isOutside = false;
         else // inside
         {
             if (srcMesh == hitMesh)
                 refracted->isOutside = !hitMatOut;
             else
                 refracted->isOutside = !hitFrontSide;
         }
  
         ++refractedRays;
     }
     else // total internal refraction results in a internal reflected ray
     {
         T                    = 2.0f * (-dir * hitNormal) * hitNormal + dir;
         refracted->contrib   = 1.0f;
         refracted->type      = REFLECTED;
         refracted->isOutside = isOutside; // remain inside
         ++tirRays;
     }
  
     refracted->setDir(T);
     refracted->origin.set(hitPoint);
     refracted->length      = FLT_MAX;
     refracted->srcNode     = hitNode;
     refracted->srcMesh     = hitMesh;
     refracted->srcTriangle = hitTriangle;
     refracted->depth       = depth + 1;
     refracted->x           = x;
     refracted->y           = y;
     refracted->sv          = sv;
     if (sv->s()->skybox())
         refracted->backgroundColor = sv->s()->skybox()->colorAtDir(refracted->dir);
     else
         refracted->backgroundColor = backgroundColor;
     depthReached = refracted->depth;
  
 #ifdef DEBUG_RAY
     cout << hitMesh->name();
     if (isOutside)
         cout << ",out";
     else
         cout << ",in";
     if (refracted->isOutside)
         cout << ">out";
     else
         cout << ">in";
     cout << ", dir: " << refracted->dir.toString();
     cout << ", contrib: " << Utils::toString(refracted->contrib, 2);
     cout << endl;
 #endif
 }

◆ refractMC()

bool SLRay::refractMC	(	SLRay *	refracted,
		const SLMat3f &	rotMat
	)		const

SLRay::refractMC scatters a ray around perfect transmissive direction according to translucency (for higher translucency the ray is less scattered). This is used for path tracing and distributed ray tracing as well as for photon scattering. The direction is calculated the same as with specular scattering (see reflectMC). The created direction is along z-axis and then transformed to lie along transmissive direction with rotationMatrix rotMat, which SLRay::lobeToWorld builds from the perfect transmissive direction. The rotation matrix must be precalculated (stays the same for each ray sample, needs to be calculated only once).

refracted->dir must hold the perfect transmissive direction on entry, i.e. the caller must have run SLRay::refract first.

Returns: false if the sample landed on the near side of the surface, for the same reason as in reflectMC. Testing against the sign of the perfect direction rather than against the normal is what makes this work for total internal reflection too, where SLRay::refract returns a direction on the incident side.

Definition at line 478 of file SLRay.cpp.

 {
     SLfloat eta1, eta2;
     SLVec3f randVec;
     SLfloat translucency = hitMesh->mat()->translucency();
  
     // The side of the surface the perfect transmissive direction leaves on
     SLfloat perfectCos = hitNormal.dot(refracted->dir);
  
     // scatter within transmissive lobe
     eta1       = rnd01();
     eta2       = Utils::TWOPI * rnd01();
     SLfloat f1 = sqrt(1.0f - pow(eta1, 2.0f / (translucency + 1.0f)));
  
     // transform to cartesian
     randVec.set(f1 * cos(eta2),
                 f1 * sin(eta2),
                 pow(eta1, 1.0f / (translucency + 1.0f)));
  
     // ray needs to be reset if already hit a scene node
     if (refracted->hitNode)
     {
         refracted->length    = FLT_MAX;
         refracted->hitNode   = nullptr;
         refracted->hitMesh   = nullptr;
         refracted->hitPoint  = SLVec3f::ZERO;
         refracted->hitNormal = SLVec3f::ZERO;
     }
  
     // Apply rotation
     refracted->setDir(rotMat * randVec);
  
     // Set pixel and background
     refracted->x  = x;
     refracted->y  = y;
     refracted->sv = sv;
     if (sv->s()->skybox())
         refracted->backgroundColor = sv->s()->skybox()->colorAtDir(refracted->dir);
     else
         refracted->backgroundColor = backgroundColor;
  
     // true if the sample stayed on the same side of the surface as the
     // perfect transmissive direction it was scattered around
     return (perfectCos * hitNormal.dot(refracted->dir) > 0.0f);
 }

◆ setDir()

void SLRay::setDir ( const SLVec3f & Dir )

inline

Setter for the rays direction in world space also setting the inverse direction.

Definition at line 149 of file SLRay.h.

 {
     dir      = Dir;
     invDir.x = (SLfloat)(1 / dir.x);
     invDir.y = (SLfloat)(1 / dir.y);
     invDir.z = (SLfloat)(1 / dir.z);
     sign[0]  = (invDir.x < 0);
     sign[1]  = (invDir.y < 0);
     sign[2]  = (invDir.z < 0);
 }

◆ setDirOS()

void SLRay::setDirOS ( const SLVec3f & Dir )

inline

Setter for the rays direction in object space also setting the inverse direction.

Definition at line 162 of file SLRay.h.

 {
     dirOS      = Dir;
     invDirOS.x = (SLfloat)(1 / dirOS.x);
     invDirOS.y = (SLfloat)(1 / dirOS.y);
     invDirOS.z = (SLfloat)(1 / dirOS.z);
     signOS[0]  = (invDirOS.x < 0);
     signOS[1]  = (invDirOS.y < 0);
     signOS[2]  = (invDirOS.z < 0);
 }

◆ totalNumRays()

static SLuint SLRay::totalNumRays ( )

inlinestatic

Total NO. of rays shot during RT.

Definition at line 87 of file SLRay.h.

                                  { return SLRay::primaryRays +
                                           SLRay::reflectedRays +
                                           SLRay::refractedRays +
                                           SLRay::tirRays +
                                           SLRay::subsampledRays +
                                           SLRay::shadowRays; }

Member Data Documentation

◆ avgDepth

SLfloat SLRay::avgDepth = 0

static

average depth reached

Definition at line 139 of file SLRay.h.

◆ backgroundColor

SLCol4f SLRay::backgroundColor

Background color at pixel x,y.

Definition at line 103 of file SLRay.h.

◆ contrib

SLfloat SLRay::contrib

Current contribution of ray to color.

Definition at line 82 of file SLRay.h.

◆ depth

SLint SLRay::depth

Recursion depth for ray tracing.

Definition at line 81 of file SLRay.h.

◆ depthReached

SLint SLRay::depthReached = 1

static

depth reached for a primary ray

Definition at line 137 of file SLRay.h.

◆ dir

SLVec3f SLRay::dir

Direction vector of ray in WS.

Definition at line 79 of file SLRay.h.

◆ dirOS

SLVec3f SLRay::dirOS

Direction vector of ray in OS.

Definition at line 84 of file SLRay.h.

◆ hitAO

SLfloat SLRay::hitAO

Ambient occlusion factor at intersection point.

Definition at line 116 of file SLRay.h.

◆ hitMesh

SLMesh* SLRay::hitMesh

Points to the intersected mesh.

Definition at line 109 of file SLRay.h.

◆ hitNode

SLNode* SLRay::hitNode

Points to the intersected node.

Definition at line 108 of file SLRay.h.

◆ hitNormal

SLVec3f SLRay::hitNormal

Surface normal at intersection point.

Definition at line 114 of file SLRay.h.

◆ hitPoint

SLVec3f SLRay::hitPoint

Point of intersection.

Definition at line 113 of file SLRay.h.

◆ hitTexColor

SLCol4f SLRay::hitTexColor

Color at intersection for texture or color attributes.

Definition at line 115 of file SLRay.h.

◆ hitTriangle

SLint SLRay::hitTriangle

Points to the intersected triangle.

Definition at line 110 of file SLRay.h.

◆ hitU

SLfloat SLRay::hitU

Definition at line 107 of file SLRay.h.

◆ hitV

SLfloat SLRay::hitV

barycentric coords in hit triangle

Definition at line 107 of file SLRay.h.

◆ ignoredRays

SLuint SLRay::ignoredRays = 0

static

NO. of ignore refraction rays.

Definition at line 132 of file SLRay.h.

◆ intersections

SLuint SLRay::intersections = 0

static

NO. of intersection.

Definition at line 136 of file SLRay.h.

◆ invDir

SLVec3f SLRay::invDir

Inverse ray dir for fast AABB hit in WS.

Definition at line 119 of file SLRay.h.

◆ invDirOS

SLVec3f SLRay::invDirOS

Inverse ray dir for fast AABB hit in OS.

Definition at line 120 of file SLRay.h.

◆ isInsideVolume

SLbool SLRay::isInsideVolume

Flag if ray is in Volume.

Definition at line 99 of file SLRay.h.

◆ isOutside

SLbool SLRay::isOutside

Flag if ray is inside of a material.

Definition at line 98 of file SLRay.h.

◆ length

SLfloat SLRay::length

length from origin to an intersection

Definition at line 80 of file SLRay.h.

◆ lightDist

SLfloat SLRay::lightDist

Distance to light for shadow rays.

Definition at line 96 of file SLRay.h.

◆ maxDepth

SLint SLRay::maxDepth = 0

static

Max. recursion depth.

Definition at line 127 of file SLRay.h.

◆ maxDepthReached

SLint SLRay::maxDepthReached = 0

static

max. depth reached for all rays

Definition at line 138 of file SLRay.h.

◆ minContrib

SLfloat SLRay::minContrib = 1.0 / 256.0

static

Min. contibution to color (1/256)

Definition at line 128 of file SLRay.h.

◆ origin

SLVec3f SLRay::origin

Vector to the origin of ray in WS.

Definition at line 78 of file SLRay.h.

◆ originOS

SLVec3f SLRay::originOS

Vector to the origin of ray in OS.

Definition at line 83 of file SLRay.h.

◆ primaryRays

SLuint SLRay::primaryRays = 0

static

NO. of primary rays shot.

Definition at line 129 of file SLRay.h.

◆ reflectedRays

SLuint SLRay::reflectedRays = 0

static

NO. of reflected rays.

Definition at line 130 of file SLRay.h.

◆ refractedRays

SLuint SLRay::refractedRays = 0

static

NO. of refracted rays.

Definition at line 131 of file SLRay.h.

◆ shadowRays

SLuint SLRay::shadowRays = 0

static

NO. of shadow rays.

Definition at line 133 of file SLRay.h.

◆ sign

SLint SLRay::sign[3]

Sign of invDir for fast AABB hit in WS.

Definition at line 121 of file SLRay.h.

◆ signOS

SLint SLRay::signOS[3]

Sign of invDir for fast AABB hit in OS.

Definition at line 122 of file SLRay.h.

◆ srcMesh

SLMesh* SLRay::srcMesh

Points to the mesh at ray origin.

Definition at line 101 of file SLRay.h.

◆ srcNode

SLNode* SLRay::srcNode

Points to the node at ray origin.

Definition at line 100 of file SLRay.h.

◆ srcTriangle

SLint SLRay::srcTriangle

Points to the triangle at ray origin.

Definition at line 102 of file SLRay.h.

◆ subsampledPixels

SLuint SLRay::subsampledPixels = 0

static

NO. of of subsampled pixels.

Definition at line 141 of file SLRay.h.

◆ subsampledRays

SLuint SLRay::subsampledRays = 0

static

NO. of of subsampled rays.

Definition at line 140 of file SLRay.h.

◆ sv

SLSceneView* SLRay::sv

Pointer to the sceneview.

Definition at line 104 of file SLRay.h.

◆ tests

SLuint SLRay::tests = 0

static

NO. of intersection tests.

Definition at line 135 of file SLRay.h.

◆ tirRays

SLuint SLRay::tirRays = 0

static

NO. of TIR refraction rays.

Definition at line 134 of file SLRay.h.

◆ tmax

SLfloat SLRay::tmax

max. dist. of last AABB intersection

Definition at line 124 of file SLRay.h.

◆ tmin

SLfloat SLRay::tmin

min. dist. of last AABB intersection

Definition at line 123 of file SLRay.h.

◆ type

SLRayType SLRay::type

PRIMARY, REFLECTED, REFRACTED, SHADOW.

Definition at line 95 of file SLRay.h.

◆ x

SLfloat SLRay::x

Definition at line 97 of file SLRay.h.

◆ y

SLfloat SLRay::y

Pixel position for primary rays.

Definition at line 97 of file SLRay.h.

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

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SLRay() [1/3]

◆ SLRay() [2/3]

◆ SLRay() [3/3]

Member Function Documentation

◆ diffuseMC()

◆ hitMatIsDiffuse()

◆ hitMatIsReflective()

◆ hitMatIsTransparent()

◆ isShaded()

◆ lobeToWorld()

◆ normalizeNormal()

◆ print()

◆ reflect()

◆ reflectMC()

◆ refract()

◆ refractMC()

◆ setDir()

◆ setDirOS()

◆ totalNumRays()

Member Data Documentation

◆ avgDepth

◆ backgroundColor

◆ contrib

◆ depth

◆ depthReached

◆ dir

◆ dirOS

◆ hitAO

◆ hitMesh

◆ hitNode

◆ hitNormal

◆ hitPoint

◆ hitTexColor

◆ hitTriangle

◆ hitU

◆ hitV

◆ ignoredRays

◆ intersections

◆ invDir

◆ invDirOS

◆ isInsideVolume

◆ isOutside

◆ length

◆ lightDist

◆ maxDepth

◆ maxDepthReached

◆ minContrib

◆ origin

◆ originOS

◆ primaryRays

◆ reflectedRays

◆ refractedRays

◆ shadowRays

◆ sign

◆ signOS

◆ srcMesh

◆ srcNode

◆ srcTriangle

◆ subsampledPixels

◆ subsampledRays

◆ sv

◆ tests

◆ tirRays

◆ tmax

◆ tmin

◆ type

◆ x

◆ y