C# Vector2.Rotate方法代码示例

        public void Leveling7PointsCorectInterpolation()
        {
			PrintLevelingData levelingData = new PrintLevelingData();

			double radius = 100;
			levelingData.SampledPositions = new List<Vector3>();
			Vector2 currentEdgePoint = new Vector2(radius, 0);
			for (int i = 0; i < 6; i++)
			{
				levelingData.SampledPositions.Add(new Vector3(currentEdgePoint, i));
				currentEdgePoint.Rotate(MathHelper.Tau / 6);
			}

			levelingData.SampledPositions.Add(new Vector3(0, 0, 6));

			for (int curPoint = 0; curPoint < 6; curPoint++)
			{
				int nextPoint = curPoint < 5 ? curPoint + 1 : 0;

				// test actual sample position
				Vector2 currentTestPoint = new Vector2(radius, 0);
				currentTestPoint.Rotate(MathHelper.Tau / 6 * curPoint);
				Vector3 outPosition = LevelWizard7PointRadial.GetPositionWithZOffset(new Vector3(currentTestPoint, 0), levelingData);
				Assert.AreEqual(outPosition.z, levelingData.SampledPositions[curPoint].z, .001);

				// test mid point between samples
				Vector3 midPoint = (levelingData.SampledPositions[curPoint] + levelingData.SampledPositions[nextPoint]) / 2;
				currentTestPoint = new Vector2(midPoint.x, midPoint.y);
				outPosition = LevelWizard7PointRadial.GetPositionWithZOffset(new Vector3(currentTestPoint, 0), levelingData);
				Assert.AreEqual(outPosition.z, midPoint.z, .001);

				// test mid point between samples with offset
				Vector3 midPointWithOffset = (levelingData.SampledPositions[curPoint] + levelingData.SampledPositions[nextPoint]) / 2 + new Vector3(0, 0, 3);
				currentTestPoint = new Vector2(midPointWithOffset.x, midPointWithOffset.y);
				outPosition = LevelWizard7PointRadial.GetPositionWithZOffset(new Vector3(currentTestPoint, 3), levelingData);
				Assert.AreEqual(outPosition.z, midPointWithOffset.z, .001);

				// test 1/2 angles (mid way between samples on radius)
				currentTestPoint = new Vector2(radius, 0);
				currentTestPoint.Rotate(MathHelper.Tau / 6 * (curPoint + .5));
				outPosition = LevelWizard7PointRadial.GetPositionWithZOffset(new Vector3(currentTestPoint, 0), levelingData);
				// the center is the higest point so the point on the radius has to be less than the mid point of the sample points (it is lower)
				Assert.IsTrue(outPosition.z < (levelingData.SampledPositions[curPoint].z + levelingData.SampledPositions[nextPoint].z) / 2 - .001);

				// test 1/2 to center
				currentTestPoint = new Vector2(radius / 2, 0);
				currentTestPoint.Rotate(MathHelper.Tau / 6 * curPoint);
				outPosition = LevelWizard7PointRadial.GetPositionWithZOffset(new Vector3(currentTestPoint, 0), levelingData);
				Assert.AreEqual(outPosition.z, (levelingData.SampledPositions[curPoint].z + levelingData.SampledPositions[6].z) / 2, .001);
			}
			
			Vector3 outPosition2 = LevelWizard7PointRadial.GetPositionWithZOffset(Vector3.Zero, levelingData);
			Assert.AreEqual(outPosition2.z, levelingData.SampledPositions[6].z, .001);
		}

		public Vector2 GetPrintLevelPositionToSample(int index, double radius)
        {
            Vector2 bedCenter = ActiveSliceSettings.Instance.BedCenter;
            if (index < NumberOfRadialSamples)
            {
                Vector2 position = new Vector2(radius, 0);
                position.Rotate(MathHelper.Tau / NumberOfRadialSamples * index);
                position += bedCenter;
                return position;
            }
            else
            {
                return bedCenter;
            }
        }

		public void Leveling7PointsNeverGetsTooHigh()
		{
			StaticData.Instance = new MatterHackers.Agg.FileSystemStaticData(Path.Combine("..", "..", "..", "..", "StaticData"));

			PrintLevelingData levelingData = new PrintLevelingData();

			double radius = 100;
			levelingData.SampledPositions = new List<Vector3>();
			levelingData.SampledPositions.Add(new Vector3(130.00, 0.00, 0));
			levelingData.SampledPositions.Add(new Vector3(65.00, 112.58, 10));
			levelingData.SampledPositions.Add(new Vector3(-65.00, 112.58, 0));
			levelingData.SampledPositions.Add(new Vector3(-130.00, 0.00, 10));
			levelingData.SampledPositions.Add(new Vector3(-65.00, -112.58, 0));
			levelingData.SampledPositions.Add(new Vector3(65.00, -112.58, 10));

			levelingData.SampledPositions.Add(new Vector3(0, 0, 0));

			levelingData.SampledPositions.Add(new Vector3(0, 0, 6));

			Vector2 bedCenter = Vector2.Zero;

			RadialLevlingFunctions levelingFunctions7Point = new RadialLevlingFunctions(6, levelingData, bedCenter);
			int totalPoints = 2000;
			for (int curPoint = 0; curPoint < totalPoints; curPoint++)
			{
				Vector2 currentTestPoint = new Vector2(radius, 0);
				currentTestPoint.Rotate(MathHelper.Tau / totalPoints * curPoint);
				Vector3 destPosition = new Vector3(currentTestPoint, 0);
				
				Vector3 outPosition = levelingFunctions7Point.GetPositionWithZOffset(destPosition);
				Assert.IsTrue(outPosition.z <= 10);
				
				string outPositionString = levelingFunctions7Point.DoApplyLeveling(GetGCodeString(destPosition), destPosition, PrinterMachineInstruction.MovementTypes.Absolute);
				double outZ = 0;
				Assert.IsTrue(GCodeFile.GetFirstNumberAfter("Z", outPositionString, ref outZ));
				Assert.IsTrue(outZ <= 10);
			}
		}

		public static void WriteTestGCodeFile()
		{
			using (StreamWriter file = new StreamWriter("PerformanceTest.gcode"))
			{
				//int loops = 150000;
				int loops = 150;
				int steps = 200;
				double radius = 50;
				Vector2 center = new Vector2(150, 100);

				file.WriteLine("G28 ; home all axes");
				file.WriteLine("G90 ; use absolute coordinates");
				file.WriteLine("G21 ; set units to millimeters");
				file.WriteLine("G92 E0");
				file.WriteLine("G1 F7800");
				file.WriteLine("G1 Z" + (5).ToString());
				WriteMove(file, center);

				for (int loop = 0; loop < loops; loop++)
				{
					for (int step = 0; step < steps; step++)
					{
						Vector2 nextPosition = new Vector2(radius, 0);
						nextPosition.Rotate(MathHelper.Tau / steps * step);
						WriteMove(file, center + nextPosition);
					}
				}

				file.WriteLine("M84     ; disable motors");
			}
		}

        // ------------------------------------------------------------------------------------------------
        private void MoveAndRotate_UserControlled(Vector3 moveIndicator, Vector2 rotationIndicator, float rollIndicator)
        {
            if (MyInput.Static.IsAnyCtrlKeyPressed())
            {
                if (MyInput.Static.PreviousMouseScrollWheelValue() < MyInput.Static.MouseScrollWheelValue())
                {
                    SpeedModeAngular = Math.Min(SpeedModeAngular * 1.5f, MAX_SPECTATOR_ANGULAR_SPEED);
                }
                else if (MyInput.Static.PreviousMouseScrollWheelValue() > MyInput.Static.MouseScrollWheelValue())
                {
                    SpeedModeAngular = Math.Max(SpeedModeAngular / 1.5f, MIN_SPECTATOR_ANGULAR_SPEED);
                }
            }
            else
            {
                if (MyInput.Static.PreviousMouseScrollWheelValue() < MyInput.Static.MouseScrollWheelValue())
                {
                    SpeedModeLinear = Math.Min(SpeedModeLinear * 1.5f, MAX_SPECTATOR_LINEAR_SPEED);
                }
                else if (MyInput.Static.PreviousMouseScrollWheelValue() > MyInput.Static.MouseScrollWheelValue())
                {
                    SpeedModeLinear = Math.Max(SpeedModeLinear / 1.5f, MIN_SPECTATOR_LINEAR_SPEED);
                }
            }

            //  Physical movement and rotation is based on constant time, therefore is indepedent of time delta
            //  This formulas works even if FPS is low or high, or if step size is 1/10 or 1/10000
            float amountOfMovement = VRage.Game.MyEngineConstants.UPDATE_STEP_SIZE_IN_SECONDS * 100;
            float amountOfRotation = 0.0025f * m_speedModeAngular;

            rollIndicator = MyInput.Static.GetDeveloperRoll();
            
            float rollAmount = 0;
            if (rollIndicator != 0)
            {
                Vector3D r, u;
                rollAmount = rollIndicator * m_speedModeAngular * 0.1f;
                rollAmount = MathHelper.Clamp(rollAmount, -0.02f, 0.02f);
                MyUtils.VectorPlaneRotation(m_orientation.Up, m_orientation.Right, out u, out r, rollAmount);
                m_orientation.Right = r;
                m_orientation.Up = u;
            }

            Vector3 moveVector;

            {
                if (AlignSpectatorToGravity)
                {
                    rotationIndicator.Rotate(m_roll); // TODO: ROLL

                    m_yaw -= rotationIndicator.Y * amountOfRotation;
                    m_pitch -= rotationIndicator.X * amountOfRotation;
                    m_roll -= rollAmount;

                    MathHelper.LimitRadians2PI(ref m_yaw);
                    m_pitch = MathHelper.Clamp(m_pitch, -Math.PI * 0.5f, Math.PI * 0.5f);
                    MathHelper.LimitRadians2PI(ref m_roll);

                    ComputeGravityAlignedOrientation(out m_orientation);
                }
                else
                {
                    if (rotationIndicator.Y != 0)
                    {
                        Vector3D r, f;
                        MyUtils.VectorPlaneRotation(m_orientation.Right, m_orientation.Forward, out r, out f,
                            -rotationIndicator.Y * amountOfRotation);

                        m_orientation.Right = r;
                        m_orientation.Forward = f;
                    }

                    if (rotationIndicator.X != 0)
                    {
                        Vector3D u, f;
                        MyUtils.VectorPlaneRotation(m_orientation.Up, m_orientation.Forward, out u, out f,
                            rotationIndicator.X * amountOfRotation);
                        m_orientation.Up = u;
                        m_orientation.Forward = f;
                    }

                    m_lastOrientation = m_orientation;
                    m_lastOrientationWeight = 1;
                    m_roll = 0;
                    m_pitch = 0;
                }

                float afterburner = (MyInput.Static.IsAnyShiftKeyPressed() ? 1.0f : 0.35f) *
                                    (MyInput.Static.IsAnyCtrlKeyPressed() ? 0.3f : 1);
                moveIndicator *= afterburner * SpeedModeLinear;
                moveVector = moveIndicator * amountOfMovement;
            }


            Position += Vector3.Transform(moveVector, m_orientation);
        }

        // 周期処理
        public override void Tick(float dt)
        {
            const float speed = 80;

            base.Tick (dt);
            if (Game.Instance.Pause)
                return;

            // SIN波の動きで移動
            var pos = this.Position;
            pos.Y += 1.7f * FMath.Sin (FrameCount * 0.015f);
            pos.X += speed * dt * direction;
            this.Position = pos;
            if (direction == 1) {
                if (this.Position.X > Game.Instance.ScreenSize.X - 100) {
                    direction = -1;
                }
            } else {
                if (this.Position.X < 100) {
                    direction = 1;
                }
            }

            counter += dt;

            // 敵弾を発射する周期を算出する
            float countBase = 1;
            if (Game.Instance.OptionDialog != null)
                countBase = 1 - 0.25f * Game.Instance.OptionDialog.BulletInterval / 100;

            if (counter > countBase) {

                // 敵弾を発射
                float[] angles = new float[]{
                     FMath.PI * 4 / 8,  FMath.PI * 3 / 8,  FMath.PI * 2 / 8,  FMath.PI * 1 / 8,0,
                    -FMath.PI * 4 / 8, -FMath.PI * 3 / 8, -FMath.PI * 2 / 8, -FMath.PI * 1 / 8};
                Vector2 srcvec = new Vector2 (0, -100f);
                foreach(float val in angles){
                    Game.Instance.AddQueue.Add (new BossBullet (this.Position, srcvec.Rotate (val)));
                }
                counter = 0;
            }
        }

        public void Leveling7PointsCorectInterpolation()
		{
			PrintLevelingData levelingData = new PrintLevelingData();

			double radius = 100;
			levelingData.SampledPositions = new List<Vector3>();
			Vector2 currentEdgePoint = new Vector2(radius, 0);
			for (int i = 0; i < 6; i++)
			{
				levelingData.SampledPositions.Add(new Vector3(currentEdgePoint, i));
				currentEdgePoint.Rotate(MathHelper.Tau / 6);
			}

			levelingData.SampledPositions.Add(new Vector3(0, 0, 6));

			Vector2 bedCenter = Vector2.Zero;

			RadialLevlingFunctions levelingFunctions7Point = new RadialLevlingFunctions(6, levelingData, bedCenter);
			for (int curPoint = 0; curPoint < 6; curPoint++)
			{
				int nextPoint = curPoint < 5 ? curPoint + 1 : 0;

				// test actual sample position
				Vector2 currentTestPoint = new Vector2(radius, 0);
				currentTestPoint.Rotate(MathHelper.Tau / 6 * curPoint);
				Vector3 destPosition = new Vector3(currentTestPoint, 0);
				Vector3 outPosition = levelingFunctions7Point.GetPositionWithZOffset(destPosition);
				Assert.AreEqual(outPosition.z, levelingData.SampledPositions[curPoint].z, .001);
				string outPositionString = levelingFunctions7Point.DoApplyLeveling(GetGCodeString(destPosition), destPosition, PrinterMachineInstruction.MovementTypes.Absolute);
				Assert.AreEqual(GetGCodeString(outPosition), outPositionString);

				// test mid point between samples
				Vector3 midPoint = (levelingData.SampledPositions[curPoint] + levelingData.SampledPositions[nextPoint]) / 2;
				currentTestPoint = new Vector2(midPoint.x, midPoint.y);
				destPosition = new Vector3(currentTestPoint, 0);
				outPosition = levelingFunctions7Point.GetPositionWithZOffset(destPosition);
				Assert.AreEqual(outPosition.z, midPoint.z, .001);
				outPositionString = levelingFunctions7Point.DoApplyLeveling(GetGCodeString(destPosition), destPosition, PrinterMachineInstruction.MovementTypes.Absolute);
				Assert.AreEqual(GetGCodeString(outPosition), outPositionString);

				// test mid point between samples with offset
				Vector3 midPointWithOffset = (levelingData.SampledPositions[curPoint] + levelingData.SampledPositions[nextPoint]) / 2 + new Vector3(0, 0, 3);
				currentTestPoint = new Vector2(midPointWithOffset.x, midPointWithOffset.y);
				destPosition = new Vector3(currentTestPoint, 3);
				outPosition = levelingFunctions7Point.GetPositionWithZOffset(destPosition);
				Assert.AreEqual(outPosition.z, midPointWithOffset.z, .001);
				outPositionString = levelingFunctions7Point.DoApplyLeveling(GetGCodeString(destPosition), destPosition, PrinterMachineInstruction.MovementTypes.Absolute);
				Assert.AreEqual(GetGCodeString(outPosition), outPositionString);

				// test 1/2 angles (mid way between samples on radius)
				currentTestPoint = new Vector2(radius, 0);
				currentTestPoint.Rotate(MathHelper.Tau / 6 * (curPoint + .5));
				destPosition = new Vector3(currentTestPoint, 0);
				outPosition = levelingFunctions7Point.GetPositionWithZOffset(destPosition);
				// the center is the higest point so the point on the radius has to be less than the mid point of the sample points (it is lower)
				Assert.IsTrue(outPosition.z < (levelingData.SampledPositions[curPoint].z + levelingData.SampledPositions[nextPoint].z) / 2 - .001);
				outPositionString = levelingFunctions7Point.DoApplyLeveling(GetGCodeString(destPosition), destPosition, PrinterMachineInstruction.MovementTypes.Absolute);
				Assert.AreEqual(GetGCodeString(outPosition), outPositionString);

				// test 1/2 to center
				currentTestPoint = new Vector2(radius / 2, 0);
				currentTestPoint.Rotate(MathHelper.Tau / 6 * curPoint);
				destPosition = new Vector3(currentTestPoint, 0);
				outPosition = levelingFunctions7Point.GetPositionWithZOffset(destPosition);
				Assert.AreEqual(outPosition.z, (levelingData.SampledPositions[curPoint].z + levelingData.SampledPositions[6].z) / 2, .001);
				outPositionString = levelingFunctions7Point.DoApplyLeveling(GetGCodeString(destPosition), destPosition, PrinterMachineInstruction.MovementTypes.Absolute);
				Assert.AreEqual(GetGCodeString(outPosition), outPositionString);
			}

			// prove that relative offsets work
			{
				Vector2 prevTestPoint = new Vector2(radius, 0);
				Vector3 prevDestPosition = new Vector3(prevTestPoint, 0);
				Vector3 prevOutPosition = levelingFunctions7Point.GetPositionWithZOffset(prevDestPosition);
				string prevOutPositionString = levelingFunctions7Point.DoApplyLeveling(GetGCodeString(prevDestPosition), prevDestPosition, PrinterMachineInstruction.MovementTypes.Absolute);

				for (int curPoint = 1; curPoint < 6; curPoint++)
				{
					// test actual sample position
					Vector2 currentTestPoint = new Vector2(radius, 0);
					currentTestPoint.Rotate(MathHelper.Tau / 6 * curPoint);
					Vector3 destPosition = new Vector3(currentTestPoint, 0);
					Vector3 outPosition = levelingFunctions7Point.GetPositionWithZOffset(destPosition);

					string outPositionString = levelingFunctions7Point.DoApplyLeveling(GetGCodeString(destPosition), destPosition, PrinterMachineInstruction.MovementTypes.Relative);
					Vector3 delatFromPrevToCurrent = outPosition - prevOutPosition;
					Assert.AreEqual(GetGCodeString(delatFromPrevToCurrent), outPositionString);

					prevTestPoint = currentTestPoint;
					prevDestPosition = destPosition;
					prevOutPosition = outPosition;
				}
			}

			Vector3 outPosition2 = levelingFunctions7Point.GetPositionWithZOffset(Vector3.Zero);
			Assert.AreEqual(outPosition2.z, levelingData.SampledPositions[6].z, .001);
		}

		public void DrawAACircle(Vector2 start, double radius, IColorType colorIn)
		{
			RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
			GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);

			Affine transform = GetTransform();
			if (!transform.is_identity())
			{
				transform.transform(ref start);
			}

			// now draw the end rounds
			int numSegments = 12;
			double anglePerSegment = MathHelper.Tau / numSegments;
			Vector2 currentOffset = new Vector2(0, radius);
			Vector2 curveStart = start + currentOffset;
			for (int i = 0; i < numSegments; i++)
			{
				currentOffset.Rotate(anglePerSegment);
				Vector2 curveEnd = start + currentOffset;

				triangleEddgeInfo.Draw1EdgeTriangle(curveStart, curveEnd, start);
				curveStart = curveEnd;
			}
		}

        public static void DrawEllipse(GLPen p, Vector2 firstPoint, Vector2 secondPoint, float height)
        {
            Vector2 deltaPoint = new Vector2(firstPoint.X - secondPoint.X, firstPoint.Y - secondPoint.Y);
            double angle = deltaPoint.ToRadians();
            deltaPoint = deltaPoint.Rotate90();
            //Vector2 thirdPoint = deltaPoint.Normalize() * height;
            float length = (float)firstPoint.DistanceTo(secondPoint);

            Vector2 PreRotDrawpoint = new Vector2(0, 0);
            Vector2 PostRotDrawPoint = new Vector2(0, 0);
            p.GLApplyPen();
            Gl.glPushMatrix();
            Gl.glTranslatef((float)firstPoint.X, (float)firstPoint.Y, 0);
            Gl.glBegin(Gl.GL_LINE_LOOP);
            for (double i = 0; i < Math.PI * 2; i += 0.05)
            {
                PreRotDrawpoint = new Vector2((float)(Math.Cos(i) * length), (float)(Math.Sin(i) * height));
                PostRotDrawPoint = PreRotDrawpoint.Rotate(angle);
                Gl.glVertex2f((float)PostRotDrawPoint.X, (float)PostRotDrawPoint.Y);
            }
            Gl.glEnd();
            Gl.glPopMatrix();
        }

		public static Vector2 GetPrintLevelPositionToSample(int index, double radius)
		{
			if (index < 6)
			{
				Vector2 position = new Vector2(radius, 0);
				position.Rotate(MathHelper.Tau / 6 * index);
				position += ActiveSliceSettings.Instance.BedCenter;
				return position;
			}
			else
			{
				return new Vector2(0, 0);
			}
		}

        //  Moves and rotates player by specified vector and angles
        public override void MoveAndRotate(Vector3 moveIndicator, Vector2 rotationIndicator, float rollIndicator)
        {
            switch (SpectatorCameraMovement)
            {
                case MySpectatorCameraMovementEnum.None:
                    return;
                    break;

                case MySpectatorCameraMovementEnum.ConstantDelta:
                    {
                        if (!MyInput.Static.IsAnyAltKeyPressed() && !MyInput.Static.IsAnyCtrlKeyPressed() && !MyInput.Static.IsAnyShiftKeyPressed())
                        {
                            if (MyInput.Static.PreviousMouseScrollWheelValue() < MyInput.Static.MouseScrollWheelValue())
                            {
                                ThirdPersonCameraDelta /= 1.1f;
                            }
                            else if (MyInput.Static.PreviousMouseScrollWheelValue() > MyInput.Static.MouseScrollWheelValue())
                            {
                                ThirdPersonCameraDelta *= 1.1f;
                            }
                        }

                        if (MySession.ControlledEntity != null)
                        {
                            Position = (Vector3D)MySession.ControlledEntity.Entity.PositionComp.GetPosition() + ThirdPersonCameraDelta;
                            Target = (Vector3D)MySession.ControlledEntity.Entity.PositionComp.GetPosition();
                        }
                    }
                    break;

                case MySpectatorCameraMovementEnum.UserControlled:
                    {
                        if (MyInput.Static.IsAnyCtrlKeyPressed())
                        {
                            if (MyInput.Static.PreviousMouseScrollWheelValue() < MyInput.Static.MouseScrollWheelValue())
                            {
                                SpeedModeAngular = Math.Min(SpeedModeAngular * 1.5f, MAX_SPECTATOR_ANGULAR_SPEED);
                            }
                            else if (MyInput.Static.PreviousMouseScrollWheelValue() > MyInput.Static.MouseScrollWheelValue())
                            {
                                SpeedModeAngular = Math.Max(SpeedModeAngular / 1.5f, MIN_SPECTATOR_ANGULAR_SPEED);
                            }
                        }
                        else
                        {
                            if (MyInput.Static.PreviousMouseScrollWheelValue() < MyInput.Static.MouseScrollWheelValue())
                            {
                                SpeedModeLinear = Math.Min(SpeedModeLinear * 1.5f, MAX_SPECTATOR_LINEAR_SPEED);
                            }
                            else if (MyInput.Static.PreviousMouseScrollWheelValue() > MyInput.Static.MouseScrollWheelValue())
                            {
                                SpeedModeLinear = Math.Max(SpeedModeLinear / 1.5f, MIN_SPECTATOR_LINEAR_SPEED);
                            }
                        }

                        //  Physical movement and rotation is based on constant time, therefore is indepedent of time delta
                        //  This formulas works even if FPS is low or high, or if step size is 1/10 or 1/10000
                        float amountOfMovement = MyEngineConstants.UPDATE_STEP_SIZE_IN_SECONDS * 100;
                        float amountOfRotation = 0.0025f * m_speedModeAngular;

                        if (MyFakes.ENABLE_DEVELOPER_SPECTATOR_CONTROLS)
                        {
                            rollIndicator = MyInput.Static.GetDeveloperRoll();
                        }

                        float rollAmount = 0;
                        if (rollIndicator != 0)
                        {
                            Vector3D r, u;
                            rollAmount = rollIndicator * m_speedModeAngular * 0.1f;
                            rollAmount = MathHelper.Clamp(rollAmount, -0.02f, 0.02f);
                            MyUtils.VectorPlaneRotation(m_orientation.Up, m_orientation.Right, out u, out r, rollAmount);
                            m_orientation.Right = r;
                            m_orientation.Up = u;
                        }

                        Vector3 moveVector;

                        if (MyPerGameSettings.RestrictSpectatorFlyMode && !MyFakes.ENABLE_DEVELOPER_SPECTATOR_CONTROLS)
                        {
                            // Spectator has constatnt speed (reset speed to default value)
                            SpeedModeLinear = 11 * MyEngineConstants.UPDATE_STEP_SIZE_IN_SECONDS;
                            if (MyInput.Static.IsAnyShiftKeyPressed())
                                SpeedModeLinear *= 5;

                            Vector3D forward = m_orientation.Forward;
                            double sinX = forward.Dot(ref Vector3D.Up);
                            double angleX = Math.Asin(sinX);
                            double angleY;
                            if (MyUtils.IsZero(sinX - 1f))
                            {
                                // Looking up
                                var up = m_orientation.Up;
                                angleY = Math.Atan2(up.Dot(ref Vector3D.Right), up.Dot(ref Vector3D.Backward));
                            }
                            else if (MyUtils.IsZero(sinX + 1f))
                            {
                                // Looking down
                                var up = m_orientation.Up;
//.........这里部分代码省略.........

        public static void WriteTestGCodeFile()
        {
            StringBuilder gcodeStringBuilder = new StringBuilder();

            int loops = 5;
            int steps = 200;
            double radius = 40;
            Vector2 center = new Vector2(50, 50);

            gcodeStringBuilder.AppendLine("G28 ; home all axes");
            gcodeStringBuilder.AppendLine("G90 ; use absolute coordinates");
            gcodeStringBuilder.AppendLine("G21 ; set units to millimeters");
            gcodeStringBuilder.AppendLine("G92 E0");
            gcodeStringBuilder.AppendLine("G1 F7800.000");
            gcodeStringBuilder.AppendLine("G1 Z" + (30).ToString());
            WriteMove(gcodeStringBuilder, center);

            for (int loop = 0; loop < loops; loop++)
            {
                for (int step = 0; step < steps; step++)
                {
                    Vector2 nextPosition = new Vector2(radius, 0);
                    nextPosition.Rotate(MathHelper.Tau / steps * step);
                    WriteMove(gcodeStringBuilder, center + nextPosition);
                }
            }

            gcodeStringBuilder.AppendLine("M84     ; disable motors");

            System.IO.File.WriteAllText("PerformanceTest.gcode", gcodeStringBuilder.ToString());
        }

 /// <summary>Lerp 2 (assumed) unit vectors (shortest path).</summary>
 public static Vector2 LerpUnitVectors( Vector2 va, Vector2 vb, float x )
 {
     return va.Rotate( va.Angle( vb ) * x );
 }

		public static Vector2 GetPrintLevelPositionToSample(int index, double radius)
		{
			if (index < 6)
			{
				Vector2 postion = new Vector2(radius, 0);
				postion.Rotate(MathHelper.Tau / 6 * index);
				return postion;
			}
			else
			{
				return new Vector2(0, 0);
			}
		}