void RenderCubemapGGXConvolution(SkyUpdateContext skyContext) { using (new ProfilingSample(m_BuiltinParameters.commandBuffer, "Update Env: GGX Convolution")) { if (skyContext.skySettings.useMIS && m_SupportsMIS) { m_IBLFilterGGX.FilterCubemapMIS(m_BuiltinParameters.commandBuffer, m_SkyboxCubemapRT, m_SkyboxGGXCubemapRT, m_SkyboxConditionalCdfRT, m_SkyboxMarginalRowCdfRT); } else { m_IBLFilterGGX.FilterCubemap(m_BuiltinParameters.commandBuffer, m_SkyboxCubemapRT, m_SkyboxGGXCubemapRT); } } }
void RenderCubemapGGXConvolution(CommandBuffer cmd, Texture input, RenderTexture target) { using (new ProfilingSample(cmd, "Update Env: GGX Convolution")) { if (m_useMIS && m_iblFilterGgx.supportMis) { m_iblFilterGgx.FilterCubemapMIS(cmd, input, target, m_SkyboxConditionalCdfRT, m_SkyboxMarginalRowCdfRT); } else { m_iblFilterGgx.FilterCubemap(cmd, input, target); } } }
private void RenderCubemapGGXConvolution(CommandBuffer cmd, BuiltinSkyParameters builtinParams, SkySettings skyParams, Texture input, RenderTexture target) { using (new Utilities.ProfilingSample("Update Env: GGX Convolution", cmd)) { int mipCount = 1 + (int)Mathf.Log(input.width, 2.0f); if (mipCount < ((int)EnvConstants.SpecCubeLodStep + 1)) { Debug.LogWarning("RenderCubemapGGXConvolution: Cubemap size is too small for GGX convolution, needs at least " + ((int)EnvConstants.SpecCubeLodStep + 1) + " mip levels"); return; } if (!m_iblFilterGgx.IsInitialized()) { m_iblFilterGgx.Initialize(cmd); } // Copy the first mip using (new Utilities.ProfilingSample("Copy Original Mip", cmd)) { for (int f = 0; f < 6; f++) { cmd.CopyTexture(input, f, 0, target, f, 0); } } using (new Utilities.ProfilingSample("GGX Convolution", cmd)) { if (m_useMIS && m_iblFilterGgx.SupportMIS) { m_iblFilterGgx.FilterCubemapMIS(cmd, input, target, mipCount, m_SkyboxConditionalCdfRT, m_SkyboxMarginalRowCdfRT, m_CubemapFaceMesh); } else { m_iblFilterGgx.FilterCubemap(cmd, input, target, mipCount, m_CubemapFaceMesh); } } } }
private void RenderCubemapGGXConvolution(ScriptableRenderContext renderContext, BuiltinSkyParameters builtinParams, SkyParameters skyParams, Texture input, RenderTexture target) { using (new Utilities.ProfilingSample("Sky Pass: GGX Convolution", renderContext)) { int mipCount = 1 + (int)Mathf.Log(input.width, 2.0f); if (mipCount < ((int)EnvConstants.SpecCubeLodStep + 1)) { Debug.LogWarning("RenderCubemapGGXConvolution: Cubemap size is too small for GGX convolution, needs at least " + ((int)EnvConstants.SpecCubeLodStep + 1) + " mip levels"); return; } if (!m_iblFilterGgx.IsInitialized()) { m_iblFilterGgx.Initialize(renderContext); } // Copy the first mip var cmd = new CommandBuffer { name = "" }; for (int f = 0; f < 6; f++) { cmd.CopyTexture(input, f, 0, target, f, 0); } renderContext.ExecuteCommandBuffer(cmd); cmd.Dispose(); if (m_useMIS) { m_iblFilterGgx.FilterCubemapMIS(renderContext, input, target, mipCount, m_SkyboxConditionalCdfRT, m_SkyboxMarginalRowCdfRT, m_CubemapFaceMesh); } else { m_iblFilterGgx.FilterCubemap(renderContext, input, target, mipCount, m_CubemapFaceMesh); } } }
Texture ConvolveProbeTexture(CommandBuffer cmd, Texture texture) { // Probes can be either Cubemaps (for baked probes) or RenderTextures (for realtime probes) Cubemap cubeTexture = texture as Cubemap; RenderTexture renderTexture = texture as RenderTexture; RenderTexture convolutionSourceTexture = null; if (cubeTexture != null) { // if the size if different from the cache probe size or if the input texture format is compressed, we need to convert it // 1) to a format for which we can generate mip maps // 2) to the proper reflection probe cache size bool sizeMismatch = cubeTexture.width != m_ProbeSize || cubeTexture.height != m_ProbeSize; bool formatMismatch = cubeTexture.format != TextureFormat.RGBAHalf; // Temporary RT for convolution is always FP16 if (formatMismatch || sizeMismatch) { // We comment the following warning as they have no impact on the result but spam the console, it is just that we waste offline time and a bit of quality for nothing. if (sizeMismatch) { // Debug.LogWarningFormat("Baked Reflection Probe {0} does not match HDRP Reflection Probe Cache size of {1}. Consider baking it at the same size for better loading performance.", texture.name, m_ProbeSize); } else if (cubeTexture.format == TextureFormat.BC6H) { // Debug.LogWarningFormat("Baked Reflection Probe {0} is compressed but the HDRP Reflection Probe Cache is not. Consider removing compression from the input texture for better quality.", texture.name); } ConvertTexture(cmd, cubeTexture, m_TempRenderTexture); } else { for (int f = 0; f < 6; f++) { cmd.CopyTexture(cubeTexture, f, 0, m_TempRenderTexture, f, 0); } } // Ideally if input is not compressed and has mipmaps, don't do anything here. Problem is, we can't know if mips have been already convolved offline... cmd.GenerateMips(m_TempRenderTexture); convolutionSourceTexture = m_TempRenderTexture; } else { Debug.Assert(renderTexture != null); if (renderTexture.dimension != TextureDimension.Cube) { Debug.LogError("Realtime reflection probe should always be a Cube RenderTexture."); return(null); } // TODO: Do a different case for downsizing, in this case, instead of doing ConvertTexture just use the relevant mipmaps. bool sizeMismatch = renderTexture.width != m_ProbeSize || renderTexture.height != m_ProbeSize; if (sizeMismatch) { ConvertTexture(cmd, renderTexture, m_TempRenderTexture); convolutionSourceTexture = m_TempRenderTexture; } else { convolutionSourceTexture = renderTexture; } // Generate unfiltered mipmaps as a base for convolution // TODO: Make sure that we don't first convolve everything on the GPU with the legacy code path executed after rendering the probe. cmd.GenerateMips(convolutionSourceTexture); } m_IBLFilterGGX.FilterCubemap(cmd, convolutionSourceTexture, m_ConvolutionTargetTexture); return(m_ConvolutionTargetTexture); }