Class that holds all visible gizmo node during mouse transforms. More...

#include <SLTransformNode.h>

Inheritance diagram for SLTransformNode:

Public Member Functions
	SLTransformNode (SLSceneView sv, SLNode targetNode, SLstring shaderDir)
	Construct a new SLTransformNode::SLTransformNode object *. More...

	~SLTransformNode () override

virtual SLbool	onMouseDown (SLMouseButton button, SLint x, SLint y, SLKey mod) override
	onMouseDown event handler during editing interaction More...

virtual SLbool	onMouseUp (SLMouseButton button, SLint x, SLint y, SLKey mod) override
	onMouseUp event handler during editing interaction More...

virtual SLbool	onMouseMove (SLMouseButton button, SLint x, SLint y, SLKey mod) override
	onMouseMove event handler during editing interaction More...

virtual void	editMode (SLNodeEditMode editMode)

SLNode *	targetNode ()

SLNodeEditMode	editMode ()

Public Member Functions inherited from SLNode
	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	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 ()

Private Member Functions
bool	getClosestPointsBetweenRays (const SLVec3f &ray1O, const SLVec3f &ray1Dir, const SLVec3f &ray2O, const SLVec3f &ray2Dir, SLVec3f &ray1P, float &t1, SLVec3f &ray2P, float &t2)

bool	getClosestPointOnAxis (const SLVec3f &pickRayO, const SLVec3f &pickRayDir, const SLVec3f &axisRayO, const SLVec3f &axisRayDir, SLVec3f &axisPoint)

bool	rayDiscIntersect (const SLVec3f &rayO, const SLVec3f &rayDir, const SLVec3f &discO, const SLVec3f &discN, const float &distR, float &t)

bool	rayPlaneIntersect (const SLVec3f &rayO, const SLVec3f &rayDir, const SLVec3f &discO, const SLVec3f &discN, float &t)

bool	isCCW (const SLVec2f &a, const SLVec2f &b, const SLVec2f &c)

void	setDrawBitRecursive (SLuint bit, SLNode *node, bool value)

void	lookAt (SLNode node, SLCamera camera)

Private Attributes
SLSceneView *	_sv = nullptr

SLNode *	_targetNode = nullptr

SLNodeEditMode	_editMode

SLMaterial *	_matR = nullptr

SLMaterial *	_matG = nullptr

SLMaterial *	_matB = nullptr

SLMaterial *	_matY = nullptr

SLMaterial *	_matRT = nullptr

SLMaterial *	_matGT = nullptr

SLMaterial *	_matBT = nullptr

SLMaterial *	_matYT = nullptr

SLMesh *	_axisR = nullptr

SLMesh *	_axisG = nullptr

SLMesh *	_axisB = nullptr

SLMesh *	_lineR = nullptr

SLMesh *	_lineG = nullptr

SLMesh *	_lineB = nullptr

SLMesh *	_circR = nullptr

SLMesh *	_circG = nullptr

SLMesh *	_circB = nullptr

SLMesh *	_circY = nullptr

SLMesh *	_diskR = nullptr

SLMesh *	_diskG = nullptr

SLMesh *	_diskB = nullptr

SLMesh *	_diskY = nullptr

bool	_mouseIsDown

float	_gizmoScale

SLVec3f	_hitCoordinate

SLNode *	_selectedGizmo = nullptr

SLNode *	_transGizmos = nullptr

SLNode *	_transLineX = nullptr

SLNode *	_transLineY = nullptr

SLNode *	_transLineZ = nullptr

SLNode *	_scaleGizmos = nullptr

SLNode *	_scaleDisk = nullptr

SLNode *	_scaleCirc = nullptr

SLNode *	_rotGizmos = nullptr

SLNode *	_rotCircX = nullptr

SLNode *	_rotDiskX = nullptr

SLNode *	_rotCircY = nullptr

SLNode *	_rotDiskY = nullptr

SLNode *	_rotCircZ = nullptr

SLNode *	_rotDiskZ = nullptr

SLNode *	_gizmosNode = nullptr

Additional Inherited Members
Static Public Attributes inherited from SLNode
static SLuint	numWMUpdates = 0
	NO. of calls to updateWMRec per frame. More...

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

Protected Attributes inherited from SLNode
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...

Detailed Description

Class that holds all visible gizmo node during mouse transforms.

An SLTransformNode is added to the scenegraph during edit mode. Depending on the transform type (translation, rotation or scaling) arrows or disks and circles get shown or hidden. The transform node gets added and removed on the fly. So the assets have to be delete in the destructor.

Definition at line 32 of file SLTransformNode.h.

Constructor & Destructor Documentation

◆ SLTransformNode()

SLTransformNode::SLTransformNode	(	SLSceneView *	sv,
		SLNode *	targetNode,
		SLstring	shaderDir
	)

Construct a new SLTransformNode::SLTransformNode object *.

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

sv	Pointer to the SLSceneView
targetNode	Pointer to the node that should be transformed.
shaderDir	Path to the shader files

