SLSceneView Class Reference

SceneView class represents a dynamic real time 3D view onto the scene. More...

#include <SLSceneView.h>

Inheritance diagram for SLSceneView:

Public Member Functions
	SLSceneView (SLScene *s, int dpi, SLInputManager &inputManager)
	SLSceneView default constructor. More...
	~SLSceneView () override
void	init (SLstring name, SLint screenWidth, SLint screenHeight, void *onWndUpdateCallback, void *onSelectNodeMeshCallback, SLUiInterface *gui, const string &configPath)
void	unInit ()
void	onInitialize ()
SLbool	onPaint ()
void	onResize (SLint width, SLint height)
virtual void	onStartup ()
virtual void	preDraw ()
virtual void	postDraw ()
virtual void	postSceneLoad ()
virtual SLbool	onMouseDown (SLMouseButton button, SLint scrX, SLint scrY, SLKey mod)
virtual SLbool	onMouseUp (SLMouseButton button, SLint scrX, SLint scrY, SLKey mod)
virtual SLbool	onMouseMove (SLint x, SLint y)
virtual SLbool	onMouseWheelPos (SLint wheelPos, SLKey mod)
virtual SLbool	onMouseWheel (SLint delta, SLKey mod)
virtual SLbool	onTouch2Down (SLint scrX1, SLint scrY1, SLint scrX2, SLint scrY2)
virtual SLbool	onTouch2Move (SLint scrX1, SLint scrY1, SLint scrX2, SLint scrY2)
virtual SLbool	onTouch2Up (SLint scrX1, SLint scrY1, SLint scrX2, SLint scrY2)
virtual SLbool	onDoubleClick (SLMouseButton button, SLint x, SLint y, SLKey mod)
virtual SLbool	onKeyPress (SLKey key, SLKey mod)
virtual SLbool	onKeyRelease (SLKey key, SLKey mod)
virtual SLbool	onCharInput (SLuint c)
SLbool	draw3DGL (SLfloat elapsedTimeSec)
	Draws the 3D scene with OpenGL. More...
void	draw3DGLAll ()
void	draw3DGLNodes (SLVNode &nodes, SLbool alphaBlended, SLbool depthSorted)
void	draw3DGLLines (SLVNode &nodes)
void	draw3DGLLinesOverlay (SLVNode &nodes)
void	draw2DGL ()
void	draw2DGLNodes ()
SLbool	draw3DRT ()
SLbool	draw3DPT ()
SLbool	draw3DCT ()
void	initSceneViewCamera (const SLVec3f &dir=-SLVec3f::AXISZ, SLProjType proj=P_monoPerspective)
void	switchToSceneViewCamera ()
void	switchToNextCameraInScene ()
	Sets the active camera to the next in the scene. More...
SLbool	isSceneViewCameraActive ()
SLstring	windowTitle ()
void	printStats ()
void	startRaytracing (SLint maxDepth)
void	startPathtracing (SLint maxDepth, SLint samples)
	Starts the path tracer. maxDepth is only a safety net against an. More...
void	setViewportFromRatio (const SLVec2i &vpRatio, SLViewportAlign vpAlignment, SLbool vpSameAsVideo)
	Sets the viewport ratio and the viewport rectangle. More...
void	saveFrameBufferAsImage (SLstring pathFilename, cv::Size targetSize=cv::Size(-1, -1))
	Saves after n wait frames the front frame buffer as a PNG image. More...
void	camera (SLCamera *camera)
void	scene (SLScene *scene)
void	scrW (SLint scrW)
void	scrH (SLint scrH)
void	doWaitOnIdle (SLbool doWI)
void	doMultiSampling (SLbool doMS)
void	doDepthTest (SLbool doDT)
void	doFrustumCulling (SLbool doFC)
void	doAlphaSorting (SLbool doAS)
void	renderType (SLRenderType rt)
void	viewportSameAsVideo (bool sameAsVideo)
void	screenCaptureIsRequested (bool doScreenCap)
SLScene *	s ()
SLCamera *	camera ()
SLCamera *	sceneViewCamera ()
SLint	scrW () const
SLint	scrH () const
SLint	scrWdiv2 () const
SLint	scrHdiv2 () const
SLfloat	scrWdivH () const
SLint	dpi () const
SLRecti	viewportRect () const
SLVec2i	viewportRatio () const
SLfloat	viewportWdivH () const
SLint	viewportW () const
SLint	viewportH () const
SLViewportAlign	viewportAlign () const
SLbool	viewportSameAsVideo () const
SLUiInterface *	gui ()
SLbool	doFrustumCulling () const
SLbool	doAlphaSorting () const
SLbool	doMultiSampling () const
SLbool	doDepthTest () const
SLbool	doWaitOnIdle () const
SLVNode &	nodesOpaque3D ()
SLVNode &	nodesBlended3D ()
SLVNode &	nodesOpaque2D ()
SLVNode &	nodesBlended2D ()
SLVNode &	nodesOverdrawn ()
SLRaytracer *	raytracer ()
SLPathtracer *	pathtracer ()
SLRenderType	renderType () const
SLGLOculusFB *	oculusFB ()
SLDrawBits *	drawBits ()
SLbool	drawBit (SLuint bit)
AvgFloat &	shadowMapTimeMS ()
AvgFloat &	cullTimesMS ()
AvgFloat &	draw2DTimesMS ()
AvgFloat &	draw3DTimesMS ()
SLNodeStats &	stats2D ()
SLNodeStats &	stats3D ()
SLbool	screenCaptureIsRequested ()
std::unordered_set< SLMaterial * > &	visibleMaterials2D ()
std::unordered_set< SLMaterial * > &	visibleMaterials3D ()
Public Member Functions inherited from SLObject
	SLObject (const SLstring &Name="", const SLstring &url="")
virtual	~SLObject ()
void	name (const SLstring &Name)
void	url (const SLstring &url)
const SLstring &	name () const
const SLstring &	url () const

Public Attributes
cbOnWndUpdate	onWndUpdate
	C-Callback for app for intermediate window repaint. More...
cbOnSelectNodeMesh	onSelectedNodeMesh
	C-Callback for app on node selection. More...

Protected Attributes
SLScene *	_s
	Pointer to the scene observed by this scene view. More...
SLCamera *	_camera
	Pointer to the _active camera. More...
SLCamera	_sceneViewCamera
	Default camera for this SceneView (default cam not in scenegraph) More...
SLUiInterface *	_gui = nullptr
	new tighter imgui wrapper More...
SLNodeStats	_stats2D
	Statistic numbers for 2D nodes. More...
SLNodeStats	_stats3D
	Statistic numbers for 3D nodes. More...
SLbool	_gotPainted
	flag if this sceneview got painted More...
SLRenderType	_renderType
	rendering type (GL,RT,PT) More...
SLbool	_doDepthTest
	Flag if depth test is turned on. More...
SLbool	_doMultiSampling
	Flag if multisampling is on. More...
SLbool	_doFrustumCulling
	Flag if view frustum culling is on. More...
SLbool	_doAlphaSorting
	Flag if alpha sorting in blending is on. More...
SLbool	_doWaitOnIdle
	Flag for Event waiting. More...
SLbool	_isFirstFrame
	Flag if it is the first frame rendering. More...
SLDrawBits	_drawBits
	Sceneview level drawing flags. More...
SLfloat	_shadowMapTimeMS
	time for drawing the shadow maps in ms More...
SLfloat	_cullTimeMS
	time for culling in ms More...
SLfloat	_draw3DTimeMS
	time for 3D drawing in ms More...
SLfloat	_draw2DTimeMS
	time for 2D drawing in ms More...
SLbool	_mouseDownL
	Flag if left mouse button is pressed. More...
SLbool	_mouseDownR
	Flag if right mouse button is pressed. More...
SLbool	_mouseDownM
	Flag if middle mouse button is pressed. More...
SLKey	_mouseMod
	mouse modifier key on key down More...
SLint	_touchDowns
	finger touch down count More...
SLVec2i	_touch [3]
	up to 3 finger touch coordinates More...
SLGLVertexArrayExt	_vaoTouch
	Buffer for touch pos. rendering. More...
SLGLVertexArrayExt	_vaoCursor
	Virtual cursor for stereo rendering. More...
SLint	_scrW
	Screen width in pixels. More...
SLint	_scrH
	Screen height in pixels. More...
SLint	_scrWdiv2
	Screen half width in pixels. More...
SLint	_scrHdiv2
	Screen half height in pixels. More...
SLfloat	_scrWdivH
	Screen side aspect ratio. More...
int	_dpi
	dots per inch of screen More...
SLVec2i	_viewportRatio
	ratio of viewport More...
SLViewportAlign	_viewportAlign
	alignment of viewport More...
SLRecti	_viewportRect
	rectangle of viewport More...
SLbool	_viewportSameAsVideo
	Adapt viewport aspect to the input video. More...
SLbool	_screenCaptureIsRequested
	Flag if screen capture is requested. More...
SLint	_screenCaptureWaitFrames
	Frames to delay the screen capture. More...
SLGLOculusFB	_oculusFB
	Oculus framebuffer. More...
std::unordered_set< SLMaterial * >	_visibleMaterials3D
	visible materials 3D per frame More...
std::unordered_set< SLMaterial * >	_visibleMaterials2D
	visible materials 2D per frame More...
SLVNode	_nodesOpaque2D
	Vector of visible opaque nodes not in _visibleMaterials2D rendered in 2D. More...
SLVNode	_nodesBlended2D
	Vector of visible blended nodes not in _visibleMaterials2D rendered in 2D. More...
SLVNode	_nodesOpaque3D
	Vector of visible opaque nodes not in _visibleMaterials3D rendered in 3D. More...
SLVNode	_nodesBlended3D
	Vector of visible blended nodes not in _visibleMaterials3D rendered in 3D. More...
SLVNode	_nodesOverdrawn
	Vector of helper nodes drawn over all others. More...
SLRaytracer	_raytracer
	Whitted style raytracer. More...
SLbool	_stopRT
	Flag to stop the RT. More...
SLPathtracer	_pathtracer
	Pathtracer. More...
SLbool	_stopPT
	Flag to stop the PT. More...
SLInputManager &	_inputManager
AvgFloat	_shadowMapTimesMS
	Averaged time for drawing the shadow maps in ms. More...
AvgFloat	_cullTimesMS
	Averaged time for culling in ms. More...
AvgFloat	_draw3DTimesMS
	Averaged time for 3D drawing in ms. More...
AvgFloat	_draw2DTimesMS
	Averaged time for 2D drawing in ms. More...
Protected Attributes inherited from SLObject
SLstring	_name
	name of an object More...
SLstring	_url
	uniform resource locator More...

Friends
class	SLNode
class	SLRaytracer
class	SLOptixRaytracer
class	SLPathtracer

Detailed Description

SceneView class represents a dynamic real time 3D view onto the scene.

The SLSceneView class has a pointer to an active camera that is used to generate the 3D view into a window of the clients GUI system. OpenGL ES3.0 or newer is used the default renderer for framebuffer rendering. Alternatively the sceneview can be rendered with a software ray tracing or path tracing renderer. All mouse, touch, keyboard, resize and paint events of the GUI system are handled in this class by the appropriate event handler methods. If your app need special event handling you can subclass this class and override the virtual function. If the scene contains itself no camera node the sceneview provides its own camera object.

Definition at line 68 of file SLSceneView.h.

Constructor & Destructor Documentation

SLSceneView()

SLSceneView::SLSceneView	(	SLScene *	s,
		int	dpi,
		SLInputManager &	inputManager
	)

SLSceneView default constructor.

The default constructor adds the this pointer to the sceneView vector in SLScene. If an in between element in the vector is zero (from previous sceneviews) it will be replaced. The sceneviews _index is the index in the sceneview vector. It never changes throughout the life of a sceneview.

Definition at line 40 of file SLSceneView.cpp.

  : SLObject(),
    _s(s),
    _dpi(dpi),
    _inputManager(inputManager),
    _shadowMapTimesMS(60, 0.0f),
    _cullTimesMS(60, 0.0f),
    _draw3DTimesMS(60, 0.0f),
    _draw2DTimesMS(60, 0.0f),
    _screenCaptureIsRequested(false),
    _screenCaptureWaitFrames(0)
{
}

~SLSceneView()

SLSceneView::~SLSceneView ( )

override

Definition at line 54 of file SLSceneView.cpp.

{
}

Member Function Documentation

camera() [1/2]

SLCamera* SLSceneView::camera ( )

inline

Definition at line 172 of file SLSceneView.h.

{ return _camera; }

camera() [2/2]

void SLSceneView::camera ( SLCamera *  camera )

inline

Definition at line 149 of file SLSceneView.h.

{ _camera = camera; }

cullTimesMS()

