RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://docs.unity3d.com/Manual/urp/use-built-in-shader-methods-indirect-lighting.html below:

Manual: Use indirect lighting in a custom URP shader

Use lighting in a custom URP shader

Use shadows in a custom URP shader

Use indirect lighting in a custom URP shader

To use indirect lighting in a custom Universal Render PipelineA series of operations that take the contents of a Scene, and displays them on a screen. Unity lets you choose from pre-built render pipelines, or write your own. More info See in Glossary (URP) shaderA program that runs on the GPU. More info See in Glossary, follow these steps:

Add an #include line inside the HLSLPROGRAM block in your shader file. Refer to the sections on this page for specific include file paths.
Use any of the methods from the following sections.

Use reflection probes in a custom URP shader

To use reflection probesA rendering component that captures a spherical view of its surroundings in all directions, rather like a camera. The captured image is then stored as a Cubemap that can be used by objects with reflective materials. More info See in Glossary or the skyboxA special type of Material used to represent skies. Usually six-sided. More info See in Glossary, use the following #include line:

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/GlobalIllumination.hlsl"

Method Syntax Description GlossyEnvironmentReflection

half3 GlossyEnvironmentReflection(half3 reflectVector, float3 positionWS, half perceptualRoughness, half occlusion, float2 normalizedScreenSpaceUV)

Samples reflection probes if the object is within a reflection probe volume. Samples the skybox otherwise. The function supports reflection probe blending.
The perceptualRoughness argument selects the mip level of the sampled texture. The higher the value, the more blurred the reflections look.
The occlusion argument is the reflection probe attenuation factor.
The normalizedScreenSpaceUV argument is the normalized screen space position of the fragment.

The GlossyEnvironmentReflection function has the following simpler overload, which does not support blending:

half3 GlossyEnvironmentReflection(half3 reflectVector, half perceptualRoughness, half occlusion)

Sample Adaptive Probe Volumes

To sample Adaptive Probe Volumes (APV), use the following #include line:

#include "Packages/com.unity.render-pipelines.core/Runtime/Lighting/ProbeVolume/ProbeVolume.hlsl"

Method Syntax Description EvaluateAdaptiveProbeVolume

void EvaluateAdaptiveProbeVolume(in float3 posWS, in float3 normalWS, in float3 viewDir, in float2 positionSS, in uint renderingLayer, out float3 bakeDiffuseLighting)

Samples lighting from Adaptive Probe Volumes.
The positionSS argument is the screen space position of a fragment that is being rendered.
The renderingLayer argument is the rendering layer mask. Sample light probes

To sample light probes, use the following #include line:

#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/AmbientProbe.hlsl"

Method Syntax Description SampleSH real3 SampleSH(real3 normalWS) Sample light probesLight probes store information about how light passes through space in your scene. A collection of light probes arranged within a given space can improve lighting on moving objects and static LOD scenery within that space. More info See in Glossary. Example

The following URP shader code computes diffuse and specular ambient lightLight that doesnât come from any specific direction, and contributes equal light in all directions to the Scene. More info See in Glossary using the GlossyEnvironmentReflection function.

float3 CustomLightingAmbient(float3 BaseColor, 
                            float3 NormalWS, 
                            float Metallic, 
                            float Smoothness, 
                            float Reflectance, 
                            float AmbientOcclusion, 
                            float PositionWS, 
                            float2 screenspaceUV, 
                            float3 ViewDirWS)
{
    // Diffuse ambient lighting.
    // Sample the sky probe with high roughness and use a normal vector instead of
    // a reflection vector to approximate ambient light
    float3 DiffuseAmbient = GlossyEnvironmentReflection(NormalWS, PositionWS, 1, 1, screenspaceUV);
    // If the surface is metallic, set ambient to zero, otherwise multiply by BaseColor
    DiffuseAmbient *= lerp(BaseColor, float3(0,0,0), Metallic);

    // Specular ambient lighting - reflections
    // Surfaces are more reflective at glancing angles. Compute the fresnel value for reflectance.
    float Fresnel = pow((1 - dot(NormalWS, ViewDirWS)), 5);
    // Reflectance is 100% at the glancing angle
    Reflectance = lerp(Reflectance, 1, Fresnel);
    // If the object is metal, use the base color for reflectance instead.
    float3 ReflectionColor = lerp(float3(Reflectance, Reflectance, Reflectance), BaseColor, Metallic);
    // Compute the reflection vector and use it to sample the sky probe for reflections.
    float3 ReflectionVector = reflect(-ViewDirWS, NormalWS);
    float3 SpecularAmbient = GlossyEnvironmentReflection(ReflectionVector, PositionWS, 1 - Smoothness, 1, screenspaceUV);
    
    return (DiffuseAmbient + SpecularAmbient) * AmbientOcclusion;
}

Shader graph custom function node example

Shader Graph Feature Examples contain examples of custom lighting models.

To learn how to use the GlossyEnvironmentReflection function in a custom function node:

In the example sceneA Scene contains the environments and menus of your game. Think of each unique Scene file as a unique level. In each Scene, you place your environments, obstacles, and decorations, essentially designing and building your game in pieces. More info See in Glossary, open the CustomLightingSimple shader graph.
Navigate to the SampleReflectionProbes sub-graph.

Inspect the URPReflectionProbe node. The node contains the HLSL code that uses the GlossyEnvironmentReflection function:

#ifdef SHADERGRAPH_PREVIEW
    reflection = float3(0,0,0);
#else
    reflection = GlossyEnvironmentReflection(reflectVector, positionWS, roughness, 1.0h, screenspaceUV);
#endif

Additional resources

Use lighting in a custom URP shader

Use shadows in a custom URP shader

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4