Exemple #1
0
        private void Render(object sender, GlControlEventArgs e)
        {
            if (_shader == null)
            {
                return;
            }

            var v = _cameraHelper.CameraMatrix;

            _shader.M = v;

            _shader.ShadingLevel = 0;
            FiguresHelper.Draw3DCross(4, 1);
            _shader.ShadingLevel = 1;

            _shader.LightPos = new Vector3(1f, 1f, 1f);

            var r1     = Matrix4x4.CreateRotationY(Mathf.ToRadian(_phi));
            var t      = Matrix4x4.CreateTranslation(new Vector3(_radius, 2f, 0f));
            var r2     = Matrix4x4.CreateRotationX(Mathf.ToRadian(90)) * Matrix4x4.CreateRotationY(Mathf.ToRadian(90)) * Matrix4x4.CreateRotationZ(Mathf.ToRadian(45));
            var scaleM = Matrix4x4.CreateScale(0.2f);
            var r3     = Matrix4x4.CreateRotationY(Mathf.ToRadian(-_phi * 10));
            var r4     = Matrix4x4.CreateRotationZ(Mathf.ToRadian(25));
            var m      = r3 * r2 * t * r1 * scaleM * r4;

            _shader.M = m * v;

            Figure3DHelper.DrawMesh(_boomerang, Colors.Chocolate);

            _phi += _step;
        }
Exemple #2
0
        protected override void Draw(float deltaSeconds)
        {
            UpdateAnimation(deltaSeconds);
            UpdateUniforms();
            _cl.Begin();
            _cl.SetFramebuffer(GraphicsDevice.SwapchainFramebuffer);
            _cl.ClearColorTarget(0, RgbaFloat.Black);
            _cl.ClearDepthStencil(1f);

            Matrix4x4 worldMatrix =
                Matrix4x4.CreateTranslation(0, 15000, -5000)
                * Matrix4x4.CreateRotationX(3 * (float)Math.PI / 2)
                * Matrix4x4.CreateScale(0.05f);

            _cl.UpdateBuffer(_worldBuffer, 0, ref worldMatrix);

            DrawMesh();

            worldMatrix =
                Matrix4x4.CreateTranslation(0, 15000, -5000)
                * Matrix4x4.CreateRotationX(3 * (float)Math.PI / 2)
                * Matrix4x4.CreateScale(0.07f);

            _cl.UpdateBuffer(_worldBuffer, 0, ref worldMatrix);
            DrawMesh();

            _cl.End();

            GraphicsDevice.SubmitCommands(_cl);
            GraphicsDevice.SwapBuffers();
        }
        /// <inheritdoc cref="NotuiElement"/>
        public override IntersectionPoint PureHitTest(Touch touch, bool prevpos, out IntersectionPoint persistentIspoint)
        {
            var intersection = PreparePlanarShapeHitTest(touch, prevpos);
            var phit         = intersection != null;

            if (!phit)
            {
                persistentIspoint = null;
                return(null);
            }

            //TODO: Ugly as f**k, fix phase like a human being
            var uvpos = Coordinates.RectToPolar(Vector2.Transform(intersection.ElementSpace.xy(), Matrix3x2.CreateRotation((float)Math.PI)));
            var d     = uvpos.Y;

            uvpos.X = uvpos.X / (float)Math.PI;
            uvpos.Y = uvpos.Y * 4 - 1;
            intersection.SurfaceSpace = new Vector3(uvpos, 0);

            var str = Matrix4x4.CreateWorld(intersection.ElementSpace, Vector3.UnitZ,
                                            -Vector3.Normalize(intersection.ElementSpace));

            intersection.WorldSurfaceTangentTransform = str * DisplayMatrix;

            persistentIspoint = intersection;
            return(d < 0.5 ? intersection : null);
        }
