SLNode represents a node in a hierarchical scene graph. More...

#include <SLNode.h>

Inheritance diagram for SLNode:

Public Member Functions
	SLNode (const SLstring &name="Node")
	Construct a new SLNode::SLNode object. More...

	SLNode (SLMesh *mesh, const SLstring &name="Node")

	SLNode (SLMesh *mesh, const SLVec3f &translation, const SLstring &name)

	~SLNode () override

virtual void	cull3DRec (SLSceneView *sv)

virtual void	cullChildren3D (SLSceneView *sv)
	Initializer function to call SLNode::cull3DRec recursively. More...

virtual void	cull2DRec (SLSceneView *sv)

virtual bool	hitRec (SLRay *ray)

virtual void	statsRec (SLNodeStats &stats)

virtual SLNode *	copyRec ()

virtual SLAABBox &	updateAABBRec (SLbool updateAlsoAABBinOS)

virtual void	dumpRec ()

void	setDrawBitsRec (SLuint bit, SLbool state)

void	setPrimitiveTypeRec (SLGLPrimitiveType primitiveType)

virtual void	addMesh (SLMesh *mesh)

virtual void	drawMesh (SLSceneView *sv)
	Draws the single mesh. More...

bool	removeMesh ()
	Returns true if a mesh was assigned and set it to nullptr. More...

bool	removeMesh (SLMesh *mesh)
	Returns true if the passed mesh was assigned and sets it to nullptr. More...

SLint	numChildren ()

void	addChild (SLNode *child)

bool	insertChild (SLNode insertC, SLNode afterC)

void	deleteChildren ()

bool	deleteChild ()

bool	deleteChild (SLNode *child)

bool	deleteChild (const SLstring &name)

bool	removeChild (SLNode *child)
	remove child from vector of children. Removes false if not found, else true. More...

template<typename T >
T *	find (const SLstring &name="", SLbool findRecursive=true)

template<typename T >
T *	findChild (const SLstring &name="", SLbool findRecursive=true)

template<typename T >
deque< T * >	findChildren (const SLstring &name="", SLbool findRecursive=true, SLbool canContain=false)

deque< SLNode * >	findChildren (const SLMesh *mesh, SLbool findRecursive=true)

deque< SLNode * >	findChildren (SLuint drawbit, SLbool findRecursive=true)

SLVec3f	translationOS () const

SLVec3f	forwardOS () const

SLVec3f	rightOS () const

SLVec3f	upOS () const

SLVec3f	axisXOS () const

SLVec3f	axisYOS () const

SLVec3f	axisZOS () const

SLVec3f	translationWS () const

SLVec3f	forwardWS () const

SLVec3f	rightWS () const

SLVec3f	upWS () const

SLVec3f	axisXWS () const

SLVec3f	axisYWS () const

SLVec3f	axisZWS () const

void	translation (const SLVec3f &pos, SLTransformSpace relativeTo=TS_parent)

void	translation (SLfloat x, SLfloat y, SLfloat z, SLTransformSpace relativeTo=TS_parent)

void	rotation (const SLQuat4f &rot, SLTransformSpace relativeTo=TS_parent)

void	rotation (SLfloat angleDeg, const SLVec3f &axis, SLTransformSpace relativeTo=TS_parent)

void	scaling (SLfloat s)

void	scaling (SLfloat x, SLfloat y, SLfloat z)

void	scaling (const SLVec3f &scaling)

void	lookAt (SLfloat targetX, SLfloat targetY, SLfloat targetZ, SLfloat upX=0, SLfloat upY=1, SLfloat upZ=0, SLTransformSpace relativeTo=TS_world)

void	lookAt (const SLVec3f &target, const SLVec3f &up=SLVec3f::AXISY, SLTransformSpace relativeTo=TS_world)

void	translate (const SLVec3f &vec, SLTransformSpace relativeTo=TS_object)

void	translate (SLfloat x, SLfloat y, SLfloat z, SLTransformSpace relativeTo=TS_object)

void	rotate (const SLQuat4f &rot, SLTransformSpace relativeTo=TS_object)

void	rotate (SLfloat angleDeg, const SLVec3f &axis, SLTransformSpace relativeTo=TS_object)

void	rotate (SLfloat angleDeg, SLfloat x, SLfloat y, SLfloat z, SLTransformSpace relativeTo=TS_object)

void	rotateAround (const SLVec3f &point, SLVec3f &axis, SLfloat angleDeg, SLTransformSpace relativeTo=TS_world)

void	scale (SLfloat s)

void	scale (SLfloat x, SLfloat y, SLfloat z)

void	scale (const SLVec3f &scale)

void	scaleToCenter (SLfloat maxDim)

void	setInitialState ()

void	resetToInitialState ()

void	parent (SLNode *p)

void	entityID (SLint entityID)

void	om (const SLMat4f &mat)

void	animation (SLAnimation *a)

void	castsShadows (SLbool castsShadows)

virtual void	needUpdate ()

void	needWMUpdate ()

void	needAABBUpdate ()

void	isSelected (bool isSelected)

void	minLodCoverage (SLfloat minLodCoverage)

void	levelForSM (SLubyte lfsm)

void	onUpdateCB (function< void()> callbackFunc)

SLNode *	parent ()

SLint	depth () const

SLint	entityID () const

const SLMat4f &	om ()

const SLMat4f &	initialOM ()

const SLMat4f &	updateAndGetWM () const

const SLMat4f &	updateAndGetWMI () const

SLDrawBits *	drawBits ()

SLbool	drawBit (SLuint bit)

SLAABBox *	aabb ()

SLAnimation *	animation ()

SLbool	castsShadows ()

SLMesh *	mesh ()

SLVNode &	children ()

const SLAnimSkeleton *	skeleton ()
	Returns the first skeleton found in the meshes. More...

void	updateRec ()

virtual void	doUpdate ()

bool	updateMeshSkins (bool forceCPUSkinning, const std::function< void(SLMesh *)> &cbInformNodes)
	Update all skinned meshes recursively. More...

void	updateMeshAccelStructs ()

void	updateMeshMat (std::function< void(SLMaterial *m)> setMat, bool recursive)
	Updates the mesh material recursively with a material lambda. More...

void	setMeshMat (SLMaterial *mat, bool recursive)
	Set the mesh material recursively. More...

bool	isSelected ()

SLfloat	minLodCoverage ()

SLubyte	levelForSM ()

Public Member Functions inherited from SLObject
	SLObject (const SLstring &Name="", const SLstring &url="")

virtual	~SLObject ()

void	name (const SLstring &Name)

void	url (const SLstring &url)

const SLstring &	name () const

const SLstring &	url () const

Public Member Functions inherited from SLEventHandler
	SLEventHandler ()

virtual	~SLEventHandler ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	mouseRotationFactor (SLfloat rf)

SLfloat	mouseRotationFactor ()

Static Public Attributes
static SLuint	numWMUpdates = 0
	NO. of calls to updateWMRec per frame. More...

static unsigned int	instanceIndex = 0
	??? More...

Protected Attributes
SLNode *	_parent
	pointer to the parent node More...

SLVNode	_children
	vector of children nodes More...

SLMesh *	_mesh
	pointer to a single mesh More...

SLint	_depth
	depth of the node in a scene tree More...

SLint	_entityID
	ID in the SLVEntity graph for Data Oriented Design. More...

SLMat4f	_om
	object matrix for local transforms More...

SLMat4f	_initialOM
	the initial om state More...

SLMat4f	_wm
	world matrix for world transform More...

SLMat4f	_wmI
	inverse world matrix More...

SLbool	_isWMUpToDate
	is the WM of this node still valid More...

SLbool	_isWMIUpToDate
	is the inverse WM of this node still valid More...

SLbool	_isAABBUpToDate
	is the saved aabb still valid More...

bool	_castsShadows
	flag if meshes of node should cast shadows More...

bool	_isSelected
	flag if node and one or more of its meshes are selected More...

SLDrawBits	_drawBits
	node level drawing flags More...

SLAABBox	_aabb
	axis aligned bounding box More...

SLAnimation *	_animation
	animation of the node More...

SLfloat	_minLodCoverage
	Min. LOD coverage for visibility (0.0 < _minLodCoverage < 1.0) More...

SLubyte	_levelForSM
	Level of LOD to use for shadow mapping (0 = the visible one will be drawn) More...

function< void()>	_onUpdateCB
	Optional lambda callback once per update. More...