AvgFloat& SLSceneView::cullTimesMS ( )

inline

Definition at line 205 of file SLSceneView.h.

{ return _cullTimesMS; }

doAlphaSorting() [1/2]

SLbool SLSceneView::doAlphaSorting ( ) const

inline

Definition at line 189 of file SLSceneView.h.

{ return _doAlphaSorting; }

doAlphaSorting() [2/2]

void SLSceneView::doAlphaSorting ( SLbool  doAS )

inline

Definition at line 157 of file SLSceneView.h.

{ _doAlphaSorting = doAS; }

doDepthTest() [1/2]

SLbool SLSceneView::doDepthTest ( ) const

inline

Definition at line 191 of file SLSceneView.h.

{ return _doDepthTest; }

doDepthTest() [2/2]

void SLSceneView::doDepthTest ( SLbool  doDT )

inline

Definition at line 155 of file SLSceneView.h.

{ _doDepthTest = doDT; }

doFrustumCulling() [1/2]

SLbool SLSceneView::doFrustumCulling ( ) const

inline

Definition at line 188 of file SLSceneView.h.

{ return _doFrustumCulling; }

doFrustumCulling() [2/2]

void SLSceneView::doFrustumCulling ( SLbool  doFC )

inline

Definition at line 156 of file SLSceneView.h.

{ _doFrustumCulling = doFC; }

doMultiSampling() [1/2]

SLbool SLSceneView::doMultiSampling ( ) const

inline

Definition at line 190 of file SLSceneView.h.

{ return _doMultiSampling; }

doMultiSampling() [2/2]

void SLSceneView::doMultiSampling ( SLbool  doMS )

inline

Definition at line 154 of file SLSceneView.h.

{ _doMultiSampling = doMS; }

doWaitOnIdle() [1/2]

SLbool SLSceneView::doWaitOnIdle ( ) const

inline

Definition at line 192 of file SLSceneView.h.

{ return _doWaitOnIdle; }

doWaitOnIdle() [2/2]

void SLSceneView::doWaitOnIdle ( SLbool  doWI )

inline

Definition at line 153 of file SLSceneView.h.

{ _doWaitOnIdle = doWI; }

dpi()

SLint SLSceneView::dpi ( ) const

inline

Definition at line 179 of file SLSceneView.h.

{ return _dpi; }

draw2DGL()

void SLSceneView::draw2DGL

(

)

SLSceneView::draw2DGL draws all 2D stuff in ortho projection. So far no update is done to the 2D scenegraph.

Definition at line 1086 of file SLSceneView.cpp.

{
    PROFILE_FUNCTION();
 
    SLGLState* stateGL = SLGLState::instance();
    SLfloat    startMS = GlobalTimer::timeMS();
 
    SLfloat w2               = (SLfloat)_scrWdiv2;
    SLfloat h2               = (SLfloat)_scrHdiv2;
    _stats2D.numNodesOpaque  = 0;
    _stats2D.numNodesBlended = 0;
 
    // Set orthographic projection with 0,0,0 in the screen center
    if (_s)
    {
        // 1. Set Projection & View
        stateGL->projectionMatrix.ortho(-w2, w2, -h2, h2, 1.0f, -1.0f);
        stateGL->viewport(0, 0, _scrW, _scrH);
 
        // 2. Pseudo 2D Frustum Culling
        for (auto material : _visibleMaterials2D)
            material->nodesVisible2D().clear();
        _visibleMaterials2D.clear();
        _nodesOpaque2D.clear();
        _nodesBlended2D.clear();
        if (_s->root2D())
            _s->root2D()->cull2DRec(this);
 
        // 3. Draw all 2D nodes opaque
        draw2DGLNodes();
 
        // Draw selection rectangle. See also SLMesh::handleRectangleSelection
        if (!_camera->selectRect().isEmpty())
        {
            SLMat4f prevViewMat = stateGL->viewMatrix;
            stateGL->viewMatrix.identity();
            stateGL->modelMatrix.identity();
            stateGL->modelMatrix.translate(-w2, h2, 1.0f);
            stateGL->depthMask(false); // Freeze depth buffer for blending
            stateGL->depthTest(false); // Disable depth testing
            _camera->selectRect().drawGL(SLCol4f::WHITE);
            stateGL->depthMask(true); // enable depth buffer writing
            stateGL->depthTest(true); // enable depth testing
            stateGL->viewMatrix = prevViewMat;
        }
 
        // Draw deselection rectangle. See also SLMesh::handleRectangleSelection
        if (!_camera->deselectRect().isEmpty())
        {
            SLMat4f prevViewMat = stateGL->viewMatrix;
            stateGL->viewMatrix.identity();
            stateGL->modelMatrix.identity();
            stateGL->modelMatrix.translate(-w2, h2, 1.0f);
            stateGL->depthMask(false); // Freeze depth buffer for blending
            stateGL->depthTest(false); // Disable depth testing
            _camera->deselectRect().drawGL(SLCol4f::MAGENTA);
            stateGL->depthMask(true); // enable depth buffer writing
            stateGL->depthTest(true); // enable depth testing
            stateGL->viewMatrix = prevViewMat;
        }
    }
 
    // 4. Draw UI
    if (_gui)
        _gui->onPaint(_viewportRect);
 
    _draw2DTimeMS = GlobalTimer::timeMS() - startMS;
}

draw2DGLNodes()

void SLSceneView::draw2DGLNodes

(

)

SLSceneView::draw2DGLNodes draws 2D nodes from root2D in orthographic projection

Definition at line 1158 of file SLSceneView.cpp.

{
    PROFILE_FUNCTION();
 
    SLfloat    depth   = 1.0f;                                         // Render depth between -1 & 1
    SLfloat    cs      = std::min((float)_scrW, (float)_scrH) * 0.01f; // center size
    SLGLState* stateGL = SLGLState::instance();
 
    SLMat4f prevViewMat(stateGL->viewMatrix);
    stateGL->viewMatrix.identity();
    stateGL->depthMask(false);   // Freeze depth buffer for blending
    stateGL->depthTest(false);   // Disable depth testing
    stateGL->blend(true);        // Enable blending
    stateGL->polygonLine(false); // Only filled polygons
 
    // Draw all 2D nodes blended (mostly text font textures)
    // draw the shapes directly with their wm transform
    for (auto material : _visibleMaterials2D)
    {
        _stats2D.numNodesOpaque += (SLuint)material->nodesVisible2D().size();
        for (auto* node : material->nodesVisible2D())
        {
            // Apply world transform
            stateGL->modelMatrix = node->updateAndGetWM();
 
            // Finally, the nodes meshes
            node->drawMesh(this);
        }
    }
 
    // Deprecated: SLText node need to be meshes as well
    _stats2D.numNodesOpaque += (SLuint)_nodesBlended2D.size();
    for (auto* node : _nodesBlended2D)
    {
        // Apply world transform
        stateGL->modelMatrix = node->updateAndGetWM();
 
        // Finally, the nodes meshes
        node->drawMesh(this);
    }
 
    // Draw rotation helpers during camera animations
    if ((_mouseDownL || _mouseDownM) && _touchDowns == 0)
    {
        if (_camera->camAnim() == CA_turntableYUp ||
            _camera->camAnim() == CA_turntableZUp)
        {
            stateGL->modelMatrix.identity();
            stateGL->modelMatrix.translate(0, 0, depth);
 
            SLVVec3f centerRombusPoints = {{-cs, 0, 0},
                                           {0, -cs, 0},
                                           {cs, 0, 0},
                                           {0, cs, 0}};
            _vaoTouch.clearAttribs();
            _vaoTouch.generateVertexPos(&centerRombusPoints);
            SLCol4f yelloAlpha(1.0f, 1.0f, 0.0f, 0.5f);
 
            _vaoTouch.drawArrayAsColored(PT_lineLoop, yelloAlpha);
        }
        else if (_camera->camAnim() == CA_trackball)
        {
            stateGL->modelMatrix.identity();
            stateGL->modelMatrix.translate(0, 0, depth);
 
            // radius = half width or height
            SLfloat r = (SLfloat)(_scrW < _scrH
                                    ? _scrW / 2
                                    : _scrH / 2) *
                        _camera->trackballSize();
 
            SLVVec3f rombusAndCirclePoints; // = {{-cs,0,0},{0,-cs,0},{cs,0,0},{0,cs,0}};
 
            // Add points for circle over window
            SLint   circlePoints = 60;
            SLfloat deltaPhi     = Utils::TWOPI / (SLfloat)circlePoints;
            for (SLint i = 0; i < circlePoints; ++i)
            {
                SLVec2f c;
                c.fromPolar(r, (float)i * deltaPhi);
                rombusAndCirclePoints.push_back(SLVec3f(c.x, c.y, 0));
            }
            _vaoTouch.clearAttribs();
            _vaoTouch.generateVertexPos(&rombusAndCirclePoints);
            SLCol4f yelloAlpha(1.0f, 1.0f, 0.0f, 0.5f);
 
            _vaoTouch.drawArrayAsColored(PT_lineLoop, yelloAlpha);
        }
    }
 
    stateGL->viewMatrix = prevViewMat;
    stateGL->blend(false);    // turn off blending
    stateGL->depthMask(true); // enable depth buffer writing
    stateGL->depthTest(true); // enable depth testing
    GET_GL_ERROR;             // check if any OGL errors occurred
}

draw2DTimesMS()

AvgFloat& SLSceneView::draw2DTimesMS ( )

inline

Definition at line 206 of file SLSceneView.h.

{ return _draw2DTimesMS; }

draw3DCT()

SLbool SLSceneView::draw3DCT

(

)

draw3DGL()

SLbool SLSceneView::draw3DGL

(

SLfloat

elapsedTimeMS

)

Draws the 3D scene with OpenGL.

This is the main routine for updating and drawing the 3D scene for one frame. The following steps are processed:

1. Render shadow maps: Renders all shadow maps for lights in SLLight::renderShadowMap
2. Updates the camera: If the active camera has an animation it gets updated first in SLCamera::camUpdate
3. Clear all buffers: The color and depth buffer are cleared in this step. If the projection is the Oculus stereo projection also the framebuffer target is bound.
4. Set viewport: Depending on the projection we set the camera projection and the view for the center or left eye.
5. Render background: If no skybox is used the background is rendered. This can be the camera image if the camera is turned on.
6. Set projection and view: Sets the camera projection matrix
7. Frustum culling: During the cull traversal all materials that are seen in the view frustum get collected in _visibleMaterials. All nodes with their meshes get collected in SLMaterial::_nodesVisible3D. These materials and nodes get drawn in draw3DGLAll.
8. Draw skybox: The skybox is draw as first object with frozen depth buffer. The skybox is always around the active camera.
9. Draw all visible nodes: By calling the SLSceneView::draw3DGL all visible nodes of all visible materials get drawn sorted by material and transparency. If a stereo projection is set, the scene gets drawn a second time for the right eye.
10. Draw right eye for stereo projections

Definition at line 659 of file SLSceneView.cpp.