Definition at line 30 of file SLTransformNode.cpp.

   : SLNode("Edit Gizmos"),
     _sv(sv),
     _targetNode(targetNode),
     _editMode(NodeEditMode_None),
     _mouseIsDown(false),
     _gizmoScale(1.0f)
 {
     SLGLProgram* prog = SLGLProgramManager::get(SP_colorUniformPoint);
  
     _matR  = new SLMaterial(nullptr, "Red Opaque", SLCol4f::RED, SLVec4f::WHITE, 100.0f, 0.0f, 0.0f, 0.0f, prog);
     _matRT = new SLMaterial(nullptr, "Red Transp", SLCol4f::RED, SLVec4f::WHITE, 100.0f, 0.0f, 0.5f, 0.0f, prog);
     _matG  = new SLMaterial(nullptr, "Green Opaque", SLCol4f::GREEN, SLVec4f::WHITE, 100.0f, 0.0f, 0.0f, 0.0f, prog);
     _matGT = new SLMaterial(nullptr, "Green Transp", SLCol4f::GREEN, SLVec4f::WHITE, 100.0f, 0.0f, 0.5f, 0.0f, prog);
     _matB  = new SLMaterial(nullptr, "Blue Opaque", SLCol4f::BLUE, SLVec4f::WHITE, 100.0f, 0.0f, 0.0f, 0.0f, prog);
     _matBT = new SLMaterial(nullptr, "Blue Transp", SLCol4f::BLUE, SLVec4f::WHITE, 100.0f, 0.0f, 0.5f, 0.0f, prog);
     _matY  = new SLMaterial(nullptr, "Yellow Opaque", SLCol4f::YELLOW, SLVec4f::WHITE, 100.0f, 0.0f, 0.0f, 0.0f, prog);
     _matYT = new SLMaterial(nullptr, "Yellow Transp", SLCol4f::YELLOW, SLVec4f::WHITE, 100.0f, 0.0f, 0.5f, 0.0f, prog);
  
     _axisR             = new SLCoordAxisArrow(nullptr, _matRT);
     _axisG             = new SLCoordAxisArrow(nullptr, _matGT);
     _axisB             = new SLCoordAxisArrow(nullptr, _matBT);
     SLNode* transAxisX = new SLNode(_axisR, "x-axis node");
     SLNode* transAxisY = new SLNode(_axisG, "y-axis node");
     SLNode* transAxisZ = new SLNode(_axisB, "z-axis node");
     transAxisX->rotate(-90.0f, SLVec3f(0.0f, 0.0f, 1.0f));
     transAxisZ->rotate(90.0f, SLVec3f(1.0f, 0.0f, 0.0f));
     transAxisX->castsShadows(false);
     transAxisY->castsShadows(false);
     transAxisZ->castsShadows(false);
  
     SLVec3f  startPoint = SLVec3f(0.0f, 0.0f, -1.0f);
     SLVec3f  endPoint   = SLVec3f(0.0f, 0.0f, 1.0f);
     SLVVec3f points;
     points.push_back(startPoint);
     points.push_back(endPoint);
  
     _lineR      = new SLPolyline(nullptr, points, false, "Translation Line Mesh X", _matR);
     _transLineX = new SLNode(_lineR);
     _transLineX->rotate(90.0f, SLVec3f(0.0f, 1.0f, 0.0f));
     _transLineX->scale(1000.0f);
     _transLineX->castsShadows(false);
  
     _lineG      = new SLPolyline(nullptr, points, false, "Translation Line Mesh Y", _matG);
     _transLineY = new SLNode(_lineG);
     _transLineY->rotate(-90.0f, SLVec3f(1.0f, 0.0f, 0.0f));
     _transLineY->scale(1000.0f);
     _transLineY->castsShadows(false);
  
     _lineB      = new SLPolyline(nullptr, points, false, "Translation Line Mesh Z", _matB);
     _transLineZ = new SLNode(_lineB);
     _transLineZ->scale(1000.0f);
     _transLineZ->castsShadows(false);
  
     _circY     = new SLCircle(nullptr, "Scale Circle Mesh", _matY);
     _scaleCirc = new SLNode(_circY, "Scale Circle");
     _scaleCirc->castsShadows(false);
     _diskY     = new SLDisk(nullptr, 1.0f, SLVec3f::AXISZ, 36U, true, "Scale Disk", _matYT);
     _scaleDisk = new SLNode(_diskY, "Scale Disk");
     _scaleDisk->castsShadows(false);
  
     _circR    = new SLCircle(nullptr, "Rotation Circle Mesh X", _matR);
     _rotCircX = new SLNode(_circR, "Rotation Circle X");
     _rotCircX->castsShadows(false);
     _diskR    = new SLDisk(nullptr, 1.0f, SLVec3f::AXISZ, 36U, true, "Rotation Disk X", _matRT);
     _rotDiskX = new SLNode(_diskR, "Rotation Disk X");
     _rotDiskX->castsShadows(false);
     _circG    = new SLCircle(nullptr, "Rotation Circle Mesh Y", _matG);
     _rotCircY = new SLNode(_circG, "Rotation Circle Y");
     _rotCircY->castsShadows(false);
     _diskG    = new SLDisk(nullptr, 1.0f, SLVec3f::AXISZ, 36U, true, "Rotation Disk Y", _matGT);
     _rotDiskY = new SLNode(_diskG, "Rotation Disk Y");
     _rotDiskY->castsShadows(false);
     _circB    = new SLCircle(nullptr, "Rotation Circle Mesh Z", _matB);
     _rotCircZ = new SLNode(_circB, "Rotation Circle Z");
     _rotCircZ->castsShadows(false);
     _diskB    = new SLDisk(nullptr, 1.0f, SLVec3f::AXISZ, 36U, true, "Rotation Disk Z", _matBT);
     _rotDiskZ = new SLNode(_diskB, "Rotation Disk Z");
     _rotDiskZ->castsShadows(false);
  
     SLNode* rotationGizmosX = new SLNode("Rotation Gizmos X");
     rotationGizmosX->addChild(_rotCircX);
     rotationGizmosX->addChild(_rotDiskX);
  
     SLNode* rotationGizmosY = new SLNode("Rotation Gizmos Y");
     rotationGizmosY->addChild(_rotCircY);
     rotationGizmosY->addChild(_rotDiskY);
  
     SLNode* rotationGizmosZ = new SLNode("Rotation Gizmos Z");
     rotationGizmosZ->addChild(_rotCircZ);
     rotationGizmosZ->addChild(_rotDiskZ);
  
     _selectedGizmo = nullptr;
  
     rotationGizmosX->rotate(90.0f, SLVec3f(0.0f, 1.0f, 0.0f));
     rotationGizmosY->rotate(-90.0f, SLVec3f(1.0f, 0.0f, 0.0f));
  
     _transGizmos = new SLNode("Translation Gizmos");
     _transGizmos->addChild(transAxisX);
     _transGizmos->addChild(_transLineX);
     _transGizmos->addChild(transAxisY);
     _transGizmos->addChild(_transLineY);
     _transGizmos->addChild(transAxisZ);
     _transGizmos->addChild(_transLineZ);
  
     _scaleGizmos = new SLNode("Scale Gizmos");
     _scaleGizmos->addChild(_scaleCirc);
     _scaleGizmos->addChild(_scaleDisk);
  
     _rotGizmos = new SLNode("Rotation Gizmos");
     _rotGizmos->addChild(rotationGizmosX);
     _rotGizmos->addChild(rotationGizmosY);
     _rotGizmos->addChild(rotationGizmosZ);
  
     _gizmosNode = new SLNode("Gizmos");
     _gizmosNode->addChild(_transGizmos);
     _gizmosNode->addChild(_scaleGizmos);
     _gizmosNode->addChild(_rotGizmos);
     this->addChild(_gizmosNode);
  
     this->updateAABBRec(true);
  
     setDrawBitRecursive(SL_DB_OVERDRAW, _gizmosNode, true);
  
     _sv->s()->eventHandlers().push_back(this);
 }

