// Used for camera stacking where we need to update the parameters per camera
internal void UpdateFromCamera(ref XRPass xrPass, Camera camera)
{
if (xrPass.enabled && display != null)
{
display.GetRenderPass(xrPass.multipassId, out var renderPass);
display.GetCullingParameters(camera, renderPass.cullingPassIndex, out var cullingParams);
// Disable legacy stereo culling path
cullingParams.cullingOptions &= ~CullingOptions.Stereo;
if (xrPass.singlePassEnabled)
{
xrPass = XRPass.Create(renderPass, multipassId: xrPass.multipassId, cullingParams, occlusionMeshMaterial);
for (int renderParamIndex = 0; renderParamIndex < renderPass.GetRenderParameterCount(); ++renderParamIndex)
{
renderPass.GetRenderParameter(camera, renderParamIndex, out var renderParam);
xrPass.AddView(renderPass, renderParam);
}
}
else
{
renderPass.GetRenderParameter(camera, 0, out var renderParam);
xrPass = XRPass.Create(renderPass, multipassId: xrPass.multipassId, cullingParams, occlusionMeshMaterial);
xrPass.AddView(renderPass, renderParam);
}
}
}
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);
}
// Used for camera stacking where we need to update the parameters per camera
internal void UpdateFromCamera(ref XRPass xrPass, CameraData cameraData)
{
bool isGameCamera = (cameraData.camera.cameraType == CameraType.Game || cameraData.camera.cameraType == CameraType.VR);
if (XRGraphicsAutomatedTests.enabled && XRGraphicsAutomatedTests.running && isGameCamera)
{
// XR test framework code path. Update 2nd view with camera's view projection data
Matrix4x4 projMatrix = cameraData.camera.projectionMatrix;
Matrix4x4 viewMatrix = cameraData.camera.worldToCameraMatrix;
Rect viewport = new Rect(0, 0, testRenderTexture.width, testRenderTexture.height);
int textureArraySlice = -1;
xrPass.UpdateView(1, projMatrix, viewMatrix, viewport, textureArraySlice);
// Update culling params for this xr pass using camera's culling params
cameraData.camera.TryGetCullingParameters(false, out var cullingParams);
//// Disable legacy stereo culling path
cullingParams.cullingOptions &= ~CullingOptions.Stereo;
xrPass.UpdateCullingParams(0, cullingParams);
}
else if (xrPass.enabled && display != null)
{
display.GetRenderPass(xrPass.multipassId, out var renderPass);
display.GetCullingParameters(cameraData.camera, renderPass.cullingPassIndex, out var cullingParams);
// Disable legacy stereo culling path
cullingParams.cullingOptions &= ~CullingOptions.Stereo;
xrPass.UpdateCullingParams(cullingPassId: renderPass.cullingPassIndex, cullingParams);
if (xrPass.singlePassEnabled)
{
for (int renderParamIndex = 0; renderParamIndex < renderPass.GetRenderParameterCount(); ++renderParamIndex)
{
renderPass.GetRenderParameter(cameraData.camera, renderParamIndex, out var renderParam);
xrPass.UpdateView(renderParamIndex, renderPass, renderParam);
}
}
else
{
renderPass.GetRenderParameter(cameraData.camera, 0, out var renderParam);
xrPass.UpdateView(0, renderPass, renderParam);
}
}
}
private bool RenderingSingleCamera(Camera camera)
{
if (!running)
{
return(false);
}
// when this camera is rendering
if (myCam != camera)
{
return(false);
}
// Our workaround is for single pass, single param rendering
if (display == null)
{
return(false);
}
if (display.GetRenderPassCount() != 1)
{
return(false);
}
display.GetRenderPass(0, out var renderPass);
return(renderPass.GetRenderParameterCount() == 1);
}
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;
}