{
    PROFILE_FUNCTION();
 
    SLGLState* stateGL = SLGLState::instance();
 
    preDraw();
 
    ///////////////////////////
    // 1. Render shadow maps //
    ///////////////////////////
 
    SLfloat startMS = GlobalTimer::timeMS();
 
    // Render shadow map for each light which creates shadows
    for (SLLight* light : _s->lights())
    {
        if (light->createsShadows())
            light->renderShadowMap(this, _s->root3D());
    }
 
    _shadowMapTimeMS = GlobalTimer::timeMS() - startMS;
 
    /////////////////////////
    // 2. Do camera update //
    /////////////////////////
 
    startMS = GlobalTimer::timeMS();
 
    // Update camera animation separately (smooth transition on key movement)
    // todo: ghm1: this is currently only necessary for walking animation (which is somehow always enabled)
    // A problem is also, that it only updates the current camera.
    // This is maybe not what we want for sensor rotated camera.
 
    SLbool camUpdated = _camera->camUpdate(this, elapsedTimeMS);
 
    //////////////////////
    // 3. Clear buffers //
    //////////////////////
 
    // Render into framebuffer if Oculus stereo projection is used
    if (_camera->projType() == P_stereoSideBySideD)
    {
        _s->oculus()->beginFrame();
        _oculusFB.bindFramebuffer((SLint)(_s->oculus()->resolutionScale() * (SLfloat)_scrW),
                                  (SLint)(_s->oculus()->resolutionScale() * (SLfloat)_scrH));
    }
 
    // Clear color buffer
    stateGL->clearColor(SLVec4f(0.00001f, 0.00001f, 0.00001f, 1.0f));
    stateGL->clearColorDepthBuffer();
 
    /////////////////////
    // 4. Set viewport //
    /////////////////////
 
    if (_camera->projType() > P_monoOrthographic)
        _camera->setViewport(this, ET_left);
    else
        _camera->setViewport(this, ET_center);
 
    //////////////////////////
    // 5. Render background //
    //////////////////////////
 
    // Render solid color, gradient or textured background from active camera
    if (!_s->skybox())
        _camera->background().render(_viewportRect.width,
                                     _viewportRect.height);
 
    // Change state (only when changed)
    stateGL->multiSample(_doMultiSampling);
    stateGL->depthTest(_doDepthTest);
 
    //////////////////////////////
    // 6. Set projection & View //
    //////////////////////////////
 
    // Set projection
    if (_camera->projType() > P_monoOrthographic)
    {
        _camera->setProjection(this, ET_left);
        _camera->setView(this, ET_left);
    }
    else
    {
        _camera->setProjection(this, ET_center);
        _camera->setView(this, ET_center);
    }
 
    ////////////////////////
    // 7. Frustum culling //
    ////////////////////////
 
    // Delete all visible nodes from the last frame
    for (auto* material : _visibleMaterials3D)
        material->nodesVisible3D().clear();
 
    _visibleMaterials3D.clear();
    _nodesOpaque3D.clear();
    _nodesBlended3D.clear();
    _nodesOverdrawn.clear();
    _stats3D.numNodesOpaque  = 0;
    _stats3D.numNodesBlended = 0;
    _camera->setFrustumPlanes();
 
    if (_s->root3D())
        _s->root3D()->cull3DRec(this);
 
    _cullTimeMS = GlobalTimer::timeMS() - startMS;
 
    ////////////////////
    // 8. Draw skybox //
    ////////////////////
 
    if (_s->skybox())
        _s->skybox()->drawAroundCamera(this);
 
    ////////////////////////////
    // 9. Draw all visible nodes
    ////////////////////////////
 
    startMS = GlobalTimer::timeMS();
 
    draw3DGLAll();
 
    ///////////////////////////////////////////////
    // 10. Draw right eye for stereo projections //
    ///////////////////////////////////////////////
 
    if (_camera->projType() > P_monoOrthographic)
    {
        _camera->setViewport(this, ET_right);
 
        // Only draw backgrounds for stereo projections in different viewports
        if (!_s->skybox() && _camera->projType() < P_stereoLineByLine)
            _camera->background().render(_viewportRect.width, _viewportRect.height);
 
        _camera->setProjection(this, ET_right);
        _camera->setView(this, ET_right);
        stateGL->depthTest(true);
        if (_s->skybox())
            _s->skybox()->drawAroundCamera(this);
        draw3DGLAll();
    }
 
    // Enable all color channels again
    stateGL->colorMask(1, 1, 1, 1);
 
    _draw3DTimeMS = GlobalTimer::timeMS() - startMS;
 
    postDraw();
 
    GET_GL_ERROR; // Check if any OGL errors occurred
    return camUpdated;
}

draw3DGLAll()

void SLSceneView::draw3DGLAll

(

)

SLSceneView::draw3DGLAll renders by material sorted to avoid expensive material switches on the GPU. During the cull traversal all materials that are seen in the view frustum get collected in _visibleMaterials. All nodes with their meshes get collected in SLMaterial::_nodesVisible3D.
The 3D rendering has then the following steps: 1) Draw nodes with meshes with opaque materials and all helper lines sorted by material
2) Draw remaining opaque nodes (SLCameras, needs redesign)
3) Draw nodes with meshes with blended materials sorted by material and sorted back to front
4) Draw remaining blended nodes (SLText, needs redesign)
5) Draw helpers in overlay mode (not depth buffered)
6) Draw visualization lines of animation curves

Definition at line 829 of file SLSceneView.cpp.

{
    PROFILE_FUNCTION();
 
    // a) Draw nodes with meshes with opaque materials and all helper lines sorted by material
    for (auto material : _visibleMaterials3D)
    {
        if (!material->hasAlpha())
        {
            draw3DGLNodes(material->nodesVisible3D(), false, false);
            _stats3D.numNodesOpaque += (SLuint)material->nodesVisible3D().size();
        }
        draw3DGLLines(material->nodesVisible3D());
    }
 
    // b) Draw remaining opaque nodes without meshes
    _stats3D.numNodesOpaque += (SLuint)_nodesOpaque3D.size();
    draw3DGLNodes(_nodesOpaque3D, false, false);
    draw3DGLLines(_nodesOpaque3D);
 
    // c) Draw nodes with meshes with blended materials sorted by material and sorted back to front
    for (auto material : _visibleMaterials3D)
    {
        if (material->hasAlpha())
        {
            draw3DGLNodes(material->nodesVisible3D(), true, _doAlphaSorting);
            _stats3D.numNodesBlended += (SLuint)material->nodesVisible3D().size();
        }
    }
 
    // d) Draw remaining blended nodes (SLText, needs redesign)
    _stats3D.numNodesBlended += (SLuint)_nodesBlended3D.size();
    draw3DGLNodes(_nodesBlended3D, true, _doAlphaSorting);
 
    // e) Draw helpers in overlay mode (not depth buffered)
    for (auto material : _visibleMaterials3D)
        draw3DGLLinesOverlay(material->nodesVisible3D());
 
    draw3DGLLinesOverlay(_nodesOverdrawn);
    draw3DGLLinesOverlay(_nodesOpaque3D);
 
    // f) Draw visualization lines of animation curves
    _s->animManager().drawVisuals(this);
 
    // g) Turn blending off again for correct anaglyph stereo modes
    SLGLState* stateGL = SLGLState::instance();
    stateGL->blend(false);
    stateGL->depthMask(true);
    stateGL->depthTest(true);
}

draw3DGLLines()

void SLSceneView::draw3DGLLines

(

SLVNode &

nodes

)

SLSceneView::draw3DGLLines draws the AABB from the passed node vector directly with their world coordinates after the view transform. The lines must be drawn without blending. Colors: Red : AABB of nodes with meshes Pink : AABB of nodes without meshes (only child nodes) Yellow: AABB of selected node

Definition at line 930 of file SLSceneView.cpp.

{
    PROFILE_FUNCTION();
 
    if (nodes.empty()) return;
 
    SLGLState* stateGL = SLGLState::instance();
    stateGL->blend(false);
    stateGL->depthMask(true);
 
    // Set the view transform for drawing in world space
    stateGL->modelMatrix.identity();
 
    // draw the opaque shapes directly w. their wm transform
    for (auto* node : nodes)
    {
        if (node != _camera)
        {
            // Draw first AABB of the shapes but not the camera
            if ((drawBit(SL_DB_BBOX) || node->drawBit(SL_DB_BBOX)) &&
                !node->isSelected())
            {
                if (node->mesh())
                    node->aabb()->drawWS(SLCol4f::RED);
                else
                    node->aabb()->drawWS(SLCol4f::MAGENTA);
            }
 
            // Draw AABB for selected shapes
            if (node->isSelected())
            {
                node->aabb()->drawWS(SLCol4f::YELLOW);
            }
        }
    }
 
    GET_GL_ERROR; // Check if any OGL errors occurred
}

draw3DGLLinesOverlay()

void SLSceneView::draw3DGLLinesOverlay

(

SLVNode &

nodes

)

SLSceneView::draw3DGLLinesOverlay draws the nodes axis and skeleton joints as overlay

Definition at line 973 of file SLSceneView.cpp.

{
    PROFILE_FUNCTION();
 
    SLGLState* stateGL = SLGLState::instance();
 
    // draw the opaque shapes directly w. their wm transform
    for (auto* node : nodes)
    {
        if (node != _camera)
        {
            if (drawBit(SL_DB_AXIS) || node->drawBit(SL_DB_AXIS) ||
                drawBit(SL_DB_SKELETON) || node->drawBit(SL_DB_SKELETON) ||
                node->isSelected())
            {
                // Set the view transform
                stateGL->modelMatrix.identity();
                stateGL->blend(false);     // Turn off blending for overlay
                stateGL->depthMask(true);  // Freeze depth buffer for blending
                stateGL->depthTest(false); // Turn of depth test for overlay
 
                // Draw axis
                if (drawBit(SL_DB_AXIS) ||
                    node->drawBit(SL_DB_AXIS) ||
                    node->isSelected())
                {
                    node->aabb()->drawAxisWS();
                }
 
                // Draw skeleton
                if (drawBit(SL_DB_SKELETON) ||
                    node->drawBit(SL_DB_SKELETON))
                {
                    // Draw axis of the skeleton joints and its parent bones
                    const SLAnimSkeleton* skeleton = node->skeleton();
                    if (skeleton)
                    {
                        for (auto joint : skeleton->joints())
                        {
                            // Get the node wm & apply the joints wm
                            SLMat4f wm = node->updateAndGetWM();
                            wm *= joint->updateAndGetWM();
 
                            // Get parent node wm & apply the parent joint wm
                            SLMat4f parentWM;
                            if (joint->parent())
                            {
                                parentWM = node->parent()->updateAndGetWM();
                                parentWM *= joint->parent()->updateAndGetWM();
                                joint->aabb()->updateBoneWS(parentWM, false, wm);
                            }
                            else
                                joint->aabb()->updateBoneWS(parentWM, true, wm);
 
                            joint->aabb()->drawBoneWS();
                        }
                    }
                }
            }
            else if (drawBit(SL_DB_BRECT) || node->drawBit(SL_DB_BRECT))
            {
                node->aabb()->calculateRectSS();
 
                SLMat4f prevProjMat = stateGL->projectionMatrix;
                SLMat4f prevViewMat = stateGL->viewMatrix;
                SLfloat w2          = (SLfloat)_scrWdiv2;
                SLfloat h2          = (SLfloat)_scrHdiv2;
                stateGL->projectionMatrix.ortho(-w2, w2, -h2, h2, 1.0f, -1.0f);
                stateGL->viewport(0, 0, _scrW, _scrH);
                stateGL->viewMatrix.identity();
                stateGL->modelMatrix.identity();
                stateGL->modelMatrix.translate(-w2, h2, 1.0f);
                stateGL->depthMask(false); // Freeze depth buffer for blending
                stateGL->depthTest(false); // Disable depth testing
 
                node->aabb()->rectSS().drawGL(SLCol4f::GREEN);
 
                stateGL->depthMask(true); // Freeze depth buffer for blending
                stateGL->depthTest(true); // Disable depth testing
                stateGL->projectionMatrix = prevProjMat;
                stateGL->viewMatrix       = prevViewMat;
            }
            else if (node->drawBit(SL_DB_OVERDRAW))
            {
                if (node->mesh() && node->mesh()->mat())
                {
                    SLMesh* mesh     = node->mesh();
                    bool    hasAlpha = mesh->mat()->hasAlpha();
 
                    // For blended nodes we activate OpenGL blending and stop depth buffer updates
                    stateGL->blend(hasAlpha);
                    stateGL->depthMask(!hasAlpha);
                    stateGL->depthTest(false); // Turn of depth test for overlay
 
                    // Set model & view transform
                    stateGL->viewMatrix  = stateGL->viewMatrix;
                    stateGL->modelMatrix = node->updateAndGetWM();
 
                    // Finally, draw the nodes mesh
                    node->drawMesh(this);
                    GET_GL_ERROR; // Check if any OGL errors occurred
                }
            }
        }
    }
 
    GET_GL_ERROR; // Check if any OGL errors occurred
}

draw3DGLNodes()

void SLSceneView::draw3DGLNodes	(	SLVNode &	nodes,
		SLbool	alphaBlended,
		SLbool	depthSorted
	)

SLSceneView::draw3DGLNodes draws the nodes meshes from the passed node vector directly with their world transform after the view transform.

Definition at line 884 of file SLSceneView.cpp.

{
    // PROFILE_FUNCTION();
 
    if (nodes.empty()) return;
 
    // For blended nodes we activate OpenGL blending and stop depth buffer updates
    SLGLState* stateGL = SLGLState::instance();
    stateGL->blend(alphaBlended);
    stateGL->depthMask(!alphaBlended);
 
    // Important and expensive step for blended nodes with alpha meshes
    // Depth sort with lambda function by their view distance
    if (depthSorted)
    {
        std::sort(nodes.begin(), nodes.end(), [](SLNode* a, SLNode* b)
                  {
                      if (!a) return false;
                      if (!b) return true;
                      return a->aabb()->sqrViewDist() > b->aabb()->sqrViewDist(); });
    }
 
    // draw the shapes directly with their wm transform
    for (auto* node : nodes)
    {
        // Set model matrix as the nodes model to world matrix
        stateGL->modelMatrix = node->updateAndGetWM();
 
        // Finally, draw the nodes mesh
        node->drawMesh(this);
    }
 
    GET_GL_ERROR; // Check if any OGL errors occurred
}

draw3DPT()

