DigitalSpaces::DIOGRENode Struct Reference
[Ogre]

#include <OGREInterfaces.h>


Public Member Functions
const char *	GetName (void)
	Returns the name of the node.
DIOGRENode *	GetParent (void)
	Gets this node's parent (NULL if this is the root).
void	GetOrientation (out_Quaternionf *q)
	Returns a quaternion representing the nodes orientation.
void	SetOrientation (in_Quaternionf *q)
	Sets the orientation of this node via a quaternion.
void	SetOrientation (float w, float x, float y, float z)
	Sets the orientation of this node via quaternion parameters.
void	ResetOrientation (void)
	Resets the nodes orientation (local axes as world axes, no rotation).
void	SetPosition (in_Vector3f *pos)
	Sets the position of the node relative to it's parent.
void	SetPosition (float x, float y, float z)
	Sets the position of the node relative to it's parent.
void	GetPosition (out_Vector3f *vec)
	Gets the position of the node relative to it's parent.
void	SetScale (in_Vector3f *scale)
	Sets the scaling factor applied to this node.
void	SetScale (float x, float y, float z)
	Sets the scaling factor applied to this node.
void	GetScale (out_Vector3f *vec)
	Gets the scaling factor of this node.
void	SetInheritScale (bool inherit)
	Tells the node whether it should inherit scaling factors from it's parent node.
bool	GetInheritScale (void)
	Returns true if this node is affected by scaling factors applied to the parent node.
void	Scale (in_Vector3f *scale)
	Scales the node, combining it's current scale with the passed in scaling factor.
void	Scale (float x, float y, float z)
	Scales the node, combining it's current scale with the passed in scaling factor.
void	Translate (in_Vector3f *d)
	Moves the node along the cartesian axes.
void	Translate (in_Vector3f *d, TransformSpace relativeTo)
void	Translate (float x, float y, float z)
	Moves the node along the cartesian axes.
void	Translate (float x, float y, float z, TransformSpace relativeTo)
void	Translate (in_Matrix3f axes, in_Vector3f move)
	Moves the node along arbitrary axes.
void	Translate (in_Matrix3f axes, in_Vector3f move, TransformSpace relativeTo)
void	Translate (in_Matrix3f *axes, float x, float y, float z)
	Moves the node along arbitrary axes.
void	Translate (in_Matrix3f *axes, float x, float y, float z, TransformSpace relativeTo)
void	RollRadian (const float angle)
	Rotate the node around the Z-axis.
void	RollRadian (const float angle, TransformSpace relativeTo)
void	RollDegree (const float angle)
void	RollDegree (const float angle, TransformSpace relativeTo)
void	PitchRadian (const float angle)
	Rotate the node around the X-axis.
void	PitchRadian (const float angle, TransformSpace relativeTo)
void	PitchDegree (const float angle)
void	PitchDegree (const float angle, TransformSpace relativeTo)
void	YawRadian (const float angle)
	Rotate the node around the Y-axis.
void	YawRadian (const float angle, TransformSpace relativeTo)
void	YawDegree (const float angle)
void	YawDegree (const float angle, TransformSpace relativeTo)
void	RotateRadian (in_Vector3f *axis, const float angle)
	Rotate the node around an arbitrary axis.
void	RotateRadian (in_Vector3f *axis, const float angle, TransformSpace relativeTo)
void	RotateDegree (in_Vector3f *axis, const float angle)
void	RotateDegree (in_Vector3f *axis, const float angle, TransformSpace relativeTo)
void	Rotate (in_Quaternionf *q)
	Rotate the node around an aritrary axis using a Quarternion.
void	Rotate (in_Quaternionf *q, TransformSpace relativeTo)
void	GetLocalAxes (out_Matrix3f *mtx)
	Gets a matrix whose columns are the local axes based on the nodes orientation relative to it's parent.
DIOGRENode *	CreateChild (void)
	Creates an unnamed new Node as a child of this node.
