public DumpContactSetSample(Microsoft.Xna.Framework.Game game)
      : base(game)
    {
      GraphicsScreen.ClearBackground = true;

      // Create two collision objects with triangle mesh shapes.
      var meshA = new SphereShape(1).GetMesh(0.01f, 4);
      var shapeA = new TriangleMeshShape(meshA, true) { Partition = new CompressedAabbTree() };
      var poseA = new Pose(new Vector3F(-1, 0, 0), RandomHelper.Random.NextQuaternionF());
      var collisionObjectA = new CollisionObject(new GeometricObject(shapeA, poseA));

      var meshB = new BoxShape(0.2f, 2, 1f).GetMesh(0.01f, 4);
      var shapeB = new TriangleMeshShape(meshB, true) { Partition = new CompressedAabbTree() };
      var poseB = new Pose(new Vector3F(0.1f, 0, 0), RandomHelper.Random.NextQuaternionF());
      var collisionObjectB = new CollisionObject(new GeometricObject(shapeB, poseB));

      // Explicitly create a contact set. (Normally you would get the contact set
      // from the collision domain...)
      var contactSet = ContactSet.Create(collisionObjectA, collisionObjectB);

      // Create a C# sample which visualizes the contact set.
      const string Filename = "DumpedContactSet001.cs";
      DumpContactSet(contactSet, Filename);

      GraphicsScreen.DebugRenderer2D.DrawText(
        "Contact set dumped into the file: " + Filename, 
        new Vector2F(300, 300), 
        Color.Black);
    }

        public ModelContainer(Model modelpass, Pose posepass, SkeletonPose skeletonpass)
        {
            _model = modelpass;
            _pose = posepass;
            _skeleton = skeletonpass;

            var additionalData = (Dictionary<string,object>)_model.Tag;
            var animations = (Dictionary<string, SkeletonKeyFrameAnimation>)additionalData["Animations"];
            int index = 0;

            _animations = new ITimeline[animations.Count];

                _animations[0] = new AnimationClip<SkeletonPose>(animations["First"])
                {
                    LoopBehavior = LoopBehavior.Cycle,
                    Duration = TimeSpan.MaxValue
                };
                index++;

                _animations[1] = new AnimationClip<SkeletonPose>(animations["Second"]);

                _animations[2] = new AnimationClip<SkeletonPose>(animations["Second"])
                {
                    LoopBehavior = LoopBehavior.Cycle,
                    Duration = TimeSpan.MaxValue
                };
        }

 private Droid(Guid id, Pose pose, Guid inventoryID, Logic logic)
     : base(id)
 {
     _pose = pose;
     _inventoryID = inventoryID;
     _logic = logic;
 }

        public void GetClosestPointCandidates(Vector3F scale, Pose pose, ISpatialPartition<int> otherPartition, Vector3F otherScale, Pose otherPose, Func<int, int, float> callback)
        {
            if (otherPartition == null)
            throw new ArgumentNullException("otherPartition");

              if (callback == null)
            throw new ArgumentNullException("callback");

              // Make sure we are up-to-date.
              var otherBasePartition = otherPartition as BasePartition<int>;
              if (otherBasePartition != null)
            otherBasePartition.UpdateInternal();
              else
            otherPartition.Update(false);

              Update(false);

              if (_numberOfItems == 0)
            return;

              if (otherPartition is ISupportClosestPointQueries<int>)
              {
            // ----- CompressedAabbTree vs. ISupportClosestPointQueries<int>
            GetClosestPointCandidatesImpl(scale, pose, (ISupportClosestPointQueries<int>)otherPartition, otherScale, otherPose, callback);
              }
              else
              {
            // ----- CompressedAabbTree vs. *
            GetClosestPointCandidatesImpl(otherPartition, callback);
              }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="PoseEventArgs"/> class.
        /// </summary>
        /// <param name="myo">The Myo that raised the event. Cannot be <c>null</c>.</param>
        /// <param name="timestamp">The timestamp of the event.</param>
        /// <param name="pose">The pose that the Myo detected.</param>
        /// <exception cref="System.ArgumentNullException">
        /// The exception that is thrown when <paramref name="myo"/> is null.
        /// </exception>
        public PoseEventArgs(IMyo myo, DateTime timestamp, Pose pose)
            : base(myo, timestamp)
        {
            Contract.Requires<ArgumentNullException>(myo != null, "myo");

            this.Pose = pose;
        }

        public void Clone()
        {
            Pose poseA = new Pose(new Vector3F(1, 2, 3));
              PointShape pointA = new PointShape(3, 4, 5);
              GeometricObject geometryA = new GeometricObject(pointA, poseA);

              Pose poseB = new Pose(new Vector3F(1, 2, 3));
              PointShape pointB = new PointShape(3, 4, 5);
              GeometricObject geometryB = new GeometricObject(pointB, poseB);

              MinkowskiSumShape minkowskiSumShape = new MinkowskiSumShape(geometryA, geometryB);
              MinkowskiSumShape clone = minkowskiSumShape.Clone() as MinkowskiSumShape;
              Assert.IsNotNull(clone);
              Assert.IsNotNull(clone.ObjectA);
              Assert.IsNotNull(clone.ObjectB);
              Assert.AreNotSame(geometryA, clone.ObjectA);
              Assert.AreNotSame(geometryB, clone.ObjectB);
              Assert.IsTrue(clone.ObjectA is GeometricObject);
              Assert.IsTrue(clone.ObjectB is GeometricObject);
              Assert.AreEqual(poseA, clone.ObjectA.Pose);
              Assert.AreEqual(poseB, clone.ObjectB.Pose);
              Assert.IsNotNull(clone.ObjectA.Shape);
              Assert.IsNotNull(clone.ObjectB.Shape);
              Assert.AreNotSame(pointA, clone.ObjectA.Shape);
              Assert.AreNotSame(pointB, clone.ObjectB.Shape);
              Assert.IsTrue(clone.ObjectA.Shape is PointShape);
              Assert.IsTrue(clone.ObjectB.Shape is PointShape);
              Assert.AreEqual(pointA.Position, ((PointShape)clone.ObjectA.Shape).Position);
              Assert.AreEqual(pointB.Position, ((PointShape)clone.ObjectB.Shape).Position);
              Assert.AreEqual(minkowskiSumShape.GetAabb(Pose.Identity).Minimum, clone.GetAabb(Pose.Identity).Minimum);
              Assert.AreEqual(minkowskiSumShape.GetAabb(Pose.Identity).Maximum, clone.GetAabb(Pose.Identity).Maximum);
        }

    public BrownOut(ContentManager contentManager)
    {
      Pose = new Pose(Matrix33F.CreateRotationX(-ConstantsF.PiOver2));

      // Smoke on a ring.
      var outerRingSmoke = CreateSmoke(contentManager);
      outerRingSmoke.Effectors.Add(new StreamEmitter { DefaultEmissionRate = 30 });
      outerRingSmoke.Effectors.Add(new StartPositionEffector
      {
        Distribution = new CircleDistribution { OuterRadius = 5, InnerRadius = 4 }
      });

      // Smoke in the area inside the ring.
      var innerCircleSmoke = CreateSmoke(contentManager);
      innerCircleSmoke.Effectors.Add(new StreamEmitter { DefaultEmissionRate = 10 });
      innerCircleSmoke.Effectors.Add(new StartPositionEffector
      {
        Distribution = new CircleDistribution { OuterRadius = 4, InnerRadius = 0 }
      });

      // Uniform particle parameter that are the same for all child particle systems.
      Parameters.AddUniform<float>(ParticleParameterNames.Lifetime).DefaultValue = 5;
      _isDepthSortedParameter = Parameters.AddUniform<bool>(ParticleParameterNames.IsDepthSorted);
      _isDepthSortedParameter.DefaultValue = true;

      Children = new ParticleSystemCollection { outerRingSmoke, innerCircleSmoke };
    }

 public Entity ReplacePose(Pose newCurrent) {
     var componentPool = GetComponentPool(UnitsComponentIds.Pose);
     var component = (PoseComponent)(componentPool.Count > 0 ? componentPool.Pop() : new PoseComponent());
     component.Current = newCurrent;
     ReplaceComponent(UnitsComponentIds.Pose, component);
     return this;
 }

 public void SetsPoseShortcut()
 {
     Actor a = new Actor();
     Pose p = new Pose();
     a.Add(p);
     Assert.AreSame(p, a.Pose);
 }

        protected HeldPose(IMyoEventGenerator myo, TimeSpan interval, IEnumerable<Pose> targetPoses)
        {
            Contract.Requires<ArgumentNullException>(myo != null, "myo");
            Contract.Requires<ArgumentOutOfRangeException>(interval.TotalMilliseconds >= 0, "interval");
            Contract.Requires<ArgumentNullException>(targetPoses != null, "targetPoses");

            _targetPoses = new List<Pose>(targetPoses);
            if (_targetPoses.Contains(Pose.Unknown))
            {
                throw new ArgumentException("All target poses must be specified.", "targetPoses");
            }

            if (_targetPoses.Count < 1)
            {
                throw new ArgumentException("At least one target pose must be specified.", "targetPoses");
            }

            _timer = new Timer()
            {
                AutoReset = true,
                Interval = interval.TotalMilliseconds,
            };
            _timer.Elapsed += Timer_Elapsed;

            _lastPose = Pose.Unknown;

            _myo = myo;
            _myo.PoseChanged += Myo_PoseChanged;
        }

 internal SkinnedModelBoneContent(ushort index, string name, Pose bindPose,
     Matrix inverseBindPoseTransform)
 {
     this.index = index;
     this.name = name;
     this.bindPose = bindPose;
     this.inverseBindPoseTransform = inverseBindPoseTransform;
 }

 public LinearSequence(AnimationData anim, bool loop)
 {
     Loop = loop;
     this.anim = anim;
     Speed = 1.0f;
     pose = new Pose(anim.Frames[0]);
     length = anim.Frames.Count/anim.Speed;
 }

 public static Pose Lerp( Pose p1, Pose p2, float t )
 {
     return new Pose(
                     Vector3.Lerp( p1.position, p2.position, t ),
                     Quaternion.Lerp( p1.rotation, p2.rotation, t ),
                     Vector3.Lerp( p1.scale, p2.scale, t )
                     );
 }

	// Use this for initialization
	void Start () {
		//the init status of the enmeny
		mDir = _CurDir;
		mPose = CurPose;

		if (Parent != null) {
			Parent.Start();
		}
	}

	//change the direction of the character
	public void CheckDir(){
		if (gameObject == null) {
			return;
		} 
		needChangeStatus = false;
		if (mDir != _CurDir) {
			needChangeStatus = true;
			mDir = _CurDir;
		}
		if (mPose != CurPose) {
			needChangeStatus = true;
			mPose = CurPose;
		}
		Quaternion dir = gameObject.transform.localRotation;
		float curAngle = dir.eulerAngles.y % 360.0f;
		curAngle = curAngle < 0.0f ? curAngle + 360.0f : curAngle;
		//rotate the weapon
		if (rotateWeapon && CurPose != Pose.Die) {
			QuadTextureNgui tex = transform.GetChild(0).GetComponent<QuadTextureNgui>();
			if(curAngle >= 0.0f && curAngle <= 151f){
				int angle = ((int)(curAngle/10.0f) * 10);
				tex.mSpriteName = ""+angle;
				tex.mirrorX = false;
				tex.InitFace();
			} else if (curAngle > 151.0f && curAngle <= 301.0f){
				int angle = ((int)((301.0f - curAngle)/10.0f) * 10);
				tex.mSpriteName = ""+angle;
				tex.mirrorX = true;
				tex.InitFace();
			} else if(curAngle > 301.0f && curAngle <= 321.0f){
				int angle = ((int)((661.0f - curAngle)/10.0f) * 10);
				tex.mSpriteName = ""+angle;
				tex.mirrorX = true;
				tex.InitFace();
			}
		} else {
			//will not be used
			if((curAngle >= 0.0f && curAngle < 45.0f) || (curAngle > 315.0f && curAngle <= 360.0f)){
				_CurDir = Dir.RightUp;
			} 
			else if(curAngle >= 270.0f && curAngle <= 315.0f){
				_CurDir = Dir.LeftUp;
			}
			else if(curAngle >= 45.0f && curAngle < 90.0f){
				_CurDir = Dir.Right;
			}
			else if(curAngle >= 100.0f && curAngle < 270.0f){
				_CurDir = Dir.Left;
			}
			else if(curAngle >= 127.0f && curAngle < 180.0f){
				_CurDir = Dir.LeftDown;
			} 
			else if(curAngle >= 90.0f && curAngle < 127.0f){
				_CurDir = Dir.RightDown;
			}
		}
	}

        public void DiscoverSequenceOfPoses()
        {
            var myo = new Mock<IMyoEventGenerator>(MockBehavior.Strict);
            var gestures = new Pose[] { Pose.WaveIn, Pose.WaveOut };

            var result = HeldPose.Create(myo.Object, gestures);

            Assert.NotNull(result);
        }

 public static Pose random()
 {
     Pose p = new Pose();
     for(int i = 0; i < 20; i++)
     {
         p.joint_rotations[i] = Random.rotation;
     }
     return p;
 }

 void IConstructable.Construct(IDictionary<string, string> param)
 {
     var anim = ResourceFactory.LoadAsset<AnimationData>(param["animData"]);
     seq = new LinearSequence(anim, true);
     var rest = ResourceFactory.LoadAsset<AnimationData>(param["restPose"]).Frames[0];
     invRest = new Pose(rest);
     pose = new Pose(rest);
     invRest.Invert();
 }

 public StaticObject(IServiceLocator services, string assetName, Vector3F scale, Pose pose, bool castsShadows, bool addRigidBody)
 {
   _services = services;
   _assetName = assetName;
   _scale = scale;
   _pose = pose;
   _castsShadows = castsShadows;
   _addRigidBody = addRigidBody;
 }

 /// <summary>
 /// Applies constant power to both wheels, driving the motor base for a fixed distance, in the current direction
 /// </summary>
 /// <param name="distance">Distance to travel, in meters</param>
 /// <param name="power">Normalized power (torque) value for both wheels</param>
 public void DriveDistance(float distance, float power)
 {
     if (distance < 0)
     {
         throw new ArgumentOutOfRangeException("distance");
     }
     _startPoseForDriveDistance = State.Pose;
     _distanceToTravel = distance;
     SetAxleVelocity(power * _motorTorqueScaling, power * _motorTorqueScaling);
 }