SLbool SLSceneView::draw3DPT

(

)

SLSceneView::updateAndRT3D starts the raytracing or refreshes the current RT image during rendering. The function returns true if an animation was done prior to the rendering start.

Definition at line 1957 of file SLSceneView.cpp.

{
    SLbool updated = false;
 
    // if the pathtracer not yet got started
    if (_pathtracer.state() == rtReady)
    {
        if (_s->root3D())
        {
            // Update transforms and AABBs
            // @Todo: causes multithreading bug in RT
            // s->root3D()->needUpdate();
 
            // Do software skinning on all changed skeletons
            _s->root3D()->updateMeshAccelStructs();
        }
 
        // Start raytracing
        _pathtracer.render(this);
    }
 
    // Refresh the render image during PT
    _pathtracer.renderImage(true);
 
    // React on the stop flag (e.g. ESC)
    if (_stopPT)
    {
        _renderType = RT_gl;
        updated     = true;
    }
 
    return updated;
}

draw3DRT()

SLbool SLSceneView::draw3DRT

(

)

SLSceneView::updateAndRT3D starts the raytracing or refreshes the current RT image during rendering. The function returns true if an animation was done prior to the rendering start.

Definition at line 1904 of file SLSceneView.cpp.

{
    SLbool updated = false;
 
    // if the raytracer not yet got started
    if (_raytracer.state() == rtReady)
    {
        if (_s->root3D())
        {
            // Update transforms and AABBs
            // @Todo: causes multithreading bug in RT
            // s->root3D()->needUpdate();
 
            // Do software skinning on all changed skeletons
            _s->root3D()->updateMeshAccelStructs();
        }
 
        // Start raytracing
        if (_raytracer.doDistributed())
            _raytracer.renderDistrib(this);
        else
            _raytracer.renderClassic(this);
    }
 
    // Refresh the render image during RT
    _raytracer.renderImage(true);
 
    // React on the stop flag (e.g. ESC)
    if (_stopRT)
    {
        _renderType = RT_gl;
        updated     = true;
    }
 
    return updated;
}

draw3DTimesMS()

AvgFloat& SLSceneView::draw3DTimesMS ( )

inline

Definition at line 207 of file SLSceneView.h.

{ return _draw3DTimesMS; }

drawBit()

SLbool SLSceneView::drawBit ( SLuint  bit )

inline

Definition at line 203 of file SLSceneView.h.

{ return _drawBits.get(bit); }

drawBits()

SLDrawBits* SLSceneView::drawBits ( )

inline

Definition at line 202 of file SLSceneView.h.

{ return &_drawBits; }

gui()

SLUiInterface* SLSceneView::gui ( )

inline

Definition at line 187 of file SLSceneView.h.

{ return _gui; }

init()

void SLSceneView::init	(	SLstring	name,
		SLint	screenWidth,
		SLint	screenHeight,
		void *	onWndUpdateCallback,
		void *	onSelectNodeMeshCallback,
		SLUiInterface *	gui,
		const string &	configPath
	)

SLSceneView::init initializes default values for an empty scene

Parameters

name	Name of the sceneview
screenWidth	Width of the OpenGL frame buffer.
screenHeight	Height of the OpenGL frame buffer.
onWndUpdateCallback	Callback for ray tracing update
onSelectNodeMeshCallback	Callback on node and mesh selection
gui	Interface for the external Gui build function
configPath	Path to the config file

Definition at line 67 of file SLSceneView.cpp.

{
    _gui        = gui;
    _name       = std::move(name);
    _scrW       = screenWidth;
    _scrH       = screenHeight;
    _gotPainted = true;
 
    // The window update callback function is used to refresh the ray tracing
    // image during the rendering process. The ray tracing image is drawn by OpenGL
    // as a texture on a single quad.
    onWndUpdate = (cbOnWndUpdate)onWndUpdateCallback;
 
    // The on select node callback is called when a node got selected on double
    // click, so that the UI can react on it.
    onSelectedNodeMesh = (cbOnSelectNodeMesh)onSelectNodeMeshCallback;
 
    _camera = &_sceneViewCamera;
 
    // enables and modes
    _mouseDownL = false;
    _mouseDownR = false;
    _mouseDownM = false;
    _touchDowns = 0;
 
    _doDepthTest      = true;
    _doMultiSampling  = true;
    _doFrustumCulling = true;
    _doAlphaSorting   = true;
    _doWaitOnIdle     = true;
    _drawBits.allOff();
 
    _stats2D.clear();
    _stats3D.clear();
 
    _scrWdiv2 = _scrW >> 1;
    _scrHdiv2 = _scrH >> 1;
    _scrWdivH = (SLfloat)_scrW / (SLfloat)_scrH;
 
    _renderType = RT_gl;
 
    _screenCaptureIsRequested = false;
 
#if defined(SL_OS_ANDROID) || defined(SL_OS_MACIOS) || defined(SL_EMSCRIPTEN)
    _viewportAlign = VA_center;
#else
    _viewportAlign = VA_leftOrBottom;
#endif
 
    if (_gui)
        _gui->init(configPath);
 
    // Set default viewport ratio to the same as the screen
    setViewportFromRatio(SLVec2i(0, 0), _viewportAlign, false);
 
    onStartup();
}

initSceneViewCamera()

void SLSceneView::initSceneViewCamera	(	const SLVec3f &	dir = -SLVec3f::AXISZ,
		SLProjType	proj = P_monoPerspective
	)

SLSceneView::onInitialize is called by the window system before the first rendering. It applies all scene rendering attributes with the according OpenGL function.

Definition at line 166 of file SLSceneView.cpp.

{
    _sceneViewCamera.camAnim(CA_turntableYUp);
    _sceneViewCamera.name("SceneView Camera");
    _sceneViewCamera.clipNear(.1f);
    _sceneViewCamera.clipFar(2000.0f);
    _sceneViewCamera.maxSpeed(40);
    _sceneViewCamera.stereoEyeSeparation(_sceneViewCamera.focalDist() / 30.0f);
    _sceneViewCamera.setProjection(this, ET_center);
    _sceneViewCamera.projType(proj);
 
    // fit scenes bounding box in view frustum
    if (_s && _s->root3D())
    {
        // we want to fit the scenes combined aabb in the view frustum
        SLAABBox* sceneBounds = _s->root3D()->aabb();
 
        _sceneViewCamera.translation(sceneBounds->centerWS(), TS_world);
        _sceneViewCamera.lookAt(sceneBounds->centerWS() + dir,
                                SLVec3f::AXISY,
                                TS_parent);
 
        SLfloat minX = sceneBounds->minWS().x;
        SLfloat minY = sceneBounds->minWS().y;
        SLfloat minZ = sceneBounds->minWS().z;
        SLfloat maxX = sceneBounds->maxWS().x;
        SLfloat maxY = sceneBounds->maxWS().y;
        SLfloat maxZ = sceneBounds->maxWS().z;
 
        // calculate the min and max points in view space
        SLVec4f vsCorners[8];
 
        vsCorners[0] = SLVec4f(minX, minY, minZ);
        vsCorners[1] = SLVec4f(maxX, minY, minZ);
        vsCorners[2] = SLVec4f(minX, maxY, minZ);
        vsCorners[3] = SLVec4f(maxX, maxY, minZ);
        vsCorners[4] = SLVec4f(minX, minY, maxZ);
        vsCorners[5] = SLVec4f(maxX, minY, maxZ);
        vsCorners[6] = SLVec4f(minX, maxY, maxZ);
        vsCorners[7] = SLVec4f(maxX, maxY, maxZ);
 
        SLVec3f vsMin(FLT_MAX, FLT_MAX, FLT_MAX);
        SLVec3f vsMax(FLT_MIN, FLT_MIN, FLT_MIN);
 
        SLMat4f vm = _sceneViewCamera.updateAndGetWMI();
 
        for (auto& vsCorner : vsCorners)
        {
            vsCorner = vm * vsCorner;
 
            vsMin.x = std::min(vsMin.x, vsCorner.x);
            vsMin.y = std::min(vsMin.y, vsCorner.y);
            vsMin.z = std::min(vsMin.z, vsCorner.z);
 
            vsMax.x = std::max(vsMax.x, vsCorner.x);
            vsMax.y = std::max(vsMax.y, vsCorner.y);
            vsMax.z = std::max(vsMax.z, vsCorner.z);
        }
 
        SLfloat distX   = 0.0f;
        SLfloat distY   = 0.0f;
        SLfloat halfTan = tan(Utils::DEG2RAD * _sceneViewCamera.fovV() * 0.5f);
 
        // @todo There is still a bug when OSX doesn't pass correct GLWidget size
        // correctly set the camera distance...
        SLfloat ar = _sceneViewCamera.aspect();
 
        // special case for orthographic cameras
        if (proj == P_monoOrthographic)
        {
            // NOTE, the orthographic camera has the ability to zoom by using the following:
            // tan(SL_DEG2RAD*_fovV*0.5f) * pos.length();
 
            distX = vsMax.x / (ar * halfTan);
            distY = vsMax.y / halfTan;
        }
        else
        {
            // for now we treat all other cases as having a single frustum
            distX = (vsMax.x - vsMin.x) * 0.5f / (ar * halfTan);
            distY = (vsMax.y - vsMin.y) * 0.5f / halfTan;
 
            distX += vsMax.z;
            distY += vsMax.z;
        }
 
        SLfloat dist = std::max(distX, distY);
 
        // set focal distance
        _sceneViewCamera.focalDist(dist);
        _sceneViewCamera.translate(SLVec3f(0, 0, dist), TS_object);
    }
 
    _sceneViewCamera.updateAABBRec(false);
    _sceneViewCamera.setInitialState();
 
    // if no camera exists or in VR mode use the sceneViewCamera
    if (_camera == nullptr)
    {
        _camera = &_sceneViewCamera;
    }
 
    _camera->needUpdate();
}

isSceneViewCameraActive()

SLbool SLSceneView::isSceneViewCameraActive ( )

inline

Definition at line 128 of file SLSceneView.h.

{ return _camera == &_sceneViewCamera; }

nodesBlended2D()

SLVNode& SLSceneView::nodesBlended2D ( )

inline

Definition at line 196 of file SLSceneView.h.

{ return _nodesBlended2D; }

nodesBlended3D()

SLVNode& SLSceneView::nodesBlended3D ( )

inline

Definition at line 194 of file SLSceneView.h.

{ return _nodesBlended3D; }

nodesOpaque2D()

SLVNode& SLSceneView::nodesOpaque2D ( )

inline

Definition at line 195 of file SLSceneView.h.

{ return _nodesOpaque2D; }

nodesOpaque3D()

SLVNode& SLSceneView::nodesOpaque3D ( )

inline

Definition at line 193 of file SLSceneView.h.

{ return _nodesOpaque3D; }

nodesOverdrawn()

SLVNode& SLSceneView::nodesOverdrawn ( )

inline

Definition at line 197 of file SLSceneView.h.

{ return _nodesOverdrawn; }

oculusFB()

SLGLOculusFB* SLSceneView::oculusFB ( )

inline

Definition at line 201 of file SLSceneView.h.

{ return &_oculusFB; }

onCharInput()

SLbool SLSceneView::onCharInput ( SLuint  c )

virtual

SLSceneView::onCharInput get called whenever a new charcter comes in

Definition at line 1808 of file SLSceneView.cpp.

{
    if (_gui)
    {
        if (_gui->doNotDispatchKeyboard())
        {
            _gui->onCharInput(c);
            return true;
        }
    }
 
    return false;
}

onDoubleClick()

SLbool SLSceneView::onDoubleClick ( SLMouseButton  button, SLint  scrX, SLint  scrY, SLKey  mod  )

virtual

SLSceneView::onDoubleClick gets called when a mouse double click or finger double tab occurs.

Definition at line 1508 of file SLSceneView.cpp.

{
    if (!_s || !_s->root3D())
        return false;
 
    // Correct viewport offset
    // mouse coordinates are top-left, viewport is bottom-left)
    SLint x = scrX - _viewportRect.x;
    SLint y = scrY - ((_scrH - _viewportRect.height) - _viewportRect.y);
 
    SLbool result = false;
 
    // Do object picking with ray cast
    if (button == MB_left)
    {
        _mouseDownR = false;
 
        SLRay pickRay(this);
        if (_camera)
        {
            _camera->eyeToPixelRay((SLfloat)x, (SLfloat)y, &pickRay);
 
            // Update the AABB min & max points in OS
            _s->root3D()->updateAABBRec(true);
 
            _s->root3D()->hitRec(&pickRay);
            if (pickRay.hitNode)
                SL_LOG("NODE HIT: %s", pickRay.hitNode->name().c_str());
        }
 
        if (pickRay.length < FLT_MAX)
        {
            if (mod & K_shift)
            {
                _s->selectNodeMesh(pickRay.hitNode, pickRay.hitMesh);
                if (onSelectedNodeMesh)
                    onSelectedNodeMesh(pickRay.hitNode, pickRay.hitMesh);
            }
            else
            {
                if (_s->singleNodeSelected() != pickRay.hitNode)
                    _s->deselectAllNodesAndMeshes();
 
                _s->selectNodeMesh(pickRay.hitNode, pickRay.hitMesh);
                if (onSelectedNodeMesh)
                    onSelectedNodeMesh(pickRay.hitNode, pickRay.hitMesh);
            }
            result = true;
        }
    }
    else
    {
        result = _camera->onDoubleClick(button, x, y, mod);
        for (auto* eh : _s->eventHandlers())
        {
            if (eh->onDoubleClick(button, x, y, mod))
                result = true;
        }
    }
    return result;
}

