平面运算方式的反射渲染

最新推荐文章于 2022-12-05 11:21:37 发布

VT LI

最新推荐文章于 2022-12-05 11:21:37 发布

阅读量414

点赞数 1

分类专栏：渲染几何运算顶点偏移文章标签：倒影反射高效率反射

本文链接：https://blog.csdn.net/llsansun/article/details/117528320

版权

渲染同时被 3 个专栏收录

22 篇文章 0 订阅

订阅专栏

几何运算

16 篇文章 2 订阅

订阅专栏

顶点偏移

2 篇文章 0 订阅

订阅专栏

现在的反射的做法有好多，有静态的做法也有动态的做法。

其中包括cubemap的方式或者reflectionprobe的方式，这两种方法都是要做预处理的，其中的reflectionprobe可以做实时反射，但是效率就比较低了。

另外还有planar reflect的倒影做法，planar reflect是利用另一个摄像机然后用平面几何的方式来计算的，当然需要重新计算裁剪空间的范围，这个方法也比较适合用在手机上，他的消耗相对来说是比较低的，但是他只适用以平直的平面。

还有一种就是ssr了，这个效果是在屏幕空间下通过深度图重建视野空间，然后通过光线步进的方式，遍历出反射的颜色。他是取视野的反向然后与视野空间的法线取reflect得到的信息去步进，查看深度是否有大于的深度值，有的话就拿当前的颜色赋值。这个做法的优点就是比较容易做各种不同地板的反射，可以很好的控制效果。难点在于他的步进次数，一般都要步进20次以上，那么对深度的采样就会要20次以上，在手机平台是很有挑战的。

而本方案有点类似planar reflect的方式，但是并没有用到多个相机，也并没有类似他那么复杂的运算，其中也做了很多取巧的做法，下面介绍一下：

其中主要介绍：

1.真实世界反射的效果

2.运算分析及模拟

3.解决zfight

4.渲染顺序

5.透明处理

6.范围限制

一：真实世界反射的效果

真实世界中的反射是跟观察方向以及物体本身每个分子离反射面的高度相关的。如果我们垂直看倒影，分子的高度跟倒影的高度应该是一致的。而不同角度看倒影，倒影中的分子会向我们的视线倾斜。

二：运算分析及模拟

那么我们要关注几个点，一个是顶点的高度跟倒影的高度相关，倒影跟观察者的位置方向相关。所以我们可以考虑每个物体多渲一次，然后这个多渲一次的物体让他放在平面上，每个顶点跟观察方向以及顶点的高度相关。

1.点到平面的距离：

我们要做的第一步是知道我们是要压平在平面上，那么每个点都压平在平面的话就得知道顶点跟平面的最短距离，而这个最短距离在之前的文章中已经给出了。https://blog.csdn.net/llsansun/article/details/103520166?spm=1001.2014.3001.5501

其中(A,B,C)是平面的法线，（x0,y0,z0）是顶点的位置。顶点的位置我们肯定知道了，那么我们要知道平面的法线，就需要在平面上拿出mesh的normal信息，因为我们是一个平面，他的每个顶点的normal都一致，所以我们随便拿一个顶点的normal就可以了。

2.向相机方向偏移顶点：

既然要跟观察者相关，而且会偏向观察者，那么我们就可以对顶点做一个相机方向的偏移操作。也就是先拿到我们点到平面的最短距离，然后在当前顶带你的世界空间上加上一段顶点到相机方向的距离。

得到的效果大概是这样

3.压平到平面：

要压平到平面就需要计算偏移后的点到平面的最短距离，也相当于沿法线的相反方向再偏移一次最短距离。

最后把这个世界坐标转换到裁剪空间就ok了

三：解决zfight

基本运算如上，但是如果只是通过这个方式实现，会出现一个问题，就是移动时倒影会闪得很厉害，这个是因为zfight的原因。zfight是说在zwrite写入的情况下，同一个深度下有多个顶点，然后提交渲染时gpu最终会渲染哪个顶点是不确定的。所以会闪烁。

解决这个问题的我的方式是对他做一些offset还有压平到平面的点上做一些世界坐标下的微小偏移

这样就没有闪烁的效果了。

四：渲染顺序

这里要关注的是倒影渲染的正确了，我们要关注一下cull，我们不能剔除正反面。虽然正常的物体我们是剔除反面是没问题的，但是倒影就可能渲染到反面了，这个时候如果我们剔除掉反面，那么效果就会不正确

而不剔除的效果就会正确

五：透明处理

我们知道，在地板下的透明可能会随着深度不断的变透明，而我们的物体很可能是不透明渲染的，那么这个情况下如果我们要做透明渲染，就需要一些技巧了。可能有人会想到用screendoor的方式实现，但是他的效果以及对逐渐透明的效果都是不理想的。

我的方式是利用透明的做法，就是（srcColor * SrcAlpha) + (BackGroundColor * (1 - SrcAlpha))。

一开始我的做法是截屏然后跟屏幕做混合，这个效果也非常好。

