Pushing latest demo - crosseyed is gone, replaced with weird fov thing

Author: Perksey

examples/CSharp/OpenGL Demos/OpenGL VR Demo/Camera.cs

@@ -55,15 +55,7 @@ public void ModifyDirection(Quaternion orientation)
 
         public Matrix4x4 GetViewMatrix()
         {
-            //return Matrix4x4.CreateLookAt(Position, Position + Front, Up);
-            var s = Matrix4x4.Invert
-                (Matrix4x4.CreateFromQuaternion(_quat) * Matrix4x4.CreateTranslation(Position), out var ret);
-            if (!s)
-            {
-                throw new();
-            }
-
-            return ret;
+            return Matrix4x4.CreateLookAt(Position, Position + Front, Up);
         }
 
         public Matrix4x4 GetProjectionMatrix()

examples/CSharp/OpenGL Demos/OpenGL VR Demo/Game.cs

@@ -114,25 +114,16 @@ protected override void Render(int eye, double delta)
             var orientation = Unsafe.As<Quaternionf, Quaternion>(ref Renderer.ViewStates[0].Pose.Orientation);
             Camera.ModifyDirection(orientation);
 
-            var cameraPosBefore = Camera.Position;
-            Camera.Position += position * Camera.Front;
-            
             Gl.Enable(EnableCap.DepthTest);
-            
-            //Gl.ClearColor(eye, 0, 1 - eye, 0);
-            var projection = Camera.GetViewMatrix();
-            var xrprojection = Renderer.Projections[eye];
-            
             Gl.Clear((uint) (ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit));
 
             VaoCube.Bind();
             LightingShader.Use();
 
             //Slightly rotate the cube to give it an angled face to look at
             LightingShader.SetUniform("uModel", Matrix4x4.CreateRotationY(MathHelper.DegreesToRadians(25f)));
-            LightingShader.SetUniform("uView", Camera.GetViewMatrix());
-            //LightingShader.SetUniform("uProjection", Camera.GetProjectionMatrix());
-            LightingShader.SetUniform("uProjection", xrprojection);
+            LightingShader.SetUniform("uView", Renderer.Views[eye]);
+            LightingShader.SetUniform("uProjection", Renderer.Projections[eye]);
             LightingShader.SetUniform("objectColor", new Vector3(1.0f, 0.5f, 0.31f));
             LightingShader.SetUniform("lightColor", Vector3.One);
             LightingShader.SetUniform("lightPos", LampPosition);
@@ -149,12 +140,10 @@ protected override void Render(int eye, double delta)
             lampMatrix *= Matrix4x4.CreateTranslation(LampPosition);
 
             LampShader.SetUniform("uModel", lampMatrix);
-            LampShader.SetUniform("uView", Camera.GetViewMatrix());
-            LampShader.SetUniform("uProjection", xrprojection);
+            LampShader.SetUniform("uView", Renderer.Views[eye]);
+            LampShader.SetUniform("uProjection", Renderer.Projections[eye]);
 
             Gl.DrawArrays(PrimitiveType.Triangles, 0, 36);
-            
-            Camera.Position = cameraPosBefore;
         }
 
         protected override void Unload()

examples/CSharp/OpenGL Demos/OpenGL VR Demo/OpenXR/Renderer.cs