onInitialize()

void SLSceneView::onInitialize

(

)

SLSceneView::onInitialize is called by the window system before the first rendering. It applies all scene rendering attributes with the according OpenGL function.

Definition at line 381 of file SLSceneView.cpp.

{
    PROFILE_FUNCTION();
 
    SLGLState* stateGL = SLGLState::instance();
 
    if (_camera)
        stateGL->onInitialize(_camera->background().colors()[0]);
    else
        stateGL->onInitialize(SLCol4f::GRAY);
 
    _visibleMaterials2D.clear();
    _visibleMaterials3D.clear();
    _nodesOverdrawn.clear();
    _stats2D.clear();
    _stats3D.clear();
 
    _raytracer.deleteData(false);
    _renderType   = RT_gl;
    _isFirstFrame = true;
 
#ifdef SL_HAS_OPTIX
    // Only worth attempting if SLOptix::createStreamAndContext got a context.
    // Building the modules compiles the PTX for this GPU, which fails on a card
    // older than the SL_OPTIX_CUDA_ARCH the kernels were built for -- something
    // no configure time check can see. It must not take the application down.
    if (SLOptix::available)
    {
        try
        {
            _optixRaytracer.setupOptix();
            _optixPathtracer.setupOptix();
        }
        catch (std::exception& e)
        {
            SLOptix::available = false;
            SL_LOG("**** OptiX renderers disabled ****");
            SL_LOG("%s", e.what());
            SL_LOG("The GPU is most likely older than the SL_OPTIX_CUDA_ARCH the");
            SL_LOG("kernels were compiled for. Everything else keeps working.");
        }
    }
#endif
 
    // init 3D scene with initial depth 1
    if (_s && _s->root3D() && _s->root3D()->aabb()->radiusOS() < 0.0001f)
    {
        // Init camera so that its frustum is set
        if (_camera)
            _camera->setProjection(this, ET_center);
 
        // build axis aligned bounding box hierarchy after init
        clock_t t = clock();
        _s->root3D()->updateAABBRec(true);
        _s->root3D()->updateMeshAccelStructs();
 
        SL_LOG_DEBUG("Time for AABBs   : %5.3f sec.",
                     (SLfloat)(clock() - t) / (SLfloat)CLOCKS_PER_SEC);
 
        // Collect node statistics
        _s->root3D()->statsRec(_stats3D);
 
        // Warn if there are no light in scene
        if (_s->lights().empty())
            SL_LOG_DEBUG("sv->onInitialize : No Lights found in scene!");
 
        //_s->root3D()->dumpRec();
    }
 
    // init 2D scene with initial depth 1
    if (_s && _s->root2D() && _s->root2D()->aabb()->radiusOS() < 0.0001f)
    {
        // build axis aligned bounding box hierarchy after init
        _s->root2D()->updateAABBRec(true);
 
        // Collect node statistics
        _stats2D.clear();
        _s->root2D()->statsRec(_stats2D);
    }
 
    // Reset timing variables
    _shadowMapTimeMS = 0.0f;
    _cullTimeMS      = 0.0f;
    _draw3DTimeMS    = 0.0f;
    _draw2DTimeMS    = 0.0f;
    _cullTimesMS.init(60, 0.0f);
    _draw3DTimesMS.init(60, 0.0f);
    _draw2DTimesMS.init(60, 0.0f);
 
    initSceneViewCamera();
 
    if (_gui)
        _gui->onResize(_viewportRect);
}

onKeyPress()

SLbool SLSceneView::onKeyPress ( SLKey  key, SLKey  mod  )

virtual

SLSceneView::onKeyPress gets get called whenever a key is pressed. Before passing the command to the eventhandlers the main key commands are handled by forwarding them to onCommand.

Reimplemented in AppDemoSceneView, and AppNodeSceneView.

Definition at line 1676 of file SLSceneView.cpp.

{
    // Pass the event to imgui
    if (_gui)
    {
        if (_gui->doNotDispatchKeyboard())
        {
            _gui->onKeyPress(key, mod);
            return true;
        }
    }
 
    if (!_s || !_s->root3D())
        return false;
 
    // clang-format off
    // We have to coordinate these shortcuts in SLDemoGui::buildMenuBar
    if (key=='L') {doMultiSampling(!doMultiSampling()); return true;}
    if (key=='I') {doWaitOnIdle(!doWaitOnIdle()); return true;}
    if (key=='F') {doFrustumCulling(!doFrustumCulling()); return true;}
    if (key=='J') {doAlphaSorting(!doAlphaSorting()); return true;}
    if (key=='T') {doDepthTest(!doDepthTest()); return true;}
    if (key==K_space) {_s->stopAnimations(!_s->stopAnimations()); return true;}
 
    if (key=='R') {startRaytracing(5);}
    if (key=='P') {startPathtracing(32, 10);}
#ifdef SL_HAS_OPTIX
    if (key=='R' && mod==K_shift) {startOptixRaytracing(5);}
    if (key=='P' && mod==K_shift) {startOptixPathtracing(5, 100);}
#endif
 
    if (key=='M') {drawBits()->toggle(SL_DB_MESHWIRED); return true;}
    if (key=='H') {drawBits()->toggle(SL_DB_WITHEDGES); return true;}
    if (key=='O') {drawBits()->toggle(SL_DB_ONLYEDGES); return true;}
    if (key=='N') {drawBits()->toggle(SL_DB_NORMALS); return true;}
    if (key=='B') {drawBits()->toggle(SL_DB_BBOX); return true;}
    if (key=='U') {drawBits()->toggle(SL_DB_BRECT); return true;}
    if (key=='V') {drawBits()->toggle(SL_DB_VOXELS); return true;}
    if (key=='X') {drawBits()->toggle(SL_DB_AXIS); return true;}
    if (key=='C') {drawBits()->toggle(SL_DB_CULLOFF); return true;}
    if (key=='K') {drawBits()->toggle(SL_DB_SKELETON); return true;}
 
    if (key=='5')
    {   if (_camera->projType() == P_monoPerspective)
            _camera->projType(P_monoOrthographic);
        else _camera->projType(P_monoPerspective);
        if (_renderType == RT_rt && !_raytracer.doContinuous() &&
            _raytracer.state() == rtFinished)
            _raytracer.state(rtReady);
    }
 
    if (key==K_tab) {switchToNextCameraInScene(); return true;}
 
    if (key==K_esc)
    {
        if (_camera && _camera->projType() == P_stereoSideBySideD)
            _camera->projType(P_monoPerspective);
 
        if (!_s->selectedNodes().empty() ||
            !_camera->selectRect().isEmpty() ||
            !_camera->deselectRect().isEmpty())
        {
            _s->deselectAllNodesAndMeshes();
            _camera->selectRect().setZero();
            _camera->deselectRect().setZero();
            return true;
        }
 
        if(_renderType == RT_rt) _stopRT = true;
        if(_renderType == RT_pt) _stopPT = true;
#ifdef SL_HAS_OPTIX
        if(_renderType == RT_optix_rt) _stopOptixRT = true;
        if(_renderType == RT_optix_pt) _stopOptixPT = true;
#endif
        return true;
    }
    // clang-format on
 
    SLbool result = false;
    if (key || mod)
    {
        // 1) pass it to the camera
        result = _camera->onKeyPress(key, mod);
 
        // 2) pass it to any other eventhandler
        for (auto* eh : _s->eventHandlers())
        {
            if (eh->onKeyPress(key, mod))
                result = true;
        }
    }
    return result;
}

onKeyRelease()

SLbool SLSceneView::onKeyRelease ( SLKey  key, SLKey  mod  )

virtual

SLSceneView::onKeyRelease get called whenever a key is released.

Reimplemented in AppDemoSceneView, and AppNodeSceneView.

Definition at line 1773 of file SLSceneView.cpp.

{
    // Pass the event to imgui
    if (_gui)
    {
        if (_gui->doNotDispatchKeyboard())
        {
            _gui->onKeyRelease(key, mod);
            return true;
        }
    }
 
    if (!_s || !_s->root3D())
        return false;
 
    SLbool result = false;
 
    if (key || mod)
    {
        // 1) pass it to the camera
        result = _camera->onKeyRelease(key, mod);
 
        // 2) pass it to any other eventhandler
        for (auto* eh : _s->eventHandlers())
        {
            if (eh->onKeyRelease(key, mod))
                result = true;
        }
    }
    return result;
}

onMouseDown()

SLbool SLSceneView::onMouseDown ( SLMouseButton  button, SLint  scrX, SLint  scrY, SLKey  mod  )

virtual

SLSceneView::onMouseDown gets called whenever a mouse button gets pressed and dispatches the event to the currently attached event handler object.

Reimplemented in AppDemoSceneView.

Definition at line 1261 of file SLSceneView.cpp.

{
    // Correct viewport offset
    // mouse coordinates are top-left, viewport is bottom-left)
    SLint x = scrX - _viewportRect.x;
    SLint y = scrY - ((_scrH - _viewportRect.height) - _viewportRect.y);
 
    // Pass the event to imgui
    if (_gui)
    {
        _gui->onMouseDown(button, x, y);
 
        // Touch devices on iOS or Android have no mouse move event when the
        // finger isn't touching the screen. Therefore, imgui can not detect hovering
        // over an imgui window. Without this extra frame you would have to touch
        // the display twice to open e.g. a menu.
        _gui->renderExtraFrame(_s, this, x, y);
 
        if (_gui->doNotDispatchMouse())
            return true;
    }
 
    _mouseDownL = (button == MB_left);
    _mouseDownR = (button == MB_right);
    _mouseDownM = (button == MB_middle);
    _mouseMod   = mod;
 
    SLbool result = false;
    if (_s && _camera && _s->root3D())
    {
        SLbool eventConsumed = false;
        for (auto* eh : _s->eventHandlers())
        {
            if (eh->onMouseDown(button, x, y, mod))
                eventConsumed = true;
        }
 
        if (!eventConsumed)
            result = _camera->onMouseDown(button, x, y, mod);
        else
            result = true;
    }
 
    return result;
}

onMouseMove()

SLbool SLSceneView::onMouseMove ( SLint  scrX, SLint  scrY  )

virtual

SLSceneView::onMouseMove gets called whenever the mouse is moved.

Definition at line 1385 of file SLSceneView.cpp.

{
    // Correct viewport offset
    // mouse corrds are top-left, viewport is bottom-left)
    SLint x = scrX - _viewportRect.x;
    SLint y = scrY - ((_scrH - _viewportRect.height) - _viewportRect.y);
 
    // Pass the event to imgui
    if (_gui)
    {
        _gui->onMouseMove(x, y);
        if (_gui->doNotDispatchMouse())
            return true;
    }
 
    if (!_s || !_s->root3D())
        return false;
 
    _touchDowns   = 0;
    SLbool result = false;
 
    SLMouseButton btn;
    if (_mouseDownL)
        btn = MB_left;
    else if (_mouseDownR)
        btn = MB_right;
    else if (_mouseDownM)
        btn = MB_middle;
    else
        btn = MB_none;
 
    if (_mouseDownL || _mouseDownR || _mouseDownM)
    {
        // Handle move in ray tracing
        if (_renderType == RT_rt && !_raytracer.doContinuous())
        {
            if (_raytracer.state() == rtFinished)
                _raytracer.state(rtMoveGL);
            else
                _raytracer.doContinuous(false);
 
            _renderType = RT_gl;
        }
 
        // Handle move in path tracing
        if (_renderType == RT_pt)
        {
            if (_pathtracer.state() == rtFinished)
                _pathtracer.state(rtMoveGL);
 
            _renderType = RT_gl;
        }
    }
 
    SLbool eventConsumed = false;
    for (auto* eh : _s->eventHandlers())
    {
        if (eh->onMouseMove(btn, x, y, _mouseMod))
            eventConsumed = true;
    }
 
    if (!eventConsumed)
        result = _camera->onMouseMove(btn, x, y, _mouseMod);
    else
        result = true;
 
    return result;
}