Exemple #4
0
        void Update()
        {
            var baseModel       = CreateMatrixFromTranslation(0.0f, 0.0f, 5.0f) * CreateMatrixFromRotation(rotation, 0.0f, 1.0f, 0.0f);
            var baseMv          = viewMatrix * baseModel;
            var modelViewMatrix = baseMv * CreateMatrixFromRotation(rotation, 1.0f, 1.0f, 1.0f);

#if NET
            Matrix4.Invert(Matrix4.Transpose(modelViewMatrix), out uniformBuffer.NormalMatrix);
#else
            uniformBuffer.NormalMatrix = Matrix4.Invert(Matrix4.Transpose(modelViewMatrix));
#endif
            uniformBuffer.ModelviewProjectionMatrix = Matrix4.Transpose(projectionMatrix * modelViewMatrix);

            // Copy uniformBuffer's content into dynamicConstantBuffer.Contents
            int    rawsize = Marshal.SizeOf(typeof(Uniforms));
            var    rawdata = new byte [rawsize];
            IntPtr ptr     = Marshal.AllocHGlobal(rawsize);
            Marshal.StructureToPtr(uniformBuffer, ptr, false);
            Marshal.Copy(ptr, rawdata, 0, rawsize);
            Marshal.FreeHGlobal(ptr);

            Marshal.Copy(rawdata, 0, dynamicConstantBuffer.Contents + rawsize * constantDataBufferIndex, rawsize);

            rotation += 0.01f;
        }
Exemple #5
0
        public override void Apply(Graphics.IRenderContext context, System.Numerics.Matrix4x4 viewProjection, Assets.Material material, System.Numerics.Matrix4x4 world)
        {
            context.SetState(Engine.RenderStatePool.GetRenderState(new RenderStateInfo()
            {
                PrimitiveType = Graphics.PrimitiveType.TriangleList,
                Shader        = shader,
                Rasterizer    = rasterizerState,
                DepthStencil  = depthStencil
            }));
            context.SetTexture(shader, "picture", material.Texture.Handle);
            if (Engine.Settings.GraphicsAPI == GraphicsAPI.Direct3D11)
            {
                context.SetSampler(shader, "pictureSampler", sampler);
            }
            else if (Engine.Settings.GraphicsAPI == GraphicsAPI.OpenGL4)
            {
                context.SetSampler(shader, "picture", sampler);
            }

            GCHandle  handle;
            DataArray dataArray = DataArray.FromObject <Matrix4x4>(Matrix4x4.Transpose(world * viewProjection), out handle);

            try
            {
                context.UpdateContext.Update(constantBuffer, dataArray);
            }
            finally
            {
                handle.Free();
            }
            context.SetConstantBuffer(shader, constantBuffer);
        }
        static void BuildTransform(Vector3 position, Vector2 size, SpriteFlags flags, out Matrix4x4 transform)
        {
            var offset = (flags & SpriteFlags.AlignmentMask) switch
            {
                0 => Vector3.Zero,
                SpriteFlags.MidAligned => new Vector3(0, -0.5f, 0),
                SpriteFlags.BottomAligned => new Vector3(0, -1.0f, 0),
                SpriteFlags.LeftAligned => new Vector3(0.5f, 0, 0),
                SpriteFlags.LeftAligned | SpriteFlags.MidAligned => new Vector3(0.5f, -0.5f, 0),
                SpriteFlags.LeftAligned | SpriteFlags.BottomAligned => new Vector3(0.5f, -1.0f, 0),
                _ => Vector3.Zero
            };

            transform = Matrix4x4.CreateTranslation(offset);

            if (flags.HasFlag(SpriteFlags.Floor))
            {
                transform *= new Matrix4x4(
                    1, 0, 0, 0,
                    0, 0, -1, 0,
                    0, 1, 0, 0,
                    0, 0, 0, 1);
            }

            transform *= Matrix4x4.CreateScale(new Vector3(size.X, size.Y, size.X));
            transform *= Matrix4x4.CreateTranslation(position);
        }
Exemple #7
0
        protected void SetView()
        {
            ViewMatrix = Matrix4x4.CreateLookAt(_cameraPosition, _cameraPosition + _cameraFront, _cameraUp);
            int location = OpenGL.Gl.GetUniformLocation(_currentProgram, "view");

            OpenGL.Gl.UniformMatrix4f(location, 1, false, ref ViewMatrix);
        }