◆ ~SLTransformNode()

SLTransformNode::~SLTransformNode ( )

override

Destructor for a transform node. Because a transform node will be added and removed on the fly to the scenegraph it is the owner of its meshes (SLMesh), materials (SLMaterial) and shader programs (SLGLProgram). It has to delete them in here.

Definition at line 165 of file SLTransformNode.cpp.

 {
     // delete gizmos
     _gizmosNode->deleteChildren();
     this->deleteChild(_gizmosNode);
     this->deleteChildren();
     
     // delete all materials and meshes
     delete _matR;
     delete _matG;
     delete _matB;
     delete _matY;
     delete _matRT;
     delete _matGT;
     delete _matBT;
     delete _matYT;
     delete _axisR;
     delete _axisG;
     delete _axisB;
     delete _lineR;
     delete _lineG;
     delete _lineB;
     delete _circR;
     delete _circG;
     delete _circB;
     delete _circY;
     delete _diskR;
     delete _diskG;
     delete _diskB;
     delete _diskY;
 }

Member Function Documentation

◆ editMode() [1/2]

SLNodeEditMode SLTransformNode::editMode ( )

inline

Definition at line 56 of file SLTransformNode.h.

56 { return _editMode; }

◆ editMode() [2/2]

void SLTransformNode::editMode ( SLNodeEditMode editMode )

virtual

Setter function for the edit mode. It shows or hides the appropriate gizmo meshes for the mouse interaction.

Parameters

editMode New edit mode to switch to.

Definition at line 202 of file SLTransformNode.cpp.

 {
     _editMode = editMode;
  
     if (_editMode)
     {
         if (_targetNode)
         {
             _gizmosNode->translation(_targetNode->updateAndGetWM().translation());
  
             SLVec2f p1 = _sv->camera()->projectWorldToNDC(SLVec4f(_gizmosNode->translationWS()));
             SLVec2f p2 = _sv->camera()->projectWorldToNDC(SLVec4f(_gizmosNode->translationWS() +
                                                                   _sv->camera()->upWS().normalize()));
  
             float actualHeight = (p1 - p2).length();
             float targetHeight = 0.2f; // % of screen that gizmos should occupy
             float scaleFactor  = targetHeight / actualHeight;
  
             _gizmosNode->scale(scaleFactor / _gizmoScale);
             _gizmoScale = scaleFactor;
  
             setDrawBitRecursive(SL_DB_HIDDEN, _gizmosNode, true);
             _gizmosNode->drawBits()->set(SL_DB_HIDDEN, false);
  
             switch (_editMode)
             {
                 case NodeEditMode_Translate:
                 {
                     setDrawBitRecursive(SL_DB_HIDDEN, _transGizmos, false);
                 }
                 break;
  
                 case NodeEditMode_Scale:
                 {
                     if (_sv->camera())
                     {
                         // TODO(dgj1): this behaviour is that of a billboard... introduce in SLProject?
                         lookAt(_scaleGizmos, _sv->camera());
                     }
  
                     setDrawBitRecursive(SL_DB_HIDDEN, _scaleGizmos, false);
                 }
                 break;
  
                 case NodeEditMode_Rotate:
                 {
                     setDrawBitRecursive(SL_DB_HIDDEN, _rotGizmos, false);
                 }
                 break;
  
                 case NodeEditMode_None:
                 default:
                 {
                 }
                 break;
             }
         }
     }
     else
     {
         setDrawBitRecursive(SL_DB_HIDDEN, _gizmosNode, true);
         _editMode = NodeEditMode_None;
     }
 }

