AppDemoScenePTMuttenzerBox2 Class Reference

Class for the Muttenzer Box path tracing scene with soft gloss materials. More...

#include <AppDemoScenePTMuttenzerBox2.h>

Inheritance diagram for AppDemoScenePTMuttenzerBox2:

Public Member Functions
	AppDemoScenePTMuttenzerBox2 ()
void	registerAssetsToLoad (SLAssetLoader &al) override
	All scene specific assets have to be registered for async loading in here. More...
void	assemble (SLAssetManager *am, SLSceneView *sv) override
	After parallel loading of the assets the scene gets assembled in here. More...
Public Member Functions inherited from SLScene
	SLScene (const SLstring &name)
	~SLScene () override
void	initOculus (SLstring shaderDir)
void	root3D (SLNode *root3D)
void	root2D (SLNode *root2D)
void	skybox (SLSkybox *skybox)
void	stopAnimations (SLbool stop)
void	info (SLstring i)
void	loadTimeMS (SLfloat loadTimeMS)
SLAnimManager &	animManager ()
SLAssetManager *	assetManager ()
SLNode *	root3D ()
SLNode *	root2D ()
SLSkybox *	skybox ()
SLstring &	info ()
SLfloat	elapsedTimeMS () const
SLfloat	elapsedTimeSec () const
SLVEventHandler &	eventHandlers ()
SLfloat	loadTimeMS () const
SLVLight &	lights ()
SLfloat	fps () const
AvgFloat &	frameTimesMS ()
AvgFloat &	updateTimesMS ()
AvgFloat &	updateAnimTimesMS ()
AvgFloat &	updateAABBTimesMS ()
AvgFloat &	updateDODTimesMS ()
SLNode *	singleNodeSelected ()
	Returns the node if only one is selected. See also SLMesh::selectNodeMesh. More...
SLMesh *	singleMeshFullSelected ()
	Returns the node if only one is selected. See also SLMesh::selectNodeMesh. More...
SLVNode &	selectedNodes ()
SLVMesh &	selectedMeshes ()
SLbool	stopAnimations () const
SLint	numSceneCameras ()
	Returns the number of camera nodes in the scene. More...
SLCamera *	nextCameraInScene (SLCamera *activeSVCam)
	Returns the next camera in the scene if there is one. More...
bool	onUpdate (bool renderTypeIsRT, bool voxelsAreShown, bool forceCPUSkinning)
	Updates animations and AABBs. More...
void	init (SLAssetManager *am)
virtual void	unInit ()
void	selectNodeMesh (SLNode *nodeToSelect, SLMesh *meshToSelect)
	Handles the full mesh selection from double-clicks. More...
void	deselectAllNodesAndMeshes ()
	Deselects all nodes and its meshes. More...
SLGLOculus *	oculus ()
Public Member Functions inherited from SLObject
	SLObject (const SLstring &Name="", const SLstring &url="")
virtual	~SLObject ()
void	name (const SLstring &Name)
void	url (const SLstring &url)
const SLstring &	name () const
const SLstring &	url () const

Private Attributes
SLGLTexture *	_tex1
SLGLProgram *	_spRefl
SLGLProgram *	_spRefr

Additional Inherited Members
Protected Attributes inherited from SLScene
SLVLight	_lights
	Vector of all lights. More...
SLVEventHandler	_eventHandlers
	Vector of all event handler. More...
SLAnimManager	_animManager
	Animation manager instance. More...
SLAssetManager *	_assetManager
	Pointer to the external assetManager. More...
SLNode *	_root3D
	Root node for 3D scene. More...
SLNode *	_root2D
	Root node for 2D scene displayed in ortho projection. More...
SLSkybox *	_skybox
	pointer to skybox More...
SLstring	_info
	scene info string More...
SLVNode	_selectedNodes
	Vector of selected nodes. See SLMesh::selectNodeMesh. More...
SLVMesh	_selectedMeshes
	Vector of selected meshes. See SLMesh::selectNodeMesh. More...
SLfloat	_loadTimeMS
	time to load scene in ms More...
SLfloat	_frameTimeMS
	Last frame time in ms. More...
SLfloat	_lastUpdateTimeMS
	Last time after update in ms. More...