Exemple #8
0
        protected override float[] F(float[] xs)
        {
            var R2 = Radius * Radius;
            var v  = new Vector2(xs[0], xs[1]);

            v = Vector2.Transform(v, Matrix4x4.CreateScale(-1) * M);
            var x    = v.X;
            var y    = v.Y;
            var x2y2 = x * x + y * y;

            var a1 = new[]
            {
                W / x2y2 * y + (1 + R2 / x2y2 - 2 * R2 * x * x / (x2y2 * x2y2)),
                W / x2y2 * -x - (2 * R2 * x * y / (x2y2 * x2y2))
            };

            //v = new Vector2(xs[0], xs[1]);
            //v = Vector2.Transform(v, Matrix4x4.CreateTranslation(-6,0,0));
            //x = v.X;
            //y = v.Y;
            //x2y2 = x * x + y * y;

            //var a2 = new[]
            //{
            //    W/x2y2 * y  + (1 + R2 / x2y2 - 2 * R2 * x * x / (x2y2 * x2y2)),
            //    W/x2y2 * -x - (2 * R2 * x * y / (x2y2 * x2y2))
            //};

            return(new[]
            {
                a1[0], // + a2[0],
                a1[1], // + a2[1]
            });
        }
Exemple #9
0
 private void WriteMatrix4x4(Matrix4x4 value, EndianBinaryWriter writer)
 {
     writer.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} {1} {2} {3}", value.M11, value.M12, value.M13, value.M14));
     writer.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} {1} {2} {3}", value.M21, value.M22, value.M23, value.M24));
     writer.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} {1} {2} {3}", value.M31, value.M32, value.M33, value.M34));
     writer.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} {1} {2} {3}", value.M41, value.M42, value.M43, value.M44));
 }
Exemple #10
0
        private void OnOnKeyDown(object sender, KeyEventArgs e)
        {
            if (_isRightMousePressed)
            {
                switch (e.KeyCode)
                {
                case Keys.W:
                    _cameraPosition += 0.2f * _cameraFront;
                    break;

                case Keys.A:
                    _cameraPosition -= Vector3.Normalize(Vector3.Cross(_cameraFront, _cameraUp)) * 0.2f;
                    break;

                case Keys.S:
                    _cameraPosition -= 0.2f * _cameraFront;
                    break;

                case Keys.D:
                    _cameraPosition += Vector3.Normalize(Vector3.Cross(_cameraFront, _cameraUp)) * 0.2f;
                    break;
                }
                return;
            }

            switch (e.KeyCode)
            {
            case Keys.W:
                ModelMatrix = ModelMatrix * _transposeYUp;
                break;

            case Keys.A:
                ModelMatrix = ModelMatrix * _transposeXDown;
                break;

            case Keys.S:
                ModelMatrix = ModelMatrix * _transposeYDown;
                break;

            case Keys.D:
                ModelMatrix = ModelMatrix * _transposeXUp;
                break;

            case Keys.E:
                ModelMatrix = ModelMatrix * _rotationLeftZLeft;
                break;

            case Keys.Q:
                ModelMatrix = ModelMatrix * _rotationLeftZRight;
                break;

            case Keys.X:
                ModelMatrix = ModelMatrix * _rotationLeftX;
                break;

            case Keys.Y:
                ModelMatrix = ModelMatrix * _rotationLeftY;
                break;
            }
        }
        public static Matrix4x4 FromNumerics(this SN.Matrix4x4 matIn)
        {
            Matrix4x4 matOut = new Matrix4x4();

            //Numerics matrix are row vector, so X,Y,Z axes are rows 1-3 and 4th row is translation.
            //Rows => Columns to make it compatible with assimp

            //X
            matOut.A1 = matIn.M11;
            matOut.B1 = matIn.M12;
            matOut.C1 = matIn.M13;
            matOut.D1 = matIn.M14;

            //Y
            matOut.A2 = matIn.M21;
            matOut.B2 = matIn.M22;
            matOut.C2 = matIn.M23;
            matOut.D2 = matIn.M24;

            //Z
            matOut.A3 = matIn.M31;
            matOut.B3 = matIn.M32;
            matOut.C3 = matIn.M33;
            matOut.D3 = matIn.M34;

            //Translation
            matOut.A4 = matIn.M41;
            matOut.B4 = matIn.M42;
            matOut.C4 = matIn.M43;
            matOut.D4 = matIn.M44;

            return(matOut);
        }
Exemple #12
0
        private void Render(object sender, GlControlEventArgs e)
        {
            if (_shader == null)
            {
                return;
            }

            Gl.Clear(ClearBufferMask.DepthBufferBit);
            Gl.MatrixMode(MatrixMode.Modelview);

            var v = _cameraHelper.CameraMatrix;
            var u = Matrix4x4.CreateRotationX(Mathf.ToRadian(90));

            var m = u * v;

            _shader.M = m;

            FiguresHelper.Draw3DCross(50f, 1f);

            Figure3DHelper.DrawSphere(15, 20, 20, true, Colors.Yellow);
            Gl.LineWidth(1);
            Figure3DHelper.DrawSphere(15, 20, 20, false, Colors.Red);

            _satelite.Draw();
        }
