C# 클래스 Axiom.Core.Node

Class representing a general-purpose node an articulated scene graph.
A node in the scene graph is a node in a structured tree. A node contains information about the transformation which will apply to it and all of its children. Child nodes can have transforms of their own, which are combined with their parent's transformations. This is an abstract class - concrete classes are based on this for specific purposes, e.g. SceneNode, Bone
상속: IRenderable
파일 보기 프로젝트 열기: WolfgangSt/axiom 1 사용 예제들

보호된 프로퍼티들

프로퍼티 타입 설명
accumAnimWeight float
cachedRelativeTransform Axiom.MathLib.Matrix4
cachedTransform Axiom.MathLib.Matrix4
childNodes Axiom.Collections.NodeCollection
childrenToUpdate Axiom.Collections.NodeCollection
customParams List
derivedOrientation Axiom.MathLib.Quaternion
derivedPosition Vector3
derivedScale Vector3
inheritOrientation bool
inheritScale bool
initialOrientation Axiom.MathLib.Quaternion
initialPosition Vector3
initialScale Vector3
isParentNotified bool
material Axiom.Graphics.Material
name string
needChildUpdate bool
needParentUpdate bool
needRelativeTransformUpdate bool
needTransformUpdate bool
nextUnnamedNodeExtNum long
nodeMaterial Axiom.Graphics.Material
nodeSubMesh SubMesh
orientation Axiom.MathLib.Quaternion
parent Node
position Vector3
rotationFromInitial Axiom.MathLib.Quaternion
scale Vector3
scaleFromInitial Vector3
subMesh SubMesh
suppressUpdateEvent bool
translationFromInitial Vector3

공개 메소드들

메소드 설명
AddChild ( Node child ) : void

Adds a node to the list of children of this node.

CancelUpdate ( Node child ) : void

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

CreateChild ( ) : Node

Creates a new Child node.

CreateChild ( Vector3 translate ) : Node

Creates a new child node.

CreateChild ( Vector3 translate, Axiom.MathLib.Quaternion rotate ) : Node

Creates a new child node.

CreateChild ( string name ) : Node

Creates a new name child node.

CreateChild ( string name, Vector3 translate ) : Node

Creates a new named child node.

CreateChild ( string name, Vector3 translate, Axiom.MathLib.Quaternion rotate ) : Node

Creates a new named child node.

GetChild ( string name ) : Node

Gets a child node by name.

GetDebugRenderable ( ) : Node.DebugRenderable
GetDebugRenderable ( Real scaling ) : Node.DebugRenderable
GetSquaredViewDepth ( Camera camera ) : float

GetWorldTransforms ( Axiom.MathLib.Matrix4 matrices ) : void

HasChild ( Node node ) : bool

Whether the specified node is a child of this node.

HasChild ( string name ) : bool

Whether this node contains a child of the specified name

NeedUpdate ( ) : void

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

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

NeedUpdate ( bool forceParentUpdate ) : void
Node ( ) : System

Node ( string name ) : System

OnUpdatedFromParent ( ) : void
Pitch ( float degrees ) : void

Rotate the node around the X-axis.

Pitch ( float degrees, TransformSpace relativeTo ) : void

Rotate the node around the X-axis.

ProcessQueuedUpdates ( ) : void
QueueNeedUpdate ( Node node ) : void
RemoveAllChildren ( ) : void

Removes all child nodes attached to this node.

RemoveChild ( string name ) : Node

Removes the child node with the specified name.

RemoveChild ( Node child ) : void

Removes the specifed node that is a child of this node.

RemoveFromParent ( ) : void

Removes the node from parent node if any

RequestUpdate ( Node child ) : void

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

ResetOrientation ( ) : void

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

ResetToInitialState ( ) : void

Resets the position / orientation / scale of this node to its initial state, see SetInitialState for more info.

Roll ( float degrees ) : void

Rotate the node around the Z-axis.

Roll ( float degrees, TransformSpace relativeTo ) : void

Rotate the node around the Z-axis.

Rotate ( Axiom.MathLib.Quaternion rotation ) : void

Rotate the node around an arbitrary axis using a Quaternion.

Rotate ( Axiom.MathLib.Quaternion rotation, TransformSpace relativeTo ) : void

Rotate the node around an arbitrary axis using a Quaternion.