Protected Attributes inherited from SLObject
SLstring	_name
	name of an object More...

SLstring	_url
	uniform resource locator More...

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

SLfloat	_keyboardDeltaPos
	Delta dist. for keyboard translation. More...

Private Member Functions
void	updateWM () const

template<typename T >
void	findChildrenHelper (const SLstring &name, deque< T * > &list, SLbool findRecursive, SLbool canContain=false)

void	findChildrenHelper (const SLMesh mesh, deque< SLNode > &list, SLbool findRecursive)

void	findChildrenHelper (SLuint drawbit, deque< SLNode * > &list, SLbool findRecursive)

Friends
class	SLSceneView

Detailed Description

SLNode represents a node in a hierarchical scene graph.

This is the most important building block of the scene graph. A node can have 0-N children nodes in the vector _children. With child nodes you can build hierarchical structures. A node without a mesh can act as parent node to group its children. A node without children only makes sense to hold a mesh for visualization. The pointer _parent points to the parent of a child node.

A node can point to a single SLMesh object for the rendering of triangles lines or points meshes. Meshes are stored in the SLAssetManager::_meshes vector. Multiple nodes can point to the same mesh object. The node is therefore not the owner of the meshes and does not delete them. The mesh is drawn by the methods SLNode::drawMesh and alternatively by SLNode::drawRec.

A node can be transformed and has therefore a object matrix (_om) for its local transform. All other matrices such as the world matrix (_wm), the inverse world matrix (_wmI) are derived from the object matrix and automatically generated and updated.

A node can be transformed by one of the various transform functions such as translate(). Many of these functions take an additional parameter 'relativeTo'. This parameter tells the transform function in what space the transformation should be applied in. The available transform spaces are:

TS_World: Space relative to the global world coordinate system.
TS_Parent: Space relative to our parent's transformation.
TS_Object: Space relative to our current node's origin.

A node can implement one of the event handlers defined in the inherited SLEventHandler interface. There is special node called SLTransformNode that acts as a visual gizmo for editing the transform. See the example in the menu Edit of the SLProject demo app.

The SLCamera is derived from the SLNode and implements a camera through which the scene can be viewed (see also SLSceneView). The SLLightSpot and SLLightRect are derived from SLNode and represent light sources in the scene. Cameras and lights can be placed in the scene because of their inheritance of SLNode.

Remarks: It is important that during instantiation NO OpenGL functions (gl*) get called because this constructor will be most probably called in a parallel thread from within an SLScene::registerAssetsToLoad or SLScene::assemble function. All objects that get rendered have to do their OpenGL initialization when they are used the first time during rendering in the main thread.

Definition at line 141 of file SLNode.h.

Constructor & Destructor Documentation

◆ SLNode() [1/3]

SLNode::SLNode ( const SLstring & name = "Node" )

explicit

Construct a new SLNode::SLNode object.

Remarks: It is important that during instantiation NO OpenGL functions (gl*) get called because this constructor will be most probably called in a parallel thread from within an SLScene::registerAssetsToLoad or SLScene::assemble function. All objects that get rendered have to do their OpenGL initialization when they are used the first time during rendering in the main thread.

Parameters

name	Name of the node

Definition at line 40 of file SLNode.cpp.

                                    : SLObject(name)
 {
     _parent   = nullptr;
     _depth    = 1;
     _entityID = INT32_MIN;
     _om.identity();
     _wm.identity();
     _wmI.identity();
     _drawBits.allOff();
     _animation      = nullptr;
     _castsShadows   = true;
     _isWMUpToDate   = false;
     _isWMIUpToDate  = false;
     _isAABBUpToDate = false;
     _isSelected     = false;
     _mesh           = nullptr;
     _minLodCoverage = 0.0f;
     _levelForSM     = 0;
 }

◆ SLNode() [2/3]

SLNode::SLNode	(	SLMesh *	mesh,
		const SLstring &	name = `"Node"`
	)

explicit

Constructor with a mesh pointer and name. It is important that during instantiation NO OpenGL functions (gl*) get called because this constructor will be most probably called in a parallel thread from within a SLScene::assemble function. All objects that get rendered have to do their OpenGL initialization when they are used the first time during rendering in the main thread.

Definition at line 68 of file SLNode.cpp.

                                                  : SLObject(name)
 {
     assert(mesh && "No mesh passed");
  
     _parent   = nullptr;
     _depth    = 1;
     _entityID = INT32_MIN;
     _om.identity();
     _wm.identity();
     _wmI.identity();
     _drawBits.allOff();
     _animation      = nullptr;
     _castsShadows   = true;
     _isWMUpToDate   = false;
     _isWMIUpToDate  = false;
     _isAABBUpToDate = false;
     _isSelected     = false;
     _minLodCoverage = 0.0f;
     _levelForSM     = 0;
     _mesh           = nullptr;
  
     addMesh(mesh);
 }

◆ SLNode() [3/3]

SLNode::SLNode	(	SLMesh *	mesh,
		const SLVec3f &	translation,
		const SLstring &	name
	)

explicit

Constructor with a mesh pointer, translation vector and name. It is important that during instantiation NO OpenGL functions (gl*) get called because this constructor will be most probably called in a parallel thread from within a SLScene::assemble function. All objects that get rendered have to do their OpenGL initialization when they are used the first time during rendering in the main thread.

Definition at line 100 of file SLNode.cpp.

                                      : SLObject(name)
 {
     assert(mesh && "No mesh passed");
  
     _parent   = nullptr;
     _depth    = 1;
     _entityID = INT32_MIN;
     _om.identity();
     _om.translate(translation);
     _wm.identity();
     _wmI.identity();
     _drawBits.allOff();
     _animation      = nullptr;
     _castsShadows   = true;
     _isWMUpToDate   = false;
     _isWMIUpToDate  = false;
     _isAABBUpToDate = false;
     _isSelected     = false;
     _minLodCoverage = 0.0f;
     _levelForSM     = 0;
     _mesh           = nullptr;
  
     addMesh(mesh);
 }

◆ ~SLNode()

SLNode::~SLNode ( )

override

Destructor deletes all children recursively and the animation. The mesh is not deleted. Meshes get deleted at the end by the SLAssetManager vector. The entire scenegraph is deleted by deleting the SLScene::_root3D node. Nodes that are not in the scenegraph will not be deleted at scene destruction.

Definition at line 133 of file SLNode.cpp.

 {
 #ifdef SL_USE_ENTITIES
     SLint entityID = SLScene::entities.getEntityID(this);
     SLint parentID = SLScene::entities.getParentID(this);
     if (entityID != INT32_MIN && parentID != INT32_MIN)
     {
         if (parentID == -1)
             SLScene::entities.clear();
         else
             SLScene::entities.deleteEntity(entityID);
     }
 #endif
  
     for (auto* child : _children)
         delete child;
     _children.clear();
  
     delete _animation;
 }

Member Function Documentation

◆ aabb()

SLAABBox* SLNode::aabb ( )

inline

Definition at line 301 of file SLNode.h.

301 { return &_aabb; }

SLNode::_aabb

SLAABBox _aabb

axis aligned bounding box

Definition: SLNode.h:360

◆ addChild()

void SLNode::addChild ( SLNode * child )

Adds a child node to the children vector

Definition at line 207 of file SLNode.cpp.

 {
     assert(child && "The child pointer is null.");
     assert(this != child && "You can not add the node to itself.");
     assert(!child->parent() && "The child has already a parent.");
  
     _children.push_back(child);
     _isAABBUpToDate = false;
     child->parent(this);
  
 #ifdef SL_USE_ENTITIES
     // Only add child to existing parents in entities
     if (_entityID != INT32_MIN)
     {
         SLScene::entities.addChildEntity(_entityID, SLEntity(child));
     }
 #endif
 }

◆ addMesh()

void SLNode::addMesh ( SLMesh * mesh )

virtual

Simply adds a mesh to its mesh pointer vector of the node.

Definition at line 157 of file SLNode.cpp.

 {
     assert(mesh && "No mesh passed");
  
     // Take over mesh name if node name is default name
     if (_name == "Node" && mesh->name() != "Mesh")
         _name = mesh->name() + "-Node";
  
     _mesh = mesh;
  
     _isAABBUpToDate = false;
     mesh->init(this);
 }

◆ animation() [1/2]

SLAnimation* SLNode::animation ( )

inline

Definition at line 302 of file SLNode.h.

302 { return _animation; }

◆ animation() [2/2]