但是他有个比较大的问题，因为grabpass会截取一张全屏像素的图片，这个消耗本身就比较大。而且不同批次的还会执行多个截图的pass。这个消耗就更大了。但是我们不能用cmb来截图，因为他们可能都是在不透明渲染或者在透明渲染，那么如果他们叠在一起，混合起来就不正确了。

那么我们要做的是一个透明效果，不一定就得要全屏得截屏功能，我考虑这个地板一般是比较单纯的颜色，或者就是有不同的颜色也不会相差比较大。我就考虑用单色来混合。然后渐变的是根据他的顶点到平面的最短距离来确定的。

虽然没有截屏的效果号，但是他也类似了一个透明效果。

六：范围限制：

如果我们就这样是控制不了倒影只在平面内的，所以我们需要用模板测试来限制。

没限制的效果：

限制的效果：

最后展示先用ssr和用本方案在手机上的性能表现：

ssr:

本方案：

最终的代码：

refrectionPlane.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;

[ExecuteInEditMode]
public class refrectionPlane : MonoBehaviour
{
    Vector3 normal;
    Vector3 p;
    MeshFilter meshfilter;
    [Range(0.1f, 10.0f)]
    public float _ReflectionLen = 1f;
    [Range(0.01f, 1.0f)]
    public float _Transparency = 1f;
    public Color _SceneColor = Color.gray;

    private Vector3 currentPos = Vector3.zero;
    private Quaternion currentRot = Quaternion.identity;
    private Vector3 currentScale = Vector3.one;
    
    private Transform mTransform = null;

    private Vector3 worldNormal = Vector3.zero;
    private float worldNormalSqrt = 0f;
    private float D = 0;

    void OnEnable()
    {
        meshfilter = this.GetComponent<MeshFilter>();
        normal = meshfilter.mesh.normals[0];

        mTransform = this.transform;
    }

    // Update is called once per frame
    void Update()
    {
        if (mTransform.position != currentPos || mTransform.rotation != currentRot || 
            mTransform.localScale != currentScale)
        {
            currentPos = mTransform.position;
            currentRot = mTransform.rotation;
            currentScale = mTransform.localScale;

            worldNormal = Vector3.Normalize(this.transform.localToWorldMatrix * normal);
            worldNormalSqrt = Mathf.Sqrt(worldNormal.x * worldNormal.x + worldNormal.y * worldNormal.y + worldNormal.z * worldNormal.z);
            p = meshfilter.mesh.vertices[0] + this.transform.localPosition;
            var worldPoint = p;//this.transform.localToWorldMatrix * p;
            D = -(worldNormal.x * worldPoint.x + worldNormal.y * worldPoint.y + worldNormal.z * worldPoint.z);
        }

        Shader.SetGlobalVector("_fpNormal", worldNormal);
        Shader.SetGlobalFloat("_D", D);
        Shader.SetGlobalFloat("_ReflectionLen", _ReflectionLen);
        Shader.SetGlobalFloat("_Transparency", _Transparency);
        Shader.SetGlobalColor("_SceneColor", _SceneColor);
        Shader.SetGlobalFloat("_WorldNormalSqrt", worldNormalSqrt);

    }
    
}

Standard Refrection VTL.shader

// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)

