public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderingData.cameraData.camera != Camera.main)
{
return;
}
VolumeStack stack = VolumeManager.instance.stack;
PUnderwaterOverride underwater = stack.GetComponent <PUnderwaterOverride>();
PWetLensOverride wetLens = stack.GetComponent <PWetLensOverride>();
bool willRenderUnderwater = underwater.intensity.value > 0;
bool willRenderWetLens = wetLens.strength.value * wetLens.intensity.value > 0;
if (!willRenderUnderwater && !willRenderWetLens)
{
return;
}
ConfigureMaterial(ref renderingData, underwater, wetLens);
CommandBuffer cmd = CommandBufferPool.Get(PROFILER_TAG);
RenderTextureDescriptor cameraTargetDescriptor = renderingData.cameraData.cameraTargetDescriptor;
cameraTargetDescriptor.depthBufferBits = 0;
cmd.GetTemporaryRT(temporaryRenderTexture.id, cameraTargetDescriptor);
Material material = willRenderUnderwater ? underwaterMaterial : wetLensMaterial;
Blit(cmd, cameraTarget, temporaryRenderTexture.Identifier(), material, 0);
Blit(cmd, temporaryRenderTexture.Identifier(), cameraTarget);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
private void LateUpdate()
{
VolumeManager.instance.Update(null, 1);
stack = VolumeManager.instance.stack;
Volume[] volumes = FindObjectsOfType <Volume>();
bool sunVolume = false;
foreach (Volume volume in volumes)
{
if (volume.sharedProfile != null)
{
sunVolume = volume.sharedProfile.Has <SunlightProperties>() ? true : sunVolume;
}
}
if (sunVolume)
{
GatherOverrides();
}
else
{
ApplyDefaults();
}
SetSunlightTransform();
SetLightSettings();
ApplyShowFlags(showEntities);
}
public void Build(HDRenderPipelineAsset hdAsset, IBLFilterGGX iblFilterGGX)
{
m_BakingSkyRenderingContext = new SkyRenderingContext(iblFilterGGX, (int)hdAsset.renderPipelineSettings.lightLoopSettings.skyReflectionSize, false);
m_SkyRenderingContext = new SkyRenderingContext(iblFilterGGX, (int)hdAsset.renderPipelineSettings.lightLoopSettings.skyReflectionSize, true);
m_StandardSkyboxMaterial = CoreUtils.CreateEngineMaterial(hdAsset.renderPipelineResources.shaders.skyboxCubemapPS);
m_BlitCubemapMaterial = CoreUtils.CreateEngineMaterial(hdAsset.renderPipelineResources.shaders.blitCubemapPS);
m_OpaqueAtmScatteringMaterial = CoreUtils.CreateEngineMaterial(hdAsset.renderPipelineResources.shaders.opaqueAtmosphericScatteringPS);
m_LightingOverrideVolumeStack = VolumeManager.instance.CreateStack();
m_LightingOverrideLayerMask = hdAsset.renderPipelineSettings.lightLoopSettings.skyLightingOverrideLayerMask;
}
private void OnEnable()
{
CreateLightYAxis();
CreateLightLattitude();
CreateSunlightTimeofdayDymmy();
CreateSunlight();
//Enable if it has been disabled
if (sunlight != null)
{
sunlight.GetComponent <Light>().enabled = true;
}
stack = VolumeManager.instance.stack;
}
SkySettings GetSkySetting(VolumeStack stack)
{
var visualEnv = stack.GetComponent<VisualEnvironment>();
int skyID = visualEnv.skyType;
Type skyType;
if(m_SkyTypesDict.TryGetValue(skyID, out skyType))
{
return (SkySettings)stack.GetComponent(skyType);
}
else
{
return null;
}
}
public void Build(HDRenderPipelineAsset hdAsset, IBLFilterBSDF[] iblFilterBSDFArray)
{
m_SkyRenderingContext = new SkyRenderingContext(iblFilterBSDFArray, (int)hdAsset.currentPlatformRenderPipelineSettings.lightLoopSettings.skyReflectionSize, true);
#if UNITY_EDITOR
m_PreviewSkyRenderingContext = new SkyRenderingContext(iblFilterBSDFArray, (int)hdAsset.currentPlatformRenderPipelineSettings.lightLoopSettings.skyReflectionSize, true);
#endif
m_StandardSkyboxMaterial = CoreUtils.CreateEngineMaterial(hdAsset.renderPipelineResources.shaders.skyboxCubemapPS);
m_BlitCubemapMaterial = CoreUtils.CreateEngineMaterial(hdAsset.renderPipelineResources.shaders.blitCubemapPS);
m_OpaqueAtmScatteringMaterial = CoreUtils.CreateEngineMaterial(hdAsset.renderPipelineResources.shaders.opaqueAtmosphericScatteringPS);
m_LightingOverrideVolumeStack = VolumeManager.instance.CreateStack();
m_LightingOverrideLayerMask = hdAsset.currentPlatformRenderPipelineSettings.lightLoopSettings.skyLightingOverrideLayerMask;
m_StaticLightingSkyRenderingContext = new SkyRenderingContext(iblFilterBSDFArray, (int)hdAsset.currentPlatformRenderPipelineSettings.lightLoopSettings.skyReflectionSize, false);
}
public void Build(HDRenderPipelineAsset hdAsset, IBLFilterGGX iblFilterGGX)
{
m_BakingSkyRenderingContext = new SkyRenderingContext(iblFilterGGX, (int)hdAsset.renderPipelineSettings.lightLoopSettings.skyReflectionSize, false);
m_SkyRenderingContext = new SkyRenderingContext(iblFilterGGX, (int)hdAsset.renderPipelineSettings.lightLoopSettings.skyReflectionSize, true);
m_StandardSkyboxMaterial = CoreUtils.CreateEngineMaterial(hdAsset.renderPipelineResources.skyboxCubemap);
m_BlitCubemapMaterial = CoreUtils.CreateEngineMaterial(hdAsset.renderPipelineResources.blitCubemap);
m_OpaqueAtmScatteringMaterial = CoreUtils.CreateEngineMaterial(hdAsset.renderPipelineResources.opaqueAtmosphericScattering);
m_LightingOverrideVolumeStack = VolumeManager.instance.CreateStack();
m_LightingOverrideLayerMask = hdAsset.renderPipelineSettings.lightLoopSettings.skyLightingOverrideLayerMask;
#if UNITY_EDITOR
m_DefaultPreviewSky = ScriptableObject.CreateInstance <ProceduralSky>();
#endif
}
internal static SkySettings GetSkySetting(VolumeStack stack)
{
var visualEnv = stack.GetComponent <VisualEnvironment>();
int skyID = visualEnv.skyType.value;
Type skyType;
if (skyTypesDict.TryGetValue(skyID, out skyType))
{
return((SkySettings)stack.GetComponent(skyType));
}
else
{
if (skyID == (int)SkyType.Procedural && logOnce)
{
Debug.LogError("You are using the deprecated Procedural Sky in your Scene. You can still use it but, to do so, you must install it separately. To do this, open the Package Manager window and import the 'Procedural Sky' sample from the HDRP package page, then close and re-open your project without saving.");
logOnce = false;
}
return(null);
}
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (material == null || !renderingData.cameraData.postProcessEnabled)
{
return;
}
VolumeStack stack = VolumeManager.instance.stack;
outlineEffect = stack.GetComponent <OutlineEffect>();
if (outlineEffect == null || !outlineEffect.IsActive())
{
return;
}
CommandBuffer buffer = CommandBufferPool.Get(OUTLINE_EFFECT_TAG);
Render(buffer, ref renderingData);
context.ExecuteCommandBuffer(buffer);
CommandBufferPool.Release(buffer);
}
protected override void Render(ScriptableRenderContext context, Camera[] cameras)
{
BeginFrameRendering(cameras);
#region Rendering setup
if (_renderersSorted == null)
{
GetRenderersForEffects();
}
// Constants used in the camera render loop.
RenderTextureDescriptor rtDesc = new RenderTextureDescriptor(_settings.m_renderResolution.x, _settings.m_renderResolution.y, RenderTextureFormat.Default, 24);
switch (_settings.m_fixedRenderResolution)
{
case RenderConstraintAxis.Horizontal:
rtDesc.height = (int)(((float)Screen.height / (float)Screen.width) * (float)rtDesc.width);
break;
case RenderConstraintAxis.Vertical:
rtDesc.width = (int)(((float)Screen.width / (float)Screen.height) * (float)rtDesc.height);
break;
case RenderConstraintAxis.None:
rtDesc.width = Screen.width;
rtDesc.height = Screen.height;
break;
}
var rtID = Shader.PropertyToID("_LowResScreen");
if (_settings.m_simulateVertexPrecision)
{
Shader.EnableKeyword("VERTEX_PRECISION_ON");
Shader.SetGlobalFloat("_VertexPrecision", _settings.m_vertexPrecision);
}
else
{
Shader.DisableKeyword("VERTEX_PRECISION_ON");
}
if (_settings.m_perspectiveCorrection)
{
Shader.EnableKeyword("PERSPECTIVE_CORRECTION_ON");
}
else
{
Shader.DisableKeyword("PERSPECTIVE_CORRECTION_ON");
}
#endregion
foreach (var camera in cameras)
{
BeginCameraRendering(camera);
var _cb = CommandBufferPool.Get();
#region Per-camera setup
// Set the camera up.
context.SetupCameraProperties(camera);
float fov = _settings.m_viewModelFOV;
bool isSceneView = false;
#if UNITY_EDITOR
if (camera.cameraType == CameraType.SceneView)
{
fov = camera.fieldOfView;
isSceneView = true;
}
#endif
_cb.SetGlobalVectorArray(k_visibleLightColorsId, visibleLightColors);
_cb.SetGlobalVectorArray(k_visibleLightDirectionsOrPositionsId, visibleLightDirectionsOrPositions);
_cb.SetGlobalVectorArray(k_visibleLightAttenuationsId, visibleLightAttenuations);
_cb.SetGlobalVectorArray(k_visibleLightSpotDirectionsId, visibleLightSpotDirections);
#region Volume stack setup
VolumeStack stack = null;
if (_volumeStacks.ContainsKey(camera))
{
stack = _volumeStacks[camera];
}
else
{
stack = VolumeManager.instance.CreateStack();
_volumeStacks.Add(camera, stack);
}
var stackLayer = camera.GetComponent <Retro3DVolumeLayer>();
VolumeManager.instance.Update(stack, camera.transform, stackLayer ? stackLayer.layers : _settings.m_defaultVolumeLayerMask);
#endregion
var vm_matrix = Matrix4x4.Perspective(fov, camera.aspect, camera.nearClipPlane, camera.farClipPlane);
_cb.SetGlobalMatrix("_ViewmodelProjMatrix", GL.GetGPUProjectionMatrix(vm_matrix, true));
// Setup commands: Initialize the temporary render texture.
_cb.name = "Setup";
_cb.GetTemporaryRT(rtID, rtDesc.width, rtDesc.height, rtDesc.depthBufferBits, FilterMode.Point, rtDesc.colorFormat, RenderTextureReadWrite.Default, (int)_settings.m_antialiasing);
_cb.SetRenderTarget(rtID);
CoreUtils.ClearRenderTarget(_cb, ClearFlag.All, camera.backgroundColor);
context.ExecuteCommandBuffer(_cb);
_cb.Clear();
#endregion
PerformSceneRender(context, camera);
if (isSceneView)
{
context.DrawGizmos(camera, GizmoSubset.PreImageEffects);
}
PerformPostProcessing(context, camera, stack);
if (isSceneView)
{
context.DrawGizmos(camera, GizmoSubset.PostImageEffects);
}
PerformFinalBlit(context, rtID, _cb);
context.Submit();
EndCameraRendering(context, camera);
CommandBufferPool.Release(_cb);
}
EndFrameRendering(context, cameras);
}
private void PerformPostProcessing(ScriptableRenderContext context, Camera camera, VolumeStack stack)
{
if (CoreUtils.ArePostProcessesEnabled(camera))
{
foreach (var renderer in _renderersSorted)
{
var renderObject = renderer.Value;
renderObject.SetupStackComponent(stack);
if (renderObject.ShouldRender())
{
CommandBuffer buf = CommandBufferPool.Get();
renderObject.Render(buf, camera);
context.ExecuteCommandBuffer(buf);
CommandBufferPool.Release(buf);
}
}
}
}
/// <summary>Get a VolumeParameter from a VolumeComponent on the <see cref="selectedCameraVolumeStack"/></summary>
/// <param name="field">The field info of the parameter.</param>
/// <returns>The volume parameter.</returns>
public VolumeParameter GetParameter(FieldInfo field)
{
VolumeStack stack = selectedCameraVolumeStack;
return(stack == null ? null : GetParameter(stack.GetComponent(selectedComponentType), field));
}
public abstract void SetupStackComponent(VolumeStack stack);