void SLNode::animation ( SLAnimation * a )

inline

Definition at line 281 of file SLNode.h.

281 { _animation = a; }

◆ axisXOS()

SLVec3f SLNode::axisXOS ( ) const

inline

Returns the x-axis in object space

Definition at line 504 of file SLNode.h.

 {
     return _om.axisX();
 }

◆ axisXWS()

SLVec3f SLNode::axisXWS ( ) const

inline

Returns the x-axis in world space

Definition at line 571 of file SLNode.h.

 {
     updateAndGetWM();
     return _wm.axisX();
 }

◆ axisYOS()

SLVec3f SLNode::axisYOS ( ) const

inline

Returns the y-axis in object space

Definition at line 513 of file SLNode.h.

 {
     return _om.axisY();
 }

◆ axisYWS()

SLVec3f SLNode::axisYWS ( ) const

inline

Returns the y-axis in world space

Definition at line 581 of file SLNode.h.

 {
     updateAndGetWM();
     return _wm.axisY();
 }

◆ axisZOS()

SLVec3f SLNode::axisZOS ( ) const

inline

Returns the z-axis in object space

Definition at line 522 of file SLNode.h.

 {
     return _om.axisZ();
 }

◆ axisZWS()

SLVec3f SLNode::axisZWS ( ) const

inline

Returns the z-axis in world space

Definition at line 591 of file SLNode.h.

 {
     updateAndGetWM();
     return _wm.axisZ();
 }

◆ castsShadows() [1/2]

SLbool SLNode::castsShadows ( )

inline

Definition at line 303 of file SLNode.h.

303 { return _castsShadows; }

◆ castsShadows() [2/2]

void SLNode::castsShadows ( SLbool castsShadows )

inline

Definition at line 282 of file SLNode.h.

282 { _castsShadows = castsShadows; }

SLNode::castsShadows

SLbool castsShadows()

Definition: SLNode.h:303

◆ children()

SLVNode& SLNode::children ( )

inline

Definition at line 305 of file SLNode.h.

305 { return _children; }

◆ copyRec()

SLNode * SLNode::copyRec ( )

virtual

Returns a deep copy of the node and its children recursively. The meshes do not get copied.

Definition at line 572 of file SLNode.cpp.

 {
     SLNode* copy = new SLNode(name());
     copy->_om.setMatrix(_om);
     copy->_depth          = _depth;
     copy->_isAABBUpToDate = _isAABBUpToDate;
     copy->_isAABBUpToDate = _isWMUpToDate;
     copy->_drawBits       = _drawBits;
     copy->_aabb           = _aabb;
     copy->_castsShadows   = _castsShadows;
  
     if (_animation)
         copy->_animation = new SLAnimation(*_animation);
     else
         copy->_animation = nullptr;
  
     if (_mesh)
         copy->addMesh(_mesh);
  
     for (auto* child : _children)
         copy->addChild(child->copyRec());
  
     return copy;
 }

◆ cull2DRec()

void SLNode::cull2DRec ( SLSceneView * sv )

virtual

Does the 2D frustum culling. If a node is visible its mesh material is added to the SLSceneview::_visibleMaterials2D set and the node to the SLMaterials::nodesVisible2D vector. See also SLSceneView::draw3DGLAll for more details.

Definition at line 455 of file SLNode.cpp.

 {
     // PROFILE_FUNCTION();
  
     _aabb.isVisible(true);
  
     // Cull the group nodes recursively
     for (auto* child : _children)
         child->cull2DRec(sv);
  
     // Add all nodes to the opaque 2D vector
     if (this->mesh())
     {
         sv->visibleMaterials2D().insert(this->mesh()->mat());
         this->mesh()->mat()->nodesVisible2D().push_back(this);
     }
     else if (typeid(*this) == typeid(SLText))
         sv->nodesBlended2D().push_back(this);
 }

◆ cull3DRec()

void SLNode::cull3DRec ( SLSceneView * sv )

virtual

Does the view frustum culling by checking whether the AABB is inside the 3D cameras view frustum. The check is done in world space. If a AABB is visible the nodes children are checked recursively. If a node is visible its mesh material is added to the SLSceneview::_visibleMaterials3D set and the node to the SLMaterials::nodesVisible3D vector. See also SLSceneView::draw3DGLAll for more details.

Definition at line 397 of file SLNode.cpp.

 {
     if (!this->drawBit(SL_DB_HIDDEN))
     {
         // Do frustum culling for all shapes except cameras & lights
         if (sv->doFrustumCulling() &&
             _parent != nullptr &&             // hsm4: do not frustum check the root node
             !dynamic_cast<SLCamera*>(this) && // Ghm1: Checking for typeid fails if someone adds a custom camera that inherits SLCamera
             typeid(*this) != typeid(SLLightRect) &&
             typeid(*this) != typeid(SLLightSpot) &&
             typeid(*this) != typeid(SLLightDirect))
         {
             sv->camera()->isInFrustum(&_aabb);
         }
         else
             _aabb.isVisible(true);
  
         // For particle system updating (Break, no update, setup to resume)
         SLParticleSystem* tempPS = dynamic_cast<SLParticleSystem*>(this->mesh());
         if (tempPS && !_aabb.isVisible())
             tempPS->setNotVisibleInFrustum();
  
         // Cull the group nodes recursively
         if (_aabb.isVisible())
         {
             cullChildren3D(sv);
  
             if (this->drawBit(SL_DB_OVERDRAW))
                 sv->nodesOverdrawn().push_back(this);
             else
             {
                 // All nodes with meshes get rendered sorted by their material
                 if (this->mesh())
                 {
                     sv->visibleMaterials3D().insert(this->mesh()->mat());
                     this->mesh()->mat()->nodesVisible3D().push_back(this);
                 }
                 else
                 {
                     // Add camera or selected node without mesh to opaque vector for line drawing
                     if (dynamic_cast<SLCamera*>(this) || this->_isSelected)
                         sv->nodesOpaque3D().push_back(this);
  
                     // Add special text node to blended vector
                     else if (typeid(*this) == typeid(SLText))
                         sv->nodesBlended3D().push_back(this);
                 }
             }
         }
     }
 }

◆ cullChildren3D()

void SLNode::cullChildren3D ( SLSceneView * sv )

virtual

Initializer function to call SLNode::cull3DRec recursively.

Reimplemented in SLNodeLOD.

Definition at line 384 of file SLNode.cpp.

 {
     for (auto* child : _children)
         child->cull3DRec(sv);
 }

◆ deleteChild() [1/3]

bool SLNode::deleteChild ( )

Deletes the last child in the child vector.

Definition at line 267 of file SLNode.cpp.

 {
     if (!_children.empty())
     {
         delete _children.back();
         _children.pop_back();
         _isAABBUpToDate = false;
         return true;
     }
     return false;
 }

◆ deleteChild() [2/3]

bool SLNode::deleteChild ( const SLstring & name )

Searches for a child with the name 'name' and deletes it.

Definition at line 301 of file SLNode.cpp.

 {
     assert(!name.empty());
     SLNode* found = findChild<SLNode>(name);
     if (found) return deleteChild(found);
     return false;
 }

◆ deleteChild() [3/3]

bool SLNode::deleteChild ( SLNode * child )

Deletes a child from the child vector.

Definition at line 282 of file SLNode.cpp.

 {
     assert(child);
     for (SLulong i = 0; i < _children.size(); ++i)
     {
         if (_children[i] == child)
         {
             _children.erase(_children.begin() + (long)i);
             delete child;
             _isAABBUpToDate = false;
             return true;
         }
     }
     return false;
 }

◆ deleteChildren()

void SLNode::deleteChildren ( )

Deletes all child nodes.

Definition at line 248 of file SLNode.cpp.

 {
     for (auto& i : _children)
         delete i;
     _children.clear();
  
 #ifdef SL_USE_ENTITIES
     SLint entityID = SLScene::entities.getEntityID(this);
     SLint parentID = SLScene::entities.getParentID(this);
     if (entityID != INT32_MIN && parentID != INT32_MIN)
     {
         SLScene::entities.deleteChildren(entityID);
     }
 #endif
 }

◆ depth()

SLint SLNode::depth ( ) const

inline

Definition at line 293 of file SLNode.h.

293 { return _depth; }

◆ doUpdate()

virtual void SLNode::doUpdate ( )

inlinevirtual

Reimplemented in SLHorizonNode.

Definition at line 308 of file SLNode.h.

308 {}