Shader "Standard Refrection VTL"
{
    Properties
    {
        _Color("Color", Color) = (1,1,1,1)
        _MainTex("Albedo", 2D) = "white" {}

        _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5

        _Glossiness("Smoothness", Range(0.0, 1.0)) = 0.5
        _GlossMapScale("Smoothness Scale", Range(0.0, 1.0)) = 1.0
        [Enum(Metallic Alpha,0,Albedo Alpha,1)] _SmoothnessTextureChannel ("Smoothness texture channel", Float) = 0

        [Gamma] _Metallic("Metallic", Range(0.0, 1.0)) = 0.0
        _MetallicGlossMap("Metallic", 2D) = "white" {}

        [ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0
        [ToggleOff] _GlossyReflections("Glossy Reflections", Float) = 1.0

        _BumpScale("Scale", Float) = 1.0
        [Normal] _BumpMap("Normal Map", 2D) = "bump" {}

        _Parallax ("Height Scale", Range (0.005, 0.08)) = 0.02
        _ParallaxMap ("Height Map", 2D) = "black" {}

        _OcclusionStrength("Strength", Range(0.0, 1.0)) = 1.0
        _OcclusionMap("Occlusion", 2D) = "white" {}

        _EmissionColor("Color", Color) = (0,0,0)
        _EmissionMap("Emission", 2D) = "white" {}

        _DetailMask("Detail Mask", 2D) = "white" {}

        _DetailAlbedoMap("Detail Albedo x2", 2D) = "grey" {}
        _DetailNormalMapScale("Scale", Float) = 1.0
        [Normal] _DetailNormalMap("Normal Map", 2D) = "bump" {}

        [Enum(UV0,0,UV1,1)] _UVSec ("UV Set for secondary textures", Float) = 0


        // Blending state
        [HideInInspector] _Mode ("__mode", Float) = 0.0
        [HideInInspector] _SrcBlend ("__src", Float) = 1.0
        [HideInInspector] _DstBlend ("__dst", Float) = 0.0
        [HideInInspector] _ZWrite ("__zw", Float) = 1.0

    }

    CGINCLUDE
        #define UNITY_SETUP_BRDF_INPUT MetallicSetup
    ENDCG

    SubShader
    {
        Tags { "RenderType"="Opaque" "PerformanceChecks"="False" "RenderQueue" = "Geometry+100" }
        LOD 300

        // ------------------------------------------------------------------
        //  Base forward pass (directional light, emission, lightmaps, ...)
		

		
		Pass
		{
			Name "FORWARD"
			Tags { "LightMode" = "ForwardBase" }

			Blend[_SrcBlend][_DstBlend]
			ZWrite[_ZWrite]

			CGPROGRAM
			#pragma target 3.0

			// -------------------------------------

			#pragma shader_feature_local _NORMALMAP
			#pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
			#pragma shader_feature _EMISSION
			#pragma shader_feature_local _METALLICGLOSSMAP
			#pragma shader_feature_local _DETAIL_MULX2
			#pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
			#pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
			#pragma shader_feature_local _GLOSSYREFLECTIONS_OFF
			#pragma shader_feature_local _PARALLAXMAP

			#pragma multi_compile_fwdbase
			#pragma multi_compile_fog
			#pragma multi_compile_instancing
			// Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes.
			//#pragma multi_compile _ LOD_FADE_CROSSFADE

			#pragma vertex vertBase
			#pragma fragment fragBase
			#include "UnityStandardCoreForward.cginc"

			ENDCG
		}
        // ------------------------------------------------------------------
        //  Additive forward pass (one light per pass)
        Pass
        {
            Name "FORWARD_DELTA"
            Tags { "LightMode" = "ForwardAdd" }
            Blend [_SrcBlend] One
            Fog { Color (0,0,0,0) } // in additive pass fog should be black
            ZWrite Off
            ZTest LEqual

            CGPROGRAM
            #pragma target 3.0

            // -------------------------------------


            #pragma shader_feature_local _NORMALMAP
            #pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
            #pragma shader_feature_local _DETAIL_MULX2
            #pragma shader_feature_local _PARALLAXMAP

            #pragma multi_compile_fwdadd_fullshadows
            #pragma multi_compile_fog
            // Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes.
            //#pragma multi_compile _ LOD_FADE_CROSSFADE

            #pragma vertex vertAdd
            #pragma fragment fragAdd
            #include "UnityStandardCoreForward.cginc"

            ENDCG
        }
        // ------------------------------------------------------------------
        //  Shadow rendering pass
        Pass {
            Name "ShadowCaster"
            Tags { "LightMode" = "ShadowCaster" }

            ZWrite On ZTest LEqual

            CGPROGRAM
            #pragma target 3.0

            // -------------------------------------


            #pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _PARALLAXMAP
            #pragma multi_compile_shadowcaster
            #pragma multi_compile_instancing
            // Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes.
            //#pragma multi_compile _ LOD_FADE_CROSSFADE

            #pragma vertex vertShadowCaster
            #pragma fragment fragShadowCaster

            #include "UnityStandardShadow.cginc"

            ENDCG
        }
        // ------------------------------------------------------------------
        //  Deferred pass
        Pass
        {
            Name "DEFERRED"
            Tags { "LightMode" = "Deferred" }

            CGPROGRAM
            #pragma target 3.0
            #pragma exclude_renderers nomrt


            // -------------------------------------

            #pragma shader_feature_local _NORMALMAP
            #pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
            #pragma shader_feature _EMISSION
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
            #pragma shader_feature_local _DETAIL_MULX2
            #pragma shader_feature_local _PARALLAXMAP

            #pragma multi_compile_prepassfinal
            #pragma multi_compile_instancing
            // Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes.
            //#pragma multi_compile _ LOD_FADE_CROSSFADE

            #pragma vertex vertDeferred
            #pragma fragment fragDeferred

            #include "UnityStandardCore.cginc"

            ENDCG
        }

        // ------------------------------------------------------------------
        // Extracts information for lightmapping, GI (emission, albedo, ...)
        // This pass it not used during regular rendering.
        Pass
        {
            Name "META"
            Tags { "LightMode"="Meta" }

            Cull Off

            CGPROGRAM
            #pragma vertex vert_meta
            #pragma fragment frag_meta

            #pragma shader_feature _EMISSION
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _DETAIL_MULX2
            #pragma shader_feature EDITOR_VISUALIZATION

            #include "UnityStandardMeta.cginc"
            ENDCG
        }

		//GrabPass{
		//			//如果在这里定义一个纹理的名称，那么在下面就要同样声明一下，截屏的纹理就储存到了这个变量里面
		//		}//截屏通道，如果在这里不指定名字就会默认使用_GrabTexture进行保存
		Pass//1
		{
			Name "FORWARD REFLECTION FRONT"
			//Tags { "LightMode" = "ForwardBase" }

			Blend[_SrcBlend][_DstBlend]
			ZWrite[_ZWrite]
			Cull Off
			Offset -1,-1

			Stencil
			{
				Ref 5
				Comp Equal
				Pass Replace
			}

			CGPROGRAM
			#pragma target 3.0

			// -------------------------------------

			#pragma shader_feature_local _NORMALMAP
			#pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
			#pragma shader_feature _EMISSION
			#pragma shader_feature_local _METALLICGLOSSMAP
			#pragma shader_feature_local _DETAIL_MULX2
			#pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
			#pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
			#pragma shader_feature_local _GLOSSYREFLECTIONS_OFF
			#pragma shader_feature_local _PARALLAXMAP

			#pragma multi_compile_fwdbase
			#pragma multi_compile_fog
			#pragma multi_compile_instancing

			#pragma vertex vertReflection
			#pragma fragment fragForwardBaseFeflection

			#include "UnityCG.cginc"
			#include "UnityStandardCoreForward.cginc"
			#include "ReflectionVTL.cginc"

			ENDCG
		}

		//Pass//1
		//{
		//	Name "FORWARD REFLECTION BACK"
		//	//Tags { "LightMode" = "ForwardBase" }

		//	Blend[_SrcBlend][_DstBlend]
		//	ZWrite[_ZWrite]
		//	Cull Front
		//	Offset -1,-1

		//	Stencil
		//	{
		//		Ref 5
		//		Comp Equal
		//		Pass Replace
		//	}

		//	CGPROGRAM
		//	#pragma target 3.0

		//	// -------------------------------------

		//	#pragma shader_feature_local _NORMALMAP
		//	#pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
		//	#pragma shader_feature _EMISSION
		//	#pragma shader_feature_local _METALLICGLOSSMAP
		//	#pragma shader_feature_local _DETAIL_MULX2
		//	#pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
		//	#pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
		//	#pragma shader_feature_local _GLOSSYREFLECTIONS_OFF
		//	#pragma shader_feature_local _PARALLAXMAP

		//	#pragma multi_compile_fwdbase
		//	#pragma multi_compile_fog
		//	#pragma multi_compile_instancing

		//	#pragma vertex vertReflection
		//	#pragma fragment fragForwardBaseFeflection

		//	#include "UnityCG.cginc"
		//	#include "UnityStandardCoreForward.cginc"
		//	#include "ReflectionVTL.cginc"

		//	ENDCG
		//}
    }

    SubShader
    {
        Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
        LOD 150

        // ------------------------------------------------------------------
        //  Base forward pass (directional light, emission, lightmaps, ...)
        Pass
        {
            Name "FORWARD"
            Tags { "LightMode" = "ForwardBase" }

            Blend [_SrcBlend] [_DstBlend]
            ZWrite [_ZWrite]

            CGPROGRAM
            #pragma target 2.0

            #pragma shader_feature_local _NORMALMAP
            #pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
            #pragma shader_feature _EMISSION
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
            #pragma shader_feature_local _GLOSSYREFLECTIONS_OFF
            // SM2.0: NOT SUPPORTED shader_feature_local _DETAIL_MULX2
            // SM2.0: NOT SUPPORTED shader_feature_local _PARALLAXMAP

            #pragma skip_variants SHADOWS_SOFT DIRLIGHTMAP_COMBINED

            #pragma multi_compile_fwdbase
            #pragma multi_compile_fog

            #pragma vertex vertBase
            #pragma fragment fragBase
            #include "UnityStandardCoreForward.cginc"

            ENDCG
        }
        // ------------------------------------------------------------------
        //  Additive forward pass (one light per pass)
        Pass
        {
            Name "FORWARD_DELTA"
            Tags { "LightMode" = "ForwardAdd" }
            Blend [_SrcBlend] One
            Fog { Color (0,0,0,0) } // in additive pass fog should be black
            ZWrite Off
            ZTest LEqual

            CGPROGRAM
            #pragma target 2.0

            #pragma shader_feature_local _NORMALMAP
            #pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
            #pragma shader_feature_local _DETAIL_MULX2
            // SM2.0: NOT SUPPORTED shader_feature_local _PARALLAXMAP
            #pragma skip_variants SHADOWS_SOFT

            #pragma multi_compile_fwdadd_fullshadows
            #pragma multi_compile_fog

            #pragma vertex vertAdd
            #pragma fragment fragAdd
            #include "UnityStandardCoreForward.cginc"

            ENDCG
        }
        // ------------------------------------------------------------------
        //  Shadow rendering pass
        Pass {
            Name "ShadowCaster"
            Tags { "LightMode" = "ShadowCaster" }

            ZWrite On ZTest LEqual

            CGPROGRAM
            #pragma target 2.0

            #pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma skip_variants SHADOWS_SOFT
            #pragma multi_compile_shadowcaster

            #pragma vertex vertShadowCaster
            #pragma fragment fragShadowCaster

            #include "UnityStandardShadow.cginc"

            ENDCG
        }

        // ------------------------------------------------------------------
        // Extracts information for lightmapping, GI (emission, albedo, ...)
        // This pass it not used during regular rendering.
        Pass
        {
            Name "META"
            Tags { "LightMode"="Meta" }

            Cull Off

            CGPROGRAM
            #pragma vertex vert_meta
            #pragma fragment frag_meta

            #pragma shader_feature _EMISSION
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _DETAIL_MULX2
            #pragma shader_feature EDITOR_VISUALIZATION

            #include "UnityStandardMeta.cginc"
            ENDCG
        }
    }


    FallBack "VertexLit"
    //CustomEditor "StandardShaderGUI"
}

Standard Refrection Plane VTL.shader

// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)

Shader "Standard Refrection Plane VTL"
{
    Properties
    {
        _Color("Color", Color) = (1,1,1,1)
        _MainTex("Albedo", 2D) = "white" {}

        _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5

        _Glossiness("Smoothness", Range(0.0, 1.0)) = 0.5
        _GlossMapScale("Smoothness Scale", Range(0.0, 1.0)) = 1.0
        [Enum(Metallic Alpha,0,Albedo Alpha,1)] _SmoothnessTextureChannel ("Smoothness texture channel", Float) = 0

        [Gamma] _Metallic("Metallic", Range(0.0, 1.0)) = 0.0
        _MetallicGlossMap("Metallic", 2D) = "white" {}

        [ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0
        [ToggleOff] _GlossyReflections("Glossy Reflections", Float) = 1.0

        _BumpScale("Scale", Float) = 1.0
        [Normal] _BumpMap("Normal Map", 2D) = "bump" {}

        _Parallax ("Height Scale", Range (0.005, 0.08)) = 0.02
        _ParallaxMap ("Height Map", 2D) = "black" {}

        _OcclusionStrength("Strength", Range(0.0, 1.0)) = 1.0
        _OcclusionMap("Occlusion", 2D) = "white" {}

        _EmissionColor("Color", Color) = (0,0,0)
        _EmissionMap("Emission", 2D) = "white" {}

        _DetailMask("Detail Mask", 2D) = "white" {}

        _DetailAlbedoMap("Detail Albedo x2", 2D) = "grey" {}
        _DetailNormalMapScale("Scale", Float) = 1.0
        [Normal] _DetailNormalMap("Normal Map", 2D) = "bump" {}

        [Enum(UV0,0,UV1,1)] _UVSec ("UV Set for secondary textures", Float) = 0


        // Blending state
        [HideInInspector] _Mode ("__mode", Float) = 0.0
        [HideInInspector] _SrcBlend ("__src", Float) = 1.0
        [HideInInspector] _DstBlend ("__dst", Float) = 0.0
        [HideInInspector] _ZWrite ("__zw", Float) = 1.0

		_OffsetFactor("Offset Factor", Float) = 0
		_OffsetUnits("Offset Units", Float) = 0
    }

    CGINCLUDE
        #define UNITY_SETUP_BRDF_INPUT MetallicSetup
    ENDCG

    SubShader
    {
        Tags { "RenderType"="Opaque" "PerformanceChecks"="False" "RenderQueue" = "Geometry+100" }
        LOD 300

        // ------------------------------------------------------------------
        //  Base forward pass (directional light, emission, lightmaps, ...)
		
		
		Pass
		{
			Name "FORWARD"
			Tags { "LightMode" = "ForwardBase" }

			Blend[_SrcBlend][_DstBlend]
			ZWrite[_ZWrite]
			Stencil
			{
				Ref 5
				Comp Always
				Pass Replace
			}

			CGPROGRAM
			#pragma target 3.0

			// -------------------------------------

			#pragma shader_feature_local _NORMALMAP
			#pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
			#pragma shader_feature _EMISSION
			#pragma shader_feature_local _METALLICGLOSSMAP
			#pragma shader_feature_local _DETAIL_MULX2
			#pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
			#pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
			#pragma shader_feature_local _GLOSSYREFLECTIONS_OFF
			#pragma shader_feature_local _PARALLAXMAP

			#pragma multi_compile_fwdbase
			#pragma multi_compile_fog
			#pragma multi_compile_instancing
			// Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes.
			//#pragma multi_compile _ LOD_FADE_CROSSFADE


			
			#pragma vertex vertBase
			#pragma fragment fragForwardBaseFeflection
			#include "UnityStandardCoreForward.cginc"

			half4 fragForwardBaseFeflection(VertexOutputForwardBase i) : SV_Target
			{
				UNITY_APPLY_DITHER_CROSSFADE(i.pos.xy);

				FRAGMENT_SETUP(s)

				UNITY_SETUP_INSTANCE_ID(i);
				UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);

				UnityLight mainLight = MainLight();
				UNITY_LIGHT_ATTENUATION(atten, i, s.posWorld);

				half occlusion = Occlusion(i.tex.xy);
				UnityGI gi = FragmentGI(s, occlusion, i.ambientOrLightmapUV, atten, mainLight);

				half4 c = UNITY_BRDF_PBS(s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, gi.light, gi.indirect);
				c.rgb += Emission(i.tex.xy);

				UNITY_EXTRACT_FOG_FROM_EYE_VEC(i);
				UNITY_APPLY_FOG(_unity_fogCoord, c.rgb);
				return OutputForward(c, 1);
			}
			ENDCG
		}
        // ------------------------------------------------------------------
        //  Additive forward pass (one light per pass)
        Pass
        {
            Name "FORWARD_DELTA"
            Tags { "LightMode" = "ForwardAdd" }
            Blend [_SrcBlend] One
            Fog { Color (0,0,0,0) } // in additive pass fog should be black
            ZWrite Off
            ZTest LEqual

            CGPROGRAM
            #pragma target 3.0

            // -------------------------------------


            #pragma shader_feature_local _NORMALMAP
            #pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
            #pragma shader_feature_local _DETAIL_MULX2
            #pragma shader_feature_local _PARALLAXMAP

            #pragma multi_compile_fwdadd_fullshadows
            #pragma multi_compile_fog
            // Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes.
            //#pragma multi_compile _ LOD_FADE_CROSSFADE

            #pragma vertex vertAdd
            #pragma fragment fragAdd
            #include "UnityStandardCoreForward.cginc"

            ENDCG
        }
        // ------------------------------------------------------------------
        //  Shadow rendering pass
        Pass {
            Name "ShadowCaster"
            Tags { "LightMode" = "ShadowCaster" }

            ZWrite On ZTest LEqual

            CGPROGRAM
            #pragma target 3.0

            // -------------------------------------


            #pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _PARALLAXMAP
            #pragma multi_compile_shadowcaster
            #pragma multi_compile_instancing
            // Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes.
            //#pragma multi_compile _ LOD_FADE_CROSSFADE

            #pragma vertex vertShadowCaster
            #pragma fragment fragShadowCaster

            #include "UnityStandardShadow.cginc"

            ENDCG
        }
        // ------------------------------------------------------------------
        //  Deferred pass
        Pass
        {
            Name "DEFERRED"
            Tags { "LightMode" = "Deferred" }

            CGPROGRAM
            #pragma target 3.0
            #pragma exclude_renderers nomrt


            // -------------------------------------

            #pragma shader_feature_local _NORMALMAP
            #pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
            #pragma shader_feature _EMISSION
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
            #pragma shader_feature_local _DETAIL_MULX2
            #pragma shader_feature_local _PARALLAXMAP

            #pragma multi_compile_prepassfinal
            #pragma multi_compile_instancing
            // Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes.
            //#pragma multi_compile _ LOD_FADE_CROSSFADE

            #pragma vertex vertDeferred
            #pragma fragment fragDeferred

            #include "UnityStandardCore.cginc"

            ENDCG
        }

        // ------------------------------------------------------------------
        // Extracts information for lightmapping, GI (emission, albedo, ...)
        // This pass it not used during regular rendering.
        Pass
        {
            Name "META"
            Tags { "LightMode"="Meta" }

            Cull Off

            CGPROGRAM
            #pragma vertex vert_meta
            #pragma fragment frag_meta

            #pragma shader_feature _EMISSION
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _DETAIL_MULX2
            #pragma shader_feature EDITOR_VISUALIZATION

            #include "UnityStandardMeta.cginc"
            ENDCG
        }
    }

    SubShader
    {
        Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
        LOD 150

        // ------------------------------------------------------------------
        //  Base forward pass (directional light, emission, lightmaps, ...)
        Pass
        {
            Name "FORWARD"
            Tags { "LightMode" = "ForwardBase" }

            Blend [_SrcBlend] [_DstBlend]
            ZWrite [_ZWrite]

            CGPROGRAM
            #pragma target 2.0

            #pragma shader_feature_local _NORMALMAP
            #pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
            #pragma shader_feature _EMISSION
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
            #pragma shader_feature_local _GLOSSYREFLECTIONS_OFF
            // SM2.0: NOT SUPPORTED shader_feature_local _DETAIL_MULX2
            // SM2.0: NOT SUPPORTED shader_feature_local _PARALLAXMAP

            #pragma skip_variants SHADOWS_SOFT DIRLIGHTMAP_COMBINED

            #pragma multi_compile_fwdbase
            #pragma multi_compile_fog

            #pragma vertex vertBase
            #pragma fragment fragBase
            #include "UnityStandardCoreForward.cginc"

            ENDCG
        }
        // ------------------------------------------------------------------
        //  Additive forward pass (one light per pass)
        Pass
        {
            Name "FORWARD_DELTA"
            Tags { "LightMode" = "ForwardAdd" }
            Blend [_SrcBlend] One
            Fog { Color (0,0,0,0) } // in additive pass fog should be black
            ZWrite Off
            ZTest LEqual

            CGPROGRAM
            #pragma target 2.0

            #pragma shader_feature_local _NORMALMAP
            #pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
            #pragma shader_feature_local _DETAIL_MULX2
            // SM2.0: NOT SUPPORTED shader_feature_local _PARALLAXMAP
            #pragma skip_variants SHADOWS_SOFT

            #pragma multi_compile_fwdadd_fullshadows
            #pragma multi_compile_fog

            #pragma vertex vertAdd
            #pragma fragment fragAdd
            #include "UnityStandardCoreForward.cginc"

            ENDCG
        }
        // ------------------------------------------------------------------
        //  Shadow rendering pass
        Pass {
            Name "ShadowCaster"
            Tags { "LightMode" = "ShadowCaster" }

            ZWrite On ZTest LEqual

            CGPROGRAM
            #pragma target 2.0

            #pragma shader_feature_local _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma skip_variants SHADOWS_SOFT
            #pragma multi_compile_shadowcaster

            #pragma vertex vertShadowCaster
            #pragma fragment fragShadowCaster

            #include "UnityStandardShadow.cginc"

            ENDCG
        }

        // ------------------------------------------------------------------
        // Extracts information for lightmapping, GI (emission, albedo, ...)
        // This pass it not used during regular rendering.
        Pass
        {
            Name "META"
            Tags { "LightMode"="Meta" }

            Cull Off

            CGPROGRAM
            #pragma vertex vert_meta
            #pragma fragment frag_meta

            #pragma shader_feature _EMISSION
            #pragma shader_feature_local _METALLICGLOSSMAP
            #pragma shader_feature_local _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
            #pragma shader_feature_local _DETAIL_MULX2
            #pragma shader_feature EDITOR_VISUALIZATION

            #include "UnityStandardMeta.cginc"
            ENDCG
        }
    }


    FallBack "VertexLit"
    //CustomEditor "StandardShaderGUI"
}

ReflectionVTL.cginc


uniform float3 _fpNormal;
uniform float _D;
uniform float4 _SceneColor;
uniform float _Transparency;
uniform float _ReflectionLen;
uniform float _WorldNormalSqrt;
//sampler2D _GrabTexture;//所以截屏的纹理保存到这里
//float4 _GrabTexture_ST;

struct VertexOutputForwardBase2
{
	UNITY_POSITION(pos);
	float4 tex                            : TEXCOORD0;
	float4 eyeVec                         : TEXCOORD1;    // eyeVec.xyz | fogCoord
	float4 tangentToWorldAndPackedData[3] : TEXCOORD2;    // [3x3:tangentToWorld | 1x3:viewDirForParallax or worldPos]
	half4 ambientOrLightmapUV             : TEXCOORD5;    // SH or Lightmap UV
	UNITY_LIGHTING_COORDS(6, 7)

		// next ones would not fit into SM2.0 limits, but they are always for SM3.0+
#if UNITY_REQUIRE_FRAG_WORLDPOS && !UNITY_PACK_WORLDPOS_WITH_TANGENT
		float3 posWorld                     : TEXCOORD8;
#endif

	UNITY_VERTEX_INPUT_INSTANCE_ID
		UNITY_VERTEX_OUTPUT_STEREO
};
VertexOutputForwardBase2 vertReflection(VertexInput v)
{

	UNITY_SETUP_INSTANCE_ID(v);
	VertexOutputForwardBase2 o;
	UNITY_INITIALIZE_OUTPUT(VertexOutputForwardBase2, o);
	UNITY_TRANSFER_INSTANCE_ID(v, o);
	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

	float4 posWorld = mul(unity_ObjectToWorld, v.vertex);


	float3 viewDir = normalize(_WorldSpaceCameraPos.xyz - posWorld);

	//老位置的最短距离
	half oldminDistance = abs(_fpNormal.x * posWorld.x + _fpNormal.y * posWorld.y + _fpNormal.z * posWorld.z + _D) * rcp(_WorldNormalSqrt);

	//先往相机方向运动一段距离
	float3 newWorldPos = viewDir * oldminDistance*_ReflectionLen + posWorld.xyz;


	//最短距离
	half minDistance = abs(_fpNormal.x * newWorldPos.x + _fpNormal.y * newWorldPos.y + _fpNormal.z * newWorldPos.z + _D) * rcp(_WorldNormalSqrt);

	posWorld = float4(newWorldPos + (minDistance) * (-_fpNormal) - (posWorld.xyz * rcp(1000)), posWorld.w);//需要做一些往posworld的偏移，不然会有很严重的zfight，因为顶点都平铺到平面上了

	//o.vertex = UnityWorldToClipPos(planePoint);
	o.pos = UnityWorldToClipPos(posWorld);

	//float4 srcPos = ComputeScreenPos(o.pos);

#if UNITY_REQUIRE_FRAG_WORLDPOS
#if UNITY_PACK_WORLDPOS_WITH_TANGENT
	o.tangentToWorldAndPackedData[0].w = posWorld.x;
	o.tangentToWorldAndPackedData[1].w = posWorld.y;
	o.tangentToWorldAndPackedData[2].w = posWorld.z;
#else
	o.posWorld = posWorld.xyz;
#endif
#endif
	//o.pos = UnityObjectToClipPos(v.vertex);

	o.tex = TexCoords(v);
	o.eyeVec.xyz = NormalizePerVertexNormal(posWorld.xyz - _WorldSpaceCameraPos);
	float3 normalWorld = UnityObjectToWorldNormal(v.normal);
#ifdef _TANGENT_TO_WORLD
	float4 tangentWorld = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w);

	float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld.xyz, tangentWorld.w);
	o.tangentToWorldAndPackedData[0].xyz = tangentToWorld[0];
	o.tangentToWorldAndPackedData[1].xyz = tangentToWorld[1];
	o.tangentToWorldAndPackedData[2].xyz = tangentToWorld[2];
