C# Bone.AddChild方法代码示例

		public TagPoint CreateTagPointOnBone( Bone bone, Quaternion offsetOrientation, Vector3 offsetPosition )
		{
			var tagPoint = new TagPoint( ++this.nextTagPointAutoHandle, this );
			this.tagPointList[ this.nextTagPointAutoHandle ] = tagPoint;

			tagPoint.Translate( offsetPosition );
			tagPoint.Rotate( offsetOrientation );
			tagPoint.SetBindingPose();
			bone.AddChild( tagPoint );

			return tagPoint;
		}

//.........这里部分代码省略.........
				else
				{
					armature.AddBone(bone);
				}
			}
			
			if(animationName!=null && animationName != armatureName)
			{
				animationArmatureData = data.GetArmatureData(animationName);
				if(animationArmatureData == null)
				{
					foreach (KeyValuePair<string, SkeletonData> skeleton in _dataDic)
					{
						data = _dataDic[skeleton.Key];
						animationArmatureData = data.GetArmatureData(animationName);
						if(animationArmatureData!=null)
						{
							break;
						}
					}
				}
			}

			if(animationArmatureData!=null)
			{
				armature.Animation.AnimationDataList = animationArmatureData.AnimationDataList;
			}
			else
			{
				armature.Animation.AnimationDataList = armatureData.AnimationDataList;
			}
			
			SkinData skinData = armatureData.GetSkinData(skinName);
			if(skinData == null)
			{
				throw new ArgumentException();
			}
			
			Slot slot;
			DisplayData displayData;
			Armature childArmature;
			int i;
			List<object> helpArray = new List<object>();
			foreach(SlotData slotData in skinData.SlotDataList)
			{
				bone = armature.GetBone(slotData.Parent);
				if(bone == null)
				{
					continue;
				}
				slot = generateSlot();
				slot.Name = slotData.Name;
				slot.BlendMode = slotData.BlendMode;
				slot._originZOrder = slotData.ZOrder;
				slot._dislayDataList = slotData.DisplayDataList;
				
				helpArray.Clear();
				i = slotData.DisplayDataList.Count;
				while(i -- >0)
				{
					displayData = slotData.DisplayDataList[i];
					
					switch(displayData.Type)
					{
					case DisplayData.ARMATURE:
						childArmature = BuildArmature(displayData.Name, null, _currentDataName, _currentTextureAtlasName);
						if(childArmature!=null)
						{
							helpArray.Insert(0, childArmature);
						}
						break;
					case DisplayData.IMAGE:
					default:
						helpArray.Insert(0, generateDisplay(_textureAtlasDic[_currentTextureAtlasName], displayData.Name, displayData.Pivot.X, displayData.Pivot.Y));
						break;
						
					}
				}
				slot.DisplayList = helpArray;
				slot.changeDisplay(0);
				bone.AddChild(slot);
			}
			
			//
			i = armature._boneList.Count;
			while(i -- >0)
			{
				armature._boneList[i].update();
			}
			
			i = armature._slotList.Count;
			while(i -- >0)
			{
				slot = armature._slotList[i];
				slot.update();
			}
			armature.UpdateSlotsZOrder();
			
			return armature;
		}

		/// <summary>
		///		Clones bones, for use in cloning the master skeleton to make this a unique
		///		skeleton instance.
		/// </summary>
		/// <param name="source"></param>
		/// <param name="parent"></param>
		protected void CloneBoneAndChildren( Bone source, Bone parent )
		{
			Bone newBone;

			if ( source.Name == "" )
			{
				newBone = CreateBone( source.Handle );
			}
			else
			{
				newBone = CreateBone( source.Name, source.Handle );
			}

			newBone.Orientation = source.Orientation;
			newBone.Position = source.Position;
			newBone.Scale = source.Scale;

			if ( parent == null )
			{
				rootBones.Add( newBone );
			}
			else
			{
				parent.AddChild( newBone );
			}

			// process children
			foreach ( Bone child in source.Children )
			{
				CloneBoneAndChildren( child, newBone );
			}
		}

        /// <summary>
        ///   Set up the skeleton based on the information in the 
        ///   invBindMatrices dictionary.
        /// </summary>
        /// <param name="invBindMatrices">Dictionary of inverse matrices for 
        ///                               each of the joints</param>
        /// <param name="skeleton">Skeleton to build</param>
        /// <param name="parentBone">Bone for which we are building children (or null to build the root)</param>
        protected void ProcessBones( Dictionary<string, Matrix4> invBindMatrices,
                                    Skeleton skeleton, Bone parentBone )
        {
            string parentName = (parentBone == null) ? null : parentBone.Name;
            Quaternion rotate;
            Vector3 translate, scale;
            foreach( string boneName in GetChildBones( parentName ) )
            {
                // Get the relative transform by this bone in transformed space
                Matrix4 boneTransform = GetLocalBindMatrix( invBindMatrices, boneName, parentName );
                Matrix4.DecomposeMatrix( ref boneTransform, out translate, out rotate, out scale );
                Bone bone = skeleton.CreateBone( boneName );
                m_Log.DebugFormat( "Bone Transform for {0}:\n{1}", boneName, boneTransform );
                if( parentBone != null )
                    parentBone.AddChild( bone );
                // Apply the inverse of the parent transform
                bone.Orientation = rotate;
                bone.Position = translate;

                ProcessBones( invBindMatrices, skeleton, bone );
            }
        }