◆ drawBit()

SLbool SLNode::drawBit ( SLuint bit )

inline

Definition at line 300 of file SLNode.h.

300 { return _drawBits.get(bit); }

SLDrawBits::get

SLbool get(SLuint bit)

Returns the specified bit.

Definition: SLDrawBits.h:69

◆ drawBits()

SLDrawBits* SLNode::drawBits ( )

inline

Definition at line 299 of file SLNode.h.

299 { return &_drawBits; }

◆ drawMesh()

void SLNode::drawMesh ( SLSceneView * sv )

virtual

Draws the single mesh.

Inserts a mesh pointer in the mesh pointer vector after the specified afterM pointer.

Reimplemented in SLText, SLLightSpot, SLLightRect, SLLightDirect, SLCamera, and SLKeyframeCamera.

Definition at line 176 of file SLNode.cpp.

 {
     if (_mesh)
         _mesh->draw(sv, this);
 }

◆ dumpRec()

void SLNode::dumpRec ( )

virtual

Prints the node name with the names of the meshes recursively

Definition at line 775 of file SLNode.cpp.

 {
     // dump node
     for (SLint i = 0; i < _depth; ++i)
         cout << "   ";
     cout << "Node: " << _name << endl;
  
     // dump meshes of node
     for (SLint i = 0; i < _depth; ++i)
         cout << "   ";
  
     if (_mesh)
     {
         cout << "- Mesh: " << _mesh->name();
         cout << ", " << _mesh->numI() * 3 << " tri";
         if (_mesh->mat())
             cout << ", Mat: " << _mesh->mat()->name();
     }
     else
         cout << "- Mesh: none";
     cout << endl;
  
     // dump children nodes
     for (auto* child : _children)
         child->dumpRec();
 }

◆ entityID() [1/2]

SLint SLNode::entityID ( ) const

inline

Definition at line 294 of file SLNode.h.

294 { return _entityID; }

◆ entityID() [2/2]

void SLNode::entityID ( SLint entityID )

inline

Definition at line 275 of file SLNode.h.

275 { _entityID = entityID; }

◆ find()

template<typename T >

T * SLNode::find	(	const SLstring &	name = `""`,
		SLbool	findRecursive = `true`
	)

SLNode::findChild<T> searches a node tree including the node by a given name.

Definition at line 376 of file SLNode.h.

 {
     T* found = dynamic_cast<T*>(this);
     if (found && (name.empty() || name == _name))
         return found;
     return findChild<T>(name, findRecursive);
 }

◆ findChild()

template<typename T >

T * SLNode::findChild	(	const SLstring &	name = `""`,
		SLbool	findRecursive = `true`
	)

SLNode::findChild<T> finds the first child that is of type T or a subclass of T.

Definition at line 388 of file SLNode.h.

 {
     for (auto node : _children)
     {
         T* found = dynamic_cast<T*>(node);
         if (found && (name.empty() || name == node->name()))
             return found;
     }
     if (findRecursive)
     {
         for (auto& i : _children)
         {
             T* found = i->findChild<T>(name, findRecursive);
             if (found)
                 return found;
         }
     }
  
     return nullptr;
 }

◆ findChildren() [1/3]

std::deque< SLNode * > SLNode::findChildren	(	const SLMesh *	mesh,
		SLbool	findRecursive = `true`
	)

Searches for all nodes that contain the provided mesh

Definition at line 313 of file SLNode.cpp.

 {
     std::deque<SLNode*> list;
     findChildrenHelper(mesh, list, findRecursive);
  
     return list;
 }

◆ findChildren() [2/3]

template<typename T >

deque< T * > SLNode::findChildren	(	const SLstring &	name = `""`,
		SLbool	findRecursive = `true`,
		SLbool	canContain = `false`
	)

SLNode::findChildren<T> finds a list of all children that are of type T or subclasses of T. If a name is specified only nodes with that name are included.

Definition at line 416 of file SLNode.h.

 {
     deque<T*> list;
     findChildrenHelper<T>(name, list, findRecursive);
     return list;
 }

◆ findChildren() [3/3]

deque< SLNode * > SLNode::findChildren	(	SLuint	drawbit,
		SLbool	findRecursive = `true`
	)

Searches for all nodes that contain the provided mesh

Definition at line 342 of file SLNode.cpp.

 {
     deque<SLNode*> list;
     findChildrenHelper(drawbit, list, findRecursive);
     return list;
 }

◆ findChildrenHelper() [1/3]

void SLNode::findChildrenHelper	(	const SLMesh *	mesh,
		deque< SLNode * > &	list,
		SLbool	findRecursive
	)

private

Helper function of findChildren for the passed mesh pointer

Definition at line 325 of file SLNode.cpp.

 {
     for (auto* child : _children)
     {
         if (child->_mesh == mesh)
             list.push_back(child);
         if (findRecursive)
             child->findChildrenHelper(mesh, list, findRecursive);
     }
 }

◆ findChildrenHelper() [2/3]

template<typename T >

void SLNode::findChildrenHelper	(	const SLstring &	name,
		deque< T * > &	list,
		SLbool	findRecursive,
		SLbool	canContain = `false`
	)

private

SLNode::findChildrenHelper<T> is the helper function for findChildren<T>. It appends all newly found children to 'list'.

Definition at line 431 of file SLNode.h.

 {
     for (auto& i : _children)
     {
         SLNode* node  = i;
         T*      found = dynamic_cast<T*>(node);
  
         if (canContain)
         {
             if (found && (name.empty() ||
                           Utils::containsString(node->name(), name)))
                 list.push_back(found);
         }
         else
         {
             if (found && (name.empty() || name == node->name()))
                 list.push_back(found);
         }
  
         if (findRecursive)
             i->findChildrenHelper<T>(name, list, findRecursive);
     }
 }

◆ findChildrenHelper() [3/3]

void SLNode::findChildrenHelper	(	SLuint	drawbit,
		deque< SLNode * > &	list,
		SLbool	findRecursive
	)

private

Helper function of findChildren for passed drawing bit

Definition at line 353 of file SLNode.cpp.

 {
     for (auto* child : _children)
     {
         if (child->drawBits()->get(drawbit))
             list.push_back(child);
         if (findRecursive)
             child->findChildrenHelper(drawbit, list, findRecursive);
     }
 }

◆ forwardOS()

SLVec3f SLNode::forwardOS ( ) const

inline

Returns the local forward vector (= -z-axis) in a right-hand y-up system

Definition at line 477 of file SLNode.h.

 {
     return SLVec3f(-_om.m(8), -_om.m(9), -_om.m(10));
 }

◆ forwardWS()

SLVec3f SLNode::forwardWS ( ) const

inline

SLNode::forward returns worlds forward vector

Definition at line 541 of file SLNode.h.

 {
     updateAndGetWM();
     return -_wm.axisZ();
 }

◆ hitRec()

bool SLNode::hitRec ( SLRay * ray )

virtual

Intersects the nodes meshes with the given ray. The intersection test is only done if the AABB is intersected. The ray-mesh intersection is done in the nodes object space. The rays origin and direction is therefore transformed into the object space.

Reimplemented in SLText, SLLightSpot, SLLightRect, and SLLightDirect.

Definition at line 508 of file SLNode.cpp.

 {
     assert(ray != nullptr);
  
     // Do not test hidden nodes
     if (_drawBits.get(SL_DB_HIDDEN))
         return false;
  
     // Do not test origin node for shadow rays
     // This restriction is not valid for objects that can shadow itself
     // if (this == ray->srcNode && ray->type == SHADOW)
     //    return false;
  
     // Check first AABB for intersection
     if (!_aabb.isHitInWS(ray))
         return false;
  
     SLbool meshWasHit = false;
  
     // Transform ray to object space for non-groups
     if (_mesh == nullptr)
     {
         // Special selection for cameras
         if (dynamic_cast<SLCamera*>(this) && ray->sv->camera() != this)
         {
             ray->hitNode = this;
             ray->hitMesh = nullptr;
             SLVec3f OC   = _aabb.centerWS() - ray->origin;
             ray->length  = OC.length();
             return true;
         }
     }
     else
     {
         // transform origin position to object space
         ray->originOS.set(updateAndGetWMI().multVec(ray->origin));
  
         // transform the direction only with the linear sub matrix
         ray->setDirOS(_wmI.mat3() * ray->dir);
  
         // test the mesh
         if (_mesh->hit(ray, this) && !meshWasHit)
             meshWasHit = true;
  
         if (ray->isShaded())
             return true;
     }
  
     // Test children nodes
     for (auto* child : _children)
     {
         if (child->hitRec(ray) && !meshWasHit)
             meshWasHit = true;
         if (ray->isShaded())
             return true;
     }
  
     return meshWasHit;
 }

