internal bool RefreshXrSdk()
{
GetDisplaySubsystem();
if (displayList.Count > 0)
{
if (displayList.Count > 1)
{
throw new NotImplementedException("Only 1 XR display is supported.");
}
display = displayList[0];
display.disableLegacyRenderer = true;
// Refresh max views
TextureXR.maxViews = Math.Max(TextureXR.slices, GetMaxViews());
return(display.running);
}
else
{
display = null;
}
return(false);
}
private void OnDisable()
{
RenderPipelineManager.endCameraRendering -= OnEndCamera;
RenderPipelineManager.beginCameraRendering -= OnBeginCamera;
myCam = null;
display = null;
}
public bool SetupForSingleCamera(float left, float right, float top, float bottom)
{
List <XRDisplaySubsystem> xrDisplayList = new List <XRDisplaySubsystem>();
SubsystemManager.GetInstances(xrDisplayList);
if (xrDisplayList.Count != 1)
{
return(false);
}
XRDisplaySubsystem display = xrDisplayList[0];
if (display.GetRenderPassCount() != 1)
{
return(false);
}
display.GetRenderPass(0, out var renderPass);
if (renderPass.GetRenderParameterCount() != 1)
{
return(false);
}
SetProjectionParamsForSingleCamera(left, right, top, bottom);
Debug.Log($"{PluginMetadata.DebugLogPrefix}Sent single-cam projection parameters to native plugin.");
return(true);
}
// Update is called once per frame
void Update()
{
if (AllowMovement)
{
float gamePad_FwdAxis = OVRInput.Get(OVRInput.RawAxis2D.LThumbstick).y;
float gamePad_StrafeAxis = OVRInput.Get(OVRInput.RawAxis2D.LThumbstick).x;
Vector3 fwdMove = (CameraRig.centerEyeAnchor.rotation * Vector3.forward) * gamePad_FwdAxis * Time.deltaTime * ForwardSpeed;
Vector3 strafeMove = (CameraRig.centerEyeAnchor.rotation * Vector3.right) * gamePad_StrafeAxis * Time.deltaTime * StrafeSpeed;
transform.position += fwdMove + strafeMove;
}
bool hasDevice = false;
#if USING_XR_SDK
XRDisplaySubsystem currentDisplaySubsystem = OVRManager.GetCurrentDisplaySubsystem();
if (currentDisplaySubsystem != null)
{
hasDevice = currentDisplaySubsystem.running;
}
#elif REQUIRES_XR_SDK
hasDevice = false;
#else
hasDevice = UnityEngine.XR.XRDevice.isPresent;
#endif
if (!hasDevice && (AllowYawLook || AllowPitchLook))
{
Quaternion r = transform.rotation;
if (AllowYawLook)
{
float gamePadYaw = OVRInput.Get(OVRInput.RawAxis2D.RThumbstick).x;
float yawAmount = gamePadYaw * Time.deltaTime * GamePad_YawDegreesPerSec;
Quaternion yawRot = Quaternion.AngleAxis(yawAmount, Vector3.up);
r = yawRot * r;
}
if (AllowPitchLook)
{
float gamePadPitch = OVRInput.Get(OVRInput.RawAxis2D.RThumbstick).y;
if (Mathf.Abs(gamePadPitch) > 0.0001f)
{
if (InvertPitch)
{
gamePadPitch *= -1.0f;
}
float pitchAmount = gamePadPitch * Time.deltaTime * GamePad_PitchDegreesPerSec;
Quaternion pitchRot = Quaternion.AngleAxis(pitchAmount, Vector3.left);
r = r * pitchRot;
}
}
transform.rotation = r;
}
}
XRDisplaySubsystem GetXRDisplaySubsystem()
{
XRDisplaySubsystem ret = null;
SubsystemManager.GetInstances <XRDisplaySubsystem>(s_displaySubsystems);
if (s_displaySubsystems.Count > 0)
{
ret = s_displaySubsystems[0];
}
return(ret);
}
/// <summary>
/// Sets the game view settings at runtime.
/// </summary>
/// <param name="newOption">enable or disable</param>
public void SetGameView(GameViewOptions newOption)
{
RenderGameView = newOption;
List <XRDisplaySubsystem> xrDisplayList = new List <XRDisplaySubsystem>();
SubsystemManager.GetInstances(xrDisplayList);
if (xrDisplayList.Count == 1)
{
XRDisplaySubsystem display = xrDisplayList[0];
// This line turns off rendering to the default game view.
display.disableLegacyRenderer = (newOption == GameViewOptions.Disable);
}
}
public static bool IsHmdPresent()
{
if (OVRManager.OVRManagerinitialized && OVRManager.loadedXRDevice == OVRManager.XRDevice.Oculus)
{
return(OVRPlugin.hmdPresent);
}
#if USING_XR_SDK
XRDisplaySubsystem currentDisplaySubsystem = OVRManager.GetCurrentDisplaySubsystem();
if (currentDisplaySubsystem != null)
{
return(currentDisplaySubsystem.running); //In 2019.3, this should be changed to currentDisplaySubsystem.isConnected, but this is a fine placeholder for now.
}
return(false);
#else
return(Device.isPresent);
#endif
}
void DisplayRenderTextures(XRDisplaySubsystem displaySubsystem)
{
RenderTexture rt = displaySubsystem.GetRenderTextureForRenderPass(s_renderPass.renderPassIndex);
if (rt == null)
{
return;
}
int rpc = s_renderPass.GetRenderParameterCount();
RenderTexture target = new RenderTexture(rt.width, rt.height, rt.depth);
Graphics.CopyTexture(rt, 0, target, 0);
EditorGUILayout.BeginHorizontal();
Rect r = EditorGUILayout.GetControlRect(false, textureImageHeight,
GUILayout.MaxWidth(textureImageWidth + textureImageLeftPadding),
GUILayout.Width(textureImageWidth),
GUILayout.MaxHeight(textureImageHeight + textureImageSpace));
EditorGUI.DrawPreviewTexture(r, target);
if (rpc > 1)
{
Graphics.CopyTexture(rt, 1, target, 0);
r = EditorGUILayout.GetControlRect(false, textureImageHeight,
GUILayout.MaxWidth(textureImageWidth + textureImageLeftPadding),
GUILayout.Width(textureImageWidth),
GUILayout.MaxHeight(textureImageHeight + textureImageSpace));
EditorGUI.DrawPreviewTexture(r, target);
}
target.DiscardContents();
target.Release();
EditorGUILayout.EndHorizontal();
}
private void PopulateDisplaySubsystem()
{
List <XRDisplaySubsystem> xrDisplayList = new List <XRDisplaySubsystem>();
SubsystemManager.GetInstances(xrDisplayList);
if (xrDisplayList.Count == 1)
{
if (display == null)
{
Debug.Log("Got single active XRDisplaySubsystem");
}
display = xrDisplayList[0];
}
else
{
if (display != null)
{
Debug.Log("Clearing cached XRDisplaySubsystem");
}
display = null;
}
}
IEnumerator SwitchToVR()
{
SubsystemManager.GetSubsystemDescriptors(displays);
Debug.Log("Number of display providers found: " + displays.Count);
foreach (var d in displays)
{
Debug.Log("Scanning display id: " + d.id);
if (d.id.Contains("OpenXR Display"))
{
Debug.Log("Creating display " + d.id);
dispInst = d.Create();
if (dispInst != null)
{
Debug.Log("Starting display ");
dispInst.Start();
}
}
}
// Wait one frame!
yield return(null);
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
m_asset.memoryConsumption = 0f;
instance = this;
display = displayList.Count > 0 && displayList[0].running ? displayList[0] : null;
bool xrEnabled = XRSettings.isDeviceActive;
// Sort cameras array by camera depth
Array.Sort(cameras, m_CameraComparer);
// SetupShaderGlobals
// =====================================================================================================
LogTrace("SetupShaderGlobals...");
{
CommandBuffer cmd5 = CommandBufferPool.Get("SetupShaderGlobals");
cmd5.SetGlobalFloat("g_AtlasResolutionScale",
m_asset.atlasResolutionScale / m_asset.visibilityPassDownscale);
float lerpFactor =
Mathf.Clamp01((float)timeSinceLastRender /
(1f / m_asset.atlasRefreshFps)); //TODO: clamp should't been neccesary
cmd5.SetGlobalFloat("g_atlasMorph", lerpFactor);
cmd5.SetGlobalTexture("g_Dither", m_asset.dither[0]);
if (m_asset.TexelSpaceBackfaceCulling)
{
cmd5.EnableShaderKeyword("TRIANGLE_CULLING");
}
else
{
cmd5.DisableShaderKeyword("TRIANGLE_CULLING");
}
context.ExecuteCommandBuffer(cmd5);
CommandBufferPool.Release(cmd5);
}
bool shouldUpdateAtlas = timeSinceLastRender > 1f / m_asset.atlasRefreshFps;
foreach (Camera camera in cameras)
{
//XR
SCREEN_X = camera.pixelWidth;
SCREEN_Y = camera.pixelHeight;
SortingSettings cameraSortSettings = new SortingSettings(camera);
ScriptableCullingParameters cullingParameters;
if (!camera.TryGetCullingParameters(xrEnabled, out cullingParameters))
{
continue;
}
m_CullResults = context.Cull(ref cullingParameters);
context.SetupCameraProperties(camera, xrEnabled);
#region XRtest
{
var cmd = CommandBufferPool.Get("Test");
if (display != null) //Vr is enabled
{
#region setup stero rendering
// XRTODO: Handle stereo mode selection in URP pipeline asset UI
display.textureLayout = XRDisplaySubsystem.TextureLayout.Texture2DArray;
display.zNear = camera.nearClipPlane;
display.zFar = camera.farClipPlane;
display.sRGB = QualitySettings.activeColorSpace == ColorSpace.Linear;
display.GetRenderPass(0, out XRDisplaySubsystem.XRRenderPass xrRenderPass);
cmd.SetRenderTarget(xrRenderPass.renderTarget);
xrRenderPass.GetRenderParameter(camera, 0, out var renderParameter0);
xrRenderPass.GetRenderParameter(camera, 1, out var renderParameter1);
#endregion
#region enable stero rendering
//enable single pass (see XRPass.cs:344)
if (SystemInfo.supportsMultiview)
{
cmd.EnableShaderKeyword("STEREO_MULTIVIEW_ON");
cmd.SetGlobalVectorArray("unity_StereoEyeIndices", stereoEyeIndices);
}
else
{
cmd.EnableShaderKeyword("STEREO_INSTANCING_ON");
const int viewCount = 2;
cmd.SetInstanceMultiplier((uint)viewCount);
}
cmd.EnableShaderKeyword(ShaderKeywordStrings.UseDrawProcedural);
#endregion
}
else
{
cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget);
}
cmd.ClearRenderTarget(true, true, Color.green);
context.ExecuteCommandBuffer(cmd);
//RenderOpaque(context, m_VistaPass, cameraSortSettings);
context.DrawSkybox(camera);
#region Disable stero rendering
if (SystemInfo.supportsMultiview)
{
cmd.DisableShaderKeyword("STEREO_MULTIVIEW_ON");
}
else
{
cmd.DisableShaderKeyword("STEREO_INSTANCING_ON");
cmd.SetInstanceMultiplier(1);
}
cmd.DisableShaderKeyword(ShaderKeywordStrings.UseDrawProcedural);
#endregion
}
#endregion
int targetAtlasSize = m_asset.maximalAtlasSizePixel;
if (g_VistaAtlas_A == null || g_VistaAtlas_A.width != targetAtlasSize)
{
CommandBuffer cmd5 = CommandBufferPool.Get("(Re)initialize Atlas");
if (g_VistaAtlas_A != null)
{
g_VistaAtlas_A.Release();
g_VistaAtlas_B.Release();
}
g_VistaAtlas_A = new RenderTexture(
targetAtlasSize,
targetAtlasSize,
0,
RenderTextureFormat.ARGB2101010,
RenderTextureReadWrite.sRGB);
g_VistaAtlas_A.Create();
g_VistaAtlas_B = new RenderTexture(g_VistaAtlas_A);
g_VistaAtlas_B.Create();
cmd5.SetRenderTarget(g_VistaAtlas_A);
cmd5.ClearRenderTarget(true, true, Color.black);
cmd5.SetRenderTarget(g_VistaAtlas_B);
cmd5.ClearRenderTarget(true, true, Color.black);
context.ExecuteCommandBuffer(cmd5);
CommandBufferPool.Release(cmd5);
}
// TODO: reuse uv output to skip rendering objects a third time in VistaPass
CommandBuffer createCameraRT = CommandBufferPool.Get("Create Camera RT");
createCameraRT.GetTemporaryRT(
g_CameraTarget,
SCREEN_X,
SCREEN_Y,
24,
FilterMode.Bilinear,
RenderTextureFormat.ARGB32,
RenderTextureReadWrite.sRGB,
Mathf.NextPowerOfTwo(m_asset.MSSALevel));
createCameraRT.SetRenderTarget(g_CameraTarget);
createCameraRT.ClearRenderTarget(true, true, Color.clear);
context.ExecuteCommandBuffer(createCameraRT);
if (shouldUpdateAtlas)
{
//Debug.Log(DateTime.Now.ToString("hh.mm.ss.ffffff") + "render" + timeSinceLastRender.ToString());
target_atlasA = !target_atlasA;
// =====================================================================================================
// CopyDataToPreFrameBuffer
// =====================================================================================================
// LogVerbose("CopyDataToPreFrameBuffer...");
CommandBuffer cmd = CommandBufferPool.Get("CopyDataToPreFrameBuffer");
cmd.SetComputeBufferParam(m_ResolveCS, m_cs_CopyDataToPreFrameBuffer, "g_ObjectToAtlasProperties",
g_ObjectToAtlasProperties);
cmd.SetComputeBufferParam(m_ResolveCS, m_cs_CopyDataToPreFrameBuffer, "g_prev_ObjectToAtlasProperties",
g_prev_ObjectToAtlasProperties);
uint threadsX, threadsY, threadsZ;
m_ResolveCS.GetKernelThreadGroupSizes(m_cs_CopyDataToPreFrameBuffer, out threadsX, out threadsY,
out threadsZ);
cmd.DispatchCompute(m_ResolveCS, m_cs_CopyDataToPreFrameBuffer,
Mathf.CeilToInt(MAXIMAL_OBJECTS_PER_VIEW / (float)64.0), 1, 1);
cmd.SetComputeBufferParam(m_ResolveCS, m_cs_InitalizePrimitiveVisiblity, g_PrimitiveVisibilityID,
g_PrimitiveVisibility);
cmd.DispatchCompute(m_ResolveCS, m_cs_InitalizePrimitiveVisiblity,
Mathf.CeilToInt(g_PrimitiveVisibility.count / (float)threadsX), 1, 1);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
// =====================================================================================================
// SetupRenderBuffers
// =====================================================================================================
LogTrace("SetupRenderBuffers...");
CommandBuffer cmd1 = CommandBufferPool.Get("SetupBuffers");
int screenX = camera.pixelWidth;
int screenY = camera.pixelHeight;
g_visibilityBuffer_dimension = new Vector2Int(
Mathf.CeilToInt(screenX / m_asset.visibilityPassDownscale),
Mathf.CeilToInt(screenY / m_asset.visibilityPassDownscale));
cmd1.GetTemporaryRT(g_VisibilityBufferID, g_visibilityBuffer_dimension.x,
g_visibilityBuffer_dimension.y, 32, FilterMode.Point, RenderTextureFormat.RInt,
RenderTextureReadWrite.Linear, 1);
cmd1.SetRenderTarget(g_visibilityBuffer_RT);
cmd1.ClearRenderTarget(true, true, Color.clear);
cmd1.SetRenderTarget(target_atlasA ? g_VistaAtlas_A : g_VistaAtlas_B);
if (m_asset.clearAtlasOnRefresh)
{
cmd1.ClearRenderTarget(true, true, Color.clear);
}
cmd1.SetGlobalTexture("g_VistaAtlas", target_atlasA ? g_VistaAtlas_A : g_VistaAtlas_B);
cmd1.SetGlobalTexture("g_prev_VistaAtlas", target_atlasA ? g_VistaAtlas_B : g_VistaAtlas_A);
cmd1.SetGlobalFloat("g_AtlasSizeExponent", m_asset.maximalAtlasSizeExponent);
context.ExecuteCommandBuffer(cmd1);
CommandBufferPool.Release(cmd1);
// =====================================================================================================
// Visiblity Pass
// Figure out what objects (and triangles) are visible and needed to be rendered.
// =====================================================================================================
// renders the current view as: objectID, primitveID and mipmap level
g_Object_MipmapLevelA.SetCounterValue(0);
CommandBuffer cmd2 = CommandBufferPool.Get("RenderTexelCoverage");
cmd2.SetRenderTarget(g_VisibilityBufferID);
//cmd.SetGlobalBuffer("g_ObjectToAtlasPropertiesRW", g_ObjectToAtlasProperties);
//cmd.SetRandomWriteTarget(1, g_ObjectToAtlasProperties);
//g_vertexIDVisiblity_B.SetData(g_vertexIDVisiblity_B_init);
context.ExecuteCommandBuffer(cmd2);
cameraSortSettings.criteria = SortingCriteria.OptimizeStateChanges;
context.StartMultiEye(camera);
RenderOpaque(context, m_VisibilityPass, cameraSortSettings);
context.StopMultiEye(camera);
cmd2.Clear();
cmd2.ClearRandomWriteTargets();
// VISIBLITY DISSOLVE PASS
// maps the previous rendered data into usable buffers
cmd2.SetComputeTextureParam(m_ResolveCS, m_cs_ExtractVisibility, g_VisibilityBufferID,
g_visibilityBuffer_RT);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_ExtractVisibility, g_PrimitiveVisibilityID,
g_PrimitiveVisibility);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_ExtractVisibility, "g_ObjectToAtlasProperties",
g_ObjectToAtlasProperties);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_ExtractVisibility, "g_ObjectMipMap_append",
g_Object_MipmapLevelA);
cmd2.DispatchCompute(m_ResolveCS, m_cs_ExtractVisibility, SCREEN_X / COMPUTE_COVERAGE_TILE_SIZE,
SCREEN_Y / COMPUTE_COVERAGE_TILE_SIZE, 1);
cmd2.CopyCounterValue(g_Object_MipmapLevelA, g_ObjectMipMapCounterValue, 0);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_MipMapFinalize, "g_ObjectMipMap_consume",
g_Object_MipmapLevelA);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_MipMapFinalize, "g_ObjectToAtlasProperties",
g_ObjectToAtlasProperties);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_MipMapFinalize, "g_ObjectMipMapCounterValue",
g_ObjectMipMapCounterValue);
cmd2.DispatchCompute(m_ResolveCS, m_cs_MipMapFinalize, 1, 1, 1);
context.ExecuteCommandBuffer(cmd2);
cmd2.Clear();
// optional debug pass
switch (m_asset.debugPass)
{
case TexelSpaceDebugMode.VisibilityPassObjectID:
case TexelSpaceDebugMode.VisibilityPassPrimitivID:
case TexelSpaceDebugMode.VisibilityPassMipMapPerObject:
case TexelSpaceDebugMode.VisibilityPassMipMapPerPixel:
int debugView = Shader.PropertyToID("g_DebugTexture");
cmd2.GetTemporaryRT(debugView, SCREEN_X, SCREEN_Y, 16, FilterMode.Point,
RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear, 1, true);
cmd2.SetComputeTextureParam(m_ResolveCS, m_cs_DebugVisibilityBuffer, g_VisibilityBufferID,
g_visibilityBuffer_RT);
cmd2.SetComputeTextureParam(m_ResolveCS, m_cs_DebugVisibilityBuffer, "g_DebugTexture",
debugView);
cmd2.SetComputeBufferParam(m_ResolveCS, m_cs_DebugVisibilityBuffer,
"g_ObjectToAtlasPropertiesR", g_ObjectToAtlasProperties);
cmd2.SetComputeIntParam(m_ResolveCS, "g_DebugPassID", (int)m_asset.debugPass);
cmd2.DispatchCompute(
m_ResolveCS,
m_cs_DebugVisibilityBuffer,
SCREEN_X / 8,
SCREEN_Y / 8,
1);
cmd2.Blit(debugView, g_CameraTarget);
cmd2.ReleaseTemporaryRT(debugView);
context.ExecuteCommandBuffer(cmd2);
cmd2.Clear();
break;
}
CommandBufferPool.Release(cmd2);
// =====================================================================================================
// PackAtlas
// =====================================================================================================
LogTrace("PackAtlas...");
CommandBuffer cmd3 = CommandBufferPool.Get("PackAtlas");
atlasAxisSize = m_asset.maximalAtlasSizePixel;
for (int i = 0; i < visibleObjects.Count; i++)
{
visibleObjects[i].SetAtlasProperties(i + 1, 1); //objectID 0 is reserved for "undefined"
}
cmd3.SetComputeIntParam(m_ResolveCS, "g_totalObjectsInView", visibleObjects.Count + 1);
cmd3.SetComputeIntParam(m_ResolveCS, "g_atlasAxisSize", atlasAxisSize);
cmd3.SetComputeBufferParam(m_ResolveCS, m_cs_AtlasPacking, "g_ObjectToAtlasProperties",
g_ObjectToAtlasProperties);
cmd3.DispatchCompute(m_ResolveCS, m_cs_AtlasPacking, 1, 1, 1);
visibleObjects.Clear();
context.ExecuteCommandBuffer(cmd3);
CommandBufferPool.Release(cmd3);
// =====================================================================================================
// RenderTexelShading
// =====================================================================================================
CommandBuffer cmd4 = CommandBufferPool.Get("RenderTexelShading");
LogTrace("setup light array...");
NativeArray <VisibleLight> visibleLights = m_CullResults.visibleLights;
g_LightsOriginRange.Clear();
g_LightColorAngle.Clear();
for (int i1 = 0; i1 < MAX_LIGHTS; i1++)
{
if (i1 >= visibleLights.Length)
{
// fill up buffer with zero lights
g_LightsOriginRange.Add(Vector4.zero);
g_LightColorAngle.Add(Vector4.zero);
continue;
}
VisibleLight light = visibleLights[i1];
// if it's a directional light, just treat it as a point light and place it very far away
Vector4 lightOriginRange = light.lightType == LightType.Directional
? -light.light.transform.forward * 99999f
: light.light.transform.position;
lightOriginRange.w = light.lightType == LightType.Directional ? 99999999f : light.range;
g_LightsOriginRange.Add(lightOriginRange);
Vector4 lightColorAngle;
lightColorAngle = light.light.color * light.light.intensity;
lightColorAngle.w = light.lightType == LightType.Directional ? Mathf.Cos(light.spotAngle) : 1f;
g_LightColorAngle.Add(lightColorAngle);
}
cmd4.SetGlobalVectorArray("g_LightsOriginRange", g_LightsOriginRange);
cmd4.SetGlobalVectorArray("g_LightColorAngle", g_LightColorAngle);
cmd4.SetGlobalInt("g_LightsCount", Mathf.Min(MAX_LIGHTS, visibleLights.Length));
cmd4.SetRenderTarget(target_atlasA ? g_VistaAtlas_A : g_VistaAtlas_B);
context.ExecuteCommandBuffer(cmd4);
RenderOpaque(context, m_TexelSpacePass, cameraSortSettings);
cmd4.Clear();
if (m_asset.debugPass == TexelSpaceDebugMode.TexelShadingPass)
{
cmd4.Blit(g_VistaAtlas_A, BuiltinRenderTextureType.CameraTarget);
context.ExecuteCommandBuffer(cmd4);
}
CommandBufferPool.Release(cmd4);
LogTrace("ReleaseBuffers...");
CommandBuffer cmd6 = CommandBufferPool.Get("ReleaseBuffers");
cmd6.ReleaseTemporaryRT(g_PrimitiveVisibilityID);
context.ExecuteCommandBuffer(cmd6);
CommandBufferPool.Release(cmd6);
#if UNITY_EDITOR
// Emit scene view UI
if (camera.cameraType == CameraType.SceneView)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
}
visibleObjects.Clear();
// =====================================================================================================
// Render Vista + Finalize
// =====================================================================================================
CommandBuffer cmdVista = CommandBufferPool.Get("Render Vista");
cmdVista.SetRenderTarget(g_CameraTarget);
context.ExecuteCommandBuffer(cmdVista);
cmdVista.Clear();
context.StartMultiEye(camera);
switch (m_asset.debugPass)
{
case TexelSpaceDebugMode.None:
cameraSortSettings.criteria = SortingCriteria.OptimizeStateChanges;
RenderOpaque(context, m_VistaPass, cameraSortSettings); // render vista
context.DrawSkybox(camera);
break;
case TexelSpaceDebugMode.VisibilityPassObjectID:
case TexelSpaceDebugMode.VisibilityPassPrimitivID:
case TexelSpaceDebugMode.VisibilityPassMipMapPerObject:
case TexelSpaceDebugMode.VisibilityPassMipMapPerPixel:
break;
case TexelSpaceDebugMode.TexelShadingPass:
cmdVista.Blit(g_VistaAtlas_A, g_CameraTarget);
context.ExecuteCommandBuffer(cmdVista);
cmdVista.Clear();
break;
default:
throw new ArgumentOutOfRangeException();
}
context.StopMultiEye(camera);
cmdVista.Blit(g_CameraTarget, BuiltinRenderTextureType.CameraTarget);
cmdVista.ReleaseTemporaryRT(g_CameraTarget);
context.ExecuteCommandBuffer(cmdVista);
CommandBufferPool.Release(cmdVista);
}
if (shouldUpdateAtlas)
{
timeSinceLastRender = 0f;
}
timeSinceLastRender += Time.deltaTime;
context.Submit();
if (g_VistaAtlas_A)
{
m_asset.memoryConsumption += g_VistaAtlas_A.width * g_VistaAtlas_A.height *
(g_VistaAtlas_A.format == RenderTextureFormat.DefaultHDR ? 8 : 4) * 2;
}
m_asset.memoryConsumption /= 1024 * 1024;
}