@@ -488,8 +488,8 @@ private unsafe void UpdateViews(in FrameState frameState)
             for (var eye = 0; eye < 2; eye++)
             {
                 var view = ViewStates[eye];
-                Projections[eye] = view.Fov.FovfToMatrix();
-                if (!Matrix4x4.Invert(view.Pose.PosefToMatrix(), out var inverse))
+                Projections[eye] = view.Fov.ToProjection();
+                if (!Matrix4x4.Invert(view.Pose.ToView(), out var inverse))
                 {
                     throw new("Couldn't create inverse pose view matrix.");
                 }

examples/CSharp/OpenGL Demos/OpenGL VR Demo/OpenXR/Utilities.cs

@@ -14,43 +14,87 @@ public static class Utilities
         public const float DefaultFarZ = 100.0f;
         public const float DefaultOffset = 0f;
 
-        public static Vector4 FovfToTanFovVector(this Fovf fovf) => new
-        (
-            MathF.Tan(fovf.AngleLeft),
-            MathF.Tan(fovf.AngleRight),
-            MathF.Tan(fovf.AngleUp),
-            MathF.Tan(fovf.AngleDown)
-        );
-
-        public static Matrix4x4 FovfToMatrix
-        (
-            this Fovf fovf,
-            float nearZ = DefaultNearZ,
-            float farZ = DefaultFarZ,
-            float offsetZ = DefaultOffset
-        )
-        {
-            var tanFov = fovf.FovfToTanFovVector();
-            var tanAngleWidth = tanFov.Y - tanFov.X;
-            var tanAngleHeight = tanFov.W - tanFov.Z;
-            return new
+        public static Matrix4x4 ToView(this Posef pose)
+            => Matrix4x4.Identity
+               * Matrix4x4.CreateTranslation(Unsafe.As<Vector3f, Vector3>(ref pose.Position))
+               * Matrix4x4.CreateFromQuaternion(Unsafe.As<Quaternionf, Quaternion>(ref pose.Orientation));
+
+        public static Matrix4x4
+            ToProjection
             (
-                2 / tanAngleWidth, 0, (tanFov.Y + tanFov.X) / tanAngleWidth, 0,
-                0, 2 / tanAngleHeight, (tanFov.Z + tanFov.W) / tanAngleHeight, 0,
-                0, 0, -(farZ + offsetZ) / (farZ - nearZ), -(farZ * (nearZ + offsetZ)) / (farZ - nearZ),
-                0, 0, -1, 0
-            );
-        }
+                this Fovf fov,
+                bool isGlSpace = true,
+                float nearZ = DefaultNearZ,
+                float farZ = DefaultFarZ
+            )
+        {
+            Matrix4x4 result = default;
 
-        public static Quaternion QuaternionfToQuaternion(this Quaternionf quat)
-            => Unsafe.As<Quaternionf, Quaternion>(ref quat);
+            var tanAngleLeft = MathF.Tan(fov.AngleLeft);
+            var tanAngleRight = MathF.Tan(fov.AngleRight);
 
-        public static Vector3 Vector3fToVector3(this Vector3f vec)
-            => Unsafe.As<Vector3f, Vector3>(ref vec);
+            var tanAngleDown = MathF.Tan(fov.AngleDown);
+            var tanAngleUp = MathF.Tan(fov.AngleUp);
 
-        public static Matrix4x4 PosefToMatrix(this Posef pose)
-            => Matrix4x4.Identity
-               * Matrix4x4.CreateTranslation(pose.Position.Vector3fToVector3())
-               * Matrix4x4.CreateFromQuaternion(pose.Orientation.QuaternionfToQuaternion());
+            var tanAngleWidth = tanAngleRight - tanAngleLeft;
+
+            // Set to tanAngleDown - tanAngleUp for a clip space with positive Y
+            // down (Vulkan). Set to tanAngleUp - tanAngleDown for a clip space with
+            // positive Y up (OpenGL / D3D / Metal).
+            var tanAngleHeight = !isGlSpace ? tanAngleDown - tanAngleUp : tanAngleUp - tanAngleDown;
+
+            // Set to nearZ for a [-1,1] Z clip space (OpenGL / OpenGL ES).
+            // Set to zero for a [0,1] Z clip space (Vulkan / D3D / Metal).
+            var offsetZ = isGlSpace ? nearZ : 0;
+
+            if (farZ <= nearZ)
+            {
+                // place the far plane at infinity
+                result.M11 = 2 / tanAngleWidth;
+                result.M21 = 0;
+                result.M31 = (tanAngleRight + tanAngleLeft) / tanAngleWidth;
+                result.M41 = 0;
+
+                result.M11 = 0;
+                result.M21 = 2 / tanAngleHeight;
+                result.M31 = (tanAngleUp + tanAngleDown) / tanAngleHeight;
+                result.M41 = 0;
+
+                result.M13 = 0;
+                result.M23 = 0;
+                result.M33 = -1;
+                result.M43 = -(nearZ + offsetZ);
+
+                result.M14 = 0;
+                result.M24 = 0;
+                result.M34 = -1;
+                result.M44 = 0;
+            }
+            else
+            {
+                // normal projection
+                result.M11 = 2 / tanAngleWidth;
+                result.M21 = 0;
+                result.M31 = (tanAngleRight + tanAngleLeft) / tanAngleWidth;
+                result.M41 = 0;
+
+                result.M12 = 0;
+                result.M22 = 2 / tanAngleHeight;
+                result.M32 = (tanAngleUp + tanAngleDown) / tanAngleHeight;
+                result.M42 = 0;
+
+                result.M13 = 0;
+                result.M23 = 0;
+                result.M33 = -(farZ + offsetZ) / (farZ - nearZ);
+                result.M43 = -(farZ * (nearZ + offsetZ)) / (farZ - nearZ);
+
+                result.M14 = 0;
+                result.M24 = 0;
+                result.M34 = -1;
+                result.M44 = 0;
+            }
+
+            return result;
+        }
     }
 }