Add maths helpers, is this progress I don't even know anymore

Author: Perksey

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

@@ -6,61 +6,16 @@ namespace OpenGL_VR_Demo
 {
     public class Camera
     {
-        private Quaternion _quat;
+        private Renderer _renderer;
 
         public Vector3 Position { get; set; }
-        public Vector3 Front { get; set; }
-
-        public Vector3 Up { get; private set; }
-        public float AspectRatio { get; set; }
-
-        public float Yaw { get; set; } = -90f;
-        public float Pitch { get; set; }
-
-        private float Zoom = 45f;
-
-        public Camera(Vector3 position, Vector3 front, Vector3 up, float aspectRatio)
+        public Camera(Vector3 position, Renderer renderer)
         {
             Position = position;
-            AspectRatio = aspectRatio;
-            Front = front;
-            Up = up;
-        }
-
-        public void ModifyZoom(float zoomAmount)
-        {
-            //We don't want to be able to zoom in too close or too far away so clamp to these values
-            Zoom = Math.Clamp(Zoom - zoomAmount, 1.0f, 45f);
-        }
-
-        //public void ModifyDirection(float xOffset, float yOffset)
-        public void ModifyDirection(Quaternion orientation)
-        {
-            // Yaw += xOffset;
-            // Pitch -= yOffset;
-
-            ////We don't want to be able to look behind us by going over our head or under our feet so make sure it stays within these bounds
-            //Pitch = Math.Clamp(Pitch, -89f, 89f);
-
-            //var cameraDirection = Vector3.Zero;
-            var cameraDirection = Vector3.Zero;
-            cameraDirection.X = MathF.Cos(MathHelper.DegreesToRadians(Yaw)) * MathF.Cos(MathHelper.DegreesToRadians(Pitch));
-            cameraDirection.Y = MathF.Sin(MathHelper.DegreesToRadians(Pitch));
-            cameraDirection.Z = MathF.Sin(MathHelper.DegreesToRadians(Yaw)) * MathF.Cos(MathHelper.DegreesToRadians(Pitch));
-            cameraDirection = Vector3.Transform(cameraDirection, orientation);
-            Front = Vector3.Normalize(cameraDirection);
-
-            _quat = orientation;
+            _renderer = renderer;
         }
 
-        public Matrix4x4 GetViewMatrix()
-        {
-            return Matrix4x4.CreateLookAt(Position, Position + Front, Up);
-        }
-
-        public Matrix4x4 GetProjectionMatrix()
-        {
-            return Matrix4x4.CreatePerspectiveFieldOfView(MathHelper.DegreesToRadians(Zoom), AspectRatio, 0.1f, 100.0f);
-        }
+        public Matrix4x4 GetViewMatrix(int eye) => _renderer.GetViewMatrix(eye, Position);
+        public Matrix4x4 GetProjectionMatrix(int eye) => _renderer.GetProjectionMatrix(eye);
     }
 }

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

@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using OpenGL_VR_Demo.OpenXR;
+using Silk.NET.Maths;
 using Silk.NET.OpenGL;
 using Silk.NET.OpenXR;
 using Shader = Silk.NET.OpenGL.Shader;
@@ -19,6 +20,7 @@ public class Game : OpenGLXRGame
         private static VertexArrayObject<float, uint> VaoCube;
         private static Shader LightingShader;
         private static Shader LampShader;
+        private static Vector3 CubePosition = new(0.2f, 0.0f, 1.0f);
         private static Vector3 LampPosition = new(1.2f, 1.0f, 2.0f);
 
         private static Camera Camera;
@@ -84,7 +86,7 @@ public Game(bool forceNoDebug = false, bool useMinimumVersion = false)
 
         protected override void Load()
         {
-            Gl = Renderer.Gl;
+            Gl = Renderer!.Gl;
 
             Ebo = new(Gl, Indices, BufferTargetARB.ElementArrayBuffer);
             Vbo = new(Gl, Vertices, BufferTargetARB.ArrayBuffer);
@@ -99,7 +101,7 @@ protected override void Load()
             LampShader = new(Gl, "shader.vert", "shader.frag");
 
             //Start a camera at position 3 on the Z axis, looking at position -1 on the Z axis
-            Camera = new(Vector3.UnitZ * 6, Vector3.UnitZ * -1, Vector3.UnitY, (float)EyeWidth / EyeHeight);
+            Camera = new(Vector3.UnitZ * 6 * 6, Renderer);
         }
 
         protected override void Update(double delta)