SLfloat	_fps
	Averaged no. of frames per second. More...
AvgFloat	_frameTimesMS
	Averaged total time per frame in ms. More...
AvgFloat	_updateTimesMS
	Averaged time for update in ms. More...
AvgFloat	_updateAABBTimesMS
	Averaged time for update the nodes AABB in ms. More...
AvgFloat	_updateAnimTimesMS
	Averaged time for update the animations in ms. More...
AvgFloat	_updateDODTimesMS
	Averaged time for update the SLEntities graph. More...
SLbool	_stopAnimations
	Global flag for stopping all animations. More...
std::unique_ptr< SLGLOculus >	_oculus
	Oculus Rift interface. More...
Protected Attributes inherited from SLObject
SLstring	_name
	name of an object More...
SLstring	_url
	uniform resource locator More...

Detailed Description

Class for the Muttenzer Box path tracing scene with soft gloss materials.

The same box and the same two spheres as AppDemoScenePTMuttenzerBox, with one difference: the shininess of the mirror sphere and both the translucency and the shininess of the glass sphere are 100 instead of SLMaterial::PERFECT (1000). Below that limit the path tracer draws the direction from the Phong lobe of the exponent (SLRay::reflectMC and SLRay::refractMC) instead of taking the perfect specular one, so the mirror sphere reflects blurred and the glass sphere is frosted in its refraction as well as in its surface reflection. The glass sphere is also given a red transmissive color, which makes its caustic on the floor red. Only the path tracer shows any of this; the OpenGL preview and the ray tracer render the scene exactly like the original.

Definition at line 30 of file AppDemoScenePTMuttenzerBox2.h.

Constructor & Destructor Documentation

AppDemoScenePTMuttenzerBox2()

AppDemoScenePTMuttenzerBox2::AppDemoScenePTMuttenzerBox2

(

)

Definition at line 21 of file AppDemoScenePTMuttenzerBox2.cpp.

  : SLScene("Muttenzer Box Path Tracing with soft gloss materials")
{
    info("Muttenzer Box with a soft gloss instead of a perfect mirror sphere and "
         "a frosted red instead of a clear glass sphere: both exponents are "
         "100 and not 1000, and the transmissive color is red, so the caustic "
         "under the glass sphere is red. Only the path tracer shows this; the "
         "OpenGL preview and the ray tracer render this exactly like the "
         "original Muttenzer Box.");
}

Member Function Documentation

assemble()

void AppDemoScenePTMuttenzerBox2::assemble ( SLAssetManager *  am, SLSceneView *  sv  )

overridevirtual

After parallel loading of the assets the scene gets assembled in here.

Remarks

All scene-specific assets have to be loaded async by overriding SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and assembling means that it happens in a parallel thread and that in there are no OpenGL calls allowed. OpenGL calls are only allowed in the main thread. It is important that all object instantiations within SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen in a parallel thread. All objects that get rendered have to do their initialization when they are used the first time during rendering in the main thread.

Reimplemented from SLScene.

Definition at line 52 of file AppDemoScenePTMuttenzerBox2.cpp.