◆ getClosestPointOnAxis()

bool SLTransformNode::getClosestPointOnAxis	(	const SLVec3f &	pickRayO,
		const SLVec3f &	pickRayDir,
		const SLVec3f &	axisRayO,
		const SLVec3f &	axisRayDir,
		SLVec3f &	axisPoint
	)

private

Definition at line 648 of file SLTransformNode.cpp.

 {
     bool result = false;
  
     // Check if lines are parallel
     SLVec3f cross;
     cross.cross(pickRayDir, axisRayDir);
     float den = cross.lengthSqr();
  
     if (den > FLT_EPSILON)
     {
         SLVec3f diffO = axisRayO - pickRayO;
  
         // clang-format off
         SLMat3f m = SLMat3f(diffO.x, pickRayDir.x, cross.x,
                             diffO.y, pickRayDir.y, cross.y,
                             diffO.z, pickRayDir.z, cross.z);
         // clang-format on
  
         float det = m.det();
         float t   = det / den;
  
         axisPoint = axisRayO + (axisRayDir * t);
  
         result = true;
     }
  
     return result;
 }

◆ getClosestPointsBetweenRays()

bool SLTransformNode::getClosestPointsBetweenRays	(	const SLVec3f &	ray1O,
		const SLVec3f &	ray1Dir,
		const SLVec3f &	ray2O,
		const SLVec3f &	ray2Dir,
		SLVec3f &	ray1P,
		float &	t1,
		SLVec3f &	ray2P,
		float &	t2
	)

private

Definition at line 604 of file SLTransformNode.cpp.

 {
     bool result = false;
  
     // Check if lines are parallel
     SLVec3f cross;
     cross.cross(ray1Dir, ray2Dir);
     float den = cross.lengthSqr();
  
     // printf("den: %f, sqrt(den): %f\n", den, cross.length());
  
     if (den > FLT_EPSILON)
     {
         SLVec3f diffO = ray2O - ray1O;
  
         // clang-format off
         SLMat3f m1   = SLMat3f(diffO.x, ray2Dir.x, cross.x,
                                diffO.y, ray2Dir.y, cross.y,
                                diffO.z, ray2Dir.z, cross.z);
         float   det1 = m1.det();
         t1   = det1 / den;
         ray1P        = ray1O + (ray1Dir * t1);
  
         SLMat3f m2   = SLMat3f(diffO.x, ray1Dir.x, cross.x,
                                diffO.y, ray1Dir.y, cross.y,
                                diffO.z, ray1Dir.z, cross.z);
         float   det2 = m2.det();
         t2   = det2 / den;
         ray2P        = ray2O + (ray2Dir * t2);
         // clang-format on
  
         result = true;
     }
  
     return result;
 }

◆ isCCW()

bool SLTransformNode::isCCW	(	const SLVec2f &	a,
		const SLVec2f &	b,
		const SLVec2f &	c
	)

private

Definition at line 725 of file SLTransformNode.cpp.

 {
     SLVec2f ac = a - c;
     SLVec2f bc = b - c;
  
     float signedArea = 0.5f * (bc.x * ac.y - ac.x * bc.y);
     bool  result     = (signedArea > 0.0f);
  
     return result;
 }

◆ lookAt()

void SLTransformNode::lookAt	(	SLNode *	node,
		SLCamera *	camera
	)

private

Definition at line 748 of file SLTransformNode.cpp.

 {
     // TODO(dgj1): this is a lookat function, because the one in SLNode doesn't work
     // or maybe I don't understand how to use it
     // TODO(dgj1): this is only correct for the case that the node doesn't have a scale
     SLVec3f nodePos    = node->translationWS();
     SLVec3f nodeTarget = camera->translationWS();
     SLVec3f nodeDir    = (nodePos - nodeTarget).normalize();
     SLVec3f up         = SLVec3f(0.0f, 1.0f, 0.0f);
     SLVec3f nodeRight  = (up ^ nodeDir).normalize();
     SLVec3f nodeUp     = (nodeDir ^ nodeRight).normalize();
  
     SLVec3f nodeTranslation = node->om().translation();
  
     // clang-format off
     SLMat4f updatedOm = SLMat4f(nodeRight.x, nodeUp.x, nodeDir.x, nodeTranslation.x,
                                 nodeRight.y, nodeUp.y, nodeDir.y, nodeTranslation.y,
                                 nodeRight.z, nodeUp.z, nodeDir.z, nodeTranslation.z,
                                        0.0f,     0.0f,      0.0f,       1.0f);
     // clang-format on
  
     node->om(updatedOm);
 }

◆ onMouseDown()

