コード例 #1
0
        public override void UpdateDataFromPhysicsEngine()
        {
            if (MotionType.Value == MotionTypeEnum.Dynamic && rigidBody != null)
            {
                var position = Physics2DUtility.Convert(rigidBody.Position);
                var rotation = -rigidBody.Rotation;

                var oldT = Transform.Value;

                Matrix3F.FromRotateByZ(rotation, out var mat3);
                var rot2 = mat3.ToQuaternion();
                //var rot2 = new Angles( 0, 0, MathEx.RadianToDegree( rot ) );

                var newT = new Transform(new Vector3(position.X, position.Y, oldT.Position.Z), rot2, oldT.Scale);

                try
                {
                    updatePropertiesWithoutUpdatingBody = true;
                    Transform       = newT;
                    LinearVelocity  = Physics2DUtility.Convert(rigidBody.LinearVelocity);
                    AngularVelocity = MathEx.RadianToDegree(rigidBody.AngularVelocity);
                }
                finally
                {
                    updatePropertiesWithoutUpdatingBody = false;
                }
            }
        }
コード例 #2
0
        public override void UpdateDataFromPhysicsEngine()
        {
            if (ConstraintRigid != null)
            {
                Transform rigidBodyTransform;

                {
                    var rigidBody = ConstraintRigid.BodyA;

                    var position = Physics2DUtility.Convert(rigidBody.Position);
                    var rotation = -rigidBody.Rotation;

                    var oldT = Transform.Value;

                    Matrix3F.FromRotateByZ(rotation, out var mat3);
                    var rot2 = mat3.ToQuaternion();
                    //var rot2 = new Angles( 0, 0, MathEx.RadianToDegree( rot ) );

                    rigidBodyTransform = new Transform(new Vector3(position.X, position.Y, oldT.Position.Z), rot2);
                }

                {
                    var transformA = rigidBodyTransform.ToMatrix4() * ConstraintAFrame;
                    transformA.Decompose(out Vector3 translation, out Matrix3 rotation, out Vector3 scale);
                    var oldT = Transform.Value;
                    var newT = new Transform(translation, rotation.ToQuaternion(), oldT.Scale);

                    SetTransformWithoutUpdatingConstraint(newT);
                }
            }
        }
コード例 #3
0
        public void ToMatrix3(out Matrix3F result)
        {
            float x2 = X + X;
            float y2 = Y + Y;
            float z2 = Z + Z;
            float xx = X * x2;
            float xy = X * y2;
            float xz = X * z2;
            float yy = Y * y2;
            float yz = Y * z2;
            float zz = Z * z2;
            float wx = W * x2;
            float wy = W * y2;
            float wz = W * z2;

            result.Item0.X = 1.0f - (yy + zz);
            result.Item0.Y = xy + wz;
            result.Item0.Z = xz - wy;
            result.Item1.X = xy - wz;
            result.Item1.Y = 1.0f - (xx + zz);
            result.Item1.Z = yz + wx;
            result.Item2.X = xz + wy;
            result.Item2.Y = yz - wx;
            result.Item2.Z = 1.0f - (xx + yy);
            //return new Mat3( 1.0f - ( yy + zz ), xy + wz, xz - wy,
            //   xy - wz, 1.0f - ( xx + zz ), yz + wx,
            //   xz + wy, yz - wx, 1.0f - ( xx + yy ) );
        }
コード例 #4
0
ファイル: Camera.cs プロジェクト: yzylovepmn/YDrawing2D
        private void _UpdateViewMatrix()
        {
            var zaxis = -_lookDirection;

            zaxis.Normalize();

            var xaxis = Vector3F.CrossProduct(_upDirection, zaxis);

            xaxis.Normalize();

            var yaxis = Vector3F.CrossProduct(zaxis, xaxis);

            var positionVec = (Vector3F)_position;
            var cx          = -Vector3F.DotProduct(xaxis, positionVec);
            var cy          = -Vector3F.DotProduct(yaxis, positionVec);
            var cz          = -Vector3F.DotProduct(zaxis, positionVec);

            _viewMatrix = new Matrix3F(
                xaxis.X, yaxis.X, zaxis.X, 0,
                xaxis.Y, yaxis.Y, zaxis.Y, 0,
                xaxis.Z, yaxis.Z, zaxis.Z, 0,
                cx, cy, cz, 1);

            _OnTransformChanged();
        }