{
    SLCol4f lightEmisRGB(10.0f, 10.0f, 10.0f);
    SLCol4f grayRGB(0.75f, 0.75f, 0.75f);
    SLCol4f redRGB(0.75f, 0.25f, 0.25f);
    SLCol4f blueRGB(0.25f, 0.25f, 0.75f);
    SLCol4f blackRGB(0.00f, 0.00f, 0.00f);
 
    // create materials
    SLMaterial* cream = new SLMaterial(am,
                                       "cream",
                                       grayRGB,
                                       SLCol4f::BLACK,
                                       0);
    SLMaterial* red   = new SLMaterial(am,
                                     "red",
                                     redRGB,
                                     SLCol4f::BLACK,
                                     0);
    SLMaterial* blue  = new SLMaterial(am,
                                      "blue",
                                      blueRGB,
                                      SLCol4f::BLACK,
                                      0);
 
    // The only difference to AppDemoScenePTMuttenzerBox: both exponents are
    // 100 instead of SLMaterial::PERFECT (1000). At PERFECT the path tracer
    // takes the perfect specular resp. transmissive direction and samples no
    // lobe at all; below it the direction is drawn from the Phong lobe of that
    // exponent, which is wider the smaller the exponent is. So the mirror
    // sphere gets a blurred reflection and the glass sphere both a blurred
    // refraction and, since point 19, a blurred surface reflection.
    const SLfloat glossiness = 100.0f;
 
    // Material for the soft gloss mirror sphere
    SLMaterial* refl = new SLMaterial(am,
                                      "refl",
                                      blackRGB,
                                      SLCol4f::WHITE,
                                      glossiness,
                                      1.0f);
    refl->addTexture(_tex1);
    refl->program(_spRefl);
 
    // Material for the frosted glass sphere. The specular color has to stay
    // black, otherwise SLRay::hitMatIsReflective would match first and the
    // transmissive branch would never run. Both exponents get the same value,
    // because a rough dielectric is rough on both sides of the interface: the
    // translucency widens the transmitted lobe and the shininess the Fresnel
    // reflected one. With the shininess left at PERFECT the sphere would still
    // mirror the light rectangle as a razor sharp quad while its transmission
    // is frosted.
    SLMaterial* refr = new SLMaterial(am,
                                      "refr",
                                      blackRGB,
                                      blackRGB,
                                      glossiness,
                                      0.05f,
                                      0.95f,
                                      1.5f);
    refr->translucency(glossiness);
 
    // The transmissive color is what the path tracer multiplies the light
    // passing through the sphere by, so a red one turns the glass into a red
    // filter and its caustic on the floor red with it. Green and blue are not
    // set to zero: a channel at 0 is opaque to that channel, and the caustic
    // would then be a pure red with no shading left in it at all.
    //
    // Note that the same color also tints the Fresnel reflection at the
    // surface, because SLPathtracer::trace uses the transmissive color as the
    // object color of the whole transmissive branch. For a dielectric that is
    // wrong -- the reflection off glass is uncolored, the color comes from the
    // absorption on the way through -- so the mirrored image of the light
    // rectangle on this sphere will come out red as well. See the note in
    // point 19 of docs/ImplementationPlan.md.
    refr->transmissive(SLCol4f(1.0f, 0.2f, 0.2f));
    refr->addTexture(_tex1);
    refr->program(_spRefr);
 
    SLNode* sphere1 = new SLNode(new SLSphere(am,
                                              0.5f,
                                              32,
                                              32,
                                              "Sphere1",
                                              refl));
    sphere1->translate(-0.65f, -0.75f, -0.55f, TS_object);
 
    SLNode* sphere2 = new SLNode(new SLSphere(am,
                                              0.45f,
                                              32,
                                              32,
                                              "Sphere2",
                                              refr));
    sphere2->translate(0.73f, -0.8f, 0.10f, TS_object);
 
    SLNode* balls = new SLNode;
    balls->addChild(sphere1);
    balls->addChild(sphere2);
 
    // Rectangular light
    SLLightRect* lightRect = new SLLightRect(am,
                                             this,
                                             1,
                                             0.65f);
    lightRect->rotate(90, -1.0f, 0.0f, 0.0f);
    lightRect->translate(0.0f, -0.25f, 1.18f, TS_object);
    lightRect->spotCutOffDEG(90);
    lightRect->spotExponent(1.0);
    lightRect->ambientColor(SLCol4f::WHITE);
    lightRect->ambientPower(0.25f);
    lightRect->diffuseColor(lightEmisRGB);
    lightRect->attenuation(0, 0, 1);
    lightRect->samplesXY(11, 7);
    lightRect->createsShadows(true);
    lightRect->createShadowMap();
 
    SLLight::globalAmbient.set(lightEmisRGB * 0.01f);
 
    // create camera
    SLCamera* cam1 = new SLCamera();
    cam1->translation(0, 0, 7.2f);
    cam1->fov(27);
    cam1->focalDist(cam1->translationOS().length());
    cam1->background().colors(SLCol4f(0.0f, 0.0f, 0.0f));
    cam1->setInitialState();
    cam1->devRotLoc(&AppCommon::devRot, &AppCommon::devLoc);
 
    // assemble scene
    SLNode* scene = new SLNode;
    root3D(scene);
    scene->addChild(cam1);
    scene->addChild(lightRect);
 
    // create wall polygons
    SLfloat pL = -1.48f, pR = 1.48f; // left/right
    SLfloat pB = -1.25f, pT = 1.19f; // bottom/top
    SLfloat pN = 1.79f, pF = -1.55f; // near/far
 
    // bottom plane
    SLNode* b = new SLNode(new SLRectangle(am,
                                           SLVec2f(pL, -pN),
                                           SLVec2f(pR, -pF),
                                           6,
                                           6,
                                           "bottom",
                                           cream));
    b->rotate(90, -1, 0, 0);
    b->translate(0, 0, pB, TS_object);
    scene->addChild(b);
 
    // top plane
    SLNode* t = new SLNode(new SLRectangle(am,
                                           SLVec2f(pL, pF),
                                           SLVec2f(pR, pN),
                                           6,
                                           6,
                                           "top",
                                           cream));
    t->rotate(90, 1, 0, 0);
    t->translate(0, 0, -pT, TS_object);
    scene->addChild(t);
 
    // far plane
    SLNode* f = new SLNode(new SLRectangle(am,
                                           SLVec2f(pL, pB),
                                           SLVec2f(pR, pT),
                                           6,
                                           6,
                                           "far",
                                           cream));
    f->translate(0, 0, pF, TS_object);
    scene->addChild(f);
 
    // left plane
    SLNode* l = new SLNode(new SLRectangle(am,
                                           SLVec2f(-pN, pB),
                                           SLVec2f(-pF, pT),
                                           6,
                                           6,
                                           "left",
                                           red));
    l->rotate(90, 0, 1, 0);
    l->translate(0, 0, pL, TS_object);
    scene->addChild(l);
 
    // right plane
    SLNode* r = new SLNode(new SLRectangle(am,
                                           SLVec2f(pF, pB),
                                           SLVec2f(pN, pT),
                                           6,
                                           6,
                                           "right",
                                           blue));
    r->rotate(90, 0, -1, 0);
    r->translate(0, 0, -pR, TS_object);
    scene->addChild(r);
 
    scene->addChild(balls);
 
    sv->camera(cam1);
}