Rotate ( Vector3 axis, float degrees ) : void

Rotate the node around an arbitrary axis.

Rotate ( Vector3 axis, float degrees, TransformSpace relativeTo ) : void

Rotate the node around an arbitrary axis.

ScaleBy ( Vector3 factor ) : void

Scales the node, combining its current scale with the passed in scaling factor.

This method applies an extra scaling factor to the node's existing scale, (unlike setScale which overwrites it) combining its 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.

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.

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 its base state, ie the state on which all keyframes are based. If you never call this method, the initial state is the identity transform (do nothing) and a position of zero

Translate ( Matrix3 axes, Vector3 move ) : void

Moves the node along arbitrary axes.

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

Translate ( Matrix3 axes, Vector3 move, TransformSpace relativeTo ) : void

Moves the node along arbitrary axes.

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

Translate ( Vector3 translate ) : void

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

Translate ( Vector3 translate, TransformSpace relativeTo ) : void

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

Yaw ( float degrees ) : void

Rotate the node around the Y-axis.

Yaw ( float degrees, TransformSpace relativeTo ) : void

Rotate the node around the Y-axis.

보호된 메소드들

메소드 설명
CreateChildImpl ( ) : Node

Must be overridden in subclasses. Specifies how a Node is created. CreateChild uses this to create a new one and add it to the list of child nodes. This allows subclasses to not have to override CreateChild and duplicate all its functionality.

CreateChildImpl ( string name ) : Node

Must be overridden in subclasses. Specifies how a Node is created. CreateChild uses this to create a new one and add it to the list of child nodes. This allows subclasses to not have to override CreateChild and duplicate all its functionality.

MakeInverseTransform ( Vector3 position, Vector3 scale, Axiom.MathLib.Quaternion orientation, Axiom.MathLib.Matrix4 &destMatrix ) : void

Internal method for building an inverse Matrix4 from orientation / scale / position.

As makeTransform except it build the inverse given the same data as makeTransform, so performing -translation, 1/scale, -rotate in that order.

MakeTransform ( Vector3 position, Vector3 scale, Axiom.MathLib.Quaternion orientation, Axiom.MathLib.Matrix4 &destMatrix ) : void

Internal method for building a Matrix4 from orientation / scale / position.

Transform is performed in the order scale, rotate, translation, i.e. translation is independent of orientation axes, scale does not affect size of translation, rotation and scaling are always centered on the origin.

NotifyOfNewParent ( Node newParent ) : void
OnRename ( string oldName ) : void

Can be overriden in derived classes to fire an event or rekey this node in the collections which contain it

RemoveChild ( Node child, bool removeFromInternalList ) : void

Internal method to remove a child of this node, keeping it in the list of child nodes by option. Useful when enumerating the list of children while removing them too.

Update ( bool updateChildren, bool hasParentChanged ) : void

Internal method to update the Node. Updates this node and any relevant children to incorporate transforms etc. Don't call this yourself unless you are writing a SceneManager implementation.

UpdateFromParent ( ) : void

Triggers the node to update its combined transforms. This method is called internally by the engine to ask the node to update its complete transformation based on its parents derived transform.

dispose ( bool disposeManagedResources ) : void

Class level dispose method