◆ initialOM()

const SLMat4f& SLNode::initialOM ( )

inline

Definition at line 296 of file SLNode.h.

296 { return _initialOM; }

SLNode::_initialOM

SLMat4f _initialOM

the initial om state

Definition: SLNode.h:351

◆ insertChild()

bool SLNode::insertChild	(	SLNode *	insertC,
		SLNode *	afterC
	)

Inserts a child node in the children vector after the afterC node.

Definition at line 229 of file SLNode.cpp.

 {
     assert(insertC && afterC);
     assert(insertC != afterC);
  
     auto found = std::find(_children.begin(), _children.end(), afterC);
     if (found != _children.end())
     {
         _children.insert(found, insertC);
         insertC->parent(this);
         _isAABBUpToDate = false;
         return true;
     }
     return false;
 }

◆ isSelected() [1/2]

bool SLNode::isSelected ( )

inline

Definition at line 315 of file SLNode.h.

315 { return _isSelected; }

◆ isSelected() [2/2]

void SLNode::isSelected ( bool isSelected )

inline

Definition at line 286 of file SLNode.h.

286 { _isSelected = isSelected; }

SLNode::isSelected

bool isSelected()

Definition: SLNode.h:315

◆ levelForSM() [1/2]

SLubyte SLNode::levelForSM ( )

inline

Definition at line 317 of file SLNode.h.

317 { return _levelForSM; }

◆ levelForSM() [2/2]

void SLNode::levelForSM ( SLubyte lfsm )

inline

Definition at line 288 of file SLNode.h.

288 { _levelForSM = lfsm; }

◆ lookAt() [1/2]

void SLNode::lookAt	(	const SLVec3f &	target,
		const SLVec3f &	up = `SLVec3f::AXISY`,
		SLTransformSpace	relativeTo = `TS_world`
	)

Rotates the object so that it's forward vector is pointing towards the 'target' point. Default forward is -Z. The 'relativeTo' parameter defines in what space the 'target' parameter is to be interpreted in.

Definition at line 1023 of file SLNode.cpp.

 {
     SLVec3f pos = translationOS();
     SLVec3f dir;
     SLVec3f localUp = up;
  
     if (relativeTo == TS_world && _parent)
     {
         SLVec3f localTarget = _parent->updateAndGetWMI() * target;
         localUp             = _parent->updateAndGetWMI().mat3() * up;
         dir                 = localTarget - translationOS();
     }
     else if (relativeTo == TS_object)
         dir = _om * target - translationOS();
     else
         dir = target - translationOS();
  
     dir.normalize();
  
     SLfloat cosAngle = localUp.dot(dir);
  
     // dir and up are parallel and facing in the same direction
     // or facing in opposite directions.
     // in this case we just rotate the up vector by 90� around
     // our current right vector
     // @todo This check might make more sense to be in Mat3.posAtUp
     if (fabs(cosAngle - 1.0) <= FLT_EPSILON || fabs(cosAngle + 1.0) <= FLT_EPSILON)
     {
         SLMat3f rot;
         rot.rotation(-90.0f, rightOS());
  
         localUp = rot * localUp;
     }
  
     _om.posAtUp(pos, pos + dir, localUp);
  
     needUpdate();
 }

◆ lookAt() [2/2]

void SLNode::lookAt	(	SLfloat	targetX,
		SLfloat	targetY,
		SLfloat	targetZ,
		SLfloat	upX = `0`,
		SLfloat	upY = `1`,
		SLfloat	upZ = `0`,
		SLTransformSpace	relativeTo = `TS_world`
	)

inline

Definition at line 652 of file SLNode.h.

 {
     lookAt(SLVec3f(targetX,
                    targetY,
                    targetZ),
            SLVec3f(upX, upY, upZ),
            relativeTo);
 }

◆ mesh()

SLMesh* SLNode::mesh ( )

inline

Definition at line 304 of file SLNode.h.

304 { return _mesh; }

◆ minLodCoverage() [1/2]

SLfloat SLNode::minLodCoverage ( )

inline

Definition at line 316 of file SLNode.h.

316 { return _minLodCoverage; }

◆ minLodCoverage() [2/2]

void SLNode::minLodCoverage ( SLfloat minLodCoverage )

inline

Definition at line 287 of file SLNode.h.

287 { _minLodCoverage = minLodCoverage; }

SLNode::minLodCoverage

SLfloat minLodCoverage()

Definition: SLNode.h:316

◆ needAABBUpdate()

void SLNode::needAABBUpdate ( )

Flags this node's AABB for an updateRec. If a node changed we need to updateRec it's world space AABB. This needs to also be propagated up the parent chain since the AABB of a node incorporates the AABB's of child nodes.

Definition at line 665 of file SLNode.cpp.

 {
     // stop if we reach a node that is already flagged.
     if (!_isAABBUpToDate)
         return;
  
     _isAABBUpToDate = false;
  
     // flag parent's for an AABB updateRec too since they need to
     // merge the child AABBs
     if (_parent)
         _parent->needAABBUpdate();
 }

◆ needUpdate()

void SLNode::needUpdate ( )

virtual

Flags this node for an updateRec. This function is called automatically if the local transform of the node or of its parent changed. Nodes that are flagged for updating will recalculate their world transform the next time it is requested by updateAndGetWM().

Reimplemented in SLJoint.

Definition at line 616 of file SLNode.cpp.

 {
 #ifdef SL_USE_ENTITIES
     if (_entityID != INT32_MIN)
         SLScene::entities.getEntity(_entityID)->om.setMatrix(_om);
 #endif
  
     // stop if we reach a node that is already flagged.
     if (!_isWMUpToDate)
         return;
  
     _isWMUpToDate  = false;
     _isWMIUpToDate = false;
  
     // mark the WM of the children dirty since their parent just changed
     for (auto* child : _children)
         child->needUpdate();
  
     // flag AABB for an updateRec
     needAABBUpdate();
 }

◆ needWMUpdate()

void SLNode::needWMUpdate ( )

Flags this node for a wm updateRec. It is almost identical to the needUpdate function but it won't flag AABBs. This function is currently not in use but could give a slight performance boost if it was called instead of needUpdate for the children of a node that changed.

Definition at line 645 of file SLNode.cpp.

 {
     // stop if we reach a node that is already flagged.
     if (!_isWMUpToDate)
         return;
  
     _isWMUpToDate  = false;
     _isWMIUpToDate = false;
  
     // mark the WM of the children dirty since their parent just changed
     for (auto* child : _children)
         child->needWMUpdate();
 }

◆ numChildren()

SLint SLNode::numChildren ( )

inline

Definition at line 175 of file SLNode.h.

175 { return (SLint)_children.size(); }

◆ om() [1/2]

const SLMat4f& SLNode::om ( )

inline

Definition at line 295 of file SLNode.h.

295 { return _om; }

◆ om() [2/2]

void SLNode::om ( const SLMat4f & mat )

inline

Definition at line 276 of file SLNode.h.

     {
         _om.setMatrix(mat);
         needUpdate();
     }

◆ onUpdateCB()

void SLNode::onUpdateCB ( function< void()> callbackFunc )

inline

Definition at line 289 of file SLNode.h.

289 { _onUpdateCB = callbackFunc; }

SLNode::_onUpdateCB

function< void()> _onUpdateCB

Optional lambda callback once per update.

Definition: SLNode.h:364

◆ parent() [1/2]

SLNode* SLNode::parent ( )

inline

Definition at line 292 of file SLNode.h.

292 { return _parent; }

◆ parent() [2/2]

void SLNode::parent ( SLNode * p )

Sets the parent for this node and updates its depth

Definition at line 600 of file SLNode.cpp.

 {
     _parent = p;
  
     if (_parent)
         _depth = _parent->depth() + 1;
     else
         _depth = 1;
 }

◆ removeChild()

bool SLNode::removeChild ( SLNode * child )

remove child from vector of children. Removes false if not found, else true.

Definition at line 367 of file SLNode.cpp.

 {
     assert(child);
     for (auto it = _children.begin(); it != _children.end(); ++it)
     {
         if (*it == child)
         {
             (*it)->parent(nullptr);
             _children.erase(it);
             return true;
         }
     }
  
     return false;
 }

