Magnifier

GraphicsToolsUnityProject/Assets/XR/Settings/Oculus Settings.asset

@@ -12,17 +12,18 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: c353a8f1e58cf884584123914fe63cd5, type: 3}
   m_Name: Oculus Settings
   m_EditorClassIdentifier: 
-  m_StereoRenderingModeDesktop: 1
-  m_StereoRenderingModeAndroid: 2
+  m_StereoRenderingModeDesktop: 0
+  m_StereoRenderingModeAndroid: 0
   SharedDepthBuffer: 1
   DashSupport: 1
-  V2Signing: 1
-  LowOverheadMode: 1
-  ProtectedContext: 0
-  FocusAware: 1
+  LowOverheadMode: 0
   OptimizeBufferDiscards: 1
-  PhaseSync: 1
+  PhaseSync: 0
+  SymmetricProjection: 1
   SubsampledLayout: 0
+  LateLatching: 0
+  LateLatchingDebug: 0
+  SpaceWarp: 0
   TargetQuest: 1
   TargetQuest2: 1
   SystemSplashScreen: {fileID: 0}

GraphicsToolsUnityProject/ProjectSettings/TagManager.asset

@@ -13,7 +13,7 @@ TagManager:
   - UI
   - PostBlur0
   - PostBlur1
-  - 
+  - AfterTransparent
   - 
   - 
   - 

com.microsoft.mrtk.graphicstools.unity/Runtime/Experimental/Magnifier/Scripts/MagnifierManager.cs

@@ -0,0 +1,158 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#if GT_USE_URP
+using System.Reflection;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering.Universal;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.Universal;
+
+namespace Microsoft.MixedReality.GraphicsTools
+{
+   /// <summary>
+   /// Manages creating and updating render features necessary for the magnification effect on the scriptable render pipeline that in use .
+   /// </summary>
+    public class MagnifierManager : MonoBehaviour
+    {
+        [SerializeField]
+        private DrawFullscreenFeature.Settings drawFullscreenSettings = new DrawFullscreenFeature.Settings()
+        {
+            renderPassEvent = RenderPassEvent.AfterRenderingTransparents,
+            SourceType = BufferType.CameraColor,
+            DestinationType = BufferType.Custom,
+            SourceTextureId = string.Empty,
+            DestinationTextureId = "MagnifierTexture",
+        };
+
+        [SerializeField, Header("Render Objects Settings")]
+        private RenderObjects.RenderObjectsSettings renderObjectsSettings = new RenderObjects.RenderObjectsSettings()
+        {
+            Event = RenderPassEvent.AfterRenderingTransparents,
+            filterSettings = new RenderObjects.FilterSettings()
+            {
+                RenderQueueType = RenderQueueType.Transparent
+            }
+        };
+
+        [Tooltip("Which renderer to use in the UniversalRenderPipelineAsset.")]
+        [SerializeField]
+        private int rendererIndex = 0;
+
+        private DrawFullscreenFeature magnifierFeature;
+        private ScriptableRendererFeature renderTransparent;
+        private bool initialized = false;
+
+#if UNITY_2021_2_OR_NEWER
+        private UniversalRendererData rendererData = null;
+#else
+        private ForwardRendererData rendererData = null;
+#endif
+        private LayerMask previousOpaqueLayerMask;
+        private LayerMask previousTransparentLayerMask;
+
+        private void OnEnable()
+        {
+            if (!initialized)
+            {
+                InitializeRendererData();
+
+                if (rendererData != null)
+                {
+                    CreateRendererFeatures();
+                    initialized = true;
+                }
+            }
+        }
+
+        private void OnDisable()
+        {
+            if (initialized)
+            {
+                if (magnifierFeature != null)
+                {
+                    rendererData.rendererFeatures.Remove(magnifierFeature);
+                }
+
+                if (renderTransparent != null)
+                {
+                    rendererData.rendererFeatures.Remove(renderTransparent);
+                }
+
+                // Reset the layer masks.
+                rendererData.opaqueLayerMask = previousOpaqueLayerMask;
+                rendererData.transparentLayerMask = previousTransparentLayerMask;
+
+                rendererData.SetDirty();
+
+                initialized = false;
+            }
+        }
+
+        /// <summary>
+        /// Method <c>InitializeRendererData</c> gets the selected scriptable render pipeline thats currently in use.
+        /// </summary>
+        private void InitializeRendererData()
+        {
+            var pipeline = ((UniversalRenderPipelineAsset)GraphicsSettings.currentRenderPipeline);
+
+            if (pipeline == null)
+            {
+                Debug.LogWarning("Universal Render Pipeline not found");
+            }
+            else
+            {
+                FieldInfo propertyInfo = pipeline.GetType().GetField("m_RendererDataList", BindingFlags.Instance | BindingFlags.NonPublic);
+#if UNITY_2021_2_OR_NEWER
+                rendererData = ((ScriptableRendererData[])propertyInfo?.GetValue(pipeline))?[rendererIndex] as UniversalRendererData;
+#else
+                rendererData = ((ScriptableRendererData[])propertyInfo?.GetValue(pipeline))?[rendererIndex] as ForwardRendererData;
+#endif
+            }
+        }
+
+        /// <summary>
+        /// Method <c>CreateRendererFeatures</c> creates renderer features and adds them to a list of features to be deployed on the scriptable render pipeline.
+        /// </summary>
+        private void CreateRendererFeatures()
+        {
+            magnifierFeature = CreateMagnifierFullsreenFeature("Magnifier Draw Fullscreen Feature", drawFullscreenSettings);
+            rendererData.rendererFeatures.Add(magnifierFeature);
+            renderTransparent = CreateMagnifierRenderObjectsFeature("Magnifier Render Objects", renderObjectsSettings);
+            rendererData.rendererFeatures.Add(renderTransparent);
+
+            // Don't render the layers rendered by the RenderObjectsFeature
+            previousOpaqueLayerMask = rendererData.opaqueLayerMask;
+            previousTransparentLayerMask = rendererData.transparentLayerMask;
+            rendererData.opaqueLayerMask &= ~renderObjectsSettings.filterSettings.LayerMask;
+            rendererData.transparentLayerMask &= ~renderObjectsSettings.filterSettings.LayerMask;
+
+            rendererData.SetDirty();
+        }
+
+        /// <summary>
+        /// Method <c>CreateMagnifierFullsreenFeature</c> creates an instance of the draw fullscreen renderer feature.
+        /// </summary>
+        private DrawFullscreenFeature CreateMagnifierFullsreenFeature(string name, DrawFullscreenFeature.Settings settings)
+        {
+            DrawFullscreenFeature feature = ScriptableObject.CreateInstance<DrawFullscreenFeature>();
+            feature.name = name;
+            feature.settings = settings;
+
+            return feature;
+        }
+
+        /// <summary>
+        /// Method <c>CreateRenderObjectsFeature</c> creates an instance of the render objects renderer feature.
+        /// </summary>
+        private ScriptableRendererFeature CreateMagnifierRenderObjectsFeature(string name, RenderObjects.RenderObjectsSettings settings)
+        {
+            RenderObjects feature = ScriptableObject.CreateInstance<RenderObjects>();
+            feature.name = name;
+            feature.settings = settings;
+
+            return feature;
+        }
+    }
+}
+#endif // GT_USE_URP