DIOGRENode *	CreateChild (in_Vector3f translate, in_Quaternionf rotate)
DIOGRENode *	CreateChild (const char *name)
	Creates a new named Node as a child of this node.
DIOGRENode *	CreateChild (const char name, in_Vector3f translate, in_Quaternionf *rotate)
void	AddChild (DIOGRENode *child)
	Adds a (precreated) child scene node to this node.
unsigned short	NumChildren (void)
	Reports the number of child nodes under this one.
DIOGRENode *	GetChildNode (unsigned short index)
	Gets a pointer to a child node.
DIOGRENode *	GetChildNode (const char *name)
	Gets a pointer to a named child node.
DIOGRENode *	RemoveChild (unsigned short index)
	Retrieves an iterator for efficiently looping through all children of this node.
DIOGRENode *	RemoveChild (DIOGRENode *child)
	Drops the specified child from this node.
DIOGRENode *	RemoveChild (const char *name)
	Drops the named child from this node.
void	RemoveAllChildren (void)
	Removes all child Nodes attached to this node.
void	SetInitialState (void)
	Sets the current transform of this node to be the 'initial state' ie that position / orientation / scale to be used as a basis for delta values used in keyframe animation.
void	ResetToInitialState (void)
	Resets the position / orientation / scale of this node to it's initial state, see setInitialState for more info.
void	GetInitialPosition (out_Vector3f *vec)
	Gets the initial position of this node, see setInitialState for more info.
void	GetInitialOrientation (out_Quaternionf *vec)
	Gets the initial orientation of this node, see setInitialState for more info.
void	GetInitialScale (out_Vector3f *vec)
	Gets the initial position of this node, see setInitialState for more info.
void	NeedUpdate ()
	To be called in the event of transform changes to this node that require it's recalculation.
void	RequestUpdate (DIOGRENode *child)
	Called by children to notify their parent that they need an update.
void	CancelUpdate (DIOGRENode *child)
	Called by children to notify their parent that they no longer need an update.

Member Function Documentation

const char* DigitalSpaces::DIOGRENode::GetName ( void )

Returns the name of the node.

DIOGRENode* DigitalSpaces::DIOGRENode::GetParent ( void )

Gets this node's parent (NULL if this is the root).

void DigitalSpaces::DIOGRENode::GetOrientation ( out_Quaternionf * q )

Returns a quaternion representing the nodes orientation.

void DigitalSpaces::DIOGRENode::SetOrientation ( in_Quaternionf * q )

Sets the orientation of this node via a quaternion.

void DigitalSpaces::DIOGRENode::SetOrientation	(	float	w,
		float	x,
		float	y,
		float	z
	)

Sets the orientation of this node via quaternion parameters.

void DigitalSpaces::DIOGRENode::ResetOrientation ( void )

Resets the nodes orientation (local axes as world axes, no rotation).

void DigitalSpaces::DIOGRENode::SetPosition ( in_Vector3f * pos )

Sets the position of the node relative to it's parent.

void DigitalSpaces::DIOGRENode::SetPosition	(	float	x,
		float	y,
		float	z
	)

Sets the position of the node relative to it's parent.

void DigitalSpaces::DIOGRENode::GetPosition ( out_Vector3f * vec )

Gets the position of the node relative to it's parent.

void DigitalSpaces::DIOGRENode::SetScale ( in_Vector3f * scale )

Sets the scaling factor applied to this node.

Remarks:: Scaling factors, unlike other transforms, are not always inherited by child nodes. Whether or not scalings affect both the size and position of the child nodes depends on the setInheritScale option of the child. In some cases you want a scaling factor of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative size and position based on the parent's size), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own size and relative position). The default is to inherit as with other transforms.

: Note that like rotations, scalings are oriented around the node's origin.

void DigitalSpaces::DIOGRENode::SetScale	(	float	x,
		float	y,
		float	z
	)

Sets the scaling factor applied to this node.