SLbool SLTransformNode::onMouseDown	(	SLMouseButton	button,
		SLint	x,
		SLint	y,
		SLKey	mod
	)

overridevirtual

onMouseDown event handler during editing interaction

Reimplemented from SLEventHandler.

Definition at line 268 of file SLTransformNode.cpp.

 {
     bool result = false;
  
     if (_editMode && _selectedGizmo)
     {
         result       = true;
         _mouseIsDown = true;
     }
  
     return result;
 }

◆ onMouseMove()

SLbool SLTransformNode::onMouseMove	(	SLMouseButton	button,
		SLint	x,
		SLint	y,
		SLKey	mod
	)

overridevirtual

onMouseMove event handler during editing interaction

Reimplemented from SLEventHandler.

Definition at line 309 of file SLTransformNode.cpp.

 {
     bool result = false;
  
     if (_editMode)
     {
         if (_sv->camera())
         {
             switch (_editMode)
             {
                 case NodeEditMode_Translate:
                 {
                     if (_targetNode)
                     {
                         SLRay pickRay(_sv);
                         _sv->camera()->eyeToPixelRay((SLfloat)x, (SLfloat)y, &pickRay);
  
                         SLVec3f pickRayPoint;
                         SLVec3f axisPoint;
                         if (_mouseIsDown)
                         {
                             float t1, t2;
                             if (getClosestPointsBetweenRays(pickRay.origin,
                                                             pickRay.dir,
                                                             _selectedGizmo->translationWS(),
                                                             _selectedGizmo->forwardWS(),
                                                             pickRayPoint,
                                                             t1,
                                                             axisPoint,
                                                             t2))
                             {
                                 SLVec3f translationDiff = axisPoint - _hitCoordinate;
                                 _targetNode->translate(translationDiff, TS_world);
                                 _gizmosNode->translation(_targetNode->updateAndGetWM().translation());
                                 _hitCoordinate = axisPoint;
                             }
  
                             result = true;
                         }
                         else
                         {
                             _selectedGizmo = nullptr;
  
                             _transLineX->drawBits()->set(SL_DB_HIDDEN, true);
                             _transLineY->drawBits()->set(SL_DB_HIDDEN, true);
                             _transLineZ->drawBits()->set(SL_DB_HIDDEN, true);
  
                             float nodeToCameraDist = (pickRay.origin - _transLineX->translationWS()).length();
  
                             float   dist = FLT_MAX;
                             SLVec3f axisPointCand;
                             float   t1, t2;
                             float   minDistToOrigin = std::min(nodeToCameraDist * 0.1f, 1.0f);
                             if (getClosestPointsBetweenRays(pickRay.origin,
                                                             pickRay.dir,
                                                             _transLineX->translationWS(),
                                                             _transLineX->forwardWS(),
                                                             pickRayPoint,
                                                             t1,
                                                             axisPointCand,
                                                             t2))
                             {
                                 float distCand = (axisPointCand - pickRayPoint).length();
  
                                 if (distCand < dist && distCand < (_gizmoScale * 0.1f) && t1 > minDistToOrigin)
                                 {
                                     dist           = distCand;
                                     _selectedGizmo = _transLineX;
                                     axisPoint      = axisPointCand;
                                 }
                             }
  
                             if (getClosestPointsBetweenRays(pickRay.origin,
                                                             pickRay.dir,
                                                             _transLineY->translationWS(),
                                                             _transLineY->forwardWS(),
                                                             pickRayPoint,
                                                             t1,
                                                             axisPointCand,
                                                             t2))
                             {
                                 float distCand = (axisPointCand - pickRayPoint).length();
  
                                 if (distCand < dist && distCand < (_gizmoScale * 0.1f) && t1 > minDistToOrigin)
                                 {
                                     dist           = distCand;
                                     _selectedGizmo = _transLineY;
                                     axisPoint      = axisPointCand;
                                 }
                             }
  
                             if (getClosestPointsBetweenRays(pickRay.origin,
                                                             pickRay.dir,
                                                             _transLineZ->translationWS(),
                                                             _transLineZ->forwardWS(),
                                                             pickRayPoint,
                                                             t1,
                                                             axisPointCand,
                                                             t2))
                             {
                                 float distCand = (axisPointCand - pickRayPoint).length();
  
                                 if (distCand < dist && distCand < (_gizmoScale * 0.1f) && t1 > minDistToOrigin)
                                 {
                                     dist           = distCand;
                                     _selectedGizmo = _transLineZ;
                                     axisPoint      = axisPointCand;
                                 }
                             }
  
                             if (_selectedGizmo)
                             {
                                 // printf("Selected gizmo %s with dist %f\n", _selectedGizmo->name().c_str(), dist);
                                 _selectedGizmo->drawBits()->set(SL_DB_HIDDEN, false);
                                 _hitCoordinate = axisPoint;
                             }
                         }
                     }
                 }
                 break;
  
                 case NodeEditMode_Scale:
                 {
                     // TODO(dgj1): this behaviour is that of a billboard... introduce in SLProject?
                     lookAt(_scaleGizmos, _sv->camera());
  
                     SLRay pickRay(_sv);
                     _sv->camera()->eyeToPixelRay((SLfloat)x, (SLfloat)y, &pickRay);
  
                     if (_targetNode)
                     {
                         if (_mouseIsDown)
                         {
                             float t = FLT_MAX;
                             if (rayPlaneIntersect(pickRay.origin,
                                                   pickRay.dir,
                                                   _selectedGizmo->translationWS(),
                                                   _selectedGizmo->forwardWS(),
                                                   t))
                             {
                                 SLVec3f intersectionPointWS = pickRay.origin + pickRay.dir * t;
                                 SLVec3f intersectionPoint   = _selectedGizmo->updateAndGetWMI() * intersectionPointWS;
  
                                 float newRadius   = (intersectionPoint - _selectedGizmo->translationOS()).length();
                                 float oldRadius   = (_hitCoordinate - _selectedGizmo->translationOS()).length();
                                 float scaleFactor = newRadius / oldRadius;
  
                                 _targetNode->scale(scaleFactor);
                                 _gizmoScale *= scaleFactor;
                                 _gizmosNode->scale(scaleFactor);
                             }
  
                             result = true;
                         }
                         else
                         {
                             _selectedGizmo = nullptr;
  
                             float t = FLT_MAX;
                             if (rayDiscIntersect(pickRay.origin,
                                                  pickRay.dir,
                                                  _scaleCirc->translationWS(),
                                                  _scaleCirc->forwardWS(),
                                                  _gizmoScale,
                                                  t))
                             {
                                 _selectedGizmo = _scaleCirc;
  
                                 SLVec3f intersectionPointWS = pickRay.origin + pickRay.dir * t;
                                 _hitCoordinate              = _scaleCirc->updateAndGetWMI() * intersectionPointWS;
  
                                 _scaleDisk->drawBits()->set(SL_DB_HIDDEN, false);
                             }
                             else
                             {
                                 _scaleDisk->drawBits()->set(SL_DB_HIDDEN, true);
                             }
                         }
                     }
                 }
                 break;
  
                 case NodeEditMode_Rotate:
                 {
                     if (_targetNode)
                     {
                         SLRay pickRay(_sv);
                         _sv->camera()->eyeToPixelRay((SLfloat)x, (SLfloat)y, &pickRay);
  
                         if (_mouseIsDown)
                         {
                             float t = FLT_MAX;
                             if (rayPlaneIntersect(pickRay.origin, pickRay.dir, _selectedGizmo->translationWS(), _selectedGizmo->forwardWS(), t))
                             {
                                 SLVec3f intersectionPointWS = pickRay.origin + pickRay.dir * t;
                                 SLVec3f intersectionPoint   = _selectedGizmo->updateAndGetWMI() * intersectionPointWS;
                                 SLVec3f rotationStartVec    = (_hitCoordinate - _selectedGizmo->translationOS()).normalize();
                                 SLVec3f rotationVec         = (intersectionPoint - _selectedGizmo->translationOS()).normalize();
  
                                 float angle = RAD2DEG * acos(rotationVec * rotationStartVec);
  
                                 if (angle > FLT_EPSILON || angle < -FLT_EPSILON)
                                 {
                                     // determine if we have to rotate ccw or cw
                                     if (!isCCW(SLVec2f(_selectedGizmo->translationOS().x, _selectedGizmo->translationOS().y),
                                                SLVec2f(_hitCoordinate.x, _hitCoordinate.y),
                                                SLVec2f(intersectionPoint.x, intersectionPoint.y)))
                                     {
                                         angle = -angle;
                                     }
  
                                     _targetNode->rotate(angle, _selectedGizmo->forwardWS().normalize(), TS_world);
  
                                     _hitCoordinate = intersectionPoint;
                                 }
                             }
  
                             result = true;
                         }
                         else
                         {
                             _rotDiskX->drawBits()->set(SL_DB_HIDDEN, true);
                             _rotDiskY->drawBits()->set(SL_DB_HIDDEN, true);
                             _rotDiskZ->drawBits()->set(SL_DB_HIDDEN, true);
  
                             _selectedGizmo = nullptr;
  
                             float t     = FLT_MAX;
                             float tCand = FLT_MAX;
                             if (rayDiscIntersect(pickRay.origin,
                                                  pickRay.dir,
                                                  _rotDiskX->translationWS(),
                                                  _rotDiskX->forwardWS(),
                                                  _gizmoScale,
                                                  tCand))
                             {
                                 _selectedGizmo = _rotDiskX;
                                 t              = tCand;
                             }
  
                             if (rayDiscIntersect(pickRay.origin,
                                                  pickRay.dir,
                                                  _rotDiskY->translationWS(),
                                                  _rotDiskY->forwardWS(),
                                                  _gizmoScale,
                                                  tCand))
                             {
                                 if (tCand < t)
                                 {
                                     _selectedGizmo = _rotDiskY;
                                     t              = tCand;
                                 }
                             }
  
                             if (rayDiscIntersect(pickRay.origin,
                                                  pickRay.dir,
                                                  _rotDiskZ->translationWS(),
                                                  _rotDiskZ->forwardWS(),
                                                  _gizmoScale,
                                                  tCand))
                             {
                                 if (tCand < t)
                                 {
                                     _selectedGizmo = _rotDiskZ;
                                     t              = tCand;
                                 }
                             }
  
                             if (_selectedGizmo)
                             {
                                 SLVec3f intersectionPointWS = pickRay.origin + pickRay.dir * t;
                                 _hitCoordinate              = _selectedGizmo->updateAndGetWMI() * intersectionPointWS;
  
                                 _selectedGizmo->drawBits()->set(SL_DB_HIDDEN, false);
                             }
                         }
                     }
                 }
                 break;
  
                 case NodeEditMode_None:
                 default:
                 {
                 }
                 break;
             }
         }
     }
  
     return result;
 }