onMouseUp()

SLbool SLSceneView::onMouseUp ( SLMouseButton  button, SLint  scrX, SLint  scrY, SLKey  mod  )

virtual

SLSceneView::onMouseUp gets called whenever a mouse button gets released.

Definition at line 1313 of file SLSceneView.cpp.

{
    _touchDowns = 0;
 
    // Correct viewport offset
    // mouse coordinates are top-left, viewport is bottom-left)
    SLint x = scrX - _viewportRect.x;
    SLint y = scrY - ((_scrH - _viewportRect.height) - _viewportRect.y);
 
    // Continue with ray tracing
    if (_raytracer.state() == rtMoveGL)
    {
        _renderType = RT_rt;
        _raytracer.state(rtReady);
    }
 
    // Continue with path tracing
    if (_pathtracer.state() == rtMoveGL)
    {
        _renderType = RT_pt;
        _pathtracer.state(rtReady);
    }
 
    // Pass the event to imgui
    if (_gui)
    {
        _gui->onMouseUp(button, x, y);
        if (_gui->doNotDispatchMouse())
            return true;
 
        // Touch devices on iOS or Android have no mouse move event when the
        // finger isn't touching the screen. Therefore imgui can not detect hovering
        // over an imgui window. Without this extra frame you would have to touch
        // the display twice to open e.g. a menu.
        _gui->renderExtraFrame(_s, this, x, y);
    }
 
    _mouseDownL = false;
    _mouseDownR = false;
    _mouseDownM = false;
 
    if (_s && _camera && _s->root3D())
    {
        SLbool result        = false;
        SLbool eventConsumed = false;
        for (auto* eh : _s->eventHandlers())
        {
            if (eh->onMouseUp(button, x, y, mod))
                eventConsumed = true;
        }
 
        if (!eventConsumed)
        {
            result = _camera->onMouseUp(button, x, y, mod);
        }
        else
        {
            result = true;
        }
 
        return result;
    }
 
    return false;
}

onMouseWheel()

SLbool SLSceneView::onMouseWheel ( SLint  delta, SLKey  mod  )

virtual

SLSceneView::onMouseWheel gets called whenever the mouse wheel is turned. The parameter delta is positive/negative depending on the wheel direction

Definition at line 1470 of file SLSceneView.cpp.

{
    // Pass the event to imgui
    if (_gui)
    {
        if (_gui->doNotDispatchMouse())
        {
            _gui->onMouseWheel((SLfloat)delta);
            return true;
        }
    }
 
    if (!_s || !_s->root3D())
        return false;
 
    // Handle mouse wheel in RT mode
    if (_renderType == RT_rt && !_raytracer.doContinuous() &&
        _raytracer.state() == rtFinished)
        _raytracer.state(rtReady);
 
    // Handle mouse wheel in PT mode
    if (_renderType == RT_pt && _pathtracer.state() == rtFinished)
        _pathtracer.state(rtReady);
 
    SLbool result = _camera->onMouseWheel(delta, mod);
 
    for (auto* eh : _s->eventHandlers())
    {
        if (eh->onMouseWheel(delta, mod))
            result = true;
    }
    return result;
}

onMouseWheelPos()

SLbool SLSceneView::onMouseWheelPos ( SLint  wheelPos, SLKey  mod  )

virtual

SLSceneView::onMouseWheel gets called whenever the mouse wheel is turned. The parameter wheelPos is an increasing or decreeing counter number.

Definition at line 1458 of file SLSceneView.cpp.

{
    static SLint lastMouseWheelPos = 0;
    SLint        delta             = wheelPos - lastMouseWheelPos;
    lastMouseWheelPos              = wheelPos;
    return onMouseWheel(delta, mod);
}

onPaint()

SLbool SLSceneView::onPaint

(

)

SLSceneView::onPaint is called by window system whenever the window and therefore the scene needs to be painted. Depending on the renderer it calls first SLSceneView::draw3DGL, SLSceneView::draw3DRT or SLSceneView::draw3DPT and then SLSceneView::draw2DGL for all UI in 2D. The method returns true if either the 2D or 3D graph was updated or waitEvents is false.

Definition at line 521 of file SLSceneView.cpp.

{
    PROFILE_FUNCTION();
 
    // SL_LOG("onPaint: -----------------------------------------------------");
 
    _shadowMapTimesMS.set(_shadowMapTimeMS);
    _cullTimesMS.set(_cullTimeMS);
    _draw3DTimesMS.set(_draw3DTimeMS);
    _draw2DTimesMS.set(_draw2DTimeMS);
 
    SLbool sceneHasChanged    = false;
    SLbool viewConsumedEvents = false;
 
    // Only update scene if sceneview got repainted: This check is necessary if
    // this function is called for multiple SceneViews. In this way we only
    // update the geometric representations if all SceneViews got painted once.
    // (can only happen during raytracing)
    if (_gotPainted)
    {
        _gotPainted = false;
 
        // Process queued up system events and poll custom input devices
        viewConsumedEvents = _inputManager.pollAndProcessEvents(this);
 
        if (_s)
        {
            // update current scene
            sceneHasChanged = _s->onUpdate((_renderType == RT_rt),
                                           drawBit(SL_DB_VOXELS),
                                           !drawBit(SL_DB_GPU_SKINNING) ||
                                             drawBit(SL_DB_WITHEDGES));
        }
    }
 
    SLbool camUpdated = false;
 
    // Init and build GUI for all projections except distorted stereo
    if (_gui && _camera && _camera->projType() != P_stereoSideBySideD)
        _gui->onInitNewFrame(_s, this);
 
    // Clear NO. of draw calls after UI creation
    SLGLVertexArray::totalDrawCalls          = 0;
    SLGLVertexArray::totalPrimitivesRendered = 0;
    SLShadowMap::drawCalls                   = 0;
 
    if (_s && _camera)
    { // Render the 3D scenegraph by raytracing, pathtracing or OpenGL
        switch (_renderType)
        {
            case RT_gl: camUpdated = draw3DGL(_s->elapsedTimeMS()); break;
            case RT_rt: camUpdated = draw3DRT(); break;
            case RT_pt: camUpdated = draw3DPT(); break;
#ifdef SL_HAS_OPTIX
            case RT_optix_rt: camUpdated = draw3DOptixRT(); break;
            case RT_optix_pt: camUpdated = draw3DOptixPT(); break;
#endif
        }
    }
 
    // Render the 2D stuff inclusive the ImGui
    draw2DGL();
 
    SLGLState::instance()->unbindAnythingAndFlush();
 
    // Finish Oculus framebuffer
    if (_s && _camera && _camera->projType() == P_stereoSideBySideD)
        _s->oculus()->renderDistortion(_scrW,
                                       _scrH,
                                       _oculusFB.texID(),
                                       _camera->background().colors()[0]);
 
    // Set gotPainted only to true if RT is not busy
    _gotPainted = _renderType == RT_gl || raytracer()->state() != rtBusy;
 
    // Return true if it is the first frame or a repaint is needed
    if (_isFirstFrame)
    {
        _isFirstFrame = false;
        return true;
    }
 
    return !_doWaitOnIdle || camUpdated || sceneHasChanged || viewConsumedEvents;
}

onResize()

void SLSceneView::onResize	(	SLint	width,
		SLint	height
	)

SLSceneView::onResize is called by the window system before the first rendering and whenever the window changes its size.

Definition at line 480 of file SLSceneView.cpp.

{
    // On OSX and Qt this can be called with invalid values > so exit
    if (width == 0 || height == 0) return;
 
    if (_scrW != width || _scrH != height)
    {
        _scrW     = width;
        _scrH     = height;
        _scrWdiv2 = _scrW >> 1; // width / 2
        _scrHdiv2 = _scrH >> 1; // height / 2
        _scrWdivH = (SLfloat)_scrW / (SLfloat)_scrH;
 
        setViewportFromRatio(_viewportRatio,
                             _viewportAlign,
                             _viewportSameAsVideo);
 
        // Resize Oculus framebuffer
        if (_s && _camera && _camera->projType() == P_stereoSideBySideD)
        {
            _oculusFB.updateSize((SLint)(_s->oculus()->resolutionScale() * (SLfloat)_viewportRect.width),
                                 (SLint)(_s->oculus()->resolutionScale() * (SLfloat)_viewportRect.height));
            _s->oculus()->renderResolution(_viewportRect.width, _viewportRect.height);
        }
 
        // Stop raytracing & pathtracing on resize
        if (_renderType != RT_gl)
        {
            _renderType = RT_gl;
            _raytracer.doContinuous(false);
        }
    }
}

onStartup()

virtual void SLSceneView::onStartup ( )

inlinevirtual

Definition at line 94 of file SLSceneView.h.

{}

onTouch2Down()

SLbool SLSceneView::onTouch2Down ( SLint  scrX1, SLint  scrY1, SLint  scrX2, SLint  scrY2  )

virtual

SLSceneView::onTouch2Down gets called whenever two fingers touch a handheld screen.

Definition at line 1577 of file SLSceneView.cpp.

{
    if (!_s || !_s->root3D())
        return false;
 
    // Correct viewport offset
    // mouse coordinates are top-left, viewport is bottom-left)
    SLint x1 = scrX1 - _viewportRect.x;
    SLint y1 = scrY1 - ((_scrH - _viewportRect.height) - _viewportRect.y);
    SLint x2 = scrX2 - _viewportRect.x;
    SLint y2 = scrY2 - ((_scrH - _viewportRect.height) - _viewportRect.y);
 
    _touch[0].set(x1, y1);
    _touch[1].set(x2, y2);
    _touchDowns = 2;
 
    SLbool result = _camera->onTouch2Down(x1, y1, x2, y2);
 
    for (auto* eh : _s->eventHandlers())
    {
        if (eh->onTouch2Down(x1, y1, x2, y2))
            result = true;
    }
    return result;
}

onTouch2Move()

SLbool SLSceneView::onTouch2Move ( SLint  scrX1, SLint  scrY1, SLint  scrX2, SLint  scrY2  )

virtual

SLSceneView::onTouch2Move gets called whenever two fingers touch a handheld screen.

Definition at line 1610 of file SLSceneView.cpp.

{
    if (!_s || !_s->root3D())
        return false;
 
    // Correct viewport offset
    SLint x1 = scrX1 - _viewportRect.x;
    SLint y1 = scrY1 - ((_scrH - _viewportRect.height) - _viewportRect.y);
    SLint x2 = scrX2 - _viewportRect.x;
    SLint y2 = scrY2 - ((_scrH - _viewportRect.height) - _viewportRect.y);
 
    _touch[0].set(x1, y1);
    _touch[1].set(x2, y2);
 
    SLbool result = false;
    if (_touchDowns == 2)
    {
        result = _camera->onTouch2Move(x1, y1, x2, y2);
        for (auto* eh : _s->eventHandlers())
        {
            if (eh->onTouch2Move(x1, y1, x2, y2))
                result = true;
        }
    }
    return result;
}

onTouch2Up()

SLbool SLSceneView::onTouch2Up ( SLint  scrX1, SLint  scrY1, SLint  scrX2, SLint  scrY2  )

virtual

SLSceneView::onTouch2Up gets called whenever two fingers lift off a handheld screen.

Definition at line 1644 of file SLSceneView.cpp.

{
    if (!_s || !_s->root3D())
        return false;
 
    // Correct viewport offset
    SLint x1 = scrX1 - _viewportRect.x;
    SLint y1 = scrY1 - ((_scrH - _viewportRect.height) - _viewportRect.y);
    SLint x2 = scrX2 - _viewportRect.x;
    SLint y2 = scrY2 - ((_scrH - _viewportRect.height) - _viewportRect.y);
 
    _touch[0].set(x1, y1);
    _touch[1].set(x2, y2);
    _touchDowns = 0;
 
    SLbool result = _camera->onTouch2Up(x1, y1, x2, y2);
    for (auto* eh : _s->eventHandlers())
    {
        if (eh->onTouch2Up(x1, y1, x2, y2))
            result = true;
    }
    return result;
}

pathtracer()

SLPathtracer* SLSceneView::pathtracer ( )

inline

Definition at line 199 of file SLSceneView.h.

{ return &_pathtracer; }

postDraw()

virtual void SLSceneView::postDraw ( )

inlinevirtual

Definition at line 96 of file SLSceneView.h.

{}

postSceneLoad()

virtual void SLSceneView::postSceneLoad ( )

inlinevirtual

Reimplemented in AppNodeSceneView.

Definition at line 97 of file SLSceneView.h.

{}

preDraw()

virtual void SLSceneView::preDraw ( )

inlinevirtual

Reimplemented in AppNodeSceneView.

Definition at line 95 of file SLSceneView.h.

{}