コード例 #5
0
ファイル: Program.cs プロジェクト: zhuchen115/Kinematics
        static void Main(string[] args)
        {
            List <IJoint> joints    = Robot6DOF.Get6DOFRobot(2, 2, 2, 2, 2, 2);
            Transform3D   base_axis = new Transform3D(new Vector3F(0, 0, 0), new Vector3F(0, 0, 0));

            Transform3D tf3d = base_axis;

            tf3d.RotationMat = Matrix3F.GetUnitMatrix();

            joints[0].Transform = new Vector3F(0, 0, Math.PI * 4 / 6);
            joints[1].Transform = new Vector3F(0, Math.PI * 5 / 6, 0);
            joints[2].Transform = new Vector3F(0, Math.PI / 6, 0);
            joints[3].Transform = new Vector3F(0, 0, Math.PI / 6);
            joints[4].Transform = new Vector3F(0, Math.PI / 3, 0);
            joints[5].Transform = new Vector3F(0, 0, Math.PI / 4);

            foreach (IJoint jo in joints)
            {
                tf3d = jo.GetEndPointState(tf3d);
            }

            Console.WriteLine("6DOF");

            Vector3F2 transform = Robot6DOF.Inverse6DOF(ref joints, tf3d);

            Console.WriteLine("The endpoint position is {0}, euler rotation is {1}", tf3d.Position - base_axis.Position, tf3d.Rotation);
            Console.WriteLine("Robot Joint Transform: {0}", transform.ToString());
            Console.ReadLine();
        }
コード例 #6
0
ファイル: TestMatrix3F.cs プロジェクト: Joxx0r/ATF
        private void TestToStringWithCulture(CultureInfo culture)
        {
            CultureInfo originalCulture = Thread.CurrentThread.CurrentCulture;
            Thread.CurrentThread.CurrentCulture = culture;
            try
            {
                string listSeparator = culture.TextInfo.ListSeparator;
                string decimalSeparator = culture.NumberFormat.NumberDecimalSeparator;
                var o = new Matrix3F(
                    1.1f, 2.2f, 3.3f,
                    4.4f, 5.5f, 6.6f,
                    7.7f, 8.8f, 9.9f);

                string s = o.ToString(null, null);
                TestToStringResults(o, s, listSeparator, decimalSeparator);

                string s2 = o.ToString();
                Assert.AreEqual(s, s2);

                s = o.ToString("G", culture);
                TestToStringResults(o, s, listSeparator, decimalSeparator);

                s = o.ToString("R", culture);
                TestToStringResults(o, s, listSeparator, decimalSeparator);
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = originalCulture;
            }
        }
コード例 #7
0
ファイル: TestMatrix3F.cs プロジェクト: zparr/ATF
        private void TestToStringWithCulture(CultureInfo culture)
        {
            CultureInfo originalCulture = Thread.CurrentThread.CurrentCulture;

            Thread.CurrentThread.CurrentCulture = culture;
            try
            {
                string listSeparator    = culture.TextInfo.ListSeparator;
                string decimalSeparator = culture.NumberFormat.NumberDecimalSeparator;
                var    o = new Matrix3F(
                    1.1f, 2.2f, 3.3f,
                    4.4f, 5.5f, 6.6f,
                    7.7f, 8.8f, 9.9f);

                string s = o.ToString(null, null);
                TestToStringResults(o, s, listSeparator, decimalSeparator);

                string s2 = o.ToString();
                Assert.AreEqual(s, s2);

                s = o.ToString("G", culture);
                TestToStringResults(o, s, listSeparator, decimalSeparator);

                s = o.ToString("R", culture);
                TestToStringResults(o, s, listSeparator, decimalSeparator);
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = originalCulture;
            }
        }
コード例 #8
0
 public static void Convert(ref Matrix3F mat, out OgreMatrix3 result)
 {
     result.mat0 = mat.Item0;
     result.mat1 = mat.Item1;
     result.mat2 = mat.Item2;
     result.Transpose();
 }
コード例 #9
0
        public void Matrix3()
        {
            string fs =
                @"#version 330

                  uniform mat3 exampleMat3;
                  out vec3 FragColor;

                  void main()
                  {
                      FragColor = vec3(exampleMat3[0].y, exampleMat3[2].x, 0.0);
                  }";

            using (GraphicsWindow window = Device.CreateWindow(1, 1))
                using (Framebuffer framebuffer = TestUtility.CreateFramebuffer(window.Context))
                    using (ShaderProgram sp = Device.CreateShaderProgram(ShaderSources.PassThroughVertexShader(), fs))
                        using (VertexArray va = TestUtility.CreateVertexArray(window.Context, sp.VertexAttributes["position"].Location))
                        {
                            Matrix3F m3 = new Matrix3F(
                                0.0f, 0.0f, 1.0f,
                                1.0f, 0.0f, 0.0f,
                                0.0f, 0.0f, 0.0f);
                            Uniform <Matrix3F> exampleMat3 = (Uniform <Matrix3F>)sp.Uniforms["exampleMat3"];
                            Assert.AreEqual("exampleMat3", exampleMat3.Name);
                            Assert.AreEqual(UniformType.FloatMatrix33, exampleMat3.Datatype);
                            Assert.AreEqual(new Matrix3F(), exampleMat3.Value);
                            exampleMat3.Value = m3;
                            Assert.AreEqual(m3, exampleMat3.Value);

                            window.Context.Framebuffer = framebuffer;
                            window.Context.Draw(PrimitiveType.Points, 0, 1, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState());
                            TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 255, 0);
                        }
        }