@@ -110,26 +112,29 @@ protected override void Update(double delta)
 
         protected override void Render(int eye, double delta)
         {
-            var position = Unsafe.As<Vector3f, Vector3>(ref Renderer.ViewStates[0].Pose.Position);
-            var orientation = Unsafe.As<Quaternionf, Quaternion>(ref Renderer.ViewStates[0].Pose.Orientation);
-            Camera.ModifyDirection(orientation);
-            
             Gl.Enable(EnableCap.DepthTest);
             Gl.Clear((uint) (ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit));
 
             VaoCube.Bind();
             LightingShader.Use();
+            
+            // Define the matrix for our cube
+            var cubeMatrix = Matrix4x4.Identity;
+            cubeMatrix *= Matrix4x4.CreateTranslation(CubePosition);
 
-            //Slightly rotate the cube to give it an angled face to look at
-            LightingShader.SetUniform("uModel", Matrix4x4.CreateRotationY(MathHelper.DegreesToRadians(25f)));
-            LightingShader.SetUniform("uView", Renderer.Views[eye]);
-            LightingShader.SetUniform("uProjection", Renderer.Projections[eye]);
+            // Slightly rotate the cube to give it an angled face to look at
+            cubeMatrix *= Matrix4x4.CreateRotationY(Scalar.DegreesToRadians(25f));
+            
+            //LightingShader.SetUniform("uModel", Matrix4x4.CreateRotationY(MathHelper.DegreesToRadians(25f)));
+            LightingShader.SetUniform("uModel", cubeMatrix);
+            LightingShader.SetUniform("uView", Camera.GetViewMatrix(eye));
+            LightingShader.SetUniform("uProjection", Camera.GetProjectionMatrix(eye));
             LightingShader.SetUniform("objectColor", new Vector3(1.0f, 0.5f, 0.31f));
             LightingShader.SetUniform("lightColor", Vector3.One);
             LightingShader.SetUniform("lightPos", LampPosition);
             LightingShader.SetUniform("viewPos", Camera.Position);
 
-            //We're drawing with just vertices and no indicies, and it takes 36 verticies to have a six-sided textured cube
+            // We're drawing with just vertices and no indicies, and it takes 36 verticies to have a six-sided textured cube
             Gl.DrawArrays(PrimitiveType.Triangles, 0, 36);
 
             LampShader.Use();
@@ -140,8 +145,8 @@ protected override void Render(int eye, double delta)
             lampMatrix *= Matrix4x4.CreateTranslation(LampPosition);
 
             LampShader.SetUniform("uModel", lampMatrix);
-            LampShader.SetUniform("uView", Renderer.Views[eye]);
-            LampShader.SetUniform("uProjection", Renderer.Projections[eye]);
+            LampShader.SetUniform("uView", Camera.GetViewMatrix(eye));
+            LampShader.SetUniform("uProjection", Camera.GetProjectionMatrix(eye));
 
             Gl.DrawArrays(PrimitiveType.Triangles, 0, 36);
         }

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

@@ -35,9 +35,20 @@ public class Renderer : IDisposable
         public uint[] SwapchainImages;
 
         // Eye Info - for use in games!
+        private Posef[] RawViews { get; set; } = new Posef[2];
+        private Matrix4x4[] Projections { get; set; } = new Matrix4x4[2];
         public View[] ViewStates { get; private set; } = new View[2];
-        public Matrix4x4[] Views { get; private set; } = new Matrix4x4[2];
-        public Matrix4x4[] Projections { get; private set; } = new Matrix4x4[2];
+        public Matrix4x4 GetViewMatrix(int eye, Vector3 offset = default)
+        {
+            if (!Matrix4x4.Invert(RawViews[eye].ToView(), out var inverse))
+            {
+                throw new("Couldn't create inverse pose view matrix.");
+            }
+
+            return inverse;
+        }
+
+        public Matrix4x4 GetProjectionMatrix(int eye) => Projections[eye];
 
         // Misc
         private IView _view;
@@ -489,12 +500,7 @@ private unsafe void UpdateViews(in FrameState frameState)
             {
                 var view = ViewStates[eye];
                 Projections[eye] = view.Fov.ToProjection();
-                if (!Matrix4x4.Invert(view.Pose.ToView(), out var inverse))
-                {
-                    throw new("Couldn't create inverse pose view matrix.");
-                }
-
-                Views[eye] = inverse;
+                RawViews[eye] = view.Pose;
             }
         }
 

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

@@ -14,10 +14,10 @@ public static class Utilities
         public const float DefaultFarZ = 100.0f;
         public const float DefaultOffset = 0f;
 