com.microsoft.mrtk.graphicstools.unity/Runtime/Experimental/Magnifier/Shaders/Magnifier.shader

@@ -0,0 +1,89 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+Shader "Graphics Tools/Magnifier"
+{
+    Properties
+    { 
+        Magnification("Magnification", Float) = 0.5
+        [ShowAsVector2]  Center("Center", Vector) = (0.5,0.5,0,0)
+    }
+    SubShader
+    {
+        PackageRequirements
+        {
+            "com.unity.render-pipelines.universal": "10.6.0"
+        }
+
+        Tags
+        {
+            "RenderType" = "Transparent"
+            "Queue" = "Transparent"
+        }
+
+        Pass
+        {
+            ZTest Always
+            Cull Off
+            ZWrite Off
+
+            HLSLPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+
+            struct appdata
+            {
+                float4 vertex : POSITION;
+
+                UNITY_VERTEX_INPUT_INSTANCE_ID
+            };
+
+            struct v2f  //vertex to fragment
+            {
+                float4 vertex : SV_POSITION;
+
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+
+            half Magnification;
+            float2 Center;
+
+            TEXTURE2D_X(MagnifierTexture);
+            SAMPLER(samplerMagnifierTexture);
+
+            float2 zoomIn(float2 uv, float zoomAmount, float2 zoomCenter)
+            {
+                return ((uv - zoomCenter) * zoomAmount) + zoomCenter;
+            }
+
+            v2f vert(appdata v)
+            {
+                v2f o = (v2f)0;
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+                o.vertex = TransformObjectToHClip(v.vertex.xyz);
+
+                return o;
+            }
+
+            half4 frag(v2f i) : SV_Target
+            {               
+                float2 normalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(i.vertex);
+
+                float2 normalizedScreenSpaceUVStereo = UnityStereoTransformScreenSpaceTex(normalizedScreenSpaceUV);              
+
+                float2 zoomedUv = zoomIn(normalizedScreenSpaceUVStereo, Magnification, Center);
+
+                float4 output = SAMPLE_TEXTURE2D_X(MagnifierTexture, samplerMagnifierTexture, zoomedUv);
+
+                return output;
+            }
+           ENDHLSL
+        }
+    }
+
+    Fallback "Hidden/InternalErrorShader"
+}