Exemple #13
0
        public static Matrix4x4 FromSystemNumerics(System.Numerics.Matrix4x4 dotNetMatrix)
        {
            return(new Matrix4x4
            {   // to row major
                M00 = dotNetMatrix.M11,
                M10 = dotNetMatrix.M21,
                M20 = dotNetMatrix.M31,
                M30 = dotNetMatrix.M41,

                M01 = dotNetMatrix.M12,
                M11 = dotNetMatrix.M22,
                M21 = dotNetMatrix.M32,
                M31 = dotNetMatrix.M42,

                M02 = dotNetMatrix.M13,
                M12 = dotNetMatrix.M23,
                M22 = dotNetMatrix.M33,
                M32 = dotNetMatrix.M43,

                M03 = dotNetMatrix.M14,
                M13 = dotNetMatrix.M24,
                M23 = dotNetMatrix.M34,
                M33 = dotNetMatrix.M44,
            });
        }
Exemple #14
0
        private static UnityEngine.Matrix4x4 ConvertMatrixFromSystemToUnity(System.Numerics.Matrix4x4 matrix)
        {
            UnityEngine.Matrix4x4 result = new UnityEngine.Matrix4x4();
            result.m00 = matrix.M11;
            result.m01 = matrix.M12;
            result.m02 = matrix.M13;
            result.m03 = matrix.M14;

            result.m10 = matrix.M21;
            result.m11 = matrix.M22;
            result.m12 = matrix.M23;
            result.m13 = matrix.M24;

            result.m20 = matrix.M31;
            result.m21 = matrix.M32;
            result.m22 = matrix.M33;
            result.m23 = matrix.M34;

            result.m30 = matrix.M41;
            result.m31 = matrix.M42;
            result.m32 = matrix.M43;
            result.m33 = matrix.M44;

            return(result);
        }
Exemple #15
0
        static NumMatrix4x4 GetTransformForFrame(NodeAnimationChannel Ch, int Frame)
        {
            VectorKey PosKey = Ch.PositionKeys[Ch.PositionKeys.Count - 1];

            if (Frame < Ch.PositionKeys.Count)
            {
                PosKey = Ch.PositionKeys[Frame];
            }

            QuaternionKey RotKey = Ch.RotationKeys[Ch.RotationKeys.Count - 1];

            if (Frame < Ch.RotationKeys.Count)
            {
                RotKey = Ch.RotationKeys[Frame];
            }

            VectorKey SclKey = Ch.ScalingKeys[Ch.ScalingKeys.Count - 1];

            if (Frame < Ch.ScalingKeys.Count)
            {
                SclKey = Ch.ScalingKeys[Frame];
            }


            NumMatrix4x4 Rot = NumMatrix4x4.CreateFromQuaternion(ConvertQuat(RotKey.Value));
            NumMatrix4x4 Pos = NumMatrix4x4.CreateTranslation(ConvertVec(PosKey.Value));
            NumMatrix4x4 Scl = NumMatrix4x4.CreateScale(ConvertVec(SclKey.Value));

            //return Pos * Rot * Scl;
            return(Scl * Rot * Pos);
        }
Exemple #16
0
        static System.Numerics.Quaternion ConvertQuat(Assimp.Quaternion Q)
        {
            NumMatrix4x4.Decompose(ConvertMatrix(new AssMatrix4x4(Q.GetMatrix())), out Vector3 _S, out System.Numerics.Quaternion Quat, out Vector3 _T);
            return(Quat);

            // return new System.Numerics.Quaternion(Q.X, Q.Y, Q.Z, Q.W);
        }
Exemple #17
0
        private bool WorldToScreen(UE.Vector3 _Enemy, out UE.Vector3 _Screen)
        {
            _Screen = new UE.Vector3(0, 0, 0);
            Numerics.Matrix4x4 temp = Numerics.Matrix4x4.Transpose(Memory.Read <Numerics.Matrix4x4>(Base.GetPtr(EFTCore.fpsCamera, new int[] { 0x30, 0x18, 0xC0 }).ToInt64()));

            UE.Vector3 translationVector = new UE.Vector3(temp.M41, temp.M42, temp.M43);
            UE.Vector3 up    = new UE.Vector3(temp.M21, temp.M22, temp.M23);
            UE.Vector3 right = new UE.Vector3(temp.M11, temp.M12, temp.M13);

            float w = D3DXVec3Dot(translationVector, _Enemy) + temp.M44;

            if (w < 0.098f)
            {
                return(false);
            }

            float y = D3DXVec3Dot(up, _Enemy) + temp.M24;
            float x = D3DXVec3Dot(right, _Enemy) + temp.M14;

            _Screen.x = (this.Width / 2) * (1f + x / w);
            _Screen.y = (this.Height / 2) * (1f - y / w);
            _Screen.z = w;

            return(true);
        }