-        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 ToView(this Posef pose, Vector3 offset = default)
+            => Matrix4x4.Transpose(Matrix4x4.Identity
+               * Matrix4x4.CreateTranslation(Unsafe.As<Vector3f, Vector3>(ref pose.Position) + offset)
+               * Matrix4x4.CreateFromQuaternion(Unsafe.As<Quaternionf, Quaternion>(ref pose.Orientation)));
 
         public static Matrix4x4
             ToProjection

src/Maths/Silk.NET.Maths/PublicAPI.Unshipped.txt

@@ -24,4 +24,8 @@ Silk.NET.Maths.Vector4D<T>.As<TOther>() -> Silk.NET.Maths.Vector4D<TOther>
 Silk.NET.Maths.Box2D<T>.GetScaled<TScale>(Silk.NET.Maths.Vector2D<TScale> scale, Silk.NET.Maths.Vector2D<T> anchor) -> Silk.NET.Maths.Box2D<T>
 Silk.NET.Maths.Box3D<T>.GetScaled<TScale>(Silk.NET.Maths.Vector3D<TScale> scale, Silk.NET.Maths.Vector3D<T> anchor) -> Silk.NET.Maths.Box3D<T>
 Silk.NET.Maths.Rectangle<T>.GetScaled<TScale>(Silk.NET.Maths.Vector2D<TScale> scale, Silk.NET.Maths.Vector2D<T> anchor) -> Silk.NET.Maths.Rectangle<T>
-Silk.NET.Maths.Cube<T>.GetScaled<TScale>(Silk.NET.Maths.Vector3D<TScale> scale, Silk.NET.Maths.Vector3D<T> anchor) -> Silk.NET.Maths.Cube<T>
+Silk.NET.Maths.Cube<T>.GetScaled<TScale>(Silk.NET.Maths.Vector3D<TScale> scale, Silk.NET.Maths.Vector3D<T> anchor) -> Silk.NET.Maths.Cube<T>
+static Silk.NET.Maths.Scalar.DegreesToRadians<T>(T degrees) -> T
+static Silk.NET.Maths.Scalar.RadiansToDegrees<T>(T radians) -> T
+static readonly Silk.NET.Maths.Scalar<T>.RadiansPerDegree -> T
+static readonly Silk.NET.Maths.Scalar<T>.DegreesPerRadian -> T

src/Maths/Silk.NET.Maths/Scalar.Constants.cs

@@ -87,6 +87,22 @@ public static partial class Scalar<T> where T : unmanaged
         /// </summary>
         public static readonly T Tau;
 
+        /// <summary>
+        /// Represents the number of degrees in a single radian.
+        /// </summary>
+        /// <remarks>
+        /// This is equivalent to <c>180 / MathF.Pi</c>
+        /// </remarks>
+        public static readonly T DegreesPerRadian;
+
+        /// <summary>
+        /// Represents the number of radians in a single degree.
+        /// </summary>
+        /// <remarks>
+        /// This is equivalent to <c>MathF.Pi / 180</c>.
+        /// </remarks>
+        public static readonly T RadiansPerDegree;
+
         internal static readonly bool IntrinsicsApplicable = typeof(T) == typeof(byte)
                                                             || typeof(T) == typeof(sbyte)
                                                             || typeof(T) == typeof(ushort)
@@ -315,6 +331,8 @@ static Scalar()
             }
 
             PiOver2 = Scalar.Divide(Pi, Two);
+            DegreesPerRadian = Scalar.Divide(Scalar.As<float, T>(180), Pi);
+            RadiansPerDegree = Scalar.Divide(Pi, Scalar.As<float, T>(180));
         }
     }
 }

src/Maths/Silk.NET.Maths/Scalar.Conversions.cs

@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Silk.NET.Maths
+{
+    public partial class Scalar
+    {
+        /// <summary>
+        /// Convert degrees to radians.
+        /// </summary>
+        /// <param name="degrees">An angle in degrees.</param>
+        /// <returns>The angle expressed in radians.</returns>
+        public static T DegreesToRadians<T>(T degrees) where T : unmanaged => Multiply(degrees, Scalar<T>.RadiansPerDegree);
+
+        /// <summary>
+        /// Convert radians to degrees.
+        /// </summary>
+        /// <param name="radians">An angle in radians.</param>
+        /// <returns>The angle expressed in degrees.</returns>
+        public static T RadiansToDegrees<T>(T radians) where T : unmanaged => Multiply(radians, Scalar<T>.DegreesPerRadian);
+    }
+}