コード例 #10
0
ファイル: SphereF.cs プロジェクト: zwiglm/NeoAxisEngine
        public bool Intersects(ref BoxF box)
        {
            Matrix3F transposedAxis;

            box.Axis.GetTranspose(out transposedAxis);

            //Vec3 diff = origin - box.center;
            Vector3F diff;

            Vector3F.Subtract(ref Origin, ref box.Center, out diff);

            //Vec3 localSpherePosition = inverseBoxAxis * diff;
            Vector3F localSpherePosition;

            Matrix3F.Multiply(ref transposedAxis, ref diff, out localSpherePosition);

            float distanceSquared = 0;

            for (int n = 0; n < 3; n++)
            {
                if (localSpherePosition[n] > box.Extents[n])
                {
                    float z = localSpherePosition[n] - box.Extents[n];
                    distanceSquared += z * z;
                }
                else if (localSpherePosition[n] < -box.Extents[n])
                {
                    float z = -box.Extents[n] - localSpherePosition[n];
                    distanceSquared += z * z;
                }
            }

            return(distanceSquared <= Radius * Radius);
        }
コード例 #11
0
        public override void OnHotSpotDragEnd(HotSpotBase hotSpot, VisionViewBase view)
        {
            base.OnHotSpotDragEnd(hotSpot, view);

            if (hotSpot == _hotSpotWindSpeed)
            {
                Vector3F vNewSpeed = _hotSpotWindSpeed.CurrentPosition;
                Vector3F vOldSpeed = _hotSpotWindSpeed.StartPosition;
                if (WindInLocalSpace)
                {
                    Matrix3F rot = Matrix3F.Transpose(RotationMatrix);
                    vNewSpeed = Matrix3F.Transform(rot, vNewSpeed);
                    vOldSpeed = Matrix3F.Transform(rot, vOldSpeed);
                }
                WindSpeed = vOldSpeed;                                                                              // set old value for the action
                EditorManager.Actions.Add(SetPropertyAction.CreateSetPropertyAction(this, "WindSpeed", vNewSpeed)); // send an action which sets the property from old value to new one
            }
            else if (hotSpot == _hotSpotLightSamplingOffset)
            {
                Vector3F vNewOffset = _hotSpotLightSamplingOffset.CurrentPosition;
                Vector3F vOldOffset = _hotSpotLightSamplingOffset.StartPosition;

                LightSamplingOffset = vOldOffset;                                                                              // set old value for the action
                EditorManager.Actions.Add(SetPropertyAction.CreateSetPropertyAction(this, "LightSamplingOffset", vNewOffset)); // send an action which sets the property from old value to new one
            }
        }
コード例 #12
0
ファイル: TestMatrix3F.cs プロジェクト: Joxx0r/ATF
 private void TestToStringResults(Matrix3F o, string s, string listSeparator, string decimalSeparator)
 {
     string[] results = s.Split(new[] { listSeparator }, StringSplitOptions.RemoveEmptyEntries);
     Assert.AreEqual(results.Length, 9);
     for (int i = 0; i < 9; i++)
     {
         Assert.True(results[i].Contains(decimalSeparator));
         float result = float.Parse(results[i]);
         Assert.AreEqual(result, o[i]);
     }
 }
コード例 #13
0
ファイル: TestMatrix3F.cs プロジェクト: zparr/ATF
 private void TestToStringResults(Matrix3F o, string s, string listSeparator, string decimalSeparator)
 {
     string[] results = s.Split(new[] { listSeparator }, StringSplitOptions.RemoveEmptyEntries);
     Assert.AreEqual(results.Length, 9);
     for (int i = 0; i < 9; i++)
     {
         Assert.True(results[i].Contains(decimalSeparator));
         float result = float.Parse(results[i]);
         Assert.AreEqual(result, o[i]);
     }
 }
コード例 #14
0
 /// <summary>
 /// Converts the current instance of <see cref="Matrix2F"/> into the equivalent <see cref="Matrix3F"/> structure.
 /// </summary>
 /// <param name="result">When the method completes, contains the equivalent <see cref="Matrix3F"/> structure.</param>
 public void ToMatrix3F(out Matrix3F result)
 {
     result.Item0.X = Item0.X;
     result.Item0.Y = Item0.Y;
     result.Item0.Z = 0;
     result.Item1.X = Item1.X;
     result.Item1.Y = Item1.Y;
     result.Item1.Z = 0;
     result.Item2.X = 0;
     result.Item2.Y = 0;
     result.Item2.Z = 1;
 }
コード例 #15
0
ファイル: Camera.cs プロジェクト: yzylovepmn/YDrawing2D
 private void _OnTransformChanged()
 {
     _totalTransform = _viewMatrix * _projectionMatrix;
     if (_totalTransform.HasInverse)
     {
         var totalTransformReverse = _totalTransform;
         totalTransformReverse.Invert();
         _totalTransformReverse = totalTransformReverse;
     }
     if (!_isLocked)
     {
         PropertyChanged(this, EventArgs.Empty);
     }
 }