Remarks:: Scaling factors, unlike other transforms, are not always inherited by child nodes. Whether or not scalings affect both the size and position of the child nodes depends on the setInheritScale option of the child. In some cases you want a scaling factor of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative size and position based on the parent's size), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own size and relative position). The default is to inherit as with other transforms.

: Note that like rotations, scalings are oriented around the node's origin.

void DigitalSpaces::DIOGRENode::GetScale ( out_Vector3f * vec )

Gets the scaling factor of this node.

void DigitalSpaces::DIOGRENode::SetInheritScale ( bool inherit )

Tells the node whether it should inherit scaling factors from it's parent node.

Remarks:: Scaling factors, unlike other transforms, are not always inherited by child nodes. Whether or not scalings affect both the size and position of the child nodes depends on the setInheritScale option of the child. In some cases you want a scaling factor of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative size and position based on the parent's size), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own size and relative position). The default is to inherit as with other transforms.

Parameters:

inherit

If true, this node's scale and position will be affected by its parent's scale. If false, it will not be affected.

bool DigitalSpaces::DIOGRENode::GetInheritScale ( void )

Returns true if this node is affected by scaling factors applied to the parent node.

Remarks:: See setInheritScale for more info.

void DigitalSpaces::DIOGRENode::Scale ( in_Vector3f * scale )

Scales the node, combining it's current scale with the passed in scaling factor.

Remarks:: This method applies an extra scaling factor to the node's existing scale, (unlike setScale which overwrites it) combining it's current scale with the new one. E.g. calling this method twice with Vector3(2,2,2) would have the same effect as setScale(Vector3(4,4,4)) if the existing scale was 1.

: Note that like rotations, scalings are oriented around the node's origin.

void DigitalSpaces::DIOGRENode::Scale	(	float	x,
		float	y,
		float	z
	)

Scales the node, combining it's current scale with the passed in scaling factor.

Remarks:: This method applies an extra scaling factor to the node's existing scale, (unlike setScale which overwrites it) combining it's current scale with the new one. E.g. calling this method twice with Vector3(2,2,2) would have the same effect as setScale(Vector3(4,4,4)) if the existing scale was 1.

: Note that like rotations, scalings are oriented around the node's origin.

void DigitalSpaces::DIOGRENode::Translate ( in_Vector3f * d )

Moves the node along the cartesian axes.

: This method moves the node by the supplied vector along the world cartesian axes, i.e. along world x,y,z

Parameters:

	d	Vector with x,y,z values representing the translation.
	relativeTo	The space which this transform is relative to.

void DigitalSpaces::DIOGRENode::Translate	(	in_Vector3f *	d,
		TransformSpace	relativeTo
	)

void DigitalSpaces::DIOGRENode::Translate	(	float	x,
		float	y,
		float	z
	)

Moves the node along the cartesian axes.

: This method moves the node by the supplied vector along the world cartesian axes, i.e. along world x,y,z

Parameters:

	x
	y
	z	float x, y and z values representing the translation.
	relativeTo	The space which this transform is relative to.

void DigitalSpaces::DIOGRENode::Translate	(	float	x,
		float	y,
		float	z,
		TransformSpace	relativeTo
	)

void DigitalSpaces::DIOGRENode::Translate	(	in_Matrix3f *	axes,
		in_Vector3f *	move
	)

Moves the node along arbitrary axes.

Remarks:: This method translates the node by a vector which is relative to a custom set of axes.

Parameters:

	axes	A 3x3 Matrix containg 3 column vectors each representing the axes X, Y and Z respectively. In this format the standard cartesian axes would be expressed as: 1 0 0 0 1 0 0 0 1 i.e. the identity matrix.
	move	Vector relative to the axes above.
	relativeTo	The space which this transform is relative to.

void DigitalSpaces::DIOGRENode::Translate	(	in_Matrix3f *	axes,
		in_Vector3f *	move,
		TransformSpace	relativeTo
	)

void DigitalSpaces::DIOGRENode::Translate	(	in_Matrix3f *	axes,
		float	x,
		float	y,
		float	z
	)

Moves the node along arbitrary axes.