◆ onMouseUp()

SLbool SLTransformNode::onMouseUp	(	SLMouseButton	button,
		SLint	x,
		SLint	y,
		SLKey	mod
	)

overridevirtual

onMouseUp event handler during editing interaction

Reimplemented from SLEventHandler.

Definition at line 285 of file SLTransformNode.cpp.

 {
     bool result = false;
  
     if (_editMode && _mouseIsDown)
     {
         result = true;
  
         if (_targetNode)
         {
             _gizmosNode->translation(_targetNode->updateAndGetWM().translation());
         }
  
         _selectedGizmo = nullptr;
         _mouseIsDown   = false;
     }
  
     return result;
 }

◆ rayDiscIntersect()

bool SLTransformNode::rayDiscIntersect	(	const SLVec3f &	rayO,
		const SLVec3f &	rayDir,
		const SLVec3f &	discO,
		const SLVec3f &	discN,
		const float &	distR,
		float &	t
	)

private

Definition at line 682 of file SLTransformNode.cpp.

 {
     bool result = false;
  
     if (rayPlaneIntersect(rayO, rayDir, discO, discN, t))
     {
         SLVec3f intersectPoint = rayO + rayDir * t;
         SLVec3f discPointDist  = intersectPoint - discO;
  
         result = (discPointDist.length() <= discR);
     }
  
     return result;
 }