◆ removeMesh() [1/2]

bool SLNode::removeMesh ( )

Returns true if a mesh was assigned and set it to nullptr.

Definition at line 183 of file SLNode.cpp.

 {
     if (_mesh)
     {
         _mesh = nullptr;
         return true;
     }
     return false;
 }

◆ removeMesh() [2/2]

bool SLNode::removeMesh ( SLMesh * mesh )

Returns true if the passed mesh was assigned and sets it to nullptr.

Definition at line 194 of file SLNode.cpp.

 {
     if (_mesh == mesh && mesh != nullptr)
     {
         _mesh = nullptr;
         return true;
     }
     return false;
 }

◆ resetToInitialState()

void SLNode::resetToInitialState ( )

Resets this object to its initial state

Definition at line 1092 of file SLNode.cpp.

 {
     _om.setMatrix(_initialOM);
     needUpdate();
 }

◆ rightOS()

SLVec3f SLNode::rightOS ( ) const

inline

Returns the local right vector (= x-axis) in a right-hand y-up system

Definition at line 486 of file SLNode.h.

 {
     return SLVec3f(_om.m(0), _om.m(1), _om.m(2));
 }

◆ rightWS()

SLVec3f SLNode::rightWS ( ) const

inline

SLNode::right returns worlds right vector

Definition at line 551 of file SLNode.h.

 {
     updateAndGetWM();
     return _wm.axisX();
 }

◆ rotate() [1/3]

void SLNode::rotate	(	const SLQuat4f &	rot,
		SLTransformSpace	relativeTo = `TS_object`
	)

Rotates the node around its local origin relative to the space expressed by 'relativeTo'.

Definition at line 945 of file SLNode.cpp.

 {
     SLMat4f rotation = rot.toMat4();
  
     if (relativeTo == TS_object)
     {
         _om.setMatrix(_om * rotation);
     }
     else if (_parent && relativeTo == TS_world)
     {
         SLMat4f rotWS;
         rotWS.translate(updateAndGetWM().translation());
         rotWS.multiply(rotation);
         rotWS.translate(-updateAndGetWM().translation());
  
         _om.setMatrix(_parent->_wm.inverted() * rotWS * updateAndGetWM());
     }
     else // relativeTo == TS_Parent || relativeTo == TS_World && !_parent
     {
         SLMat4f rotOS;
         rotOS.translate(translationOS());
         rotOS.multiply(rotation);
         rotOS.translate(-translationOS());
  
         _om.setMatrix(rotOS * _om);
     }
  
     needUpdate();
 }

◆ rotate() [2/3]

void SLNode::rotate	(	SLfloat	angleDeg,
		const SLVec3f &	axis,
		SLTransformSpace	relativeTo = `TS_object`
	)

Rotates the node around its local origin relative to the space expressed by 'relativeTo'.

Definition at line 934 of file SLNode.cpp.

 {
     SLQuat4f rot(angleDeg, axis);
     rotate(rot, relativeTo);
 }

◆ rotate() [3/3]

void SLNode::rotate	(	SLfloat	angleDeg,
		SLfloat	x,
		SLfloat	y,
		SLfloat	z,
		SLTransformSpace	relativeTo = `TS_object`
	)

inline

Definition at line 630 of file SLNode.h.

 {
     rotate(angleDeg, SLVec3f(x, y, z), relativeTo);
 }

◆ rotateAround()

void SLNode::rotateAround	(	const SLVec3f &	point,
		SLVec3f &	axis,
		SLfloat	angleDeg,
		SLTransformSpace	relativeTo = `TS_world`
	)

Rotates the node around an arbitrary point. The 'axis' and 'point' parameter are relative to the space described by 'relativeTo'.

Definition at line 979 of file SLNode.cpp.

 {
     SLVec3f localPoint = point;
     SLVec3f localAxis  = axis;
  
     if (relativeTo == TS_world && _parent)
     {
         localPoint = _parent->updateAndGetWMI() * point;
         localAxis  = _parent->updateAndGetWMI().mat3() * axis;
     }
  
     SLMat4f rot;
     rot.translate(localPoint);
     rot.rotate(angleDeg, localAxis);
     rot.translate(-localPoint);
  
     if (relativeTo == TS_object)
         _om.setMatrix(_om * rot);
     else
         _om.setMatrix(rot * _om);
  
     needUpdate();
 }

◆ rotation() [1/2]

void SLNode::rotation	(	const SLQuat4f &	rot,
		SLTransformSpace	relativeTo = `TS_parent`
	)

sets the rotation of this node. The axis parameter will be transformed into 'relativeTo' space. So an passing in an axis of (0, 1, 0) with TS_Object will rotate the node around its own up axis.

Definition at line 846 of file SLNode.cpp.

 {
     SLMat4f rotation = rot.toMat4();
  
     if (_parent && relativeTo == TS_world)
     {
         // get the inverse parent rotation to remove it from our current rotation
         // we want the input quaternion to absolutely set our new rotation relative
         // to the world axes
         SLMat4f parentRotInv = _parent->updateAndGetWMI();
         parentRotInv.translation(0, 0, 0);
  
         // set the om rotation to the inverse of the parents rotation to achieve a
         // 0, 0, 0 relative rotation in world space
         _om.rotation(0, 0, 0, 0);
         _om.setMatrix(_om * parentRotInv);
         rotate(rot, relativeTo);
     }
     else if (relativeTo == TS_parent)
     { // relative to parent, reset current rotation and just rotate again
         _om.rotation(0, 0, 0, 0);
         rotate(rot, relativeTo);
     }
     else
     {
         // in TS_Object everything is relative to our current orientation
         _om.rotation(0, 0, 0, 0);
         _om.setMatrix(_om * rotation);
     }
     needUpdate();
 }

◆ rotation() [2/2]

void SLNode::rotation	(	SLfloat	angleDeg,
		const SLVec3f &	axis,
		SLTransformSpace	relativeTo = `TS_parent`
	)

sets the rotation of this node. The axis parameter will be transformed into 'relativeTo' space. So a passing in an axis of (0, 1, 0) with TS_Object will rotate the node around its own up axis.

Definition at line 884 of file SLNode.cpp.

 {
     SLQuat4f rot(angleDeg, axis);
     rotation(rot, relativeTo);
 }

◆ scale() [1/3]

void SLNode::scale ( const SLVec3f & scale )

Adds a scale transform to the current object matrix

Note: this is not a setter but a scale modifier.; this modifier doesn't allow for different transform spaces, so there isn't the possibility for shearing an object currently.

Definition at line 1012 of file SLNode.cpp.

 {
     _om.scale(scale);
     needUpdate();
 }

◆ scale() [2/3]

void SLNode::scale ( SLfloat s )

inline

Definition at line 640 of file SLNode.h.

 {
     scale(SLVec3f(s, s, s));
 }

◆ scale() [3/3]

void SLNode::scale	(	SLfloat	x,
		SLfloat	y,
		SLfloat	z
	)

inline

Definition at line 646 of file SLNode.h.

 {
     scale(SLVec3f(x, y, z));
 }

◆ scaleToCenter()

void SLNode::scaleToCenter ( SLfloat maxDim )

Scales and translates the node so that its largest dimension is maxDim and the center is in [0,0,0].

Definition at line 1068 of file SLNode.cpp.

 {
     _aabb = updateAABBRec(true);
     SLVec3f size(_aabb.maxWS() - _aabb.minWS());
     SLVec3f center((_aabb.maxWS() + _aabb.minWS()) * 0.5f);
     SLfloat scaleFactor = maxDim / size.maxXYZ();
     if (fabs(scaleFactor) > FLT_EPSILON)
         scale(scaleFactor);
     else
         cout << "Node can't be scaled: " << name().c_str() << endl;
     translate(-center);
 }

◆ scaling() [1/3]

void SLNode::scaling ( const SLVec3f & scaling )

Sets the scaling of current object matrix

Note: this modifier doesn't allow for different transform spaces, so there isn't the possiblity for shearing an object currently.

Definition at line 897 of file SLNode.cpp.

 {
     _om.scaling(scaling);
     needUpdate();
 }

◆ scaling() [2/3]

void SLNode::scaling ( SLfloat s )

inline

Definition at line 607 of file SLNode.h.

 {
     scaling(SLVec3f(s, s, s));
 }

◆ scaling() [3/3]