Exemple #18
0
        private void ComputeBoundingBox(Node node, ref Vector3 min, ref Vector3 max, ref Matrix4x4 trafo)
        {
            var prev = trafo;

            trafo = Matrix4x4.Multiply(prev, FromMatrix(node.Transform));

            if (node.HasMeshes)
            {
                foreach (var index in node.MeshIndices)
                {
                    var mesh = _scene.Meshes[index];
                    for (var i = 0; i < mesh.VertexCount; i++)
                    {
                        var tmp = FromVector(mesh.Vertices[i]);
                        tmp = Vector3.Transform(tmp, trafo);

                        min.X = Math.Min(min.X, tmp.X);
                        min.Y = Math.Min(min.Y, tmp.Y);
                        min.Z = Math.Min(min.Z, tmp.Z);

                        max.X = Math.Max(max.X, tmp.X);
                        max.Y = Math.Max(max.Y, tmp.Y);
                        max.Z = Math.Max(max.Z, tmp.Z);
                    }
                }
            }

            for (var i = 0; i < node.ChildCount; i++)
            {
                ComputeBoundingBox(node.Children[i], ref min, ref max, ref trafo);
            }
            trafo = prev;
        }
Exemple #19
0
        public void Draw(CommandList cmdList, Camera cam)
        {
            cmdList.SetVertexBuffer(0, m_vertexBuffer);
            cmdList.SetIndexBuffer(m_indexBuffer, IndexFormat.UInt32);
            cmdList.SetPipeline(m_pipelineState);

            SN.Matrix4x4 transform = WorldMatrix;

            for (int i = 0; i < m_meshesToDraw.Count; i++)
            {
                MeshDrawCall   drawParams = m_meshesToDraw[i];
                MeshPart       partData   = m_meshesData[drawParams.MeshPartIndex];
                SimpleMaterial material   = m_materials[partData.MaterialIndex];

                SN.Matrix4x4 w   = drawParams.World * transform;
                SN.Matrix4x4 wvp = w * cam.ViewProjection;

                cmdList.UpdateBuffer(m_wvpParam, 0, ref wvp);
                cmdList.UpdateBuffer(m_worldParam, 0, ref w);
                cmdList.UpdateBuffer(m_lightPosParam, 0, LightPosition);
                cmdList.UpdateBuffer(m_camPosParam, 0, cam.Position);

                cmdList.SetGraphicsResourceSet(0, m_worldLightCBSet);
                cmdList.SetGraphicsResourceSet(1, material.ColorAndTexture);

                cmdList.DrawIndexed((uint)partData.IndexCount, 1, (uint)partData.IndexOffset, 0, 0);
            }
        }
Exemple #20
0
        /// <summary>
        /// This method bakes transform values to 4x4 matrix
        /// </summary>
        private void UpdateMatrix()
        {
            if (m_hasRotation)
            {
                MathHelper.GetMatrix3d(m_position, m_rotation, m_scale, ref m_matrix);
            }
            else // calculation is much simpler without rotation, it saves 3 pairs of sin+cos calculations
            {
                MathHelper.GetMatrix3d(m_position, m_scale, ref m_matrix);
            }

            if (m_parent != null) // if there is parent transform, baked value contains also parent transforms
            {
                m_parent.PrepareMatrix();

                // this one is the most expensive thing in whole engine
#if USE_NUMERICS
                m_matrix = Matrix.Multiply(m_matrix, m_parent.m_matrix);
#else
                if (m_parent.m_parent == null && !m_parent.m_hasRotation) // things are little bit easier if parent doesn't have a rotation matrix. We can save 20+ multiplications on this
                {
                    MathHelper.TransformMatrix3d(m_parent.m_position, m_parent.m_scale, ref m_matrix);
                }
                else
                {
                    MathHelper.Mul(ref m_parent.m_matrix, ref m_matrix, ref m_matrix);
                }
#endif
                m_parentVersion = m_parent.m_version;
            }

            m_iMatrixChanged = true;
            m_changed        = false;
            m_version++;
        }