◆ rayPlaneIntersect()

bool SLTransformNode::rayPlaneIntersect	(	const SLVec3f &	rayO,
		const SLVec3f &	rayDir,
		const SLVec3f &	discO,
		const SLVec3f &	discN,
		float &	t
	)

private

Definition at line 702 of file SLTransformNode.cpp.

 {
     bool result = false;
  
     float den = planeN * rayDir;
     if (den > FLT_EPSILON || den < -FLT_EPSILON)
     {
         SLVec3f oDiff = planeO - rayO;
         t             = (oDiff * planeN) / den;
  
         result = (t >= 0);
     }
  
     return result;
 }

◆ setDrawBitRecursive()

void SLTransformNode::setDrawBitRecursive	(	SLuint	bit,
		SLNode *	node,
		bool	value
	)

private

Definition at line 738 of file SLTransformNode.cpp.

 {
     node->drawBits()->set(bit, value);
  
     for (SLNode* child : node->children())
     {
         setDrawBitRecursive(bit, child, value);
     }
 }

◆ targetNode()

SLNode* SLTransformNode::targetNode ( )

inline

Definition at line 55 of file SLTransformNode.h.

55 { return _targetNode; }

Member Data Documentation

◆ _axisB

SLMesh* SLTransformNode::_axisB = nullptr

private

Definition at line 74 of file SLTransformNode.h.

◆ _axisG

SLMesh* SLTransformNode::_axisG = nullptr

private

Definition at line 73 of file SLTransformNode.h.

◆ _axisR

SLMesh* SLTransformNode::_axisR = nullptr

private

Definition at line 72 of file SLTransformNode.h.

◆ _circB

SLMesh* SLTransformNode::_circB = nullptr

private

Definition at line 80 of file SLTransformNode.h.

◆ _circG

SLMesh* SLTransformNode::_circG = nullptr

private

Definition at line 79 of file SLTransformNode.h.

◆ _circR

SLMesh* SLTransformNode::_circR = nullptr

private

Definition at line 78 of file SLTransformNode.h.

◆ _circY

SLMesh* SLTransformNode::_circY = nullptr

private

Definition at line 81 of file SLTransformNode.h.

◆ _diskB

SLMesh* SLTransformNode::_diskB = nullptr

private

Definition at line 84 of file SLTransformNode.h.

◆ _diskG

SLMesh* SLTransformNode::_diskG = nullptr

private

Definition at line 83 of file SLTransformNode.h.

◆ _diskR

SLMesh* SLTransformNode::_diskR = nullptr

private

Definition at line 82 of file SLTransformNode.h.

◆ _diskY

SLMesh* SLTransformNode::_diskY = nullptr

private

Definition at line 85 of file SLTransformNode.h.

◆ _editMode

SLNodeEditMode SLTransformNode::_editMode

private

Definition at line 62 of file SLTransformNode.h.

◆ _gizmoScale

float SLTransformNode::_gizmoScale

private

Definition at line 88 of file SLTransformNode.h.

◆ _gizmosNode

SLNode* SLTransformNode::_gizmosNode = nullptr

private

Definition at line 113 of file SLTransformNode.h.

◆ _hitCoordinate

SLVec3f SLTransformNode::_hitCoordinate

private

Definition at line 89 of file SLTransformNode.h.

◆ _lineB

SLMesh* SLTransformNode::_lineB = nullptr

private

Definition at line 77 of file SLTransformNode.h.

◆ _lineG

SLMesh* SLTransformNode::_lineG = nullptr

private

Definition at line 76 of file SLTransformNode.h.

◆ _lineR

SLMesh* SLTransformNode::_lineR = nullptr

