public override void RenderSky(BuiltinSkyParameters builtinParams, bool renderForCubemap, bool renderSunDisk)
{
var hdriSky = builtinParams.skySettings as HDRISky;
float intensity, phi, backplatePhi;
GetParameters(out intensity, out phi, out backplatePhi, builtinParams, hdriSky);
int passID;
if (hdriSky.enableBackplate.value == false)
{
if (renderForCubemap)
{
passID = m_RenderCubemapID;
}
else
{
passID = m_RenderFullscreenSkyID;
}
}
else
{
if (renderForCubemap)
{
passID = m_RenderCubemapWithBackplateID;
}
else
{
passID = m_RenderFullscreenSkyWithBackplateID;
}
}
if (hdriSky.enableDistortion.value == true)
{
m_SkyHDRIMaterial.EnableKeyword("SKY_MOTION");
if (hdriSky.procedural.value == false)
{
m_SkyHDRIMaterial.EnableKeyword("USE_FLOWMAP");
m_SkyHDRIMaterial.SetTexture(HDShaderIDs._Flowmap, hdriSky.flowmap.value);
}
else
{
m_SkyHDRIMaterial.DisableKeyword("USE_FLOWMAP");
}
float rot = -Mathf.Deg2Rad * hdriSky.scrollDirection.value;
bool upperHemisphereOnly = hdriSky.upperHemisphereOnly.value || hdriSky.procedural.value;
Vector4 flowmapParam = new Vector4(upperHemisphereOnly ? 1.0f : 0.0f, scrollFactor, Mathf.Cos(rot), Mathf.Sin(rot));
m_SkyHDRIMaterial.SetVector(HDShaderIDs._FlowmapParam, flowmapParam);
#if UNITY_EDITOR
// Time.time is not always updated in editor
float time = (float)EditorApplication.timeSinceStartup;
#else
float time = Time.time;
#endif
scrollFactor += hdriSky.scrollSpeed.value * (time - lastTime) * 0.01f;
lastTime = time;
}
else
{
m_SkyHDRIMaterial.DisableKeyword("SKY_MOTION");
}
m_SkyHDRIMaterial.SetTexture(HDShaderIDs._Cubemap, hdriSky.hdriSky.value);
m_SkyHDRIMaterial.SetVector(HDShaderIDs._SkyParam, new Vector4(intensity, 0.0f, Mathf.Cos(phi), Mathf.Sin(phi)));
m_SkyHDRIMaterial.SetVector(HDShaderIDs._BackplateParameters0, GetBackplateParameters0(hdriSky));
m_SkyHDRIMaterial.SetVector(HDShaderIDs._BackplateParameters1, GetBackplateParameters1(backplatePhi, hdriSky));
m_SkyHDRIMaterial.SetVector(HDShaderIDs._BackplateParameters2, GetBackplateParameters2(hdriSky));
m_SkyHDRIMaterial.SetColor(HDShaderIDs._BackplateShadowTint, hdriSky.shadowTint.value);
uint shadowFilter = 0u;
if (hdriSky.pointLightShadow.value)
{
shadowFilter |= unchecked ((uint)LightFeatureFlags.Punctual);
}
if (hdriSky.dirLightShadow.value)
{
shadowFilter |= unchecked ((uint)LightFeatureFlags.Directional);
}
if (hdriSky.rectLightShadow.value)
{
shadowFilter |= unchecked ((uint)LightFeatureFlags.Area);
}
m_SkyHDRIMaterial.SetInt(HDShaderIDs._BackplateShadowFilter, unchecked ((int)shadowFilter));
// This matrix needs to be updated at the draw call frequency.
m_PropertyBlock.SetMatrix(HDShaderIDs._PixelCoordToViewDirWS, builtinParams.pixelCoordToViewDirMatrix);
CoreUtils.DrawFullScreen(builtinParams.commandBuffer, m_SkyHDRIMaterial, m_PropertyBlock, passID);
}
// 'renderSunDisk' parameter is not supported.
// Users should instead create an emissive (or lit) mesh for every relevant light source
// (to support multiple stars in space, moons with moon phases, etc).
public override void RenderSky(BuiltinSkyParameters builtinParams, bool renderForCubemap, bool renderSunDisk)
{
var pbrSky = builtinParams.skySettings as PhysicallyBasedSky;
// TODO: the following expression is somewhat inefficient, but good enough for now.
Vector3 X = builtinParams.worldSpaceCameraPos;
float r = Vector3.Distance(X, pbrSky.GetPlanetCenterPosition(X));
float R = pbrSky.GetPlanetaryRadius();
bool isPbrSkyActive = r > R; // Disable sky rendering below the ground
CommandBuffer cmd = builtinParams.commandBuffer;
// Precomputation is done, shading is next.
Quaternion planetRotation = Quaternion.Euler(pbrSky.planetRotation.value.x,
pbrSky.planetRotation.value.y,
pbrSky.planetRotation.value.z);
Quaternion spaceRotation = Quaternion.Euler(pbrSky.spaceRotation.value.x,
pbrSky.spaceRotation.value.y,
pbrSky.spaceRotation.value.z);
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._PixelCoordToViewDirWS, builtinParams.pixelCoordToViewDirMatrix);
s_PbrSkyMaterialProperties.SetVector(HDShaderIDs._WorldSpaceCameraPos1, builtinParams.worldSpaceCameraPos);
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._ViewMatrix1, builtinParams.viewMatrix);
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._PlanetRotation, Matrix4x4.Rotate(planetRotation));
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._SpaceRotation, Matrix4x4.Rotate(spaceRotation));
m_PrecomputedData.BindBuffers(cmd, s_PbrSkyMaterialProperties);
int hasGroundAlbedoTexture = 0;
if (pbrSky.groundColorTexture.value != null)
{
hasGroundAlbedoTexture = 1;
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._GroundAlbedoTexture, pbrSky.groundColorTexture.value);
}
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._HasGroundAlbedoTexture, hasGroundAlbedoTexture);
int hasGroundEmissionTexture = 0;
if (pbrSky.groundEmissionTexture.value != null)
{
hasGroundEmissionTexture = 1;
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._GroundEmissionTexture, pbrSky.groundEmissionTexture.value);
s_PbrSkyMaterialProperties.SetFloat(HDShaderIDs._GroundEmissionMultiplier, pbrSky.groundEmissionMultiplier.value);
}
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._HasGroundEmissionTexture, hasGroundEmissionTexture);
int hasSpaceEmissionTexture = 0;
if (pbrSky.spaceEmissionTexture.value != null)
{
hasSpaceEmissionTexture = 1;
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._SpaceEmissionTexture, pbrSky.spaceEmissionTexture.value);
s_PbrSkyMaterialProperties.SetFloat(HDShaderIDs._SpaceEmissionMultiplier, pbrSky.spaceEmissionMultiplier.value);
}
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._HasSpaceEmissionTexture, hasSpaceEmissionTexture);
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._RenderSunDisk, renderSunDisk ? 1 : 0);
int pass = (renderForCubemap ? 0 : 2) + (isPbrSkyActive ? 0 : 1);
CloudLayer.Apply(builtinParams.cloudLayer, m_PbrSkyMaterial);
CoreUtils.DrawFullScreen(builtinParams.commandBuffer, m_PbrSkyMaterial, s_PbrSkyMaterialProperties, pass);
}
// The actual rendering execution is done here
public override void Render(CommandBuffer cmd, RenderTargetIdentifier source, RenderTargetIdentifier destination, ref RenderingData renderingData, CustomPostProcessInjectionPoint injectionPoint)
{
// Get camera instance id
int id = renderingData.cameraData.camera.GetInstanceID();
// Get an RT descriptor for temporary or history RTs.
RenderTextureDescriptor descriptor = GetTempRTDescriptor(renderingData);
CameraHistory history;
// See if we already have a history for this camera
if (_histories.TryGetValue(id, out history))
{
var frame = history.Frame;
// If the camera target is resized, we need to resize the history too.
if (frame.width != descriptor.width || frame.height != descriptor.height)
{
RenderTexture newframe = new RenderTexture(descriptor);
newframe.name = "_CameraHistoryTexture";
if (history.Invalidated) // if invalidated, blit from source to history
{
cmd.Blit(source, newframe);
}
else // if not invalidated, copy & resize the old history to the new size
{
Graphics.Blit(frame, newframe);
}
frame.Release();
history.Frame = newframe;
}
else if (history.Invalidated)
{
cmd.Blit(source, frame); // if invalidated, blit from source to history
}
history.Invalidated = false; // No longer invalid :D
}
else
{
// If we had no history for this camera, create one for it.
history = new CameraHistory(descriptor);
history.Frame.name = "_CameraHistoryTexture";
_histories.Add(id, history);
cmd.Blit(source, history.Frame); // Copy frame from source to history
}
// set material properties
if (m_Material != null)
{
Color blend = m_VolumeComponent.blend.value;
float power = Time.deltaTime / Mathf.Max(Mathf.Epsilon, m_VolumeComponent.timeScale.value);
// The amound of blending should depend on the delta time to make fading time frame-rate independent.
blend.r = Mathf.Pow(blend.r, power);
blend.g = Mathf.Pow(blend.g, power);
blend.b = Mathf.Pow(blend.b, power);
m_Material.SetColor(ShaderIDs.Blend, blend);
}
// set source texture
cmd.SetGlobalTexture(ShaderIDs.Input, source);
// set source texture
cmd.SetGlobalTexture(ShaderIDs.Other, history.Frame);
// See if the destination is the camera target. If yes, then we need to use an intermediate texture to avoid reading from destination
bool isCameraTarget = destination == RenderTargetHandle.CameraTarget.Identifier();
if (isCameraTarget)
{
// Create a temporary target
cmd.GetTemporaryRT(_intermediate.id, descriptor, FilterMode.Point);
// blend current frame with history frame into the temporary target
CoreUtils.DrawFullScreen(cmd, m_Material, _intermediate.Identifier());
// Copy the temporary target to the destination and history
cmd.Blit(_intermediate.Identifier(), destination);
cmd.Blit(_intermediate.Identifier(), history.Frame);
// Release the temporary target
cmd.ReleaseTemporaryRT(_intermediate.id);
}
else
{
// the destination isn't the camera target, blend onto the destination directly.
CoreUtils.DrawFullScreen(cmd, m_Material, destination);
// Then copy the destination to the history
cmd.Blit(destination, history.Frame);
}
}
// Combines specular lighting and diffuse lighting with subsurface scattering.
public void SubsurfaceScatteringPass(HDCamera hdCamera, CommandBuffer cmd, DiffusionProfileSettings sssParameters, FrameSettings frameSettings,
RenderTargetIdentifier colorBufferRT, RenderTargetIdentifier diffuseBufferRT, RenderTargetIdentifier depthStencilBufferRT, RenderTargetIdentifier depthTextureRT)
{
if (sssParameters == null || !frameSettings.enableSubsurfaceScattering)
{
return;
}
using (new ProfilingSample(cmd, "Subsurface Scattering", CustomSamplerId.SubsurfaceScattering.GetSampler()))
{
// For Jimenez we always need an extra buffer, for Disney it depends on platform
if (ShaderConfig.k_UseDisneySSS == 0 || NeedTemporarySubsurfaceBuffer())
{
// Caution: must be same format as m_CameraSssDiffuseLightingBuffer
cmd.ReleaseTemporaryRT(m_CameraFilteringBuffer);
CoreUtils.CreateCmdTemporaryRT(cmd, m_CameraFilteringBuffer, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
// Clear the SSS filtering target
using (new ProfilingSample(cmd, "Clear SSS filtering target", CustomSamplerId.ClearSSSFilteringTarget.GetSampler()))
{
CoreUtils.SetRenderTarget(cmd, m_CameraFilteringBufferRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
}
}
if (ShaderConfig.s_UseDisneySSS == 1) // use static here to quiet the compiler warning
{
using (new ProfilingSample(cmd, "HTile for SSS", CustomSamplerId.HTileForSSS.GetSampler()))
{
// Currently, Unity does not offer a way to access the GCN HTile even on PS4 and Xbox One.
// Therefore, it's computed in a pixel shader, and optimized to only contain the SSS bit.
CoreUtils.SetRenderTarget(cmd, m_HTileRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
cmd.SetRandomWriteTarget(1, m_HTile);
// Generate HTile for the split lighting stencil usage. Don't write into stencil texture (shaderPassId = 2)
// Use ShaderPassID 1 => "Pass 2 - Export HTILE for stencilRef to output"
CoreUtils.SetRenderTarget(cmd, depthStencilBufferRT); // No need for color buffer here
CoreUtils.DrawFullScreen(cmd, m_CopyStencilForSplitLighting, null, 2);
cmd.ClearRandomWriteTargets();
}
// TODO: Remove this once fix, see comment inside the function
hdCamera.SetupComputeShader(m_SubsurfaceScatteringCS, cmd);
unsafe
{
// Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
// Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
uint texturingModeFlags = sssParameters.texturingModeFlags;
cmd.SetComputeFloatParam(m_SubsurfaceScatteringCS, HDShaderIDs._TexturingModeFlags, *(float *)&texturingModeFlags);
}
cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._WorldScales, sssParameters.worldScales);
cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._FilterKernels, sssParameters.filterKernels);
cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._ShapeParams, sssParameters.shapeParams);
cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._DepthTexture, depthTextureRT);
cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._SSSHTile, m_HTileRT);
cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._IrradianceSource, diffuseBufferRT);
for (int i = 0; i < sssBufferCount; ++i)
{
cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._SSSBufferTexture[i], GetSSSBuffers(i));
}
if (NeedTemporarySubsurfaceBuffer())
{
cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._CameraFilteringBuffer, m_CameraFilteringBufferRT);
// Perform the SSS filtering pass which fills 'm_CameraFilteringBufferRT'.
// We dispatch 4x swizzled 16x16 groups per a 32x32 macro tile.
cmd.DispatchCompute(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, 4, ((int)hdCamera.screenSize.x + 31) / 32, ((int)hdCamera.screenSize.y + 31) / 32);
cmd.SetGlobalTexture(HDShaderIDs._IrradianceSource, m_CameraFilteringBufferRT); // Cannot set a RT on a material
// Additively blend diffuse and specular lighting into 'm_CameraColorBufferRT'.
CoreUtils.DrawFullScreen(cmd, m_CombineLightingPass, colorBufferRT, depthStencilBufferRT);
}
else
{
cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._CameraColorTexture, colorBufferRT);
// Perform the SSS filtering pass which performs an in-place update of 'colorBuffer'.
// We dispatch 4x swizzled 16x16 groups per a 32x32 macro tile.
cmd.DispatchCompute(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, 4, ((int)hdCamera.screenSize.x + 31) / 32, ((int)hdCamera.screenSize.y + 31) / 32);
}
}
else
{
for (int i = 0; i < sssBufferCount; ++i)
{
cmd.SetGlobalTexture(HDShaderIDs._SSSBufferTexture[i], GetSSSBuffers(i));
}
cmd.SetGlobalTexture(HDShaderIDs._IrradianceSource, diffuseBufferRT); // Cannot set a RT on a material
m_SssVerticalFilterPass.SetVectorArray(HDShaderIDs._FilterKernelsBasic, sssParameters.filterKernelsBasic);
m_SssVerticalFilterPass.SetVectorArray(HDShaderIDs._HalfRcpWeightedVariances, sssParameters.halfRcpWeightedVariances);
// Perform the vertical SSS filtering pass which fills 'm_CameraFilteringBufferRT'.
CoreUtils.DrawFullScreen(cmd, m_SssVerticalFilterPass, m_CameraFilteringBufferRT, depthStencilBufferRT);
cmd.SetGlobalTexture(HDShaderIDs._IrradianceSource, m_CameraFilteringBufferRT); // Cannot set a RT on a material
m_SssHorizontalFilterAndCombinePass.SetVectorArray(HDShaderIDs._FilterKernelsBasic, sssParameters.filterKernelsBasic);
m_SssHorizontalFilterAndCombinePass.SetVectorArray(HDShaderIDs._HalfRcpWeightedVariances, sssParameters.halfRcpWeightedVariances);
// Perform the horizontal SSS filtering pass, and combine diffuse and specular lighting into 'm_CameraColorBufferRT'.
CoreUtils.DrawFullScreen(cmd, m_SssHorizontalFilterAndCombinePass, colorBufferRT, depthStencilBufferRT);
}
}
}
// Combines specular lighting and diffuse lighting with subsurface scattering.
// In the case our frame is MSAA, for the moment given the fact that we do not have read/write access to the stencil buffer of the MSAA target; we need to keep this pass MSAA
// However, the compute can't output and MSAA target so we blend the non-MSAA target into the MSAA one.
public void SubsurfaceScatteringPass(HDCamera hdCamera, CommandBuffer cmd, RTHandleSystem.RTHandle colorBufferRT,
RTHandleSystem.RTHandle diffuseBufferRT, RTHandleSystem.RTHandle depthStencilBufferRT, RTHandleSystem.RTHandle depthTextureRT)
{
if (!hdCamera.frameSettings.IsEnabled(FrameSettingsField.SubsurfaceScattering))
{
return;
}
// TODO: For MSAA, at least initially, we can only support Jimenez, because we can't
// create MSAA + UAV render targets.
using (new ProfilingSample(cmd, "Subsurface Scattering", CustomSamplerId.SubsurfaceScattering.GetSampler()))
{
// For Jimenez we always need an extra buffer, for Disney it depends on platform
if (NeedTemporarySubsurfaceBuffer() || hdCamera.frameSettings.IsEnabled(FrameSettingsField.MSAA))
{
// Clear the SSS filtering target
using (new ProfilingSample(cmd, "Clear SSS filtering target", CustomSamplerId.ClearSSSFilteringTarget.GetSampler()))
{
HDUtils.SetRenderTarget(cmd, m_CameraFilteringBuffer, ClearFlag.Color, Color.clear);
}
}
using (new ProfilingSample(cmd, "HTile for SSS", CustomSamplerId.HTileForSSS.GetSampler()))
{
// Currently, Unity does not offer a way to access the GCN HTile even on PS4 and Xbox One.
// Therefore, it's computed in a pixel shader, and optimized to only contain the SSS bit.
// Clear the HTile texture. TODO: move this to ClearBuffers(). Clear operations must be batched!
HDUtils.SetRenderTarget(cmd, m_HTile, ClearFlag.Color, Color.clear);
HDUtils.SetRenderTarget(cmd, depthStencilBufferRT); // No need for color buffer here
cmd.SetRandomWriteTarget(1, m_HTile); // This need to be done AFTER SetRenderTarget
// Generate HTile for the split lighting stencil usage. Don't write into stencil texture (shaderPassId = 2)
// Use ShaderPassID 1 => "Pass 2 - Export HTILE for stencilRef to output"
CoreUtils.DrawFullScreen(cmd, m_CopyStencilForSplitLighting, null, 2);
cmd.ClearRandomWriteTargets();
}
unsafe
{
// Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
// Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
uint texturingModeFlags = this.texturingModeFlags;
cmd.SetComputeFloatParam(m_SubsurfaceScatteringCS, HDShaderIDs._TexturingModeFlags, *(float *)&texturingModeFlags);
}
cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._WorldScales, worldScales);
cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._FilterKernels, filterKernels);
cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._ShapeParams, shapeParams);
cmd.SetComputeFloatParams(m_SubsurfaceScatteringCS, HDShaderIDs._DiffusionProfileHashTable, diffusionProfileHashes);
int sssKernel = hdCamera.frameSettings.IsEnabled(FrameSettingsField.MSAA) ? m_SubsurfaceScatteringKernelMSAA : m_SubsurfaceScatteringKernel;
cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, sssKernel, HDShaderIDs._DepthTexture, depthTextureRT);
cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, sssKernel, HDShaderIDs._SSSHTile, m_HTile);
cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, sssKernel, HDShaderIDs._IrradianceSource, diffuseBufferRT);
for (int i = 0; i < sssBufferCount; ++i)
{
cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, sssKernel, HDShaderIDs._SSSBufferTexture[i], GetSSSBuffer(i));
}
int numTilesX = ((int)hdCamera.screenSize.x + 15) / 16;
int numTilesY = ((int)hdCamera.screenSize.y + 15) / 16;
int numTilesZ = hdCamera.viewCount;
if (NeedTemporarySubsurfaceBuffer() || hdCamera.frameSettings.IsEnabled(FrameSettingsField.MSAA))
{
cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, sssKernel, HDShaderIDs._CameraFilteringBuffer, m_CameraFilteringBuffer);
// Perform the SSS filtering pass which fills 'm_CameraFilteringBufferRT'.
cmd.DispatchCompute(m_SubsurfaceScatteringCS, sssKernel, numTilesX, numTilesY, numTilesZ);
cmd.SetGlobalTexture(HDShaderIDs._IrradianceSource, m_CameraFilteringBuffer); // Cannot set a RT on a material
// Additively blend diffuse and specular lighting into 'm_CameraColorBufferRT'.
HDUtils.DrawFullScreen(cmd, m_CombineLightingPass, colorBufferRT, depthStencilBufferRT);
}
else
{
cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._CameraColorTexture, colorBufferRT);
// Perform the SSS filtering pass which performs an in-place update of 'colorBuffer'.
cmd.DispatchCompute(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, numTilesX, numTilesY, numTilesZ);
}
}
}
protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult)
{
// Validate inputs
if (material == null || material.shader != shader)
{
material = new Material(shader);
}
numStepsLight = Mathf.Max(1, numStepsLight);
// Noise
var noise = Object.FindObjectOfType <NoiseGenerator> ();
noise.UpdateNoise();
material.SetTexture("NoiseTex", noise.shapeTexture);
material.SetTexture("DetailNoiseTex", noise.detailTexture);
material.SetTexture("BlueNoise", blueNoise);
// Weathermap
//var weatherMapGen = Object.FindObjectOfType<WeatherMap>();
//if (!Application.isPlaying)
//{
// weatherMapGen.UpdateMap();
//}
//material.SetTexture("WeatherMap", weatherMapGen.weatherMap);
Vector3 size = container.localScale;
int width = Mathf.CeilToInt(size.x);
int height = Mathf.CeilToInt(size.y);
int depth = Mathf.CeilToInt(size.z);
material.SetFloat("scale", cloudScale);
material.SetFloat("densityMultiplier", densityMultiplier);
material.SetFloat("densityOffset", densityOffset);
material.SetFloat("lightAbsorptionThroughCloud", lightAbsorptionThroughCloud);
material.SetFloat("lightAbsorptionTowardSun", lightAbsorptionTowardSun);
material.SetFloat("darknessThreshold", darknessThreshold);
material.SetVector("params", cloudTestParams);
material.SetFloat("rayOffsetStrength", rayOffsetStrength);
material.SetFloat("detailNoiseScale", detailNoiseScale);
material.SetFloat("detailNoiseWeight", detailNoiseWeight);
material.SetVector("shapeOffset", shapeOffset);
material.SetVector("detailOffset", detailOffset);
material.SetVector("detailWeights", detailNoiseWeights);
material.SetVector("shapeNoiseWeights", shapeNoiseWeights);
material.SetVector("phaseParams", new Vector4(forwardScattering, backScattering, baseBrightness, phaseFactor));
material.SetVector("boundsMin", container.position - container.localScale / 2);
material.SetVector("boundsMax", container.position + container.localScale / 2);
material.SetInt("numStepsLight", numStepsLight);
material.SetVector("mapSize", new Vector4(width, height, depth, 0));
material.SetFloat("timeScale", (Application.isPlaying) ? timeScale : 0);
material.SetFloat("baseSpeed", baseSpeed);
material.SetFloat("detailSpeed", detailSpeed);
// Set debug params
SetDebugParams();
material.SetColor("colA", colA);
material.SetColor("colB", colB);
// Bind the camera color buffer along with depth without clearing the buffers.
// Or set the a custom render target with CoreUtils.SetRenderTarget()
SetCameraRenderTarget(cmd);
CoreUtils.DrawFullScreen(cmd, material, shaderPassId: 0);
}
// 'renderSunDisk' parameter is not supported.
// Users should instead create an emissive (or lit) mesh for every relevant light source
// (to support multiple stars in space, moons with moon phases, etc).
public override void RenderSky(BuiltinSkyParameters builtinParams, bool renderForCubemap, bool renderSunDisk)
{
var pbrSky = builtinParams.skySettings as PhysicallyBasedSky;
// TODO: the following expression is somewhat inefficient, but good enough for now.
Vector3 cameraPos = builtinParams.worldSpaceCameraPos;
Vector3 planetCenter = pbrSky.GetPlanetCenterPosition(cameraPos);
float R = pbrSky.GetPlanetaryRadius();
Vector3 cameraToPlanetCenter = planetCenter - cameraPos;
float r = cameraToPlanetCenter.magnitude;
cameraPos = planetCenter - Mathf.Max(R, r) * cameraToPlanetCenter.normalized;
bool simpleEarthMode = pbrSky.type.value == PhysicallyBasedSkyModel.EarthSimple;
CommandBuffer cmd = builtinParams.commandBuffer;
// Precomputation is done, shading is next.
Quaternion planetRotation = Quaternion.Euler(pbrSky.planetRotation.value.x,
pbrSky.planetRotation.value.y,
pbrSky.planetRotation.value.z);
Quaternion spaceRotation = Quaternion.Euler(pbrSky.spaceRotation.value.x,
pbrSky.spaceRotation.value.y,
pbrSky.spaceRotation.value.z);
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._PixelCoordToViewDirWS, builtinParams.pixelCoordToViewDirMatrix);
s_PbrSkyMaterialProperties.SetVector(HDShaderIDs._WorldSpaceCameraPos1, cameraPos);
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._ViewMatrix1, builtinParams.viewMatrix);
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._PlanetRotation, Matrix4x4.Rotate(planetRotation));
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._SpaceRotation, Matrix4x4.Rotate(spaceRotation));
m_PrecomputedData.BindBuffers(cmd, s_PbrSkyMaterialProperties);
int hasGroundAlbedoTexture = 0;
if (pbrSky.groundColorTexture.value != null && !simpleEarthMode)
{
hasGroundAlbedoTexture = 1;
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._GroundAlbedoTexture, pbrSky.groundColorTexture.value);
}
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._HasGroundAlbedoTexture, hasGroundAlbedoTexture);
int hasGroundEmissionTexture = 0;
if (pbrSky.groundEmissionTexture.value != null && !simpleEarthMode)
{
hasGroundEmissionTexture = 1;
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._GroundEmissionTexture, pbrSky.groundEmissionTexture.value);
s_PbrSkyMaterialProperties.SetFloat(HDShaderIDs._GroundEmissionMultiplier, pbrSky.groundEmissionMultiplier.value);
}
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._HasGroundEmissionTexture, hasGroundEmissionTexture);
int hasSpaceEmissionTexture = 0;
if (pbrSky.spaceEmissionTexture.value != null && !simpleEarthMode)
{
hasSpaceEmissionTexture = 1;
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._SpaceEmissionTexture, pbrSky.spaceEmissionTexture.value);
s_PbrSkyMaterialProperties.SetFloat(HDShaderIDs._SpaceEmissionMultiplier, pbrSky.spaceEmissionMultiplier.value);
}
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._HasSpaceEmissionTexture, hasSpaceEmissionTexture);
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._RenderSunDisk, renderSunDisk ? 1 : 0);
int pass = (renderForCubemap ? 0 : 2);
CoreUtils.DrawFullScreen(builtinParams.commandBuffer, m_PbrSkyMaterial, s_PbrSkyMaterialProperties, pass);
}
void GenerateGaussianMips(CommandBuffer cmd, HDCamera hdCam)
{
RTHandle source;
Vector2Int size = new Vector2Int(hdCam.actualWidth, hdCam.actualHeight);
if (targetColorBuffer == TargetBuffer.Camera)
{
GetCameraBuffers(out source, out _);
}
else
{
GetCustomBuffers(out source, out _);
}
int dstMipWidth = Mathf.Max(1, size.x >> 1);
int dstMipHeight = Mathf.Max(1, size.y >> 1);
// Scale for downsample
float scaleX = ((float)size.x / source.rt.width);
float scaleY = ((float)size.y / source.rt.height);
if (useMask)
{
// Save the non blurred color into a copy:
cmd.CopyTexture(source, colorCopy);
}
// Downsample.
using (new ProfilingSample(cmd, "Downsample", CustomSampler.Create("Downsample")))
{
var downsampleProperties = new MaterialPropertyBlock();
downsampleProperties.SetTexture(ShaderID._BlitTexture, source);
downsampleProperties.SetVector(ShaderID._BlitScaleBias, new Vector4(scaleX, scaleY, 0f, 0f));
downsampleProperties.SetFloat(ShaderID._BlitMipLevel, 0);
CoreUtils.SetRenderTarget(cmd, downSampleBuffer, ClearFlag.None);
cmd.SetViewport(new Rect(0, 0, dstMipWidth, dstMipHeight));
cmd.DrawProcedural(Matrix4x4.identity, HDUtils.GetBlitMaterial(source.rt.dimension), 1, MeshTopology.Triangles, 3, 1, downsampleProperties);
}
// Horizontal Blur
using (new ProfilingSample(cmd, "H Blur", CustomSampler.Create("H Blur")))
{
var hBlurProperties = new MaterialPropertyBlock();
CoreUtils.SetRenderTarget(cmd, blurBuffer, ClearFlag.None);
hBlurProperties.SetFloat(ShaderID._Radius, radius / 4.0f); // The blur is 4 pixel wide in the shader
hBlurProperties.SetTexture(ShaderID._Source, downSampleBuffer); // The blur is 4 pixel wide in the shader
hBlurProperties.SetFloat(ShaderID._UVScale, 2);
cmd.SetViewport(new Rect(0, 0, dstMipWidth, dstMipHeight));
CoreUtils.DrawFullScreen(cmd, blurMaterial, shaderPassId: 0, properties: hBlurProperties); // Do not forget the shaderPassId: ! or it won't work
}
// Copy back the result in the color buffer while doing a vertical blur
using (new ProfilingSample(cmd, "V Blur + Copy back", CustomSampler.Create("V Blur + Copy back")))
{
var vBlurProperties = new MaterialPropertyBlock();
// When we use a mask, we do the vertical blur into the downsampling buffer instead of the camera buffer
// We need that because we're going to write to the color buffer and read from this blured buffer which we can't do
// if they are in the same buffer
CoreUtils.SetRenderTarget(cmd, (useMask) ? downSampleBuffer : source, ClearFlag.None);
vBlurProperties.SetFloat(ShaderID._Radius, radius / 4.0f); // The blur is 4 pixel wide in the shader
vBlurProperties.SetTexture(ShaderID._Source, blurBuffer);
vBlurProperties.SetFloat(ShaderID._UVScale, (useMask) ? 2 : 1);
CoreUtils.DrawFullScreen(cmd, blurMaterial, shaderPassId: 1, properties: vBlurProperties);
}
if (useMask)
{
using (new ProfilingSample(cmd, "Compose Mask Blur", CustomSampler.Create("Compose Mask Blur")))
{
var compositingProperties = new MaterialPropertyBlock();
CoreUtils.SetRenderTarget(cmd, source, ClearFlag.None);
compositingProperties.SetFloat(ShaderID._Radius, radius / 4.0f); // The blur is 4 pixel wide in the shader
compositingProperties.SetTexture(ShaderID._Source, downSampleBuffer);
compositingProperties.SetTexture(ShaderID._ColorBufferCopy, colorCopy);
compositingProperties.SetTexture(ShaderID._Mask, maskBuffer);
compositingProperties.SetTexture(ShaderID._MaskDepth, maskDepthBuffer);
compositingProperties.SetFloat(ShaderID._InvertMask, invertMask ? 1 : 0);
CoreUtils.DrawFullScreen(cmd, blurMaterial, shaderPassId: 2, properties: compositingProperties);
}
}
}
internal TextureHandle RenderVolumetricClouds_Sky(RenderGraph renderGraph, HDCamera hdCamera, Matrix4x4[] pixelCoordToViewDir, VolumetricClouds settings, int width, int height, TextureHandle skyboxCubemap)
{
// If the current volume does not enable the feature, quit right away.
if (!HasVolumetricClouds(hdCamera, in settings))
{
return(skyboxCubemap);
}
if (hdCamera.frameSettings.IsEnabled(FrameSettingsField.FullResolutionCloudsForSky))
{
using (var builder = renderGraph.AddRenderPass <VolumetricCloudsSkyHighPassData>("FullResolutionCloudsForSky", out var passData, ProfilingSampler.Get(HDProfileId.VolumetricCloudsTrace)))
{
PrepareVolumetricCloudsSkyHighPassData(renderGraph, builder, hdCamera, width, height, pixelCoordToViewDir, CubemapFace.Unknown, settings, skyboxCubemap, passData);
builder.SetRenderFunc(
(VolumetricCloudsSkyHighPassData data, RenderGraphContext ctx) =>
{
for (int faceIdx = 0; faceIdx < 6; ++faceIdx)
{
// Update the cubemap face and the inverse projection matrix
data.cubemapFace = (CubemapFace)faceIdx;
data.commonData.cloudsCB._CloudsPixelCoordToViewDirWS = data.pixelCoordToViewDir[faceIdx];
data.commonData.cloudsCB._ValidMaxZMask = 0;
// Render the face straight to the output cubemap
RenderVolumetricClouds_Sky_High(ctx.cmd, data, ctx.renderGraphPool.GetTempMaterialPropertyBlock());
}
});
return(passData.output);
}
}
else
{
TextureHandle intermediateCubemap;
using (var builder = renderGraph.AddRenderPass <VolumetricCloudsSkyLowPassData>("LowResolutionCloudsForSky", out var passData, ProfilingSampler.Get(HDProfileId.VolumetricCloudsTrace)))
{
PrepareVolumetricCloudsSkyLowPassData(renderGraph, builder, hdCamera, width, height, pixelCoordToViewDir, CubemapFace.Unknown, settings, passData);
builder.SetRenderFunc(
(VolumetricCloudsSkyLowPassData data, RenderGraphContext ctx) =>
{
for (int faceIdx = 0; faceIdx < 6; ++faceIdx)
{
// Update the cubemap face and the inverse projection matrix
data.cubemapFace = (CubemapFace)faceIdx;
data.commonData.cloudsCB._CloudsPixelCoordToViewDirWS = data.pixelCoordToViewDir[faceIdx];
data.commonData.cloudsCB._ValidMaxZMask = 0;
// Render the face straight to the output cubemap
TraceVolumetricClouds_Sky_Low(ctx.cmd, data, ctx.renderGraphPool.GetTempMaterialPropertyBlock());
}
});
intermediateCubemap = passData.output;
}
using (var builder = renderGraph.AddRenderPass <VolumetricCloudsPreUpscalePassData>("VolumetricCloudsPreUpscale", out var passData, ProfilingSampler.Get(HDProfileId.VolumetricCloudsPreUpscale)))
{
int skyResolution = (int)m_Asset.currentPlatformRenderPipelineSettings.lightLoopSettings.skyReflectionSize;
passData.cloudCombinePass = m_CloudCombinePass;
passData.pixelCoordToViewDir = pixelCoordToViewDir;
passData.input = builder.ReadTexture(intermediateCubemap);
passData.output = builder.WriteTexture(renderGraph.CreateTexture(GetVolumetricCloudsIntermediateCubeTextureDesc()));
builder.SetRenderFunc(
(VolumetricCloudsPreUpscalePassData data, RenderGraphContext ctx) =>
{
for (int faceIdx = 0; faceIdx < 6; ++faceIdx)
{
var mpb = ctx.renderGraphPool.GetTempMaterialPropertyBlock();
mpb.Clear();
mpb.SetTexture(HDShaderIDs._VolumetricCloudsTexture, data.input);
mpb.SetMatrix(HDShaderIDs._PixelCoordToViewDirWS, data.pixelCoordToViewDir[faceIdx]);
mpb.SetInt(HDShaderIDs._Mipmap, 2);
CoreUtils.SetRenderTarget(ctx.cmd, data.output, ClearFlag.None, 1, (CubemapFace)faceIdx);
CoreUtils.DrawFullScreen(ctx.cmd, data.cloudCombinePass, mpb, 4);
}
});
intermediateCubemap = passData.output;
}
using (var builder = renderGraph.AddRenderPass <VolumetricCloudsUpscalePassData>("VolumetricCloudsUpscaleAndCombine", out var passData, ProfilingSampler.Get(HDProfileId.VolumetricCloudsUpscaleAndCombine)))
{
passData.cloudCombinePass = m_CloudCombinePass;
passData.pixelCoordToViewDir = pixelCoordToViewDir;
passData.input = builder.ReadTexture(intermediateCubemap);
if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Metal)
{
passData.intermediateBuffer = builder.CreateTransientTexture(GetVolumetricCloudsIntermediateLightingBufferDesc());
passData.output = builder.ReadWriteTexture(skyboxCubemap);
}
else
{
passData.output = builder.WriteTexture(skyboxCubemap);
}
builder.SetRenderFunc(
(VolumetricCloudsUpscalePassData data, RenderGraphContext ctx) =>
{
for (int faceIdx = 0; faceIdx < 6; ++faceIdx)
{
var mpb = ctx.renderGraphPool.GetTempMaterialPropertyBlock();
if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Metal)
{
// On Intel GPUs on OSX, due to the fact that we cannot always rely on pre-exposure the hardware blending fails and turns into Nans when
// the values are close to the max fp16 value. We do the blending manually on metal to avoid that behavior.
// Copy the target face of the cubemap into a temporary texture
ctx.cmd.CopyTexture(data.output, faceIdx, 0, data.intermediateBuffer, 0, 0);
mpb.Clear();
mpb.SetTexture(HDShaderIDs._CameraColorTexture, data.intermediateBuffer);
mpb.SetTexture(HDShaderIDs._VolumetricCloudsTexture, data.input);
mpb.SetMatrix(HDShaderIDs._PixelCoordToViewDirWS, data.pixelCoordToViewDir[faceIdx]);
mpb.SetInt(HDShaderIDs._Mipmap, 1);
CoreUtils.SetRenderTarget(ctx.cmd, data.output, ClearFlag.None, 0, (CubemapFace)faceIdx);
CoreUtils.DrawFullScreen(ctx.cmd, data.cloudCombinePass, mpb, 5);
}
else
{
mpb.Clear();
mpb.SetTexture(HDShaderIDs._VolumetricCloudsTexture, data.input);
mpb.SetMatrix(HDShaderIDs._PixelCoordToViewDirWS, data.pixelCoordToViewDir[faceIdx]);
mpb.SetInt(HDShaderIDs._Mipmap, 1);
CoreUtils.SetRenderTarget(ctx.cmd, data.output, ClearFlag.None, 0, (CubemapFace)faceIdx);
CoreUtils.DrawFullScreen(ctx.cmd, data.cloudCombinePass, mpb, 6);
}
}
});
return(passData.output);
}
}
}
// 'renderSunDisk' parameter is not supported.
// Users should instead create an emissive (or lit) mesh for every relevant light source
// (to support multiple stars in space, moons with moon phases, etc).
public override void RenderSky(BuiltinSkyParameters builtinParams, bool renderForCubemap, bool renderSunDisk)
{
var pbrSky = builtinParams.skySettings as PhysicallyBasedSky;
float r = Vector3.Distance(builtinParams.worldSpaceCameraPos, pbrSky.planetCenterPosition.value);
float R = pbrSky.planetaryRadius.value;
bool isPbrSkyActive = r > R; // Disable sky rendering below the ground
CommandBuffer cmd = builtinParams.commandBuffer;
// Precomputation is done, shading is next.
Quaternion planetRotation = Quaternion.Euler(pbrSky.planetRotation.value.x,
pbrSky.planetRotation.value.y,
pbrSky.planetRotation.value.z);
Quaternion spaceRotation = Quaternion.Euler(pbrSky.spaceRotation.value.x,
pbrSky.spaceRotation.value.y,
pbrSky.spaceRotation.value.z);
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._PixelCoordToViewDirWS, builtinParams.pixelCoordToViewDirMatrix);
s_PbrSkyMaterialProperties.SetVector(HDShaderIDs._WorldSpaceCameraPos1, builtinParams.worldSpaceCameraPos);
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._ViewMatrix1, builtinParams.viewMatrix);
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._PlanetRotation, Matrix4x4.Rotate(planetRotation));
s_PbrSkyMaterialProperties.SetMatrix(HDShaderIDs._SpaceRotation, Matrix4x4.Rotate(spaceRotation));
if (m_LastPrecomputedBounce != 0)
{
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._GroundIrradianceTexture, m_GroundIrradianceTables[0]);
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._AirSingleScatteringTexture, m_InScatteredRadianceTables[0]);
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._AerosolSingleScatteringTexture, m_InScatteredRadianceTables[1]);
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._MultipleScatteringTexture, m_InScatteredRadianceTables[2]);
}
else
{
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._GroundIrradianceTexture, Texture2D.blackTexture);
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._AirSingleScatteringTexture, CoreUtils.blackVolumeTexture);
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._AerosolSingleScatteringTexture, CoreUtils.blackVolumeTexture);
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._MultipleScatteringTexture, CoreUtils.blackVolumeTexture);
}
int hasGroundAlbedoTexture = 0;
if (pbrSky.groundAlbedoTexture.value != null)
{
hasGroundAlbedoTexture = 1;
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._GroundAlbedoTexture, pbrSky.groundAlbedoTexture.value);
}
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._HasGroundAlbedoTexture, hasGroundAlbedoTexture);
int hasGroundEmissionTexture = 0;
if (pbrSky.groundEmissionTexture.value != null)
{
hasGroundEmissionTexture = 1;
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._GroundEmissionTexture, pbrSky.groundEmissionTexture.value);
}
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._HasGroundEmissionTexture, hasGroundEmissionTexture);
int hasSpaceEmissionTexture = 0;
if (pbrSky.spaceEmissionTexture.value != null)
{
hasSpaceEmissionTexture = 1;
s_PbrSkyMaterialProperties.SetTexture(HDShaderIDs._SpaceEmissionTexture, pbrSky.spaceEmissionTexture.value);
}
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._HasSpaceEmissionTexture, hasSpaceEmissionTexture);
s_PbrSkyMaterialProperties.SetInt(HDShaderIDs._RenderSunDisk, renderSunDisk ? 1 : 0);
int pass = (renderForCubemap ? 0 : 2) + (isPbrSkyActive ? 0 : 1);
CoreUtils.DrawFullScreen(builtinParams.commandBuffer, s_PbrSkyMaterial, s_PbrSkyMaterialProperties, pass);
}
public override void RenderSky(BuiltinSkyParameters builtinParams, bool renderForCubemap, bool renderSunDisk)
{
var hdriSky = builtinParams.skySettings as HDRISky;
float intensity, phi, backplatePhi;
GetParameters(out intensity, out phi, out backplatePhi, builtinParams, hdriSky);
int passID;
if (renderForCubemap)
{
passID = m_RenderCubemapID;
}
else
{
if (hdriSky.enableBackplate.value == false)
{
passID = m_RenderFullscreenSkyID;
}
else
{
passID = m_RenderFullscreenSkyWithBackplateID;
}
}
if (hdriSky.distortionMode.value != HDRISky.DistortionMode.None)
{
m_SkyHDRIMaterial.EnableKeyword("SKY_MOTION");
if (hdriSky.distortionMode.value == HDRISky.DistortionMode.Flowmap)
{
m_SkyHDRIMaterial.EnableKeyword("USE_FLOWMAP");
m_SkyHDRIMaterial.SetTexture(HDShaderIDs._Flowmap, hdriSky.flowmap.value);
}
else
{
m_SkyHDRIMaterial.DisableKeyword("USE_FLOWMAP");
}
var hdCamera = builtinParams.hdCamera;
float rot = Mathf.Deg2Rad * (hdriSky.scrollOrientation.GetValue(hdCamera) - hdriSky.rotation.value);
bool upperHemisphereOnly = hdriSky.upperHemisphereOnly.value || (hdriSky.distortionMode.value == HDRISky.DistortionMode.Procedural);
Vector4 flowmapParam = new Vector4(upperHemisphereOnly ? 1.0f : 0.0f, scrollFactor / 200.0f, -Mathf.Cos(rot), -Mathf.Sin(rot));
m_SkyHDRIMaterial.SetVector(HDShaderIDs._FlowmapParam, flowmapParam);
scrollFactor += hdCamera.animateMaterials ? hdriSky.scrollSpeed.GetValue(hdCamera) * (hdCamera.time - lastTime) * 0.01f : 0.0f;
lastTime = hdCamera.time;
}
else
{
m_SkyHDRIMaterial.DisableKeyword("SKY_MOTION");
}
m_SkyHDRIMaterial.SetTexture(HDShaderIDs._Cubemap, hdriSky.hdriSky.value);
m_SkyHDRIMaterial.SetVector(HDShaderIDs._SkyParam, new Vector4(intensity, 0.0f, Mathf.Cos(phi), Mathf.Sin(phi)));
m_SkyHDRIMaterial.SetVector(HDShaderIDs._BackplateParameters0, GetBackplateParameters0(hdriSky));
m_SkyHDRIMaterial.SetVector(HDShaderIDs._BackplateParameters1, GetBackplateParameters1(backplatePhi, hdriSky));
m_SkyHDRIMaterial.SetVector(HDShaderIDs._BackplateParameters2, GetBackplateParameters2(hdriSky));
m_SkyHDRIMaterial.SetColor(HDShaderIDs._BackplateShadowTint, hdriSky.shadowTint.value);
uint shadowFilter = 0u;
if (hdriSky.pointLightShadow.value)
{
shadowFilter |= unchecked ((uint)LightFeatureFlags.Punctual);
}
if (hdriSky.dirLightShadow.value)
{
shadowFilter |= unchecked ((uint)LightFeatureFlags.Directional);
}
if (hdriSky.rectLightShadow.value)
{
shadowFilter |= unchecked ((uint)LightFeatureFlags.Area);
}
m_SkyHDRIMaterial.SetInt(HDShaderIDs._BackplateShadowFilter, unchecked ((int)shadowFilter));
// This matrix needs to be updated at the draw call frequency.
m_PropertyBlock.SetMatrix(HDShaderIDs._PixelCoordToViewDirWS, builtinParams.pixelCoordToViewDirMatrix);
CoreUtils.DrawFullScreen(builtinParams.commandBuffer, m_SkyHDRIMaterial, m_PropertyBlock, passID);
}