Exemple #21
0
        /* VULKAN METHODS*/

        // The TryGetProjectionMatrix code was taken from https://github.com/VulcanTechnologies/HoloLensCameraStream/blob/master/HoloLensCameraStream/Plugin%20Project/VideoCaptureSample.cs
        // Copyright (c) 2017 Vulcan, Inc. All rights reserved.
        // Licensed under the Apache 2.0 license

        /// <summary>
        /// This returns the projection matrix at the time the photo was captured, if location data if available.
        /// If it's not, that is probably an indication that the HoloLens is not tracking and its location is not known.
        /// It could also mean the VideoCapture stream is not running.
        /// If location data is unavailable then the projecgtion matrix will be set to the identity matrix.
        /// </summary>
        /// <param name="matrix">The projection matrix used to match the true camera projection.
        /// The matrix will have to be converted to a Unity matrix before it can be used by methods in the UnityEngine namespace.
        /// See https://forum.unity3d.com/threads/locatable-camera-in-unity.398803/ for details.</param>
        public static bool TryGetProjectionMatrix(
            System.Numerics.Matrix4x4 projectionMatrix,
            float nearPlane,
            float farPlane,
            out UnityEngine.Matrix4x4 outMatrix)
        {
            // The following code enforces valid near/far clip plane values
            float epsilon = 0.01f;

            if (nearPlane < epsilon)
            {
                nearPlane = epsilon;
            }

            if (farPlane < nearPlane + epsilon)
            {
                farPlane = nearPlane + epsilon;
            }

            // Transpose matrix to match expected Unity format
            outMatrix = ConvertMatrixFromSystemToUnity(System.Numerics.Matrix4x4.Transpose(projectionMatrix));

            outMatrix.m22 = -(farPlane + nearPlane) / (farPlane - nearPlane);
            outMatrix.m23 = -(2.0f * farPlane * nearPlane) / (farPlane - nearPlane);

            return(true);
        }
Exemple #22
0
        // From Veldrid Neo Demo
        public static System.Numerics.Matrix4x4 CreatePerspective(
            GraphicsDevice gd,
            bool useReverseDepth,
            float fov,
            float aspectRatio,
            float near, float far)
        {
            System.Numerics.Matrix4x4 persp;
            if (useReverseDepth)
            {
                persp = CreatePerspective(fov, aspectRatio, far, near);
            }
            else
            {
                persp = CreatePerspective(fov, aspectRatio, near, far);
            }
            if (gd.IsClipSpaceYInverted)
            {
                persp *= new System.Numerics.Matrix4x4(
                    1, 0, 0, 0,
                    0, -1, 0, 0,
                    0, 0, 1, 0,
                    0, 0, 0, 1);
            }

            /*persp = new System.Numerics.Matrix4x4(
             *  -1, 0, 0, 0,
             *  0, 1, 0, 0,
             *  0, 0, 1, 0,
             *  0, 0, 0, 1) * persp;*/

            return(persp);
        }
Exemple #23
0
        protected void SetProjection(int viewPortWidth, int viewPortHeight)
        {
            ProjectionMatrix = Matrix4x4.CreatePerspectiveFieldOfView(_fov.ToRadians(),
                                                                      (float)viewPortWidth / viewPortHeight, 0.1f, 100.0f);
            int location = OpenGL.Gl.GetUniformLocation(_currentProgram, "projection");

            OpenGL.Gl.UniformMatrix4f(location, 1, false, ref ProjectionMatrix);
        }
 public static VMatrix AsVMatrix4X4(this SMatrix m)
 {
     return(new VMatrix(
                m.M11, m.M12, m.M13, m.M14,
                m.M21, m.M22, m.M23, m.M24,
                m.M31, m.M32, m.M33, m.M34,
                m.M41, m.M42, m.M43, m.M44));
 }
Exemple #25
0
        private void DrawSphere(Vector2 pos, Vector2 v, Vector2 a, Color color)
        {
            var t  = Matrix4x4.CreateTranslation(new Vector3(pos, 0));
            var vM = _cameraHelper.CameraMatrix;

            _shader.M *= t * vM;
            Figure3DHelper.DrawSphere(2, 20, 20, true, color);
        }