When implementing this method in an inherited class the following template should be used; protected override void dispose( bool disposeManagedResources ) { if ( !isDisposed ) { if ( disposeManagedResources ) { // Dispose managed resources. } // There are no unmanaged resources to release, but // if we add them, they need to be released here. } // If it is available, make the call to the // base class's Dispose(Boolean) method base.dispose( disposeManagedResources ); }

비공개 메소드들

메소드 설명
Clear ( ) : void

Simply clears the collection of children.

WeightedTransform ( float weight, Vector3 translate, Axiom.MathLib.Quaternion rotate, Vector3 scale ) : void

This method transforms a Node by a weighted amount from its initial state. If weighted transforms have already been applied, the previous transforms and this one are blended together based on their relative weight. This method should not be used in combination with the unweighted rotate, translate etc methods.

WeightedTransform ( float weight, Vector3 translate, Axiom.MathLib.Quaternion rotate, Vector3 scale, bool lookInMovementDirection ) : void

This method transforms a Node by a weighted amount from its initial state. If weighted transforms have already been applied, the previous transforms and this one are blended together based on their relative weight. This method should not be used in combination with the unweighted rotate, translate etc methods.

메소드 상세

AddChild() 공개 메소드

Adds a node to the list of children of this node.
public AddChild ( Node child ) : void
child Node
리턴 void

CancelUpdate() 공개 메소드

Called by children to notify their parent that they no longer need an update.
public CancelUpdate ( Node child ) : void
child Node
리턴 void

CreateChild() 공개 메소드

Creates a new Child node.
public CreateChild ( ) : Node
리턴 Node

CreateChild() 공개 메소드

Creates a new child node.
public CreateChild ( Vector3 translate ) : Node
translate Vector3 A vector to specify the position relative to the parent.
리턴 Node

CreateChild() 공개 메소드

Creates a new child node.
public CreateChild ( Vector3 translate, Axiom.MathLib.Quaternion rotate ) : Node
translate Vector3 A vector to specify the position relative to the parent.
rotate Axiom.MathLib.Quaternion A quaternion to specify the orientation relative to the parent.
리턴 Node

CreateChild() 공개 메소드

Creates a new name child node.
public CreateChild ( string name ) : Node
name string
리턴 Node

CreateChild() 공개 메소드

Creates a new named child node.
public CreateChild ( string name, Vector3 translate ) : Node
name string Name of the node.
translate Vector3 A vector to specify the position relative to the parent.
리턴 Node

CreateChild() 공개 메소드

Creates a new named child node.
public CreateChild ( string name, Vector3 translate, Axiom.MathLib.Quaternion rotate ) : Node
name string Name of the node.
translate Vector3 A vector to specify the position relative to the parent.
rotate Axiom.MathLib.Quaternion A quaternion to specify the orientation relative to the parent.
리턴 Node

CreateChildImpl() 보호된 추상적인 메소드

Must be overridden in subclasses. Specifies how a Node is created. CreateChild uses this to create a new one and add it to the list of child nodes. This allows subclasses to not have to override CreateChild and duplicate all its functionality.
protected abstract CreateChildImpl ( ) : Node
리턴 Node

CreateChildImpl() 보호된 추상적인 메소드

Must be overridden in subclasses. Specifies how a Node is created. CreateChild uses this to create a new one and add it to the list of child nodes. This allows subclasses to not have to override CreateChild and duplicate all its functionality.
protected abstract CreateChildImpl ( string name ) : Node
name string The name of the node to add.
리턴 Node

GetChild() 공개 메소드

Gets a child node by name.
public GetChild ( string name ) : Node
name string
리턴 Node

GetDebugRenderable() 공개 메소드

public GetDebugRenderable ( ) : Node.DebugRenderable
리턴 Node.DebugRenderable

GetDebugRenderable() 공개 메소드

public GetDebugRenderable ( Real scaling ) : Node.DebugRenderable
scaling Real
리턴 Node.DebugRenderable

GetSquaredViewDepth() 공개 메소드

public GetSquaredViewDepth ( Camera camera ) : float
camera Camera
리턴 float

GetWorldTransforms() 공개 메소드

public GetWorldTransforms ( Axiom.MathLib.Matrix4 matrices ) : void
matrices Axiom.MathLib.Matrix4
리턴 void

HasChild() 공개 메소드

Whether the specified node is a child of this node.
public HasChild ( Node node ) : bool
node Node
리턴 bool

HasChild() 공개 메소드

Whether this node contains a child of the specified name
public HasChild ( string name ) : bool
name string
리턴 bool

MakeInverseTransform() 보호된 메소드

Internal method for building an inverse Matrix4 from orientation / scale / position.
As makeTransform except it build the inverse given the same data as makeTransform, so performing -translation, 1/scale, -rotate in that order.
protected MakeInverseTransform ( Vector3 position, Vector3 scale, Axiom.MathLib.Quaternion orientation, Axiom.MathLib.Matrix4 &destMatrix ) : void
position Vector3
scale Vector3
orientation Axiom.MathLib.Quaternion
destMatrix Axiom.MathLib.Matrix4
리턴 void

MakeTransform() 보호된 메소드

Internal method for building a Matrix4 from orientation / scale / position.
Transform is performed in the order scale, rotate, translation, i.e. translation is independent of orientation axes, scale does not affect size of translation, rotation and scaling are always centered on the origin.
protected MakeTransform ( Vector3 position, Vector3 scale, Axiom.MathLib.Quaternion orientation, Axiom.MathLib.Matrix4 &destMatrix ) : void
position Vector3
scale Vector3
orientation Axiom.MathLib.Quaternion
destMatrix Axiom.MathLib.Matrix4
리턴 void

NeedUpdate() 공개 메소드

To be called in the event of transform changes to this node that require its recalculation.
This not only tags the node state as being 'dirty', it also requests its parent to know about its dirtiness so it will get an update next time.
public NeedUpdate ( ) : void
리턴 void

NeedUpdate() 공개 메소드

public NeedUpdate ( bool forceParentUpdate ) : void
forceParentUpdate bool
리턴 void

Node() 공개 메소드

public Node ( ) : System
리턴 System

Node() 공개 메소드

public Node ( string name ) : System
name string
리턴 System

NotifyOfNewParent() 보호된 메소드

protected NotifyOfNewParent ( Node newParent ) : void
newParent Node
리턴 void

OnRename() 보호된 메소드

Can be overriden in derived classes to fire an event or rekey this node in the collections which contain it
protected OnRename ( string oldName ) : void
oldName string
리턴 void

OnUpdatedFromParent() 공개 메소드

public OnUpdatedFromParent ( ) : void
리턴 void

Pitch() 공개 메소드

Rotate the node around the X-axis.
public Pitch ( float degrees ) : void
degrees float
리턴 void

Pitch() 공개 메소드

Rotate the node around the X-axis.
public Pitch ( float degrees, TransformSpace relativeTo ) : void
degrees float
relativeTo TransformSpace
리턴 void

ProcessQueuedUpdates() 공개 정적인 메소드

public static ProcessQueuedUpdates ( ) : void
리턴 void

QueueNeedUpdate() 공개 정적인 메소드

public static QueueNeedUpdate ( Node node ) : void
node Node
리턴 void

RemoveAllChildren() 공개 메소드

Removes all child nodes attached to this node.
public RemoveAllChildren ( ) : void
리턴 void

RemoveChild() 공개 메소드

Removes the child node with the specified name.
public RemoveChild ( string name ) : Node
name string Name of the child node
리턴 Node

RemoveChild() 공개 메소드

Removes the specifed node that is a child of this node.
public RemoveChild ( Node child ) : void
child Node
리턴 void

RemoveChild() 보호된 메소드

Internal method to remove a child of this node, keeping it in the list of child nodes by option. Useful when enumerating the list of children while removing them too.
protected RemoveChild ( Node child, bool removeFromInternalList ) : void
child Node
removeFromInternalList bool
리턴 void

RemoveFromParent() 공개 메소드

Removes the node from parent node if any
public RemoveFromParent ( ) : void
리턴 void

RequestUpdate() 공개 메소드

Called by children to notify their parent that they need an update.
public RequestUpdate ( Node child ) : void
child Node
리턴 void

ResetOrientation() 공개 메소드

Resets the nodes orientation (local axes as world axes, no rotation).
public ResetOrientation ( ) : void
리턴 void

ResetToInitialState() 공개 메소드

Resets the position / orientation / scale of this node to its initial state, see SetInitialState for more info.
public ResetToInitialState ( ) : void
리턴 void

Roll() 공개 메소드

Rotate the node around the Z-axis.
public Roll ( float degrees ) : void
degrees float
리턴 void

Roll() 공개 메소드

Rotate the node around the Z-axis.
public Roll ( float degrees, TransformSpace relativeTo ) : void
degrees float
relativeTo TransformSpace
리턴 void

Rotate() 공개 메소드

Rotate the node around an arbitrary axis using a Quaternion.
public Rotate ( Axiom.MathLib.Quaternion rotation ) : void
rotation Axiom.MathLib.Quaternion
리턴 void

Rotate() 공개 메소드

Rotate the node around an arbitrary axis using a Quaternion.
public Rotate ( Axiom.MathLib.Quaternion rotation, TransformSpace relativeTo ) : void
rotation Axiom.MathLib.Quaternion
relativeTo TransformSpace
리턴 void

Rotate() 공개 메소드

Rotate the node around an arbitrary axis.
public Rotate ( Vector3 axis, float degrees ) : void
axis Vector3
degrees float
리턴 void

Rotate() 공개 메소드

Rotate the node around an arbitrary axis.
public Rotate ( Vector3 axis, float degrees, TransformSpace relativeTo ) : void
axis Vector3
degrees float
relativeTo TransformSpace
리턴 void

ScaleBy() 공개 메소드

Scales the node, combining its current scale with the passed in scaling factor.
This method applies an extra scaling factor to the node's existing scale, (unlike setScale which overwrites it) combining its 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.
public ScaleBy ( Vector3 factor ) : void
factor Vector3
리턴 void

SetInitialState() 공개 메소드

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.
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 its base state, ie the state on which all keyframes are based. If you never call this method, the initial state is the identity transform (do nothing) and a position of zero
public SetInitialState ( ) : void
리턴 void

Translate() 공개 메소드

Moves the node along arbitrary axes.
This method translates the node by a vector which is relative to a custom set of axes.
public Translate ( Matrix3 axes, Vector3 move ) : void
axes Matrix3 3x3 Matrix containg 3 column vectors each representing the /// X, Y and Z axes 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 Vector3 Vector relative to the supplied axes.
리턴 void

Translate() 공개 메소드

Moves the node along arbitrary axes.
This method translates the node by a vector which is relative to a custom set of axes.
public Translate ( Matrix3 axes, Vector3 move, TransformSpace relativeTo ) : void
axes Matrix3 3x3 Matrix containg 3 column vectors each representing the /// X, Y and Z axes 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 Vector3 Vector relative to the supplied axes.
relativeTo TransformSpace
리턴 void

Translate() 공개 메소드

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
public Translate ( Vector3 translate ) : void
translate Vector3 Vector with x,y,z values representing the translation.
리턴 void

Translate() 공개 메소드

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
public Translate ( Vector3 translate, TransformSpace relativeTo ) : void
translate Vector3 Vector with x,y,z values representing the translation.
relativeTo TransformSpace
리턴 void

Update() 보호된 메소드

Internal method to update the Node. Updates this node and any relevant children to incorporate transforms etc. Don't call this yourself unless you are writing a SceneManager implementation.
protected Update ( bool updateChildren, bool hasParentChanged ) : void
updateChildren bool If true, the update cascades down to all children. Specify false if you wish to /// update children separately, e.g. because of a more selective SceneManager implementation.
hasParentChanged bool if true then this will update its derived properties (scale, orientation, position) accoarding to the parent's
리턴 void

UpdateFromParent() 보호된 메소드

Triggers the node to update its combined transforms. This method is called internally by the engine to ask the node to update its complete transformation based on its parents derived transform.
protected UpdateFromParent ( ) : void
리턴 void

Yaw() 공개 메소드

Rotate the node around the Y-axis.
public Yaw ( float degrees ) : void
degrees float
리턴 void

Yaw() 공개 메소드

Rotate the node around the Y-axis.
public Yaw ( float degrees, TransformSpace relativeTo ) : void
degrees float
relativeTo TransformSpace
리턴 void

dispose() 보호된 메소드

Class level dispose method
When implementing this method in an inherited class the following template should be used; protected override void dispose( bool disposeManagedResources ) { if ( !isDisposed ) { if ( disposeManagedResources ) { // Dispose managed resources. } // There are no unmanaged resources to release, but // if we add them, they need to be released here. } // If it is available, make the call to the // base class's Dispose(Boolean) method base.dispose( disposeManagedResources ); }
protected dispose ( bool disposeManagedResources ) : void
disposeManagedResources bool True if Unmanaged resources should be released.
리턴 void

프로퍼티 상세

accumAnimWeight 보호되어 있는 프로퍼티

Weight of applied animations so far, used for blending.
protected float accumAnimWeight
리턴 float

cachedRelativeTransform 보호되어 있는 프로퍼티

Cached relative transform as a 4x4 matrix.
protected Matrix4,Axiom.MathLib cachedRelativeTransform
리턴 Axiom.MathLib.Matrix4

cachedTransform 보호되어 있는 프로퍼티

Cached derived transform as a 4x4 matrix.
protected Matrix4,Axiom.MathLib cachedTransform
리턴 Axiom.MathLib.Matrix4

childNodes 보호되어 있는 프로퍼티

Collection of this nodes child nodes.
protected NodeCollection,Axiom.Collections childNodes
리턴 Axiom.Collections.NodeCollection

childrenToUpdate 보호되어 있는 프로퍼티

Collection of this nodes child nodes.
protected NodeCollection,Axiom.Collections childrenToUpdate
리턴 Axiom.Collections.NodeCollection

customParams 보호되어 있는 프로퍼티

protected List customParams
리턴 List

derivedOrientation 보호되어 있는 프로퍼티

World orientation of this node based on parents orientation.
protected Quaternion,Axiom.MathLib derivedOrientation
리턴 Axiom.MathLib.Quaternion

derivedPosition 보호되어 있는 프로퍼티

protected Vector3 derivedPosition
리턴 Vector3

derivedScale 보호되어 있는 프로퍼티

protected Vector3 derivedScale
리턴 Vector3

inheritOrientation 보호되어 있는 프로퍼티

protected bool inheritOrientation
리턴 bool

inheritScale 보호되어 있는 프로퍼티

protected bool inheritScale
리턴 bool

initialOrientation 보호되어 있는 프로퍼티

Original orientation of this node, used for resetting to original.
protected Quaternion,Axiom.MathLib initialOrientation
리턴 Axiom.MathLib.Quaternion

initialPosition 보호되어 있는 프로퍼티

protected Vector3 initialPosition
리턴 Vector3

initialScale 보호되어 있는 프로퍼티

protected Vector3 initialScale
리턴 Vector3

isParentNotified 보호되어 있는 프로퍼티

Flag indicating that parent has been notified about update request.
protected bool isParentNotified
리턴 bool

material 보호되어 있는 정적으로 프로퍼티

protected static Material,Axiom.Graphics material
리턴 Axiom.Graphics.Material

name 보호되어 있는 프로퍼티

Name of this node.
protected string name
리턴 string

needChildUpdate 보호되어 있는 프로퍼티

Flag to indicate all children need to be updated.
protected bool needChildUpdate
리턴 bool

needParentUpdate 보호되어 있는 프로퍼티

Flag to indicate own transform from parent is out of date.
protected bool needParentUpdate
리턴 bool

needRelativeTransformUpdate 보호되어 있는 프로퍼티

protected bool needRelativeTransformUpdate
리턴 bool

needTransformUpdate 보호되어 있는 프로퍼티

protected bool needTransformUpdate
리턴 bool

nextUnnamedNodeExtNum 보호되어 있는 정적으로 프로퍼티

protected static long nextUnnamedNodeExtNum
리턴 long

nodeMaterial 보호되어 있는 프로퍼티

Material to be used is this node itself will be rendered (axes, or bones).
protected Material,Axiom.Graphics nodeMaterial
리턴 Axiom.Graphics.Material

nodeSubMesh 보호되어 있는 프로퍼티

SubMesh to be used is this node itself will be rendered (axes, or bones).
protected SubMesh,Axiom.Core nodeSubMesh
리턴 SubMesh

orientation 보호되어 있는 프로퍼티

Orientation of this node relative to its parent.
protected Quaternion,Axiom.MathLib orientation
리턴 Axiom.MathLib.Quaternion

parent 보호되어 있는 프로퍼티

Parent node (if any)
protected Node,Axiom.Core parent
리턴 Node

position 보호되어 있는 프로퍼티

Position of this node relative to its parent.
protected Vector3 position
리턴 Vector3

rotationFromInitial 보호되어 있는 프로퍼티

protected Quaternion,Axiom.MathLib rotationFromInitial
리턴 Axiom.MathLib.Quaternion

scale 보호되어 있는 프로퍼티

protected Vector3 scale
리턴 Vector3

scaleFromInitial 보호되어 있는 프로퍼티

protected Vector3 scaleFromInitial
리턴 Vector3

subMesh 보호되어 있는 정적으로 프로퍼티

protected static SubMesh,Axiom.Core subMesh
리턴 SubMesh

suppressUpdateEvent 보호되어 있는 프로퍼티

protected bool suppressUpdateEvent
리턴 bool

translationFromInitial 보호되어 있는 프로퍼티

protected Vector3 translationFromInitial
리턴 Vector3