Mindgames/Library/PackageCache/com.unity.render-pipelines.high-definition@6.9.0-preview/Runtime/RenderPipeline/XR/XRPass.cs

   1 // This file contain the two main data structures controlled by the XRSystem.
   2 // XRView contains the parameters required to render (proj and view matrices, viewport, etc)
   3 // XRPass holds the render target information and a list of XRView.
   4 // When a pass has 2+ views, hardware instancing will be active.
   5 // To avoid allocating every frame, XRView is a struct and XRPass is pooled.
   6
   7 #if UNITY_2019_3_OR_NEWER && ENABLE_VR
   8 #define USE_XR_SDK
   9 #endif
  10
  11 using System;
  12 using System.Collections.Generic;
  13 using UnityEngine.Rendering;
  14 #if USE_XR_SDK
  15 using UnityEngine.Experimental.XR;
  16 #endif
  17
  18 namespace UnityEngine.Experimental.Rendering.HDPipeline
  19 {
  20     internal struct XRView
  21     {
  22         internal readonly Matrix4x4 projMatrix;
  23         internal readonly Matrix4x4 viewMatrix;
  24         internal readonly Rect viewport;
  25         internal readonly Mesh occlusionMesh;
  26         internal readonly Camera.StereoscopicEye legacyStereoEye;
  27
  28         internal XRView(Camera camera, Camera.StereoscopicEye eye)
  29         {
  30             projMatrix = camera.GetStereoProjectionMatrix(eye);
  31             viewMatrix = camera.GetStereoViewMatrix(eye);
  32             viewport = camera.pixelRect;
  33             occlusionMesh = null;
  34             legacyStereoEye = eye;
  35         }
  36
  37         internal XRView(Matrix4x4 proj, Matrix4x4 view, Rect vp)
  38         {
  39             projMatrix = proj;
  40             viewMatrix = view;
  41             viewport = vp;
  42             occlusionMesh = null;
  43             legacyStereoEye = (Camera.StereoscopicEye)(-1);
  44         }
  45
  46 #if USE_XR_SDK
  47         internal XRView(XRDisplaySubsystem.XRRenderParameter renderParameter)
  48         {
  49             projMatrix = renderParameter.projection;
  50             viewMatrix = renderParameter.view;
  51             viewport = renderParameter.viewport;
  52             occlusionMesh = renderParameter.occlusionMesh;
  53             legacyStereoEye = (Camera.StereoscopicEye)(-1);
  54         }
  55 #endif
  56     }
  57
  58     public class XRPass
  59     {
  60         readonly List<XRView> views = new List<XRView>(2);
  61
  62         internal bool enabled      { get => views.Count > 0; }
  63         internal bool xrSdkEnabled { get; private set; }
  64
  65         internal int multipassId    { get; private set; }
  66         internal int cullingPassId  { get; private set; }
  67
  68         // Ability to specify where to render the pass
  69         internal RenderTargetIdentifier  renderTarget     { get; private set; }
  70         internal RenderTextureDescriptor renderTargetDesc { get; private set; }
  71         static RenderTargetIdentifier    invalidRT = -1;
  72         internal bool                    renderTargetValid { get => renderTarget != invalidRT; }
  73
  74         // Access to view information
  75         internal Matrix4x4 GetProjMatrix(int viewIndex = 0) { return views[viewIndex].projMatrix; }
  76         internal Matrix4x4 GetViewMatrix(int viewIndex = 0) { return views[viewIndex].viewMatrix; }
  77         internal Rect GetViewport(int viewIndex = 0)        { return views[viewIndex].viewport; }
  78
  79         // Instanced views support (instanced draw calls or multiview extension)
  80         internal int viewCount { get => views.Count; }
  81         internal bool instancingEnabled { get => viewCount > 1; }
  82
  83         // XRTODO(2019.3) : remove once XRE-445 is done
  84         // We need an intermediate target to render the mirror view
  85         public RenderTexture tempRenderTexture { get; private set; } = null;
  86 #if USE_XR_SDK
  87         RenderTextureDescriptor tempRenderTextureDesc;
  88 #endif
  89
  90         // Legacy multipass support
  91         internal int  legacyMultipassEye      { get => (int)views[0].legacyStereoEye; }
  92         internal bool legacyMultipassEnabled  { get => enabled && !instancingEnabled && legacyMultipassEye >= 0; }
  93
  94         internal static XRPass Create(int multipassId, RenderTexture rt = null)
  95         {
  96             XRPass passInfo = GenericPool<XRPass>.Get();
  97
  98             passInfo.multipassId = multipassId;
  99             passInfo.cullingPassId = multipassId;
 100             passInfo.views.Clear();
 101
 102             if (rt != null)
 103             {
 104                 passInfo.renderTarget = new RenderTargetIdentifier(rt);
 105                 passInfo.renderTargetDesc = rt.descriptor;
 106             }
 107             else
 108             {
 109                 passInfo.renderTarget = invalidRT;
 110                 passInfo.renderTargetDesc = default;
 111             }
 112
 113             passInfo.xrSdkEnabled = false;
 114             passInfo.tempRenderTexture = null;
 115
 116 #if USE_XR_SDK
 117             passInfo.tempRenderTextureDesc = default;
 118 #endif
 119
 120             return passInfo;
 121         }
 122
 123         internal void AddView(Camera camera, Camera.StereoscopicEye eye)
 124         {
 125             AddViewInternal(new XRView(camera, eye));
 126         }
 127
 128         internal void AddView(Matrix4x4 proj, Matrix4x4 view, Rect vp)
 129         {
 130             AddViewInternal(new XRView(proj, view, vp));
 131         }
 132
 133 #if USE_XR_SDK
 134         internal static XRPass Create(XRDisplaySubsystem.XRRenderPass xrRenderPass)
 135         {
 136             XRPass passInfo = GenericPool<XRPass>.Get();
 137
 138             passInfo.multipassId = xrRenderPass.renderPassIndex;
 139             passInfo.cullingPassId = xrRenderPass.cullingPassIndex;
 140             passInfo.views.Clear();
 141             passInfo.renderTarget = xrRenderPass.renderTarget;
 142             passInfo.renderTargetDesc = xrRenderPass.renderTargetDesc;
 143             passInfo.xrSdkEnabled = true;
 144
 145             Debug.Assert(passInfo.renderTargetValid, "Invalid render target from XRDisplaySubsystem!");
 146
 147             // XRTODO(2019.3) : remove once XRE-445 is done
 148             {
 149                 // Avoid allocating every frame by reusing the same RT unless the configuration changed
 150                 if (passInfo.tempRenderTexture == null || !Equals(passInfo.tempRenderTextureDesc, xrRenderPass.renderTargetDesc))
 151                 {
 152                     if (passInfo.tempRenderTexture != null)
 153                         passInfo.tempRenderTexture.Release();
 154
 155                     passInfo.tempRenderTexture = new RenderTexture(xrRenderPass.renderTargetDesc);
 156                     passInfo.tempRenderTexture.Create();
 157
 158                     // Store the original descriptor because the one from the RT has the flag 'CreatedFromScript' and would fail the Equals()
 159                     passInfo.tempRenderTextureDesc = xrRenderPass.renderTargetDesc;
 160                 }
 161             }
 162
 163             return passInfo;
 164         }
 165
 166         // XRTODO(2019.3) : remove once XRE-445 is done
 167         ~XRPass()
 168         {
 169             if (tempRenderTexture != null)
 170                 tempRenderTexture.Release();
 171         }
 172
 173         internal void AddView(XRDisplaySubsystem.XRRenderParameter xrSdkRenderParameter)
 174         {
 175             AddViewInternal(new XRView(xrSdkRenderParameter));
 176         }
 177 #endif
 178         internal static void Release(XRPass xrPass)
 179         {
 180             GenericPool<XRPass>.Release(xrPass);
 181         }
 182
 183         internal void AddViewInternal(XRView xrView)
 184         {
 185             views.Add(xrView);
 186
 187             // Validate memory limitations
 188             Debug.Assert(views.Count <= TextureXR.kMaxSlices);
 189         }
 190
 191         internal void StartLegacyStereo(Camera camera, CommandBuffer cmd, ScriptableRenderContext renderContext)
 192         {
 193             if (enabled)
 194             {
 195                 // Required for some legacy shaders (text for example)
 196                 cmd.SetViewProjectionMatrices(GetViewMatrix(), GetProjMatrix());
 197
 198                 if (camera.stereoEnabled)
 199                 {
 200                     // Reset scissor and viewport for C++ stereo code
 201                     cmd.DisableScissorRect();
 202                     cmd.SetViewport(camera.pixelRect);
 203
 204                     renderContext.ExecuteCommandBuffer(cmd);
 205                     cmd.Clear();
 206
 207                     if (legacyMultipassEnabled)
 208                         renderContext.StartMultiEye(camera, legacyMultipassEye);
 209                     else
 210                         renderContext.StartMultiEye(camera);
 211                 }
 212             }
 213         }
 214
 215         internal void StopLegacyStereo(Camera camera, CommandBuffer cmd, ScriptableRenderContext renderContext)
 216         {
 217             if (enabled && camera.stereoEnabled)
 218             {
 219                 renderContext.ExecuteCommandBuffer(cmd);
 220                 cmd.Clear();
 221                 renderContext.StopMultiEye(camera);
 222             }
 223         }
 224
 225         internal void EndCamera(HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd)
 226         {
 227             if (!enabled)
 228                 return;
 229
 230             if (xrSdkEnabled)
 231             {
 232                 // XRTODO(2019.3) : remove once XRE-445 is done
 233                 if (tempRenderTexture && hdCamera.camera.targetTexture == null)
 234                 {
 235                     // Multipass only for now
 236                     if (viewCount == 1)
 237                     {
 238                         // Blit to device
 239                         cmd.SetRenderTarget(renderTarget);
 240                         cmd.SetViewport(hdCamera.finalViewport);
 241                         HDUtils.BlitQuad(cmd, tempRenderTexture, new Vector4(1, 1, 0, 0), new Vector4(1, 1, 0, 0), 0, false);
 242
 243                         // Mirror view (only works with stereo for now)
 244                         if (multipassId < 2)
 245                         {
 246                             cmd.SetRenderTarget(new RenderTargetIdentifier(BuiltinRenderTextureType.CameraTarget));
 247                             cmd.SetViewport(hdCamera.camera.pixelRect);
 248
 249                             Vector4 scaleBiasRT = new Vector4(0.5f, 1, multipassId * 0.5f, 0);
 250                             HDUtils.BlitQuad(cmd, tempRenderTexture, new Vector4(1, 1, 0, 0), scaleBiasRT, 0, true);
 251                         }
 252                         else
 253                         {
 254                             throw new NotImplementedException();
 255                         }
 256                     }
 257                     else
 258                     {
 259                         throw new NotImplementedException();
 260                     }
 261                 }
 262             }
 263             else
 264             {
 265                 renderContext.ExecuteCommandBuffer(cmd);
 266                 cmd.Clear();
 267
 268                 // Pushes to XR headset and/or display mirror
 269                 if (legacyMultipassEnabled)
 270                     renderContext.StereoEndRender(hdCamera.camera, legacyMultipassEye, legacyMultipassEye == 1);
 271                 else
 272                     renderContext.StereoEndRender(hdCamera.camera);
 273             }
 274         }
 275     }
 276 }