void SLNode::scaling	(	SLfloat	x,
		SLfloat	y,
		SLfloat	z
	)

inline

Definition at line 613 of file SLNode.h.

 {
     scaling(SLVec3f(x, y, z));
 }

◆ setDrawBitsRec()

void SLNode::setDrawBitsRec	(	SLuint	bit,
		SLbool	state
	)

Recursively sets the specified drawbit on or off. See also SLDrawBits.

Definition at line 804 of file SLNode.cpp.

 {
     _drawBits.set(bit, state);
     for (auto* child : _children)
         child->setDrawBitsRec(bit, state);
 }

◆ setInitialState()

void SLNode::setInitialState ( )

Saves the current position as the initial state

Definition at line 1084 of file SLNode.cpp.

 {
     _initialOM = _om;
 }

◆ setMeshMat()

void SLNode::setMeshMat	(	SLMaterial *	mat,
		bool	recursive
	)

Set the mesh material recursively.

Definition at line 1172 of file SLNode.cpp.

 {
     if (_mesh)
         _mesh->mat(mat);
  
     if (recursive)
         for (auto* child : _children)
             child->setMeshMat(mat, recursive);
 }

◆ setPrimitiveTypeRec()

void SLNode::setPrimitiveTypeRec ( SLGLPrimitiveType primitiveType )

Recursively sets the specified OpenGL primitive type.

Definition at line 813 of file SLNode.cpp.

 {
     for (auto* child : _children)
         child->setPrimitiveTypeRec(primitiveType);
  
     _mesh->primitive(primitiveType);
 }

◆ skeleton()

const SLAnimSkeleton * SLNode::skeleton ( )

Returns the first skeleton found in the meshes.

Definition at line 1100 of file SLNode.cpp.

 {
     if (_mesh && _mesh->skeleton())
         return _mesh->skeleton();
     return nullptr;
 }

◆ statsRec()

void SLNode::statsRec ( SLNodeStats & stats )

virtual

Updates the statistic numbers of the passed SLNodeStats struct and calls recursively the same method for all children.

Reimplemented in SLText, SLLightSpot, SLLightRect, SLLightDirect, and SLCamera.

Definition at line 479 of file SLNode.cpp.

 {
     // PROFILE_FUNCTION();
  
     stats.numBytes += sizeof(SLNode);
     stats.numNodes++;
  
     if (_children.empty())
         stats.numNodesLeaf++;
     else
         stats.numNodesGroup++;
  
     if (typeid(*this) == typeid(SLLightSpot)) stats.numLights++;
     if (typeid(*this) == typeid(SLLightRect)) stats.numLights++;
     if (typeid(*this) == typeid(SLLightDirect)) stats.numLights++;
  
     if (_mesh)
         _mesh->addStats(stats);
  
     for (auto* child : _children)
         child->statsRec(stats);
 }

◆ translate() [1/2]

void SLNode::translate	(	const SLVec3f &	delta,
		SLTransformSpace	relativeTo = `TS_object`
	)

Moves the node by the vector 'delta' relative to the space expressed by 'relativeTo'.

Definition at line 906 of file SLNode.cpp.

 {
     switch (relativeTo)
     {
         case TS_object:
             _om.translate(delta);
             break;
  
         case TS_world:
             if (_parent)
             {
                 SLVec3f localVec = _parent->updateAndGetWMI().mat3() * delta;
                 _om.translation(localVec + _om.translation());
             }
             else
                 _om.translation(delta + _om.translation());
             break;
  
         case TS_parent:
             _om.translation(delta + _om.translation());
             break;
     }
     needUpdate();
 }

◆ translate() [2/2]

void SLNode::translate	(	SLfloat	x,
		SLfloat	y,
		SLfloat	z,
		SLTransformSpace	relativeTo = `TS_object`
	)

inline

Definition at line 621 of file SLNode.h.

 {
     translate(SLVec3f(x, y, z), relativeTo);
 }

◆ translation() [1/2]

void SLNode::translation	(	const SLVec3f &	pos,
		SLTransformSpace	relativeTo = `TS_parent`
	)

sets the position of this node to pos in 'relativeTo' space.

Note: using TS_Object for this function yields the same result as calling translate(pos, TS_Object)

Definition at line 828 of file SLNode.cpp.

 {
     if (relativeTo == TS_world && _parent)
     { // transform position to local space
         SLVec3f localPos = _parent->updateAndGetWMI() * pos;
         _om.translation(localPos);
     }
     else
         _om.translation(pos);
  
     needUpdate();
 }

◆ translation() [2/2]

void SLNode::translation	(	SLfloat	x,
		SLfloat	y,
		SLfloat	z,
		SLTransformSpace	relativeTo = `TS_parent`
	)

inline

Definition at line 598 of file SLNode.h.

 {
     translation(SLVec3f(x, y, z), relativeTo);
 }

◆ translationOS()

SLVec3f SLNode::translationOS ( ) const

inline

SLNode::position returns current local position

Definition at line 468 of file SLNode.h.

 {
     return _om.translation();
 }

◆ translationWS()

SLVec3f SLNode::translationWS ( ) const

inline

SLNode::position returns current world position

Definition at line 531 of file SLNode.h.

 {
     updateAndGetWM();
     return _wm.translation();
 }

◆ updateAABBRec()

SLAABBox & SLNode::updateAABBRec ( SLbool updateAlsoAABBinOS )

virtual

Updates the axis aligned bounding box in world space recursively.

Reimplemented in SLText.

Definition at line 731 of file SLNode.cpp.

 {
     if (_isAABBUpToDate)
         return _aabb;
  
     // empty the AABB (= max negative AABB)
     if (_mesh || !_children.empty())
     {
         _aabb.minWS(SLVec3f(FLT_MAX, FLT_MAX, FLT_MAX));
         _aabb.maxWS(SLVec3f(-FLT_MAX, -FLT_MAX, -FLT_MAX));
     }
  
     // Update special case of camera because it has no mesh
     if (dynamic_cast<SLCamera*>(this))
         ((SLCamera*)this)->buildAABB(_aabb, updateAndGetWM());
  
     // Build or updateRec AABB of meshes & merge them to the nodes aabb in WS
     if (_mesh)
     {
         SLAABBox aabbMesh;
         _mesh->buildAABB(aabbMesh, updateAndGetWM());
         _aabb.mergeWS(aabbMesh);
     }
  
     // Merge children in WS recursively
     for (auto* child : _children)
         _aabb.mergeWS(child->updateAABBRec(updateAlsoAABBinOS));
  
     // We need min & max also in OS for the uniform grid intersection in OS
     // This is used for ray casts (picking) and raytracing.
     if (updateAlsoAABBinOS)
         _aabb.fromWStoOS(_aabb.minWS(), _aabb.maxWS(), updateAndGetWMI());
  
     _aabb.setCenterAndRadiusWS();
  
     // For visualizing the nodes' orientation we finally updateRec the axis in WS
     _aabb.updateAxisWS(updateAndGetWM());
  
     _isAABBUpToDate = true;
     return _aabb;
 }

◆ updateAndGetWM()

const SLMat4f & SLNode::updateAndGetWM ( ) const

Returns the current world matrix for this node. If the world matrix is out of date it will updateRec it and return a current result.

Definition at line 703 of file SLNode.cpp.

 {
     if (!_isWMUpToDate)
         updateWM();
  
     return _wm;
 }

◆ updateAndGetWMI()

const SLMat4f & SLNode::updateAndGetWMI ( ) const

Returns the current world inverse matrix for this node. If the world matrix is out of date it will updateRec it and return a current result.

Definition at line 714 of file SLNode.cpp.

 {
     if (!_isWMUpToDate)
         updateWM();
  
     if (!_isWMIUpToDate)
     {
         _wmI.setMatrix(_wm);
         _wmI.invert();
         _isWMIUpToDate = true;
     }
  
     return _wmI;
 }

◆ updateMeshAccelStructs()

void SLNode::updateMeshAccelStructs ( )

Definition at line 1149 of file SLNode.cpp.

 {
     PROFILE_FUNCTION();
  
     if (_mesh && _mesh->accelStructIsOutOfDate())
         _mesh->updateAccelStruct();
  
     for (auto* child : _children)
         child->updateMeshAccelStructs();
 }

◆ updateMeshMat()

void SLNode::updateMeshMat	(	std::function< void(SLMaterial *m)>	setMat,
		bool	recursive
	)

Updates the mesh material recursively with a material lambda.