printStats()

void SLSceneView::printStats ( )

inline

Definition at line 132 of file SLSceneView.h.

{ _stats3D.print(); }

raytracer()

SLRaytracer* SLSceneView::raytracer ( )

inline

Definition at line 198 of file SLSceneView.h.

{ return &_raytracer; }

renderType() [1/2]

SLRenderType SLSceneView::renderType ( ) const

inline

Definition at line 200 of file SLSceneView.h.

{ return _renderType; }

renderType() [2/2]

void SLSceneView::renderType ( SLRenderType  rt )

inline

Definition at line 158 of file SLSceneView.h.

{ _renderType = rt; }

s()

SLScene* SLSceneView::s ( )

inline

Definition at line 171 of file SLSceneView.h.

{ return _s; }

saveFrameBufferAsImage()

void SLSceneView::saveFrameBufferAsImage	(	SLstring	pathFilename,
		cv::Size	targetSize = cv::Size(-1, -1)
	)

Saves after n wait frames the front frame buffer as a PNG image.

Definition at line 2107 of file SLSceneView.cpp.

{
    if (_screenCaptureWaitFrames == 0)
    {
        SLint fbW = _viewportRect.width;
        SLint fbH = _viewportRect.height;
 
#ifndef SL_EMSCRIPTEN
        GLsizei nrChannels = 3;
#else
        GLsizei nrChannels = 4;
#endif
 
        GLsizei stride = nrChannels * fbW;
        stride += (stride % 4) ? (4 - stride % 4) : 0;
        GLsizei       bufferSize = stride * fbH;
        vector<uchar> buffer(bufferSize);
 
        SLGLState::instance()->readPixels(buffer.data());
 
#ifndef SL_EMSCRIPTEN
        CVMat rgbImg = CVMat(fbH, fbW, CV_8UC3, (void*)buffer.data(), stride);
        cv::cvtColor(rgbImg, rgbImg, cv::COLOR_BGR2RGB);
#else
        CVMat rgbImg = CVMat(fbH,
                             fbW,
                             CV_8UC4,
                             (void*)buffer.data(),
                             stride);
        cv::cvtColor(rgbImg, rgbImg, cv::COLOR_RGBA2RGB);
        nrChannels = 3;
        stride     = nrChannels * fbW;
#endif
 
        cv::flip(rgbImg, rgbImg, 0);
        if (targetSize.width > 0 && targetSize.height > 0)
            cv::resize(rgbImg, rgbImg, targetSize);
 
#ifndef SL_EMSCRIPTEN
        vector<int> compression_params;
        compression_params.push_back(cv::IMWRITE_PNG_COMPRESSION);
        compression_params.push_back(6);
 
        try
        {
            imwrite(pathFilename, rgbImg, compression_params);
            string msg = "Screenshot saved to: " + pathFilename;
            SL_LOG(msg.c_str());
        }
        catch (std::runtime_error& ex)
        {
            string msg = "SLSceneView::saveFrameBufferAsImage: Exception: ";
            msg += ex.what();
            Utils::exitMsg("SLProject", msg.c_str(), __LINE__, __FILE__);
        }
#else
        auto writer = [](void* context, void* data, int size)
        {
            SLIOStream* stream = (SLIOStream*)context;
            stream->write(data, size);
        };
 
        SLIOStream* stream = SLFileStorage::open(pathFilename,
                                                 IOK_image,
                                                 IOM_write);
        stbi_write_png_to_func(writer,
                               (void*)stream,
                               fbW,
                               fbH,
                               nrChannels,
                               rgbImg.data,
                               stride);
        SLFileStorage::close(stream);
#endif
 
#if !defined(SL_OS_ANDROID) && !defined(SL_OS_MACIOS) && !defined(SL_EMSCRIPTEN)
        _gui->drawMouseCursor(true);
#endif
        _screenCaptureIsRequested = false;
    }
    else
        _screenCaptureWaitFrames--;
}

scene()

void SLSceneView::scene ( SLScene *  scene )

inline

Definition at line 150 of file SLSceneView.h.

{ _s = scene; }

sceneViewCamera()

SLCamera* SLSceneView::sceneViewCamera ( )

inline

Definition at line 173 of file SLSceneView.h.

{ return &_sceneViewCamera; }

screenCaptureIsRequested() [1/2]

SLbool SLSceneView::screenCaptureIsRequested ( )

inline

Definition at line 210 of file SLSceneView.h.

{ return _screenCaptureIsRequested; }

screenCaptureIsRequested() [2/2]

void SLSceneView::screenCaptureIsRequested ( bool  doScreenCap )

inline

Definition at line 160 of file SLSceneView.h.

    {
        if (doScreenCap)
        {
            _gui->drawMouseCursor(false);
            _screenCaptureWaitFrames = 4;
        }
        _screenCaptureIsRequested = doScreenCap;
    }

scrH() [1/2]

SLint SLSceneView::scrH ( ) const

inline

Definition at line 175 of file SLSceneView.h.

{ return _scrH; }

scrH() [2/2]

void SLSceneView::scrH ( SLint  scrH )

inline

Definition at line 152 of file SLSceneView.h.

{ _scrH = scrH; }

scrHdiv2()

SLint SLSceneView::scrHdiv2 ( ) const

inline

Definition at line 177 of file SLSceneView.h.

{ return _scrHdiv2; }

scrW() [1/2]

SLint SLSceneView::scrW ( ) const

inline

Definition at line 174 of file SLSceneView.h.

{ return _scrW; }

scrW() [2/2]

void SLSceneView::scrW ( SLint  scrW )

inline

Definition at line 151 of file SLSceneView.h.

{ _scrW = scrW; }

scrWdiv2()

SLint SLSceneView::scrWdiv2 ( ) const

inline

Definition at line 176 of file SLSceneView.h.

{ return _scrWdiv2; }

scrWdivH()

SLfloat SLSceneView::scrWdivH ( ) const

inline

Definition at line 178 of file SLSceneView.h.

{ return _scrWdivH; }

setViewportFromRatio()

void SLSceneView::setViewportFromRatio	(	const SLVec2i &	vpRatio,
		SLViewportAlign	vpAlignment,
		SLbool	vpSameAsVideo
	)

Sets the viewport ratio and the viewport rectangle.

Definition at line 312 of file SLSceneView.cpp.

{
    assert(_scrW > 0 && _scrH > 0 && "SLSceneView::setViewportFromRatio: Invalid screen size");
 
    _viewportRatio       = vpRatio;
    _viewportAlign       = vpAlign;
    _viewportSameAsVideo = vpSameAsVideo;
 
    // Shortcut if viewport is the same as the screen
    if (vpRatio == SLVec2i::ZERO)
    {
        _viewportRect.set(0, 0, _scrW, _scrH);
        _viewportAlign = VA_leftOrBottom;
        if (_gui)
            _gui->onResize(_viewportRect);
        return;
    }
 
    // Calculate viewport rect from viewport aspect ratio
    SLfloat vpWdivH = (float)vpRatio.x / (float)vpRatio.y;
    _scrWdivH       = (float)_scrW / (float)_scrH;
    SLRecti vpRect;
 
    if (_scrWdivH > vpWdivH)
    {
        vpRect.width  = (int)((float)_scrH * vpWdivH);
        vpRect.height = _scrH;
        vpRect.y      = 0;
 
        switch (vpAlign)
        {
            // viewport coordinates are bottom-left
            case VA_leftOrBottom: vpRect.x = 0; break;
            case VA_center:
            default: vpRect.x = (_scrW - vpRect.width) / 2; break;
        }
    }
    else
    {
        vpRect.width  = _scrW;
        vpRect.height = (SLint)((float)_scrW / (float)vpWdivH);
        vpRect.x      = 0;
 
        switch (vpAlign)
        {
            // viewport coordinates are bottom-left
            case VA_leftOrBottom: vpRect.y = 0; break;
            case VA_center:
            default: vpRect.y = (_scrH - vpRect.height) / 2; break;
        }
    }
 
    if (SLRecti(_scrW, _scrH).contains(vpRect))
    {
        _viewportRect = vpRect;
        if (_gui)
            _gui->onResize(_viewportRect);
    }
    else
        SL_EXIT_MSG("SLSceneView::viewport: Viewport is bigger than the screen!");
}

shadowMapTimeMS()

AvgFloat& SLSceneView::shadowMapTimeMS ( )

inline

Definition at line 204 of file SLSceneView.h.

{ return _shadowMapTimesMS; }

startPathtracing()

void SLSceneView::startPathtracing	(	SLint	maxDepth,
		SLint	samples
	)

Starts the path tracer. maxDepth is only a safety net against an.

endless specular chain: since SLPathtracer uses Russian roulette, the length of a path is decided by the albedo of the surfaces it meets and virtually no path reaches this cap.

Starts the pathtracing

Definition at line 1944 of file SLSceneView.cpp.

{
    _renderType = RT_pt;
    _stopPT     = false;
    _pathtracer.maxDepth(maxDepth);
    _pathtracer.aaSamples(samples);
}

startRaytracing()

void SLSceneView::startRaytracing

(

SLint

maxDepth

)

Starts the ray tracing & sets the RT menu

Definition at line 1892 of file SLSceneView.cpp.

{
    _renderType = RT_rt;
    _stopRT     = false;
    _raytracer.maxDepth(maxDepth);
}

stats2D()

SLNodeStats& SLSceneView::stats2D ( )

inline

Definition at line 208 of file SLSceneView.h.

{ return _stats2D; }

stats3D()

SLNodeStats& SLSceneView::stats3D ( )

inline

Definition at line 209 of file SLSceneView.h.

{ return _stats3D; }

switchToNextCameraInScene()

void SLSceneView::switchToNextCameraInScene

(

)

Sets the active camera to the next in the scene.

Definition at line 293 of file SLSceneView.cpp.

{
    if (!_s)
        return;
 
    SLCamera* nextCam = _s->nextCameraInScene(this->camera());
 
    if (nextCam == nullptr)
        return;
 
    if (nextCam != _camera)
        _camera = nextCam;
    else
        _camera = &_sceneViewCamera;
 
    _camera->background().rebuild();
}

switchToSceneViewCamera()

void SLSceneView::switchToSceneViewCamera

(

)

SLSceneView::switchToSceneViewCamera the general idea for this function is to switch to the editor camera from a scene camera. It could provide functionality to stay at the position of the previous camera, or to be reset to the init position etc..

Definition at line 277 of file SLSceneView.cpp.

{
    // if we have an active camera, use its position and orientation
    if (_camera)
    {
        SLMat4f currentWM = _camera->updateAndGetWM();
        SLVec3f position  = currentWM.translation();
        SLVec3f forward(-currentWM.m(8), -currentWM.m(9), -currentWM.m(10));
        _sceneViewCamera.translation(position);
        _sceneViewCamera.lookAt(position + forward);
    }
 
    _camera = &_sceneViewCamera;
}

unInit()

void SLSceneView::unInit

(

)

Definition at line 131 of file SLSceneView.cpp.

{
    _camera     = &_sceneViewCamera;
    _mouseDownL = false;
    _mouseDownR = false;
    _mouseDownM = false;
    _touchDowns = 0;
 
    _renderType = RT_gl;
 
    _doDepthTest      = true;
    _doMultiSampling  = true;
    _doFrustumCulling = true;
    _doAlphaSorting   = true;
    _doWaitOnIdle     = true;
    _drawBits.allOff();
 
    for (auto* material : _visibleMaterials2D)
        material->nodesVisible2D().clear();
    _visibleMaterials2D.clear();
 
    for (auto* material : _visibleMaterials3D)
        material->nodesVisible3D().clear();
    _visibleMaterials3D.clear();
 
    _stats2D.clear();
    _stats3D.clear();
    _s = nullptr;
}

viewportAlign()

SLViewportAlign SLSceneView::viewportAlign ( ) const

inline

Definition at line 185 of file SLSceneView.h.

{ return _viewportAlign; }

viewportH()

SLint SLSceneView::viewportH ( ) const

inline

Definition at line 184 of file SLSceneView.h.

{ return _viewportRect.height; }

viewportRatio()

SLVec2i SLSceneView::viewportRatio ( ) const

inline

Definition at line 181 of file SLSceneView.h.

{ return _viewportRatio; }

viewportRect()

SLRecti SLSceneView::viewportRect ( ) const

inline

Definition at line 180 of file SLSceneView.h.

{ return _viewportRect; }

viewportSameAsVideo() [1/2]

SLbool SLSceneView::viewportSameAsVideo ( ) const

inline

Definition at line 186 of file SLSceneView.h.

{ return _viewportSameAsVideo; }

viewportSameAsVideo() [2/2]

void SLSceneView::viewportSameAsVideo ( bool  sameAsVideo )

inline

Definition at line 159 of file SLSceneView.h.