registerAssetsToLoad()

void AppDemoScenePTMuttenzerBox2::registerAssetsToLoad ( SLAssetLoader &  al )

overridevirtual

All scene specific assets have to be registered for async loading in here.

All assets the should be loaded in parallel must be registered in here.

Remarks

All scene sspecific assets have to be loaded async by overriding SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and assembling means that it happens in a parallel thread and that in there are no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.

Reimplemented from SLScene.

Definition at line 33 of file AppDemoScenePTMuttenzerBox2.cpp.

{
    al.addTextureToLoad(_tex1,
                        AppCommon::texturePath + "MuttenzerBox+X0512_C.png",
                        AppCommon::texturePath + "MuttenzerBox-X0512_C.png",
                        AppCommon::texturePath + "MuttenzerBox+Y0512_C.png",
                        AppCommon::texturePath + "MuttenzerBox-Y0512_C.png",
                        AppCommon::texturePath + "MuttenzerBox+Z0512_C.png",
                        AppCommon::texturePath + "MuttenzerBox-Z0512_C.png");
 
    al.addProgramToLoad(_spRefl,
                        AppCommon::shaderPath + "Reflect.vert",
                        AppCommon::shaderPath + "Reflect.frag");
    al.addProgramToLoad(_spRefr,
                        AppCommon::shaderPath + "RefractReflect.vert",
                        AppCommon::shaderPath + "RefractReflect.frag");
}

Member Data Documentation

_spRefl

SLGLProgram* AppDemoScenePTMuttenzerBox2::_spRefl

private

Definition at line 56 of file AppDemoScenePTMuttenzerBox2.h.

_spRefr

SLGLProgram* AppDemoScenePTMuttenzerBox2::_spRefr

private

Definition at line 57 of file AppDemoScenePTMuttenzerBox2.h.

_tex1

SLGLTexture* AppDemoScenePTMuttenzerBox2::_tex1

private

Definition at line 55 of file AppDemoScenePTMuttenzerBox2.h.

---

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

• AppDemoScenePTMuttenzerBox2.h
• AppDemoScenePTMuttenzerBox2.cpp