Exemple #26
0
        void Reshape()
        {
            // When reshape is called, update the view and projection matricies since this means the view orientation or size changed
            var aspect = (float)(View.Bounds.Size.Width / View.Bounds.Size.Height);

            projectionMatrix = CreateMatrixFromPerspective(65.0f * ((float)Math.PI / 180.0f), aspect, 0.1f, 100.0f);

            viewMatrix = Matrix4.Identity;
        }
 public static void ToNumerics(this Assimp.Matrix4x4 matIn, out SN.Matrix4x4 matOut)
 {
     //Assimp matrices are column vector, so X,Y,Z axes are columns 1-3 and 4th column is translation.
     //Columns => Rows to make it compatible with numerics
     matOut = new System.Numerics.Matrix4x4(matIn.A1, matIn.B1, matIn.C1, matIn.D1,  //X
                                            matIn.A2, matIn.B2, matIn.C2, matIn.D2,  //Y
                                            matIn.A3, matIn.B3, matIn.C3, matIn.D3,  //Z
                                            matIn.A4, matIn.B4, matIn.C4, matIn.D4); //Translation
 }
Exemple #28
0
 public void Draw(System.Numerics.Matrix4x4 proj, System.Numerics.Matrix4x4 view, System.Numerics.Matrix4x4 model, string[] uniformNames)
 {
     for (int i = 0; i < objs.Count; i++)
     {
         objs[i].SetUniformfv(uniformNames[0], proj);
         objs[i].SetUniformfv(uniformNames[1], view);
         objs[i].SetUniformfv(uniformNames[2], model);
         objs[i].Render();
     }
 }
Exemple #29
0
 private static Matrix Convert(System.Numerics.Matrix4x4 mat)
 {
     return(new Matrix
     {
         M11 = mat.M11, M12 = mat.M12, M13 = mat.M13, M14 = mat.M14,
         M21 = mat.M21, M22 = mat.M22, M23 = mat.M23, M24 = mat.M24,
         M31 = mat.M31, M32 = mat.M32, M33 = mat.M33, M34 = mat.M34,
         M41 = mat.M41, M42 = mat.M42, M43 = mat.M43, M44 = mat.M44,
     });
 }
Exemple #30
0
        // TODO: Tehdäänkö tällä enää mitään?
        /// <summary>
        /// Muuntaa matriisin Jypelin ruutukoordinaateista XNA:n ruutukoordinaatteihin.
        /// </summary>
        /// <param name="matrix"></param>
        /// <param name="screenSize"></param>
        /// <param name="scale"></param>
        /// <returns></returns>
        internal static Matrix ToXnaCoords(ref Matrix matrix, Vector screenSize, Vector scale)
        {
            // Keskitetään sprite ruudulla, mutta toteutetaan alkuperäinen muunnos Jypelin koordinaateissa.
            var centralize = Matrix.CreateTranslation((screenSize - scale) / 2);
            var toXna      = Matrix.CreateScale(1, -1, 1) * Matrix.CreateTranslation(screenSize / 2);

            Matrix.Invert(toXna, out Matrix toJypeli);

            return(centralize * toJypeli * matrix * toXna);
        }
Exemple #31
0
        internal void SetWorldMatrix(Matrix4x4 worldMatrix)
        {
            var worldTransposed = Matrix4x4.Transpose(worldMatrix);
            var viewTransposed = Matrix4x4.Transpose(viewMatrix);
            var projectionTransposed = Matrix4x4.Transpose(projectionMatrix);

            MatricesBuffer matricesBuffer = new MatricesBuffer(ref worldTransposed, ref viewTransposed, ref projectionTransposed);
            deviceContext.UpdateSubresource<MatricesBuffer>(ref matricesBuffer, this.worldViewProjectionMatrixBuffer);
            deviceContext.VertexShader.SetConstantBuffer(0, this.worldViewProjectionMatrixBuffer);
        }
Exemple #32
0
 public MatricesBuffer(ref Matrix4x4 world, ref Matrix4x4 view, ref Matrix4x4 projection)
 {
     this.worldMatrix = world;
     this.viewMatrix = view;
     this.projectionMatrix = projection;
 }
Exemple #33
0
 private void UpdateViewProjectionBuffers()
 {
     projectionMatrix = camera.GetProjectionMatrix();
     viewMatrix = camera.GetViewMatrix();
 }