コード例 #16
0
        public void MeshInSpaceAnimationController_CalculateBoneTransforms(NeoAxis.Component_MeshInSpaceAnimationController sender, NeoAxis.Component_SkeletonAnimationTrack.CalculateBoneTransformsItem[] result)
        {
            //to enable this event handler in the editor change "When Enable" property to "Simulation | Instance | Editor".
            //component: Character/Mesh In Space/C# Script/Event Handler CalculateBoneTransforms.
            var boneIndex = sender.GetBoneIndex("chest");

            if (boneIndex != -1)
            {
                ref var item = ref result[boneIndex];
                //calculate bone offset
                var angle  = new Degree(60) * Math.Sin(Time.Current);
                var offset = Matrix3F.FromRotateByY((float)angle.InRadians()).ToQuaternion();
                //update the bone
                item.Rotation *= offset;
            }
コード例 #17
0
ファイル: Camera.cs プロジェクト: yzylovepmn/YDrawing2D
        private void _UpdateProjectionMatrix()
        {
            switch (_type)
            {
            case CameraType.Perspective:
                _projectionMatrix = _GeneratePerspectiveMatrix();
                break;

            case CameraType.Orthographic:
                _projectionMatrix = _GenerateOrthographicMatrix();
                break;
            }

            _OnTransformChanged();
        }
コード例 #18
0
ファイル: Camera.cs プロジェクト: yzylovepmn/YDrawing2D
        private Matrix3F _GeneratePerspectiveMatrix()
        {
            var mat = new Matrix3F();

            var tanHalfFovy = (float)Math.Tan(MathUtil.DegreesToRadians(_fieldOfView / 2));
            var deep        = _farPlaneDistance - _nearPlaneDistance;

            mat.M11     = 1 / (_aspect * tanHalfFovy);
            mat.M22     = 1 / tanHalfFovy;
            mat.M33     = float.IsInfinity(_farPlaneDistance) ? -1 : -(_farPlaneDistance + _nearPlaneDistance) / deep;
            mat.M44     = 0;
            mat.M34     = -1;
            mat.OffsetZ = float.IsInfinity(_farPlaneDistance) ? -2 * _nearPlaneDistance : -2 * _farPlaneDistance * _nearPlaneDistance / deep;

            return(mat);
        }
コード例 #19
0
ファイル: ImportFBX.cs プロジェクト: yf885188/NeoAxisEngine
 static bool HasTransformMatrixNegParity(Matrix3F m)
 {
     return(Vector3F.Dot(Vector3F.Cross(m.Item0, m.Item1), m.Item2) < 0.0f ? true : false);
 }
コード例 #20
0
 public void GetLightingCubemapRotationMatrix(out Matrix3F result)
 {
     Matrix3.FromRotateByZ(LightingCubemapRotation.Value.InRadians()).ToMatrix3F(out result);
 }
コード例 #21
0
        //

        static SimpleTypes()
        {
            //string
            RegisterType(typeof(string), delegate(string value)
            {
                if (value == null)
                {
                    return("");
                    //throw new Exception( "GetSimpleTypeValue: string type, value = null" );
                }
                return(value);
            }, "");

            //bool
            RegisterType(typeof(bool), delegate(string value)
            {
                string lower = value.ToLower();
                if (value == "1" || lower == "yes" || lower == "true")
                {
                    return(true);
                }
                else if (value == "0" || lower == "no" || lower == "false")
                {
                    return(false);
                }
                else
                {
                    return(bool.Parse(value));
                }
            }, false);

            //sbyte
            RegisterType(typeof(sbyte), delegate(string value) { return(sbyte.Parse(value)); }, 0);

            //byte
            RegisterType(typeof(byte), delegate(string value) { return(byte.Parse(value)); }, 0);

            //char
            RegisterType(typeof(char), delegate(string value) { return(char.Parse(value)); }, 0);

            //short
            RegisterType(typeof(short), delegate(string value) { return(short.Parse(value)); }, 0);

            //ushort
            RegisterType(typeof(ushort), delegate(string value) { return(ushort.Parse(value)); }, 0);

            //int
            RegisterType(typeof(int), delegate(string value) { return(int.Parse(value)); }, 0);

            //uint
            RegisterType(typeof(uint), delegate(string value) { return(uint.Parse(value)); }, (uint)0);

            //long
            RegisterType(typeof(long), delegate(string value) { return(long.Parse(value)); }, (long)0);

            //ulong
            RegisterType(typeof(ulong), delegate(string value) { return(ulong.Parse(value)); }, (ulong)0);

            //float
            RegisterType(typeof(float), delegate(string value) { return(float.Parse(value)); }, 0.0f);

            //double
            RegisterType(typeof(double), delegate(string value) { return(double.Parse(value)); }, 0.0);

            //decimal
            RegisterType(typeof(decimal), delegate(string value) { return(decimal.Parse(value)); }, (decimal)0.0);

            //Vec2
            RegisterType(typeof(Vector2F), delegate(string value) { return(Vector2F.Parse(value)); }, Vector2F.Zero);

            //Range
            RegisterType(typeof(RangeF), delegate(string value) { return(RangeF.Parse(value)); }, RangeF.Zero);

            //Vec3
            RegisterType(typeof(Vector3F), delegate(string value) { return(Vector3F.Parse(value)); }, Vector3F.Zero);

            //Vec4
            RegisterType(typeof(Vector4F), delegate(string value) { return(Vector4F.Parse(value)); }, Vector4F.Zero);

            //Bounds
            RegisterType(typeof(BoundsF), delegate(string value) { return(BoundsF.Parse(value)); }, BoundsF.Zero);

            //Quat
            RegisterType(typeof(QuaternionF), delegate(string value) { return(QuaternionF.Parse(value)); }, QuaternionF.Identity);

            //ColorValue
            RegisterType(typeof(ColorValue), delegate(string value) { return(ColorValue.Parse(value)); }, ColorValue.Zero);

            //ColorValuePowered
            RegisterType(typeof(ColorValuePowered), delegate(string value) { return(ColorValuePowered.Parse(value)); }, ColorValuePowered.Zero);

            //ColorPacked
            RegisterType(typeof(ColorByte), delegate(string value) { return(ColorByte.Parse(value)); }, ColorByte.Zero);

            //SphereDir
            RegisterType(typeof(SphericalDirectionF), delegate(string value) { return(SphericalDirectionF.Parse(value)); }, SphericalDirectionF.Zero);

            //Vec2I
            RegisterType(typeof(Vector2I), delegate(string value) { return(Vector2I.Parse(value)); }, Vector2I.Zero);

            //Vec3I
            RegisterType(typeof(Vector3I), delegate(string value) { return(Vector3I.Parse(value)); }, Vector3I.Zero);

            //Vec4I
            RegisterType(typeof(Vector4I), delegate(string value) { return(Vector4I.Parse(value)); }, Vector4I.Zero);

            //Rect
            RegisterType(typeof(RectangleF), delegate(string value) { return(RectangleF.Parse(value)); }, RectangleF.Zero);

            //RectI
            RegisterType(typeof(RectangleI), delegate(string value) { return(RectangleI.Parse(value)); }, RectangleI.Zero);

            //Degree
            RegisterType(typeof(DegreeF), delegate(string value) { return(DegreeF.Parse(value)); }, DegreeF.Zero);

            //Radian
            RegisterType(typeof(RadianF), delegate(string value) { return(RadianF.Parse(value)); }, RadianF.Zero);

            //Vec2D
            RegisterType(typeof(Vector2), delegate(string value) { return(Vector2.Parse(value)); }, Vector2.Zero);

            //RangeD
            RegisterType(typeof(Range), delegate(string value) { return(Range.Parse(value)); }, Range.Zero);

            //RangeI
            RegisterType(typeof(RangeI), delegate(string value) { return(RangeI.Parse(value)); }, RangeI.Zero);

            //Vec3D
            RegisterType(typeof(Vector3), delegate(string value) { return(Vector3.Parse(value)); }, Vector3.Zero);

            //Vec4D
            RegisterType(typeof(Vector4), delegate(string value) { return(Vector4.Parse(value)); }, Vector4.Zero);

            //BoundsD
            RegisterType(typeof(Bounds), delegate(string value) { return(Bounds.Parse(value)); }, Bounds.Zero);

            //QuatD
            RegisterType(typeof(Quaternion), delegate(string value) { return(Quaternion.Parse(value)); }, Quaternion.Identity);

            //SphereDirD
            RegisterType(typeof(SphericalDirection), delegate(string value) { return(SphericalDirection.Parse(value)); }, SphericalDirection.Zero);

            //RectD
            RegisterType(typeof(Rectangle), delegate(string value) { return(Rectangle.Parse(value)); }, Rectangle.Zero);

            //DegreeD
            RegisterType(typeof(Degree), delegate(string value) { return(Degree.Parse(value)); }, Degree.Zero);

            //RadianD
            RegisterType(typeof(Radian), delegate(string value) { return(Radian.Parse(value)); }, Radian.Zero);

            //Angles
            RegisterType(typeof(AnglesF), delegate(string value) { return(AnglesF.Parse(value)); }, AnglesF.Zero);

            //AnglesD
            RegisterType(typeof(Angles), delegate(string value) { return(Angles.Parse(value)); }, Angles.Zero);

            //Mat2F
            RegisterType(typeof(Matrix2F), delegate(string value) { return(Matrix2F.Parse(value)); }, Matrix2F.Zero);

            //Mat2D
            RegisterType(typeof(Matrix2), delegate(string value) { return(Matrix2.Parse(value)); }, Matrix2.Zero);

            //Mat3F
            RegisterType(typeof(Matrix3F), delegate(string value) { return(Matrix3F.Parse(value)); }, Matrix3F.Zero);

            //Mat3D
            RegisterType(typeof(Matrix3), delegate(string value) { return(Matrix3.Parse(value)); }, Matrix3.Zero);

            //Mat4F
            RegisterType(typeof(Matrix4F), delegate(string value) { return(Matrix4F.Parse(value)); }, Matrix4F.Zero);

            //Mat4D
            RegisterType(typeof(Matrix4), delegate(string value) { return(Matrix4.Parse(value)); }, Matrix4.Zero);

            //PlaneF
            RegisterType(typeof(PlaneF), delegate(string value) { return(PlaneF.Parse(value)); }, PlaneF.Zero);

            //PlaneD
            RegisterType(typeof(Plane), delegate(string value) { return(Plane.Parse(value)); }, Plane.Zero);

            //Transform
            RegisterType(typeof(Transform), delegate(string value) { return(Transform.Parse(value)); }, Transform.Identity);

            //UIMeasureValueDouble
            RegisterType(typeof(UIMeasureValueDouble), delegate(string value) { return(UIMeasureValueDouble.Parse(value)); }, new UIMeasureValueDouble());

            //UIMeasureValueVec2
            RegisterType(typeof(UIMeasureValueVector2), delegate(string value) { return(UIMeasureValueVector2.Parse(value)); }, new UIMeasureValueVector2());

            //UIMeasureValueRect
            RegisterType(typeof(UIMeasureValueRectangle), delegate(string value) { return(UIMeasureValueRectangle.Parse(value)); }, new UIMeasureValueRectangle());

            RegisterType(typeof(RangeVector3F), delegate(string value) { return(RangeVector3F.Parse(value)); }, RangeVector3F.Zero);
            RegisterType(typeof(RangeColorValue), delegate(string value) { return(RangeColorValue.Parse(value)); }, RangeColorValue.Zero);

            //no Parse methods. This is complex structures. This is not simple types? or just can't parse?
            //Box
            //Capsule
            //Cone
            //Line3
            //Line2
            //Ray
            //Frustum?

            RegisterConvertDoubleToFloatTypes();
        }
コード例 #22
0
ファイル: PathShape.cs プロジェクト: bgarrels/projectanarchy
        /// <summary>
        /// Overridden function to create the shape instance
        /// </summary>
        /// <returns></returns>
        public override ShapeBase CreateShapeInstance()
        {
            PathShape shape = new PathShape("Circle Path");
              shape.Position = EditorManager.Scene.CurrentShapeSpawnPosition;
              shape.Closed = true;

              // Magic number: http://www.tinaja.com/glib/ellipse4.pdf
              float fMagic = 0.551784f;
              float fRadius = 200.0f * EditorManager.Settings.GlobalUnitScaling;

              Vector3F rotCenter = shape.Position;
              Vector3F rotAngle = new Vector3F(0.0f, 0.0f, 0.0f);
              Matrix3F rotMatrix = new Matrix3F();
              rotMatrix.FromEuler(rotAngle.X, rotAngle.Y, rotAngle.Z);
              PathNodeShape node;

              for (int i = 0; i < 4; i++)
              {
            node = new PathNodeShape();
            node.Position = shape.Position;
            node.y -= fRadius;

            node.TangentIn = new Vector3F(node.TangentIn.X - fRadius * fMagic, 0.0f, 0.0f);
            node.TangentOut = new Vector3F(node.TangentOut.X + fRadius * fMagic, 0.0f, 0.0f);

            node.Position = shape.Position + rotMatrix * (node.Position - rotCenter);
            node.TangentIn = rotMatrix * (node.TangentIn);
            node.TangentOut = rotMatrix * (node.TangentOut);

            node.InType = PathNodeShape.PathNodeInOutType.Custom;
            node.OutType = PathNodeShape.PathNodeInOutType.Custom;

            node.ShapeName = "node" + i;

            node.SetParent(shape);

            rotAngle.X += 90.0f;
            rotMatrix.FromEuler(rotAngle.X, rotAngle.Y, rotAngle.Z);
              }

              return shape;
        }
コード例 #23
0
ファイル: EulerAngles.cs プロジェクト: JanDeHud/LevelEditor
        /// <summary>
        /// Calculates the rotation matrix representing the given Euler angles and in the correct order</summary>
        /// <returns>Rotation matrix</returns>
        public Matrix3F CalculateMatrix()
        {
            Matrix3F M = new Matrix3F();
            Matrix3F temp = new Matrix3F();

            switch (m_Order)
            {
                case EulerAngleOrder.XYZ:
                    if (m_Angles.X != 0)
                    {
                        temp.RotX(m_Angles.X);
                        M.Mul(M, temp);
                    }
                    if (m_Angles.Y != 0)
                    {
                        temp.RotY(m_Angles.Y);
                        M.Mul(M, temp);
                    }
                    if (m_Angles.Z != 0)
                    {
                        temp.RotZ(m_Angles.Z);
                        M.Mul(M, temp);
                    }
                    break;
                case EulerAngleOrder.XZY:
                    if (m_Angles.X != 0)
                    {
                        temp.RotX(m_Angles.X);
                        M.Mul(M, temp);
                    }
                    if (m_Angles.Z != 0)
                    {
                        temp.RotZ(m_Angles.Z);
                        M.Mul(M, temp);
                    }
                    if (m_Angles.Y != 0)
                    {
                        temp.RotY(m_Angles.Y);
                        M.Mul(M, temp);
                    }
                    break;
                case EulerAngleOrder.YXZ:
                    if (m_Angles.Y != 0)
                    {
                        temp.RotY(m_Angles.Y);
                        M.Mul(M, temp);
                    }
                    if (m_Angles.X != 0)
                    {
                        temp.RotX(m_Angles.X);
                        M.Mul(M, temp);
                    }
                    if (m_Angles.Z != 0)
                    {
                        temp.RotZ(m_Angles.Z);
                        M.Mul(M, temp);
                    }
                    break;
                case EulerAngleOrder.YZX:
                    if (m_Angles.Y != 0)
                    {
                        temp.RotY(m_Angles.Y);
                        M.Mul(M, temp);
                    }
                    if (m_Angles.Z != 0)
                    {
                        temp.RotZ(m_Angles.Z);
                        M.Mul(M, temp);
                    }
                    if (m_Angles.X != 0)
                    {
                        temp.RotX(m_Angles.X);
                        M.Mul(M, temp);
                    }
                    break;
                case EulerAngleOrder.ZXY:
                    if (m_Angles.Z != 0)
                    {
                        temp.RotZ(m_Angles.Z);
                        M.Mul(M, temp);
                    }
                    if (m_Angles.X != 0)
                    {
                        temp.RotX(m_Angles.X);
                        M.Mul(M, temp);
                    }
                    if (m_Angles.Y != 0)
                    {
                        temp.RotY(m_Angles.Y);
                        M.Mul(M, temp);
                    }
                    break;
                case EulerAngleOrder.ZYX:
                    if (m_Angles.Z != 0)
                    {
                        temp.RotZ(m_Angles.Z);
                        M.Mul(M, temp);
                    }
                    if (m_Angles.Y != 0)
                    {
                        temp.RotY(m_Angles.Y);
                        M.Mul(M, temp);
                    }
                    if (m_Angles.X != 0)
                    {
                        temp.RotX(m_Angles.X);
                        M.Mul(M, temp);
                    }
                    break;
                default:
                    throw new Exception("Illegal euler rotation order ");
            }

            return M;
        }
コード例 #24
0
ファイル: TransformUtils.cs プロジェクト: ldh9451/XLE
        /// <summary>
        /// Given an object's current Euler angles and a surface normal, will calculate
        ///  the Euler angles necessary to rotate the object so that it's up-vector is
        ///  aligned with the surface normal.
        /// </summary>
        /// <param name="originalEulers">From an IRenderableNode.Rotation, for example.</param>
        /// <param name="surfaceNormal">a unit vector that the object should be rotate-snapped to</param>
        /// <param name="upAxis">y or z is up?</param>
        /// <returns>The resulting angles to be assigned to IRenderableNode.Rotation</returns>
        /// <remarks>
        /// Note that QuatF was attempted to be used, but I could not get it to work reliably
        ///  with the Matrix3F.GetEulerAngles(). Numerical instability? The basis vector
        ///  method below works well except for when the target surface is 90 degrees different
        ///  than the starting up vector in which case the rotation around the up vector is lost
        ///  (gimbal lock) but the results are always valid in the sense that the up vector
        ///  is aligned with the surface normal. --Ron Little
        /// </remarks>
        public static Vec3F RotateToVector(Vec3F originalEulers, Vec3F surfaceNormal, AxisSystemType upAxis)
        {
            // get basis vectors for the current rotation
            Matrix3F rotMat = new Matrix3F();
            rotMat.Rotation(originalEulers);
            Vec3F a1 = rotMat.XAxis;
            Vec3F a2 = rotMat.YAxis;
            Vec3F a3 = rotMat.ZAxis;

            // calculate destination basis vectors
            Vec3F b1, b2, b3;
            if (upAxis == AxisSystemType.YIsUp)
            {
                // a2 is the current up vector. b2 is the final up vector.
                // now, find either a1 or a3, whichever is most orthogonal to surface
                b2 = new Vec3F(surfaceNormal);
                float a1DotS = Vec3F.Dot(a1, surfaceNormal);
                float a3DotS = Vec3F.Dot(a3, surfaceNormal);
                if (Math.Abs(a1DotS) < Math.Abs(a3DotS))
                {
                    b1 = new Vec3F(a1);
                    b3 = Vec3F.Cross(b1, b2);
                    b1 = Vec3F.Cross(b2, b3);
                }
                else
                {
                    b3 = new Vec3F(a3);
                    b1 = Vec3F.Cross(b2, b3);
                    b3 = Vec3F.Cross(b1, b2);
                }
            }
            else
            {
                // a3 is the current up vector. b3 is the final up vector.
                // now, find either a1 or a2, whichever is most orthogonal to surface
                b3 = new Vec3F(surfaceNormal);
                float a1DotS = Vec3F.Dot(a1, surfaceNormal);
                float a2DotS = Vec3F.Dot(a2, surfaceNormal);
                if (Math.Abs(a1DotS) < Math.Abs(a2DotS))
                {
                    b1 = new Vec3F(a1);
                    b2 = Vec3F.Cross(b3, b1);
                    b1 = Vec3F.Cross(b2, b3);
                }
                else
                {
                    b2 = new Vec3F(a2);
                    b1 = Vec3F.Cross(b2, b3);
                    b2 = Vec3F.Cross(b3, b1);
                }
            }

            // in theory, this isn't necessary, but in practice...
            b1.Normalize();
            b2.Normalize();
            b3.Normalize();

            // construct new rotation matrix and extract euler angles
            rotMat.XAxis = b1;
            rotMat.YAxis = b2;
            rotMat.ZAxis = b3;

            Vec3F newEulers = new Vec3F();
            rotMat.GetEulerAngles(out newEulers.X, out newEulers.Y, out newEulers.Z);
            return newEulers;
        }
コード例 #25
0
        /// <summary>
        /// Given an object's current Euler angles and a surface normal, will calculate
        ///  the Euler angles necessary to rotate the object so that it's up-vector is
        ///  aligned with the surface normal.
        /// </summary>
        /// <param name="originalEulers">From an IRenderableNode.Rotation, for example.</param>
        /// <param name="surfaceNormal">a unit vector that the object should be rotate-snapped to</param>
        /// <param name="upAxis">y or z is up?</param>
        /// <returns>The resulting angles to be assigned to IRenderableNode.Rotation</returns>
        /// <remarks>
        /// Note that QuatF was attempted to be used, but I could not get it to work reliably
        ///  with the Matrix3F.GetEulerAngles(). Numerical instability? The basis vector
        ///  method below works well except for when the target surface is 90 degrees different
        ///  than the starting up vector in which case the rotation around the up vector is lost
        ///  (gimbal lock) but the results are always valid in the sense that the up vector
        ///  is aligned with the surface normal. --Ron Little
        /// </remarks>
        public static Vec3F RotateToVector(Vec3F originalEulers, Vec3F surfaceNormal, AxisSystemType upAxis)
        {
            // get basis vectors for the current rotation
            Matrix3F rotMat = new Matrix3F();

            rotMat.Rotation(originalEulers);
            Vec3F a1 = rotMat.XAxis;
            Vec3F a2 = rotMat.YAxis;
            Vec3F a3 = rotMat.ZAxis;

            // calculate destination basis vectors
            Vec3F b1, b2, b3;

            if (upAxis == AxisSystemType.YIsUp)
            {
                // a2 is the current up vector. b2 is the final up vector.
                // now, find either a1 or a3, whichever is most orthogonal to surface
                b2 = new Vec3F(surfaceNormal);
                float a1DotS = Vec3F.Dot(a1, surfaceNormal);
                float a3DotS = Vec3F.Dot(a3, surfaceNormal);
                if (Math.Abs(a1DotS) < Math.Abs(a3DotS))
                {
                    b1 = new Vec3F(a1);
                    b3 = Vec3F.Cross(b1, b2);
                    b1 = Vec3F.Cross(b2, b3);
                }
                else
                {
                    b3 = new Vec3F(a3);
                    b1 = Vec3F.Cross(b2, b3);
                    b3 = Vec3F.Cross(b1, b2);
                }
            }
            else
            {
                // a3 is the current up vector. b3 is the final up vector.
                // now, find either a1 or a2, whichever is most orthogonal to surface
                b3 = new Vec3F(surfaceNormal);
                float a1DotS = Vec3F.Dot(a1, surfaceNormal);
                float a2DotS = Vec3F.Dot(a2, surfaceNormal);
                if (Math.Abs(a1DotS) < Math.Abs(a2DotS))
                {
                    b1 = new Vec3F(a1);
                    b2 = Vec3F.Cross(b3, b1);
                    b1 = Vec3F.Cross(b2, b3);
                }
                else
                {
                    b2 = new Vec3F(a2);
                    b1 = Vec3F.Cross(b2, b3);
                    b2 = Vec3F.Cross(b3, b1);
                }
            }

            // in theory, this isn't necessary, but in practice...
            b1.Normalize();
            b2.Normalize();
            b3.Normalize();

            // construct new rotation matrix and extract euler angles
            rotMat.XAxis = b1;
            rotMat.YAxis = b2;
            rotMat.ZAxis = b3;

            Vec3F newEulers = new Vec3F();

            rotMat.GetEulerAngles(out newEulers.X, out newEulers.Y, out newEulers.Z);
            return(newEulers);
        }
コード例 #26
0
 public void GetRotationMatrix(out Matrix3F result)
 {
     Matrix3.FromRotateByZ(Rotation.Value.InRadians()).ToMatrix3F(out result);
 }
コード例 #27
0
 public static QuaternionF LookAt(Vector3F direction, Vector3F up)
 {
     return(Matrix3F.LookAt(direction, up).ToQuaternion());
 }
コード例 #28
0
 public EnvironmentTextureData(Component_Image texture)
 {
     this.texture    = texture;
     this.rotation   = Matrix3F.Identity;
     this.multiplier = Vector3F.One;
 }
コード例 #29
0
 public EnvironmentTextureData(Component_Image texture, ref Matrix3F rotation, ref Vector3F multiplier)
 {
     this.texture    = texture;
     this.rotation   = rotation;
     this.multiplier = multiplier;
 }
コード例 #30
0
 public static QuaternionF FromRotateByZ(RadianF angle)
 {
     Matrix3F.FromRotateByZ(angle, out var mat);
     return(mat.ToQuaternion());
 }
コード例 #31
0
 public static void FromRotateByZ(RadianF angle, out QuaternionF result)
 {
     Matrix3F.FromRotateByZ(angle, out var mat);
     mat.ToQuaternion(out result);
 }