private

Definition at line 75 of file SLTransformNode.h.

◆ _matB

SLMaterial* SLTransformNode::_matB = nullptr

private

Definition at line 66 of file SLTransformNode.h.

◆ _matBT

SLMaterial* SLTransformNode::_matBT = nullptr

private

Definition at line 70 of file SLTransformNode.h.

◆ _matG

SLMaterial* SLTransformNode::_matG = nullptr

private

Definition at line 65 of file SLTransformNode.h.

◆ _matGT

SLMaterial* SLTransformNode::_matGT = nullptr

private

Definition at line 69 of file SLTransformNode.h.

◆ _matR

SLMaterial* SLTransformNode::_matR = nullptr

private

Definition at line 64 of file SLTransformNode.h.

◆ _matRT

SLMaterial* SLTransformNode::_matRT = nullptr

private

Definition at line 68 of file SLTransformNode.h.

◆ _matY

SLMaterial* SLTransformNode::_matY = nullptr

private

Definition at line 67 of file SLTransformNode.h.

◆ _matYT

SLMaterial* SLTransformNode::_matYT = nullptr

private

Definition at line 71 of file SLTransformNode.h.

◆ _mouseIsDown

bool SLTransformNode::_mouseIsDown

private

Definition at line 87 of file SLTransformNode.h.

◆ _rotCircX

SLNode* SLTransformNode::_rotCircX = nullptr

private

Definition at line 105 of file SLTransformNode.h.

◆ _rotCircY

SLNode* SLTransformNode::_rotCircY = nullptr

private

Definition at line 107 of file SLTransformNode.h.

◆ _rotCircZ

SLNode* SLTransformNode::_rotCircZ = nullptr

private

Definition at line 109 of file SLTransformNode.h.

◆ _rotDiskX

SLNode* SLTransformNode::_rotDiskX = nullptr

private

Definition at line 106 of file SLTransformNode.h.

◆ _rotDiskY

SLNode* SLTransformNode::_rotDiskY = nullptr

private

Definition at line 108 of file SLTransformNode.h.

◆ _rotDiskZ

SLNode* SLTransformNode::_rotDiskZ = nullptr

private

Definition at line 110 of file SLTransformNode.h.

◆ _rotGizmos

SLNode* SLTransformNode::_rotGizmos = nullptr

private

Definition at line 104 of file SLTransformNode.h.

◆ _scaleCirc

SLNode* SLTransformNode::_scaleCirc = nullptr

private

Definition at line 101 of file SLTransformNode.h.

◆ _scaleDisk

SLNode* SLTransformNode::_scaleDisk = nullptr

private

Definition at line 100 of file SLTransformNode.h.

◆ _scaleGizmos

SLNode* SLTransformNode::_scaleGizmos = nullptr

private

Definition at line 99 of file SLTransformNode.h.

◆ _selectedGizmo

SLNode* SLTransformNode::_selectedGizmo = nullptr

private

Definition at line 90 of file SLTransformNode.h.

◆ _sv

SLSceneView* SLTransformNode::_sv = nullptr

private

Definition at line 59 of file SLTransformNode.h.

◆ _targetNode

SLNode* SLTransformNode::_targetNode = nullptr

private

Definition at line 60 of file SLTransformNode.h.

◆ _transGizmos

SLNode* SLTransformNode::_transGizmos = nullptr

private

Definition at line 93 of file SLTransformNode.h.

◆ _transLineX

SLNode* SLTransformNode::_transLineX = nullptr

private

Definition at line 94 of file SLTransformNode.h.

◆ _transLineY

SLNode* SLTransformNode::_transLineY = nullptr

private

Definition at line 95 of file SLTransformNode.h.

◆ _transLineZ

SLNode* SLTransformNode::_transLineZ = nullptr

private

Definition at line 96 of file SLTransformNode.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SLTransformNode()

◆ ~SLTransformNode()

Member Function Documentation

◆ editMode() [1/2]

◆ editMode() [2/2]

◆ getClosestPointOnAxis()

◆ getClosestPointsBetweenRays()

◆ isCCW()

◆ lookAt()

◆ onMouseDown()

◆ onMouseMove()

◆ onMouseUp()

◆ rayDiscIntersect()

◆ rayPlaneIntersect()

◆ setDrawBitRecursive()

◆ targetNode()

Member Data Documentation

◆ _axisB

◆ _axisG

◆ _axisR

◆ _circB

◆ _circG

◆ _circR

◆ _circY

◆ _diskB

◆ _diskG

◆ _diskR

◆ _diskY

◆ _editMode

◆ _gizmoScale

◆ _gizmosNode

◆ _hitCoordinate

◆ _lineB

◆ _lineG

◆ _lineR

◆ _matB

◆ _matBT

◆ _matG

◆ _matGT

◆ _matR

◆ _matRT

◆ _matY

◆ _matYT

◆ _mouseIsDown

◆ _rotCircX

◆ _rotCircY

◆ _rotCircZ

◆ _rotDiskX

◆ _rotDiskY

◆ _rotDiskZ

◆ _rotGizmos

◆ _scaleCirc

◆ _scaleDisk

◆ _scaleGizmos

◆ _selectedGizmo

◆ _sv

◆ _targetNode

◆ _transGizmos

◆ _transLineX

◆ _transLineY

◆ _transLineZ