Definition at line 1161 of file SLNode.cpp.

 {
     if (_mesh && _mesh->mat())
         setMat(_mesh->mat());
  
     if (recursive)
         for (auto* child : _children)
             child->updateMeshMat(setMat, recursive);
 }

◆ updateMeshSkins()

bool SLNode::updateMeshSkins	(	bool	forceCPUSkinning,
		const std::function< void(SLMesh *)> &	cbInformNodes
	)

Update all skinned meshes recursively.

Do software skinning on all changed skeletons && updateRec any out of date acceleration structure for RT or if they're being rendered.

Definition at line 1126 of file SLNode.cpp.

 {
     if (drawBit(SL_DB_WITHEDGES) ||
         drawBit(SL_DB_ONLYEDGES) ||
         drawBit(SL_DB_VOXELS))
         forceCPUSkinning = true;
  
     bool hasChanges = false;
  
     // Do software skinning on changed skeleton
     if (_mesh && _mesh->skeleton() && _mesh->skeleton()->changed())
     {
         _mesh->transformSkin(forceCPUSkinning, cbInformNodes);
         hasChanges = true;
     }
  
     for (auto* child : _children)
         hasChanges |= child->updateMeshSkins(forceCPUSkinning, cbInformNodes);
  
     return hasChanges;
 }

◆ updateRec()

void SLNode::updateRec ( )

Definition at line 1107 of file SLNode.cpp.

 {
     // if (_parent == nullptr) PROFILE_FUNCTION();
  
     // Call optional update callback of attached
     if (_onUpdateCB)
         _onUpdateCB();
  
     // Call doUpdate for inherited classes if implemented
     doUpdate();
  
     for (auto* child : _children)
         child->updateRec();
 }

◆ updateWM()

void SLNode::updateWM ( ) const

private

A helper function that updates the current _wm to reflect the local matrix. recursively calls the updateAndGetWM of the node's parent.

Note: This function is const because it has to be called from inside the updateAndGetWM function which has to be const. Since we only updateRec the private cache of this class it is ok.

Definition at line 687 of file SLNode.cpp.

 {
     // PROFILE_FUNCTION();
  
     if (_parent)
         _wm.setMatrix(_parent->updateAndGetWM() * _om);
     else
         _wm.setMatrix(_om);
  
     _isWMUpToDate = true;
     numWMUpdates++;
 }

◆ upOS()

SLVec3f SLNode::upOS ( ) const

inline

Returns the local up vector in a right-hand y-up system

Definition at line 495 of file SLNode.h.

 {
     return SLVec3f(_om.m(4), _om.m(5), _om.m(6));
 }

◆ upWS()

SLVec3f SLNode::upWS ( ) const

inline

SLNode::up returns worlds up vector

Definition at line 561 of file SLNode.h.

 {
     updateAndGetWM();
     return _wm.axisY();
 }

Friends And Related Function Documentation

◆ SLSceneView

friend class SLSceneView

friend

Definition at line 148 of file SLNode.h.

Member Data Documentation

◆ _aabb

SLAABBox SLNode::_aabb

protected

axis aligned bounding box

Definition at line 360 of file SLNode.h.

◆ _animation

SLAnimation* SLNode::_animation

protected

animation of the node

Definition at line 361 of file SLNode.h.

◆ _castsShadows

bool SLNode::_castsShadows

protected

flag if meshes of node should cast shadows

Definition at line 357 of file SLNode.h.

◆ _children

SLVNode SLNode::_children

protected

vector of children nodes

Definition at line 345 of file SLNode.h.

◆ _depth

SLint SLNode::_depth

protected

depth of the node in a scene tree

Definition at line 348 of file SLNode.h.

◆ _drawBits

SLDrawBits SLNode::_drawBits

protected

node level drawing flags

Definition at line 359 of file SLNode.h.

◆ _entityID

SLint SLNode::_entityID

protected

ID in the SLVEntity graph for Data Oriented Design.

Definition at line 349 of file SLNode.h.

◆ _initialOM

SLMat4f SLNode::_initialOM

protected

the initial om state

Definition at line 351 of file SLNode.h.

◆ _isAABBUpToDate

SLbool SLNode::_isAABBUpToDate

mutableprotected

is the saved aabb still valid

Definition at line 356 of file SLNode.h.

◆ _isSelected

bool SLNode::_isSelected

protected

flag if node and one or more of its meshes are selected

Definition at line 358 of file SLNode.h.

◆ _isWMIUpToDate

SLbool SLNode::_isWMIUpToDate

mutableprotected

is the inverse WM of this node still valid

Definition at line 355 of file SLNode.h.

◆ _isWMUpToDate

SLbool SLNode::_isWMUpToDate

mutableprotected

is the WM of this node still valid

Definition at line 354 of file SLNode.h.

◆ _levelForSM

SLubyte SLNode::_levelForSM

protected

Level of LOD to use for shadow mapping (0 = the visible one will be drawn)

Definition at line 363 of file SLNode.h.

◆ _mesh

SLMesh* SLNode::_mesh

protected

pointer to a single mesh

Definition at line 346 of file SLNode.h.

◆ _minLodCoverage

SLfloat SLNode::_minLodCoverage

protected

Min. LOD coverage for visibility (0.0 < _minLodCoverage < 1.0)

Definition at line 362 of file SLNode.h.

◆ _om

SLMat4f SLNode::_om

protected

object matrix for local transforms

Definition at line 350 of file SLNode.h.

◆ _onUpdateCB

function<void()> SLNode::_onUpdateCB

protected

Optional lambda callback once per update.

Definition at line 364 of file SLNode.h.

◆ _parent

SLNode* SLNode::_parent

protected

pointer to the parent node

Definition at line 344 of file SLNode.h.

◆ _wm

SLMat4f SLNode::_wm

mutableprotected

world matrix for world transform

Definition at line 352 of file SLNode.h.

◆ _wmI

SLMat4f SLNode::_wmI

mutableprotected

inverse world matrix

Definition at line 353 of file SLNode.h.

◆ instanceIndex

unsigned int SLNode::instanceIndex = 0

static

???

Definition at line 321 of file SLNode.h.

◆ numWMUpdates

SLuint SLNode::numWMUpdates = 0

static

NO. of calls to updateWMRec per frame.

Definition at line 319 of file SLNode.h.

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

Public Member Functions

Static Public Attributes

Protected Attributes

Private Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

◆ SLNode() [1/3]

◆ SLNode() [2/3]

◆ SLNode() [3/3]

◆ ~SLNode()

Member Function Documentation

◆ aabb()

◆ addChild()

◆ addMesh()

◆ animation() [1/2]

◆ animation() [2/2]

◆ axisXOS()

◆ axisXWS()

◆ axisYOS()

◆ axisYWS()

◆ axisZOS()

◆ axisZWS()

◆ castsShadows() [1/2]

◆ castsShadows() [2/2]

◆ children()

◆ copyRec()

◆ cull2DRec()

◆ cull3DRec()

◆ cullChildren3D()

◆ deleteChild() [1/3]

◆ deleteChild() [2/3]

◆ deleteChild() [3/3]

◆ deleteChildren()

◆ depth()

◆ doUpdate()

◆ drawBit()

◆ drawBits()

◆ drawMesh()

◆ dumpRec()

◆ entityID() [1/2]

◆ entityID() [2/2]

◆ find()

◆ findChild()

◆ findChildren() [1/3]

◆ findChildren() [2/3]

◆ findChildren() [3/3]

◆ findChildrenHelper() [1/3]

◆ findChildrenHelper() [2/3]

◆ findChildrenHelper() [3/3]

◆ forwardOS()

◆ forwardWS()

◆ hitRec()

◆ initialOM()

◆ insertChild()

◆ isSelected() [1/2]

◆ isSelected() [2/2]

◆ levelForSM() [1/2]

◆ levelForSM() [2/2]

◆ lookAt() [1/2]

◆ lookAt() [2/2]

◆ mesh()

◆ minLodCoverage() [1/2]

◆ minLodCoverage() [2/2]

◆ needAABBUpdate()

◆ needUpdate()

◆ needWMUpdate()

◆ numChildren()

◆ om() [1/2]

◆ om() [2/2]

◆ onUpdateCB()

◆ parent() [1/2]

◆ parent() [2/2]

◆ removeChild()

◆ removeMesh() [1/2]

◆ removeMesh() [2/2]

◆ resetToInitialState()

◆ rightOS()

◆ rightWS()

◆ rotate() [1/3]