Remarks:: This method translates the node by a vector which is relative to a custom set of axes.

Parameters:

	axes	A 3x3 Matrix containg 3 column vectors each representing the axes X, Y and Z respectively. In this format the standard cartesian axes would be expressed as 1 0 0 0 1 0 0 0 1 i.e. the identity matrix.
	x,y,z	Translation components relative to the axes above.
	relativeTo	The space which this transform is relative to.

void DigitalSpaces::DIOGRENode::Translate	(	in_Matrix3f *	axes,
		float	x,
		float	y,
		float	z,
		TransformSpace	relativeTo
	)

void DigitalSpaces::DIOGRENode::RollRadian ( const float angle )

Rotate the node around the Z-axis.

void DigitalSpaces::DIOGRENode::RollRadian	(	const float	angle,
		TransformSpace	relativeTo
	)

void DigitalSpaces::DIOGRENode::RollDegree ( const float angle )

void DigitalSpaces::DIOGRENode::RollDegree	(	const float	angle,
		TransformSpace	relativeTo
	)

void DigitalSpaces::DIOGRENode::PitchRadian ( const float angle )

Rotate the node around the X-axis.

void DigitalSpaces::DIOGRENode::PitchRadian	(	const float	angle,
		TransformSpace	relativeTo
	)

void DigitalSpaces::DIOGRENode::PitchDegree ( const float angle )

void DigitalSpaces::DIOGRENode::PitchDegree	(	const float	angle,
		TransformSpace	relativeTo
	)

void DigitalSpaces::DIOGRENode::YawRadian ( const float angle )

Rotate the node around the Y-axis.

void DigitalSpaces::DIOGRENode::YawRadian	(	const float	angle,
		TransformSpace	relativeTo
	)

void DigitalSpaces::DIOGRENode::YawDegree ( const float angle )

void DigitalSpaces::DIOGRENode::YawDegree	(	const float	angle,
		TransformSpace	relativeTo
	)

void DigitalSpaces::DIOGRENode::RotateRadian	(	in_Vector3f *	axis,
		const float	angle
	)

Rotate the node around an arbitrary axis.

void DigitalSpaces::DIOGRENode::RotateRadian	(	in_Vector3f *	axis,
		const float	angle,
		TransformSpace	relativeTo
	)

void DigitalSpaces::DIOGRENode::RotateDegree	(	in_Vector3f *	axis,
		const float	angle
	)

void DigitalSpaces::DIOGRENode::RotateDegree	(	in_Vector3f *	axis,
		const float	angle,
		TransformSpace	relativeTo
	)

void DigitalSpaces::DIOGRENode::Rotate ( in_Quaternionf * q )

Rotate the node around an aritrary axis using a Quarternion.

void DigitalSpaces::DIOGRENode::Rotate	(	in_Quaternionf *	q,
		TransformSpace	relativeTo
	)

void DigitalSpaces::DIOGRENode::GetLocalAxes ( out_Matrix3f * mtx )

Gets a matrix whose columns are the local axes based on the nodes orientation relative to it's parent.

DIOGRENode* DigitalSpaces::DIOGRENode::CreateChild ( void )

Creates an unnamed new Node as a child of this node.

Parameters:

	translate	Initial translation offset of child relative to parent
	rotate	Initial rotation relative to parent

DIOGRENode* DigitalSpaces::DIOGRENode::CreateChild	(	in_Vector3f *	translate,
		in_Quaternionf *	rotate
	)

DIOGRENode* DigitalSpaces::DIOGRENode::CreateChild ( const char * name )

Creates a new named Node as a child of this node.

Remarks:: This creates a child node with a given name, which allows you to look the node up from the parent which holds this collection of nodes.

Parameters:

	translate	Initial translation offset of child relative to parent
	rotate	Initial rotation relative to parent

DIOGRENode* DigitalSpaces::DIOGRENode::CreateChild	(	const char *	name,
		in_Vector3f *	translate,
		in_Quaternionf *	rotate
	)