{ _viewportSameAsVideo = sameAsVideo; }

viewportW()

SLint SLSceneView::viewportW ( ) const

inline

Definition at line 183 of file SLSceneView.h.

{ return _viewportRect.width; }

viewportWdivH()

SLfloat SLSceneView::viewportWdivH ( ) const

inline

Definition at line 182 of file SLSceneView.h.

{ return (float)_viewportRect.width / (float)_viewportRect.height; }

visibleMaterials2D()

std::unordered_set<SLMaterial*>& SLSceneView::visibleMaterials2D ( )

inline

Definition at line 212 of file SLSceneView.h.

{ return _visibleMaterials2D; }

visibleMaterials3D()

std::unordered_set<SLMaterial*>& SLSceneView::visibleMaterials3D ( )

inline

Definition at line 213 of file SLSceneView.h.

{ return _visibleMaterials3D; }

windowTitle()

SLstring SLSceneView::windowTitle

(

)

Returns the window title with name & FPS

Definition at line 1825 of file SLSceneView.cpp.

{
    SLchar   title[255];
    SLstring profiling = "";
 
#if PROFILING
    profiling = " *** PROFILING *** ";
#endif
 
    if (_s)
    {
        if (_renderType == RT_rt)
        {
            SLuint numThreads = _raytracer.doDistributed() ? _raytracer.numThreads() : 1;
 
            if (_raytracer.doContinuous())
            {
                snprintf(title,
                         sizeof(title),
                         "Ray Tracing: %s (fps: %4.1f, Threads: %d)",
                         _s->name().c_str(),
                         _s->fps(),
                         numThreads);
            }
            else
            {
                snprintf(title,
                         sizeof(title),
                         "Ray Tracing: %s (Threads: %d)",
                         _s->name().c_str(),
                         numThreads);
            }
        }
        else if (_renderType == RT_pt)
        {
            snprintf(title,
                     sizeof(title),
                     "Path Tracing: %s (Threads: %d)",
                     _s->name().c_str(),
                     _pathtracer.numThreads());
        }
        else
        {
            string format;
            if (_s->fps() > 5)
                format = "OpenGL Renderer: %s (fps: %4.0f, %u nodes of %u rendered)";
            else
                format = "OpenGL Renderer: %s (fps: %4.1f, %u nodes of %u rendered)";
 
            snprintf(title,
                     sizeof(title),
                     format.c_str(),
                     _s->name().c_str(),
                     _s->fps(),
                     _stats3D.numNodesOpaque + _stats3D.numNodesBlended,
                     _stats3D.numNodes);
        }
    }
    else
        snprintf(title, sizeof(title), "Scene is loading ...");
 
    return profiling + SLstring(title) + profiling;
}

Friends And Related Function Documentation

SLNode

friend class SLNode

friend

Definition at line 70 of file SLSceneView.h.

SLOptixRaytracer

friend class SLOptixRaytracer

friend

Definition at line 72 of file SLSceneView.h.

SLPathtracer

friend class SLPathtracer

friend

Definition at line 73 of file SLSceneView.h.

SLRaytracer

friend class SLRaytracer

friend

Definition at line 71 of file SLSceneView.h.

Member Data Documentation

_camera

SLCamera* SLSceneView::_camera

protected

Pointer to the _active camera.

Definition at line 229 of file SLSceneView.h.

_cullTimeMS

SLfloat SLSceneView::_cullTimeMS

protected

time for culling in ms

Definition at line 246 of file SLSceneView.h.

_cullTimesMS

AvgFloat SLSceneView::_cullTimesMS

protected

Averaged time for culling in ms.

Definition at line 299 of file SLSceneView.h.

_doAlphaSorting

SLbool SLSceneView::_doAlphaSorting

protected

Flag if alpha sorting in blending is on.

Definition at line 240 of file SLSceneView.h.

_doDepthTest

SLbool SLSceneView::_doDepthTest

protected

Flag if depth test is turned on.

Definition at line 237 of file SLSceneView.h.

_doFrustumCulling

SLbool SLSceneView::_doFrustumCulling

protected

Flag if view frustum culling is on.

Definition at line 239 of file SLSceneView.h.

_doMultiSampling

SLbool SLSceneView::_doMultiSampling

protected

Flag if multisampling is on.

Definition at line 238 of file SLSceneView.h.

_doWaitOnIdle

SLbool SLSceneView::_doWaitOnIdle

protected

Flag for Event waiting.

Definition at line 241 of file SLSceneView.h.

_dpi

int SLSceneView::_dpi

protected

dots per inch of screen

Definition at line 265 of file SLSceneView.h.

_draw2DTimeMS

SLfloat SLSceneView::_draw2DTimeMS

protected

time for 2D drawing in ms

Definition at line 248 of file SLSceneView.h.

_draw2DTimesMS

AvgFloat SLSceneView::_draw2DTimesMS

protected

Averaged time for 2D drawing in ms.

Definition at line 301 of file SLSceneView.h.

_draw3DTimeMS

SLfloat SLSceneView::_draw3DTimeMS

protected

time for 3D drawing in ms

Definition at line 247 of file SLSceneView.h.

_draw3DTimesMS

AvgFloat SLSceneView::_draw3DTimesMS

protected

Averaged time for 3D drawing in ms.

Definition at line 300 of file SLSceneView.h.

_drawBits

SLDrawBits SLSceneView::_drawBits

protected

Sceneview level drawing flags.

Definition at line 243 of file SLSceneView.h.

_gotPainted

SLbool SLSceneView::_gotPainted

protected

flag if this sceneview got painted

Definition at line 234 of file SLSceneView.h.

_gui

SLUiInterface* SLSceneView::_gui = nullptr

protected

new tighter imgui wrapper

Definition at line 231 of file SLSceneView.h.

_inputManager

SLInputManager& SLSceneView::_inputManager

protected

Definition at line 296 of file SLSceneView.h.

_isFirstFrame

SLbool SLSceneView::_isFirstFrame

protected

Flag if it is the first frame rendering.

Definition at line 242 of file SLSceneView.h.

_mouseDownL

SLbool SLSceneView::_mouseDownL

protected

Flag if left mouse button is pressed.

Definition at line 250 of file SLSceneView.h.

_mouseDownM

SLbool SLSceneView::_mouseDownM

protected

Flag if middle mouse button is pressed.

Definition at line 252 of file SLSceneView.h.

_mouseDownR

SLbool SLSceneView::_mouseDownR

protected

Flag if right mouse button is pressed.

Definition at line 251 of file SLSceneView.h.

_mouseMod

SLKey SLSceneView::_mouseMod

protected

mouse modifier key on key down

Definition at line 253 of file SLSceneView.h.

_nodesBlended2D

SLVNode SLSceneView::_nodesBlended2D

protected

Vector of visible blended nodes not in _visibleMaterials2D rendered in 2D.

Definition at line 279 of file SLSceneView.h.

_nodesBlended3D

SLVNode SLSceneView::_nodesBlended3D

protected

Vector of visible blended nodes not in _visibleMaterials3D rendered in 3D.

Definition at line 281 of file SLSceneView.h.

_nodesOpaque2D

SLVNode SLSceneView::_nodesOpaque2D

protected

Vector of visible opaque nodes not in _visibleMaterials2D rendered in 2D.

Definition at line 278 of file SLSceneView.h.

_nodesOpaque3D

SLVNode SLSceneView::_nodesOpaque3D

protected

Vector of visible opaque nodes not in _visibleMaterials3D rendered in 3D.

Definition at line 280 of file SLSceneView.h.

_nodesOverdrawn

SLVNode SLSceneView::_nodesOverdrawn

protected

Vector of helper nodes drawn over all others.

Definition at line 282 of file SLSceneView.h.

_oculusFB

SLGLOculusFB SLSceneView::_oculusFB

protected

Oculus framebuffer.

Definition at line 273 of file SLSceneView.h.

_pathtracer

SLPathtracer SLSceneView::_pathtracer

protected

Pathtracer.

Definition at line 286 of file SLSceneView.h.

_raytracer

SLRaytracer SLSceneView::_raytracer

protected

Whitted style raytracer.

Definition at line 284 of file SLSceneView.h.

_renderType

SLRenderType SLSceneView::_renderType

protected

rendering type (GL,RT,PT)

Definition at line 235 of file SLSceneView.h.

_s

SLScene* SLSceneView::_s

protected

Pointer to the scene observed by this scene view.

Definition at line 228 of file SLSceneView.h.

_sceneViewCamera

SLCamera SLSceneView::_sceneViewCamera

protected

Default camera for this SceneView (default cam not in scenegraph)

Definition at line 230 of file SLSceneView.h.

_screenCaptureIsRequested

SLbool SLSceneView::_screenCaptureIsRequested

protected

Flag if screen capture is requested.

Definition at line 270 of file SLSceneView.h.

_screenCaptureWaitFrames

SLint SLSceneView::_screenCaptureWaitFrames

protected

Frames to delay the screen capture.

Definition at line 271 of file SLSceneView.h.

_scrH

SLint SLSceneView::_scrH

protected

Screen height in pixels.

Definition at line 261 of file SLSceneView.h.

_scrHdiv2

SLint SLSceneView::_scrHdiv2

protected

Screen half height in pixels.

Definition at line 263 of file SLSceneView.h.

_scrW

SLint SLSceneView::_scrW

protected

Screen width in pixels.

Definition at line 260 of file SLSceneView.h.

_scrWdiv2

SLint SLSceneView::_scrWdiv2

protected

Screen half width in pixels.

Definition at line 262 of file SLSceneView.h.

_scrWdivH

SLfloat SLSceneView::_scrWdivH

protected

Screen side aspect ratio.

Definition at line 264 of file SLSceneView.h.

_shadowMapTimeMS

SLfloat SLSceneView::_shadowMapTimeMS

protected

time for drawing the shadow maps in ms

Definition at line 245 of file SLSceneView.h.

_shadowMapTimesMS

AvgFloat SLSceneView::_shadowMapTimesMS

protected

Averaged time for drawing the shadow maps in ms.

Definition at line 298 of file SLSceneView.h.

_stats2D

SLNodeStats SLSceneView::_stats2D

protected

Statistic numbers for 2D nodes.

Definition at line 232 of file SLSceneView.h.

_stats3D

SLNodeStats SLSceneView::_stats3D

protected

Statistic numbers for 3D nodes.

Definition at line 233 of file SLSceneView.h.

_stopPT

SLbool SLSceneView::_stopPT

protected

Flag to stop the PT.

Definition at line 287 of file SLSceneView.h.

_stopRT

SLbool SLSceneView::_stopRT

protected

Flag to stop the RT.

Definition at line 285 of file SLSceneView.h.

_touch

SLVec2i SLSceneView::_touch[3]

protected

up to 3 finger touch coordinates

Definition at line 255 of file SLSceneView.h.

_touchDowns

SLint SLSceneView::_touchDowns

protected

finger touch down count

Definition at line 254 of file SLSceneView.h.

_vaoCursor

SLGLVertexArrayExt SLSceneView::_vaoCursor

protected

Virtual cursor for stereo rendering.

Definition at line 258 of file SLSceneView.h.

_vaoTouch

SLGLVertexArrayExt SLSceneView::_vaoTouch

protected

Buffer for touch pos. rendering.

Definition at line 257 of file SLSceneView.h.

_viewportAlign

SLViewportAlign SLSceneView::_viewportAlign

protected

alignment of viewport

Definition at line 267 of file SLSceneView.h.

_viewportRatio

SLVec2i SLSceneView::_viewportRatio

protected

ratio of viewport

Definition at line 266 of file SLSceneView.h.

_viewportRect

SLRecti SLSceneView::_viewportRect

protected

rectangle of viewport

Definition at line 268 of file SLSceneView.h.

_viewportSameAsVideo

SLbool SLSceneView::_viewportSameAsVideo

protected

Adapt viewport aspect to the input video.

Definition at line 269 of file SLSceneView.h.

_visibleMaterials2D

std::unordered_set<SLMaterial*> SLSceneView::_visibleMaterials2D

protected

visible materials 2D per frame

Definition at line 276 of file SLSceneView.h.

_visibleMaterials3D

std::unordered_set<SLMaterial*> SLSceneView::_visibleMaterials3D

protected

visible materials 3D per frame

Definition at line 275 of file SLSceneView.h.

onSelectedNodeMesh

cbOnSelectNodeMesh SLSceneView::onSelectedNodeMesh

C-Callback for app on node selection.

Definition at line 146 of file SLSceneView.h.

onWndUpdate

cbOnWndUpdate SLSceneView::onWndUpdate

C-Callback for app for intermediate window repaint.

Definition at line 145 of file SLSceneView.h.

---

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

• SLSceneView.h
• SLSceneView.cpp