protected virtual void NotifyOfNewParent( Node newParent ) { parent = newParent; isParentNotified = false; NeedUpdate(); }
/// <summary> /// Whether the specified node is a child of this node. /// </summary> /// <param name="node"></param> /// <returns></returns> public bool HasChild( Node node ) { return node.Parent == this; }
public virtual void NotifyAttached(Node parent) { this.parentNode = parent; if ( parent != null ) { tileSceneNode = (SceneNode)( parent.CreateChild( name ) ); //mTileNode.setPosition( (Real)mTableX , 0.0, (Real)mTableZ ); if ( renderable != null) if (renderable.IsLoaded) { tileSceneNode.AttachObject( (MovableObject) renderable ); } tileSceneNode.NeedUpdate(); } }
/// <summary> /// Called by children to notify their parent that they need an update. /// </summary> /// <param name="child"></param> public virtual void RequestUpdate( Node child ) { // if we are already going to update everything, this wont matter if ( needChildUpdate ) return; // add to the list of children that need updating if ( !childrenToUpdate.ContainsKey( child.name ) ) childrenToUpdate.Add( child ); // request to update me if ( parent != null && !isParentNotified ) { parent.RequestUpdate( this ); isParentNotified = true; } }
/// <summary> /// Creates a new NodeAnimationTrack automatically associated with a Node. /// </summary> /// <param name="handle">Handle to give the track, used for accessing the track later.</param> /// <param name="targetNode">Node object which will be affected by this track.</param> /// <returns></returns> public NodeAnimationTrack CreateNodeTrack( ushort handle, Node targetNode ) { // create a new track and set it's target NodeAnimationTrack track = CreateNodeTrack( handle ); track.TargetNode = targetNode; return track; }
/// <summary> /// Internal method called to notify the object that it has been attached to a node. /// </summary> /// <param name="node">Scene node to notify.</param> internal virtual void NotifyAttached(Node node, bool isTagPoint) { parentNode = node; parentIsTagPoint = isTagPoint; }
public static void QueueNeedUpdate(Node node) { // Don't queue the node more than once if (!node.queuedForUpdate) { node.queuedForUpdate = true; queuedUpdates.Add(node); } }
public int IndexOf(T item) { return objectList.IndexOfKey(item.Name); }
protected virtual void ParentChanged(Node oldParent, Node newParent) { if(oldParent != null) { oldParent.RemoveChild(this); if (NodeDetachedEvent != null) NodeDetachedEvent(this); } if (newParent != null) { newParent.AddChild(this); if (NodeAttachedEvent != null) NodeAttachedEvent(this); } }
/// <summary> /// /// </summary> public Node() { this.name = "Unnamed_" + nextUnnamedNodeExtNum++; parent = null; // initialize objects orientation = initialOrientation = derivedOrientation = Quaternion.Identity; position = initialPosition = derivedPosition = Vector3.Zero; scale = initialScale = derivedScale = Vector3.UnitScale; cachedTransform = Matrix4.Identity; inheritsScale = true; accumAnimWeight = 0.0f; childNodes = new Dictionary<string, Node>(); childrenToUpdate = new List<Node>(); NeedUpdate(); }
/// <summary> /// Adds a named object to the collection. /// </summary> /// <param name="name"></param> /// <param name="item"></param> public void Add(K key, T item) { base.Add(key, item); }
/// <summary> /// Adds an object to the collection. /// </summary> /// <param name="item"></param> public void Add(T item) { Add(item.Name, item); }
public void Remove(T item) { objectList.Remove(item.Name); }
/// <summary> /// 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. /// </summary> /// <param name="child"></param> /// <param name="removeFromInternalList"></param> protected virtual void RemoveChild( Node child, bool removeFromInternalList ) { CancelUpdate( child ); child.NotifyOfNewParent( null ); if (removeFromInternalList) { childNodes.Remove(child.Name); } }
public bool HasChild(Node node) { return childNodes.ContainsValue(node); }
/// <summary> /// Removes the specified node from the scene graph and the octree, optionally keeping it in the internal node list yet. For internal use. /// </summary> /// <remarks> /// Removes all of the node's child subtree from the octree, but children remain linked to parents. /// </remarks> /// <param name="child"></param> /// <param name="removeFromInternalList"></param> protected override void RemoveChild( Node child, bool removeFromInternalList ) { Debug.Assert( child is OctreeNode, "node is not an octree node" ); // remove all linked nodes from octree RemoveNodesFromOctree( (OctreeNode)child ); // remove child from scene graph base.RemoveChild( child, removeFromInternalList ); }
/// <summary> /// Removes the specifed node as a child of this node. /// </summary> /// <param name="child"></param> public virtual void RemoveChild(Node child) { if (child != null) { CancelUpdate(child); child.NotifyOfNewParent(null); } childNodes.Remove(child.Name); }
/// <summary> /// Same as the Apply method, but applies to a specified Node instead of it's associated node. /// </summary> public void ApplyToNode( Node node, float time, float weight, bool accumulate, float scale ) { this.GetInterpolatedKeyFrame( time, kf ); if ( accumulate ) { // add to existing. Weights are not relative, but treated as absolute multipliers for the animation Vector3 translate = kf.Translate * weight * scale; node.Translate( translate ); // interpolate between not rotation and full rotation, to point weight, so 0 = no rotate, and 1 = full rotation Quaternion rotate = Quaternion.Slerp( weight, Quaternion.Identity, kf.Rotation ); node.Rotate( rotate ); // TODO: not yet sure how to modify scale for cumulative animations Vector3 scaleVector = kf.Scale; // Not sure how to modify scale for cumulative anims... leave it alone //scaleVector = ((Vector3::UNIT_SCALE - kf.getScale()) * weight) + Vector3::UNIT_SCALE; if ( scale != 1.0f && scaleVector != Vector3.UnitScale ) scaleVector = Vector3.UnitScale + ( scaleVector - Vector3.UnitScale ) * scale; node.ScaleBy( scaleVector ); } else { // apply using weighted transform method node.WeightedTransform( weight, kf.Translate, kf.Rotation, kf.Scale ); } }
public void Remove(T item) { objectList.Remove(item.Name); }
/// <summary> /// Internal method called to notify the object that it has been attached to a node. /// </summary> /// <param name="node">Scene node to notify.</param> internal virtual void NotifyAttached(Node node) { NotifyAttached(node, false); }
public bool Contains(T item) { return(objectList.Contains(item.Name)); }
//----------------------------------------------------------------------- public override void NotifyAttached(Node parent, bool isTagPoint) { billboardSet.NotifyAttached(parent, isTagPoint); }
public int IndexOf(T item) { return(objectList.IndexOfKey(item.Name)); }
public static void QueueNeedUpdate( Node node ) { if ( !_queuedForUpdate.Contains( node ) ) { _queuedForUpdate.Add( node ); } }
/// <summary> /// Adds an object to the collection. /// </summary> /// <param name="item"></param> public void Add(T item) { Add(item.Name, item); }
/// <summary> /// Called by children to notify their parent that they no longer need an update. /// </summary> /// <param name="child"></param> public virtual void CancelUpdate( Node child ) { // remove this from the list of children to update childrenToUpdate.Remove( child.Name ); // propogate this changed if we are done if ( childrenToUpdate.Count == 0 && parent != null && !needChildUpdate ) { parent.CancelUpdate( this ); isParentNotified = false; } }
/// <summary> /// Adds a named object to the collection. /// </summary> /// <param name="name"></param> /// <param name="item"></param> public void Add(K key, T item) { base.Add(key, item); }
/// <summary> /// Adds a node to the list of children of this node. /// </summary> public void AddChild( Node child ) { string childName = child.Name; if ( child == this ) throw new ArgumentException( string.Format( "Node '{0}' cannot be added as a child of itself.", childName ) ); if ( childNodes.ContainsKey( childName ) ) throw new ArgumentException( string.Format( "Node '{0}' already has a child node with the name '{1}'.", this.name, childName ) ); child.RemoveFromParent(); childNodes.Add( childName, child ); child.NotifyOfNewParent( this ); }
public void DetachScriptNode(Node node) { if (!scriptNodeAttachments.ContainsKey(node)) { log.Warn("Got DetachScriptNode without valid node"); return; } long objectId = scriptNodeAttachments[node]; DetachNode(objectId, true); scriptNodeAttachments.Remove(node); return; }
/// <summary> /// Removes the specifed node that is a child of this node. /// </summary> /// <param name="child"></param> public virtual void RemoveChild( Node child ) { RemoveChild( child, true ); }
/// <summary> /// Internal constructor, to prevent direction instantiation. Should be created /// via a call to the CreateTrack method of an Animation. /// </summary> public NodeAnimationTrack( Animation parent, Node target ) : base( parent ) { this.target = target; }
public DebugRenderable( Node parent ) { _parent = parent; string materialName = "Axiom/Debug/AxesMat"; _material = (Material)MaterialManager.Instance[ materialName ]; if ( _material == null ) { _material = (Material)MaterialManager.Instance.Create( materialName, ResourceGroupManager.InternalResourceGroupName ); Pass p = _material.GetTechnique( 0 ).GetPass( 0 ); p.LightingEnabled = false; //TODO: p.PolygonModeOverrideable = false; p.VertexColorTracking = TrackVertexColor.Ambient; p.SetSceneBlending( SceneBlendType.TransparentAlpha ); p.CullingMode = CullingMode.None; p.DepthWrite = false; } string meshName = "Axiom/Debug/AxesMesh"; _mesh = MeshManager.Instance[ meshName ]; if ( _mesh == null ) { ManualObject mo = new ManualObject( "tmp" ); mo.Begin( Material.Name, OperationType.TriangleList ); /* 3 axes, each made up of 2 of these (base plane = XY) * .------------|\ * '------------|/ */ mo.EstimateVertexCount( 7 * 2 * 3 ); mo.EstimateIndexCount( 3 * 2 * 3 ); Quaternion[] quat = new Quaternion[ 6 ]; ColorEx[] col = new ColorEx[ 3 ]; // x-axis quat[ 0 ] = Quaternion.Identity; quat[ 1 ] = Quaternion.FromAxes( Vector3.UnitX, Vector3.NegativeUnitZ, Vector3.UnitY ); col[ 0 ] = ColorEx.Red; col[ 0 ].a = 0.8f; // y-axis quat[ 2 ] = Quaternion.FromAxes( Vector3.UnitY, Vector3.NegativeUnitX, Vector3.UnitZ ); quat[ 3 ] = Quaternion.FromAxes( Vector3.UnitY, Vector3.UnitZ, Vector3.UnitX ); col[ 1 ] = ColorEx.Green; col[ 1 ].a = 0.8f; // z-axis quat[ 4 ] = Quaternion.FromAxes( Vector3.UnitZ, Vector3.UnitY, Vector3.NegativeUnitX ); quat[ 5 ] = Quaternion.FromAxes( Vector3.UnitZ, Vector3.UnitX, Vector3.UnitY ); col[ 2 ] = ColorEx.Blue; col[ 2 ].a = 0.8f; Vector3[] basepos = new Vector3[ 7 ] { // stalk new Vector3(0f, 0.05f, 0f), new Vector3(0f, -0.05f, 0f), new Vector3(0.7f, -0.05f, 0f), new Vector3(0.7f, 0.05f, 0f), // head new Vector3(0.7f, -0.15f, 0f), new Vector3(1f, 0f, 0f), new Vector3(0.7f, 0.15f, 0f) }; // vertices // 6 arrows for ( int i = 0; i < 6; ++i ) { // 7 points for ( int p = 0; p < 7; ++p ) { Vector3 pos = quat[ i ] * basepos[ p ]; mo.Position( pos ); mo.Color( col[ i / 2 ] ); } } // indices // 6 arrows for ( int i = 0; i < 6; ++i ) { ushort baseIndex = (ushort)( i * 7 ); mo.Triangle( (ushort)( baseIndex + 0 ), (ushort)( baseIndex + 1 ), (ushort)( baseIndex + 2 ) ); mo.Triangle( (ushort)( baseIndex + 0 ), (ushort)( baseIndex + 2 ), (ushort)( baseIndex + 3 ) ); mo.Triangle( (ushort)( baseIndex + 4 ), (ushort)( baseIndex + 5 ), (ushort)( baseIndex + 6 ) ); } mo.End(); _mesh = mo.ConvertToMesh( meshName, ResourceGroupManager.InternalResourceGroupName ); } }
public NodeAnimationTrack( Animation parent ) : base( parent ) { this.target = null; }
/// <summary> /// Internal method called to notify the object that it has been attached to a node. /// </summary> /// <param name="node">Scene node to which we are being attached.</param> /// <param name="isTagPoint"></param> internal override void NotifyAttached( Node node, bool isTagPoint ) { base.NotifyAttached( node, isTagPoint ); // Also notify LOD entities foreach ( var lodEntity in this.lodEntityList ) { lodEntity.NotifyAttached( node, isTagPoint ); } }
public bool Contains(T item) { return objectList.Contains(item.Name); }