#else
	o.tangentToWorldAndPackedData[0].xyz = 0;
	o.tangentToWorldAndPackedData[1].xyz = 0;
	o.tangentToWorldAndPackedData[2].xyz = normalWorld;
#endif

	//We need this for shadow receving
	UNITY_TRANSFER_LIGHTING(o, v.uv1);

	o.ambientOrLightmapUV = VertexGIForward(v, posWorld, normalWorld);

	/*o.tex.zw = srcPos.xy;
	o.ambientOrLightmapUV.w = srcPos.w;*/
	o.eyeVec.w = 1 / (oldminDistance);

#ifdef _PARALLAXMAP
	TANGENT_SPACE_ROTATION;
	half3 viewDirForParallax = mul(rotation, ObjSpaceViewDir(v.vertex));
	o.tangentToWorldAndPackedData[0].w = viewDirForParallax.x;
	o.tangentToWorldAndPackedData[1].w = viewDirForParallax.y;
	o.tangentToWorldAndPackedData[2].w = viewDirForParallax.z;
#endif

	UNITY_TRANSFER_FOG_COMBINED_WITH_EYE_VEC(o, o.pos);
	return o;
}

half4 fragForwardBaseFeflection(VertexOutputForwardBase2 i) : SV_Target
{
	UNITY_APPLY_DITHER_CROSSFADE(i.pos.xy);

	FRAGMENT_SETUP(s)

	UNITY_SETUP_INSTANCE_ID(i);
	UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);

	UnityLight mainLight = MainLight();
	UNITY_LIGHT_ATTENUATION(atten, i, s.posWorld);

	half occlusion = Occlusion(i.tex.xy);
	UnityGI gi = FragmentGI(s, occlusion, i.ambientOrLightmapUV, atten, mainLight);

	half4 c = UNITY_BRDF_PBS(s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, gi.light, gi.indirect);
	c.rgb += Emission(i.tex.xy);

	UNITY_EXTRACT_FOG_FROM_EYE_VEC(i);
	UNITY_APPLY_FOG(_unity_fogCoord, c.rgb);
	//#ifdef _TRANSPARENCY
	//				half2 ibluv = (i.tex.zw / i.ambientOrLightmapUV.w);
	//				float _Transparency = i.eyeVec.w;//ibluv.y;
	//				// Screen-door transparency: Discard pixel if below threshold.
	//				half total = 17;
	//				float4x4 thresholdMatrix =
	//				{ 1.0 / total,  9.0 / total,  3.0 / total, 11.0 / total,
	//				  13.0 / total,  5.0 / total, 15.0 / total,  7.0 / total,
	//				   4.0 / total, 12.0 / total,  2.0 / total, 10.0 / total,
	//				  16.0 / total,  8.0 / total, 14.0 / total,  6.0 / total
	//				};
	//
	//				float4x4 _RowAccess = { 1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1 };
	//				ibluv *= _ScreenParams.xy; // pixel position
	//				clip(_Transparency - thresholdMatrix[fmod(ibluv.x, 1.5)] * _RowAccess[fmod(ibluv.y, 1.5)]);
	//#endif
	float transparency = i.eyeVec.w * _Transparency;
	/*half2 ibluv = (i.tex.zw / i.ambientOrLightmapUV.w);
	float4 _GrabColor = tex2D(_GrabTexture, ibluv);*/
	return OutputForward(c * transparency + _SceneColor * (1 - transparency), 1);
}

VT LI

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
平面运算方式的反射渲染

现在的反射的做法有好多，有静态的做法也有动态的做法。其中包括cubemap的方式或者reflectionprobe的方式，这两种方法都是要做预处理的，其中的reflectionprobe可以做实时反射，但是效率就比较低了。另外还有planar reflect的倒影做法，planar reflect是利用另一个摄像机然后用平面几何的方式来计算的，当然需要重新计算裁剪空间的范围，这个方法也比较适合用在手机上，他的消耗相对来说是比较低的，但是他只适用以平直的平面。还有一种就是ssr了，这个效果是在屏幕
复制链接

扫一扫