void DigitalSpaces::DIOGRENode::AddChild ( DIOGRENode * child )

Adds a (precreated) child scene node to this node.

Parameters:

child

The Node which is to become a child node of this one

unsigned short DigitalSpaces::DIOGRENode::NumChildren ( void )

Reports the number of child nodes under this one.

DIOGRENode* DigitalSpaces::DIOGRENode::GetChildNode ( unsigned short index )

Gets a pointer to a child node.

Remarks:: There is an alternate getChild method which returns a named child.

DIOGRENode* DigitalSpaces::DIOGRENode::GetChildNode ( const char * name )

Gets a pointer to a named child node.

DIOGRENode* DigitalSpaces::DIOGRENode::RemoveChild ( unsigned short index )

Retrieves an iterator for efficiently looping through all children of this node.

Remarks:: Using this is faster than repeatedly calling getChild if you want to go through all (or most of) the children of this node. Note that the returned iterator is only valid whilst no children are added or removed from this node. Thus you should not store this returned iterator for later use, nor should you add / remove children whilst iterating through it; store up changes for later. Note that calling methods on returned items in the iterator IS allowed and does not invalidate the iterator. Drops the specified child from this node.
Does not delete the node, just detaches it from this parent, potentially to be reattached elsewhere. There is also an alternate version which drops a named child from this node.

DIOGRENode* DigitalSpaces::DIOGRENode::RemoveChild ( DIOGRENode * child )

Drops the specified child from this node.

Remarks:: Does not delete the node, just detaches it from this parent, potentially to be reattached elsewhere. There is also an alternate version which drops a named child from this node.

DIOGRENode* DigitalSpaces::DIOGRENode::RemoveChild ( const char * name )

Drops the named child from this node.

Remarks:: Does not delete the node, just detaches it from this parent, potentially to be reattached elsewhere.

void DigitalSpaces::DIOGRENode::RemoveAllChildren ( void )

Removes all child Nodes attached to this node.

Does not delete the nodes, just detaches them from this parent, potentially to be reattached elsewhere.

void DigitalSpaces::DIOGRENode::SetInitialState ( void )

Sets the current transform of this node to be the 'initial state' ie that position / orientation / scale to be used as a basis for delta values used in keyframe animation.

Remarks:: You never need to call this method unless you plan to animate this node. If you do plan to animate it, call this method once you've loaded the node with it's base state, ie the state on which all keyframes are based.

: If you never call this method, the initial state is the identity transform, ie do nothing.

void DigitalSpaces::DIOGRENode::ResetToInitialState ( void )

Resets the position / orientation / scale of this node to it's initial state, see setInitialState for more info.

void DigitalSpaces::DIOGRENode::GetInitialPosition ( out_Vector3f * vec )

Gets the initial position of this node, see setInitialState for more info.

Remarks:: Also resets the cumulative animation weight used for blending.

void DigitalSpaces::DIOGRENode::GetInitialOrientation ( out_Quaternionf * vec )

Gets the initial orientation of this node, see setInitialState for more info.

void DigitalSpaces::DIOGRENode::GetInitialScale ( out_Vector3f * vec )

Gets the initial position of this node, see setInitialState for more info.

void DigitalSpaces::DIOGRENode::NeedUpdate ( )

To be called in the event of transform changes to this node that require it's recalculation.

Remarks:: This not only tags the node state as being 'dirty', it also requests it's parent to know about it's dirtiness so it will get an update next time.

void DigitalSpaces::DIOGRENode::RequestUpdate ( DIOGRENode * child )

Called by children to notify their parent that they need an update.

void DigitalSpaces::DIOGRENode::CancelUpdate ( DIOGRENode * child )

Called by children to notify their parent that they no longer need an update.

The documentation for this struct was generated from the following file:

OGREInterfaces/OGREInterfaces.h

DigitalSpaces::DIOGRENode Struct Reference [Ogre]

Public Member Functions

Member Function Documentation

DigitalSpaces::DIOGRENode Struct Reference
[Ogre]