Unity URP 渲染管线着色器编程 103 之 创建高级水体材质--几何波

最新推荐文章于 2024-05-18 19:23:16 发布
最新推荐文章于 2024-05-18 19:23:16 发布
阅读量3.1k 收藏 25
点赞数 4
分类专栏： unity shader 文章标签： unity shader URP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013746357/article/details/107525900
版权

上一节我们得到了一个简单但是功能完备的曲面细分着色器的模板，而且细心的朋友可能已经注意到上一节我们创建的shader的名字是tutorial/chapter_2/water，这次我们将在上一节的曲面细分着色器的基础上创建一个有物理波浪的水面材质。

最终我们会得到如下图的一个水面材质：
在这里插入图片描述

在这里插入图片描述

后续的文章里我们会对该shader继续进行扩展，增加浪花和水下焦散效果

按照惯例，我们从零碎的知识点开始，最终提供一个完整的shader示例代码。

根据摄像机远近控制曲面细分的精度

要得到有几何波动的水面，作为水面载体的mesh必须有足够的精度，为了得到这样的精度，
使用曲面细分是最简单的方式，如果硬件不支持曲面细分，也可以直接让3D建模师制作一个高模的平面,或者使用一些策略，让离玩家最近的水面保持高模而远处的水面使用低模。

我们对之前的曲面细分着色器的 constant hull shader 部分进行修改，使得细分因子根据当前patch离相机的距离动态调节：

float3 GetDistanceBasedTessFactor(float3 p0, float3 p1, float3 p2, float3 cameraPosWS, float tessMinDist, float tessMaxDist)
{
    float3 edgePosition0 = 0.5 * (p1 + p2);
    float3 edgePosition1 = 0.5 * (p0 + p2);
    float3 edgePosition2 = 0.5 * (p0 + p1);

    // In case camera-relative rendering is enabled, 'cameraPosWS' is statically known to be 0,
    // so the compiler will be able to optimize distance() to length().
    float dist0 = distance(edgePosition0, cameraPosWS);
    float dist1 = distance(edgePosition1, cameraPosWS);
    float dist2 = distance(edgePosition2, cameraPosWS);

    // The saturate will handle the produced NaN in case min == max
    float fadeDist = tessMaxDist - tessMinDist;
    float3 tessFactor;
    tessFactor.x = saturate(1.0 - (dist0 - tessMinDist) / fadeDist);
    tessFactor.y = saturate(1.0 - (dist1 - tessMinDist) / fadeDist);
    tessFactor.z = saturate(1.0 - (dist2 - tessMinDist) / fadeDist);
    return tessFactor;
}
PatchTess ConstantHS(InputPatch<VertexOut,3> patch,uint patchID:SV_PrimitiveID)
{
    int factor=15;
    PatchTess pt;
    float3 tessFactor=GetDistanceBasedTessFactor(patch[0].PosWS,patch[1].PosWS,patch[2].PosWS,GetCameraPositionWS(),0,50);
    pt.EdgeTess[0]=max(2,factor*tessFactor.x);
    pt.EdgeTess[1]=max(2,factor*tessFactor.y);
    pt.EdgeTess[2]=max(2,factor*tessFactor.z);
    pt.InsideTess=max(2,factor*(tessFactor.x+tessFactor.y+tessFactor.z)/3);
    return pt;
}

在这里插入图片描述

使用 多个Gerstner 波创建有几何波动的水面

关于Gerstner wave的论文可以参考 《GPU Gems 1》 Chapter 1: Effective
Water Simulation from Physical Models

具体不多讲我们直接沾上Gerstner波的公式以及求偏导计算副切线，切线，法线的公式:

在这里插入图片描述

对上面的函数分别关于x和y求偏导就得了副切线和切线公式

在这里插入图片描述

在这里插入图片描述

而切线和副切线叉乘可以得到法线

在这里插入图片描述

公式中S(),C(),WA如下

在这里插入图片描述

有了BTN，就得到了切线空间下空间坐标系的一组标准正交基

上述公式是从标准的正弦波公式引申而来，因此里边的一些系数都对应的正弦波的一些物理参数：

在这里插入图片描述

  • L 是波长，标识临近的波峰到波峰之间的水平距离，波长L和角频率W相关，这里W=2xPI/L
  • A 是振幅，表示从水平位置到波峰的垂直距离
  • S 是波的移动速度，表示单位时间内波形沿着移动方向上运动的距离，波的速度S和相位常量φ相关，φ=Sx2xPI/L
  • D 是波的水平移动方向
Gerstner波是正弦波的变体，目的是得到波峰更加锋锐的效果

在这里插入图片描述

参数Q作为一个常量，用来描述波峰的锋锐程度。其他参数物理意义和正弦波一致。

而对于角频率W的计算也做了一点修改:

W = sqrt(g*2*PI/L)

注：这里PI表示圆周率常量，sqrt 是hlsl中的求二次方根的函数

前面公式中用到了求和符号，目的是使用多个不同系数的 Gerstner波，利用多波形的干涉原理，生成视觉上没有明显重复的复杂波形。

单个Gerstner波的结果如下：
在这里插入图片描述

而当应用了16个Gerstner波的干涉结果如下：
在这里插入图片描述

上述公式转换为代码如下

  • Phi表示相位常量φ
  • p 为当前顶点的3D坐标
  • 和公式中不同的是，unity中使用xz平面作为水平平面，而y轴做为竖直轴。而原始公式中以xy平面作为水平平面，z轴作为竖直轴。
float3 generatePosOffset(float3 p,float Q,float A,float W,float2 D,float Phi)
{
    float x=Q*A*D.x*cos(W*dot(D,p.xz)+Phi*_Time.y);
    float z=Q*A*D.y*cos(W*dot(D,p.xz)+Phi*_Time.y);
    float y=A*sin(W*dot(D,p.xz)+Phi*_Time.y);    
    return float3(x,y,z);
}
float3 generateNormalOffset(float3 positionWS,float _Q,float _A,float _W,float2 D,float _Phi)
{
    float S=sin(_W*dot(D,positionWS.xz)+_Phi*_Time.y);
    float C=cos(_W*dot(D,positionWS.xz)+_Phi*_Time.y);
    float WA=_W*_A;
   float x=-D.x*WA*C;
   float  z=-D.y*WA*C;
    float  y=_Q*WA*S;
    return float3(x,y,z);
}
float3 generateBinormalOffset(float3 positionWS,float _Q,float _A,float _W,float2 D,float _Phi)
{
    float S=sin(_W*dot(D,positionWS.xz)+_Phi*_Time.y);
    float C=cos(_W*dot(D,positionWS.xz)+_Phi*_Time.y);
    float WA=_W*_A;
                    
    float x=-_Q*D.x*D.x*WA*S;
    float z=-_Q*D.x*D.y*WA*S;
    float y=D.x*WA*C;
    return float3(x,y,z);
}
float3 generateTangentOffset(float3 positionWS,float _Q,float _A,float _W,float2 D,float _Phi)
{
    float S=sin(_W*dot(D,positionWS.xz)+_Phi*_Time.y);
    float C=cos(_W*dot(D,positionWS.xz)+_Phi*_Time.y);
    float WA=_W*_A;
    
     float x=-_Q*D.x*D.y*WA*S;
    float  z=-_Q*D.y*D.y*WA*S;
    float  y=D.y*WA*C;
    return float3(x,y,z);
}

上述代码的计算得到的是3D坐标和TBN的偏移量，要得到最终的3D坐标和TBN向量需要加上原始值

float3 posWS=float3(positionWS.x,0,positionWS.z)+offset;                   
float3 binormal=float3(1,0,0)+binormalOffset;               
float3 tangent=float3(0,0,1)+tangentOffset;               
float3 normal=float3(0,1,0)+normalOffset;

我们的原始水面是一个完全光滑的平面，因此法线为(0,1,0),对应的切线和副切线(也可以成为副法线)分别为(0,0,1)和(1,0,0)。如果使用的不是平面模型，可以使用模型的法线，切线作为基准。

使用纹理波构建水面的细节

有了基于物理的几何波作为水面的框架结构，我们接下来利用纹理波(实际上就是水面波纹的法线贴图)来得到更加精细的结果，到这之后和常规的水面材质实现是类似的。

在这里插入图片描述

为了让纹理波的方向和几何波的方向一致，我们使用二维旋转矩阵对UV进行旋转
half2 rotateUV(float2 uv,float angle)
{
    float cosAngle=cos(angle);
    float sinAngle=sin(angle);
    float2x2 rotateM=float2x2(cosAngle,-sinAngle,sinAngle,cosAngle);
    return mul(rotateM,uv);
}
float2 uv0=rotateUV(IN.uv0,_WaveMapAngle);

引入 _WaveMapAngle 参数，用来调整纹理波的采样方向

这里的采样方向和波的移动方向是完全不相干的内容，目的是让纹理波的波形移动方向(视觉移动方向)和几何波的方向一致，可以理解为我们在着色器里沿着水面旋转了这张法线贴图。

为了避免单张纹理贴图重复采样产生的视觉上的重复,我们对单张法线纹理，使用不同的UV采样两次

为了得到更加精细的结果，可以使用两张不同的水面法线纹理，分别代表不同尺寸的波形，这里只是描述原理，因此对同一张纹理使用不同的UV采样两次得到的是类似的结果。

float4 animUV=uv0.xyxy*float4(1,1,0.5,0.5)+float4(normalize(_Direction.xy),normalize(_Direction.zw))*_WaveSpeed*_TexWaveSpeed*_Time.y;
float4 n1=SAMPLE_TEXTURE2D(_BumpMap,sampler_BumpMap,animUV.xy);
float4 n2=SAMPLE_TEXTURE2D(_BumpMap,sampler_BumpMap,animUV.zy);

同样为了让纹理波的速度和几何波的速度匹配，我们单独引入了 _TexWaveSpeed 参数，控制纹理波的速度，通过调整可以让纹理波的速度接近几何波的速度。

为了得到当前水面的深度我们要利用URP 保存的深度缓冲RT
为了制作水面对光线的折射产生的对水底的扭曲，我们需要用到URP保存的颜色缓冲RT

默认URP不会把深度RT和颜色RT保存起来，需要在管线的配置里打开该功能：

在这里插入图片描述

在shader中引用这两张RT的代码如下:

TEXTURE2D(_CameraDepthTexture); // z buffer
SAMPLER(sampler_CameraDepthTexture);
TEXTURE2D(_CameraOpaqueTexture);　// color buffer
SAMPLER(sampler_CameraOpaqueTexture);

在Builtin管线里，我们要得到颜色缓冲区的内容，通常是调用GrabPass把渲染水面之前的渲染结果捕获到一张额外的RT里。
而在Builtin管线里要获得深度缓冲区内容，需要对相机参数进行设置。 而在移动端设备上，不一定能靠这个办法拿到深度缓冲区内容,因此通常采用把深度值离线烘焙到水面模型的顶点色或者单独的一张纹理里的办法来得到深度值。

有了这些基本信息，就可以像Builtin管线下实现水体材质的常规做法来创建水面材质了。

完整代码如下:

Shader "tutorial/chapter_2/water"
{
    Properties
    {
        _Q("Q",Range(0,1))=0.1
        _WaveLength("波长",Range(0.01,30))=0.1
        _WaveSpeed("波速度",Range(0.01,1))=0.1 
        _TexWaveSpeed("纹理波速度",Range(0.01,1))=0.1
        _TexWaveAmplitude("纹理波振幅",Range(0,1))=0.5
        _AmplitudeRatio("振幅和波长的比例",Range(0.00001,0.002))=0.1                       
        _Direction("方向12",Vector)=(1,1,1,1) // 移动方向
        _Direction2("方向34",Vector)=(1,1,1,1) // 移动方向       
        _Direction3("方向56",Vector)=(1,1,1,1) // 移动方向       
        _Direction4("方向78",Vector)=(1,1,1,1) // 移动方向               
        
        _ShallowColor("浅水区颜色",Color)=(1,1,1,1)
        _DeepColor("深水区颜色",Color)=(1,1,1,1)
        _DeepWaterDepth("深水区深度",float)=3
        _RimPower("RimPower",Range(1,20))=5
        _Reflection("Reflection",Range(0,1))=1
        _Cube("Cube",Cube)="black"{}
        _BumpMap("MicroDetail",2D)="bump"{}
        _BumpMapLarge("Large Dtail",2D)="bump"{}          
        _Smoothness("Smoothness",Range(0.1,2))=1      
        _SpecularColor("SpecularColor",Color)=(1,1,1,1)
        _WaveMapAngle("WaveMapAngle",Range(0,3.14))=0
    }
    SubShader
    {
        Pass 
        {
            Tags{"RenderType"="Opaque" "Queue"="Transparent"}
//            ZWrite Off            
//            Cull Off 
            HLSLPROGRAM
            #pragma target 5.0 
            #pragma vertex vert
            #pragma hull HS
            #pragma domain DS 
            #pragma fragment frag
            #include  "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            float _AmplitudeRatio;
            float _Q;
            float _WaveLength;
            float _WaveSpeed;
            float4 _Direction;
            float4 _Direction2;
            float4 _Direction3;
            float4 _Direction4;
            half4 _ShallowColor;
            half4 _DeepColor;
            half _WaveMapAngle;
            float _DeepWaterDepth;
            float _TexWaveAmplitude;
            float _TexWaveSpeed;
            TEXTURE2D(_CameraDepthTexture);
            SAMPLER(sampler_CameraDepthTexture);
            TEXTURE2D(_CameraOpaqueTexture);
            SAMPLER(sampler_CameraOpaqueTexture);
            TEXTURECUBE(_Cube);
            SAMPLER(sampler_Cube);
            TEXTURE2D(_BumpMap);
            float4 _BumpMap_ST;
            SAMPLER(sampler_BumpMap);
            float _RimPower;
            float _Reflection;
            half4 _SpecularColor;
            half _Smoothness;
            struct app_data
            {
                float4 positionOS:POSITION;
                float2 uv0:TEXCOORD0;
            };
            struct VertexOut
            {
                float3 PosL:TEXCOORD0;
                float3 PosWS:TEXCOORD1;
                float2 uv0:TEXCOORD2;
            };
            VertexOut vert(app_data IN)
            {
                VertexOut o;
                o.PosL=IN.positionOS.xyz;
                o.PosWS=TransformObjectToWorld(IN.positionOS.xyz);
                o.uv0=IN.uv0*_BumpMap_ST.xy+_BumpMap_ST.zw;
                return o;
            }
            
            struct PatchTess
            {
                float EdgeTess[3]:SV_TessFactor;
                float InsideTess:SV_InsideTessFactor;
            };
            real3 GetDistanceBasedTessFactor(real3 p0, real3 p1, real3 p2, real3 cameraPosWS, real tessMinDist, real tessMaxDist)
            {
                real3 edgePosition0 = 0.5 * (p1 + p2);
                real3 edgePosition1 = 0.5 * (p0 + p2);
                real3 edgePosition2 = 0.5 * (p0 + p1);
            
                // In case camera-relative rendering is enabled, 'cameraPosWS' is statically known to be 0,
                // so the compiler will be able to optimize distance() to length().
                real dist0 = distance(edgePosition0, cameraPosWS);
                real dist1 = distance(edgePosition1, cameraPosWS);
                real dist2 = distance(edgePosition2, cameraPosWS);
            
                // The saturate will handle the produced NaN in case min == max
                real fadeDist = tessMaxDist - tessMinDist;
                real3 tessFactor;
                tessFactor.x = saturate(1.0 - (dist0 - tessMinDist) / fadeDist);
                tessFactor.y = saturate(1.0 - (dist1 - tessMinDist) / fadeDist);
                tessFactor.z = saturate(1.0 - (dist2 - tessMinDist) / fadeDist);
            
                return tessFactor;
            }
            PatchTess ConstantHS(InputPatch<VertexOut,3> patch,uint patchID:SV_PrimitiveID)
            {
                int factor=15;
                PatchTess pt;
                float3 tessFactor=GetDistanceBasedTessFactor(patch[0].PosWS,patch[1].PosWS,patch[2].PosWS,GetCameraPositionWS(),0,200);
                pt.EdgeTess[0]=max(2,factor*tessFactor.x);
                pt.EdgeTess[1]=max(2,factor*tessFactor.y);
                pt.EdgeTess[2]=max(2,factor*tessFactor.z);
                pt.InsideTess=max(2,factor*(tessFactor.x+tessFactor.y+tessFactor.z)/3);
                return pt;
            }
            
            struct HullOut
            {
                float3 PosL:TEXCOORD0;
                float2 uv0:TEXCOORD1;
            };
            
            [domain("tri")]
            [partitioning("fractional_even")]
            [outputtopology("triangle_cw")]
            [outputcontrolpoints(3)]
            [patchconstantfunc("ConstantHS")]
            [maxtessfactor(64.0f)]
            HullOut HS(InputPatch<VertexOut,3> p,uint i:SV_OutputControlPointID)
            {
                HullOut hout;
                hout.PosL=p[i].PosL;
                hout.uv0=p[i].uv0;
                return hout;
            }
            
            struct DomainOut
            {
                float4 PosH:SV_POSITION;
                float4 binormalWS:TEXCOORD0;
                float4 tangentWS:TEXCOORD1;    
                float4 normalWS:TEXCOORD2;               
                float4 projection:TEXCOORD3;
                float2 uv0:TEXCOORD4;
                
            };
            
            float3 generatePosOffset(float3 p,float Q,float A,float W,float2 D,float Phi)
            {
                float x=Q*A*D.x*cos(W*dot(D,p.xz)+Phi*_Time.y);
                float z=Q*A*D.y*cos(W*dot(D,p.xz)+Phi*_Time.y);
                float y=A*sin(W*dot(D,p.xz)+Phi*_Time.y);    
                return float3(x,y,z);
            }
            float3 generateNormalOffset(float3 positionWS,float _Q,float _A,float _W,float2 D,float _Phi)
            {
                float S=sin(_W*dot(D,positionWS.xz)+_Phi*_Time.y);
                float C=cos(_W*dot(D,positionWS.xz)+_Phi*_Time.y);
                float WA=_W*_A;
               float x=-D.x*WA*C;
               float  z=-D.y*WA*C;
                float  y=_Q*WA*S;
                return float3(x,y,z);
            }
            float3 generateBinormalOffset(float3 positionWS,float _Q,float _A,float _W,float2 D,float _Phi)
            {
                float S=sin(_W*dot(D,positionWS.xz)+_Phi*_Time.y);
                float C=cos(_W*dot(D,positionWS.xz)+_Phi*_Time.y);
                float WA=_W*_A;
                                
                float x=-_Q*D.x*D.x*WA*S;
                float z=-_Q*D.x*D.y*WA*S;
                float y=D.x*WA*C;
                return float3(x,y,z);
            }
            float3 generateTangentOffset(float3 positionWS,float _Q,float _A,float _W,float2 D,float _Phi)
            {
                float S=sin(_W*dot(D,positionWS.xz)+_Phi*_Time.y);
                float C=cos(_W*dot(D,positionWS.xz)+_Phi*_Time.y);
                float WA=_W*_A;
                
                 float x=-_Q*D.x*D.y*WA*S;
                float  z=-_Q*D.y*D.y*WA*S;
                float  y=D.y*WA*C;
                return float3(x,y,z);
            }
            
            [domain("tri")]
            DomainOut DS(PatchTess patchTess,float3 baryCoords:SV_DomainLocation,const OutputPatch<HullOut,3> triangles)
            {
                DomainOut dout;              
                float3 p=triangles[0].PosL*baryCoords.x+triangles[1].PosL*baryCoords.y+triangles[2].PosL*baryCoords.z;
                float2 uv=triangles[0].uv0*baryCoords.x+triangles[1].uv0*baryCoords.y+triangles[2].uv0*baryCoords.z;
                dout.uv0=uv;
                float3 positionWS= TransformObjectToWorld(p.xyz);
                                
                
                                
                                
                                
                float2 D=normalize(_Direction.xy);
                float2 D2=normalize(_Direction.zw);
                float2 D3=normalize(_Direction2.xy);
                float2 D4=normalize(_Direction2.zw);
                float2 D5=normalize(_Direction3.xy);
                float2 D6=normalize(_Direction3.zw);
                float2 D7=normalize(_Direction4.xy);
                float2 D8=normalize(_Direction4.zw);                                
                
                const float g=9.8f; //重力常数
                //float _W=sqrt(9.8f*2*PI/_WaveLength); //角频率      
                //float _Phi= _WaveSpeed*_W; //相位常量                   
                //float _A=_AmplitudeRatio*_WaveLength; // 波长和振幅通常成正比

                // 正弦波函数
                // positionWS.y=_A*sin(dot(D,positionWS.xz)*_W+_Time.y*_Phi);
                
                float3 offset=float3(0,0,0);
                float3 normalOffset=float3(0,0,0);
                float3 binormalOffset=float3(0,0,0);
                float3 tangentOffset=float3(0,0,0);
                for(uint i=0;i<16;i++)
                {
                    float _QQ=saturate(_Q*(1+0.05*i));
                    float _W=sqrt(9.8f*2*PI/(_WaveLength*(1+0.05*i)));
                    float _Phi=_WaveSpeed*(1+0.05*i)*_W;
                    float _A=_AmplitudeRatio*_WaveLength*(1+0.05*i);
                    float2 realD=D;
                    switch(i)
                    {
                    case 0:
                    case 8:
                    break;
                    break;
                    case 1:
                    case 9:
                    realD=D2;
                    break;
                    case 2:
                    case 10:
                    realD=D3;
                    break;
                    case 3:
                    case 11:
                    realD=D4;
                    break;
                    case 4:
                    case 12:
                    realD=D5;
                    break;
                    case 5:
                    case 13:
                    realD=D6;
                    break;
                    case 6:
                    case 14:
                    realD=D7;
                    break;
                    case 7:
                    case 15:
                    realD=D8;
                    break;
                    }
                    offset+=generatePosOffset(positionWS,_QQ,_A,_W,realD,_Phi);
                    binormalOffset+=generateBinormalOffset(positionWS,_QQ,_A,_W,realD,_Phi);
                    tangentOffset+=generateTangentOffset(positionWS,_QQ,_A,_W,realD,_Phi);
                    normalOffset+=generateNormalOffset(positionWS,_QQ,_A,_W,realD,_Phi);
                }

                float3 posWS=float3(positionWS.x,0,positionWS.z)+offset;                                                               
                dout.PosH=TransformWorldToHClip(posWS);
                
                float3 binormal=float3(1,0,0)+binormalOffset;               
                float3 tangent=float3(0,0,1)+tangentOffset;               
                float3 normal=float3(0,1,0)+normalOffset;
                
                
                
                dout.tangentWS=float4(tangent.x,binormal.x,normal.x,posWS.y);
                dout.binormalWS=float4(tangent.y,binormal.y,normal.y,posWS.x);
                dout.normalWS=float4(tangent.z,binormal.z,normal.z,posWS.z);
                
                // 这里计算深度使用变形前的坐标     
                 float4 positionCS= dout.PosH;// TransformWorldToHClip(positionWS);                  
                float4 ndc = positionCS * 0.5f;
                float4 positionNDC;
                positionNDC.xy= float2(ndc.x, ndc.y * _ProjectionParams.x) + ndc.w;
                positionNDC.zw = positionCS.zw;
                dout.projection=positionNDC;                                              
                return dout;
            }
            half3 UnpackNormalBlend(half4 n1,half4 n2,half scale){
                n1.w*=n1.r;
                n2.w*=n2.r;
                half3 normal;
                normal.xy=(n1.wy*2-1)+(n2.wy*2-1);
                normal.xy*=scale;
                normal.z=sqrt(1-saturate(dot(normal.xy,normal.xy)));
                return normalize(normal);
            }
            half SpecularFactor(half gloss,half3 lightDir,half3 viewDir,half3 normalDir)
            {
                half reflectiveFactor=max(0.0,dot(-viewDir,reflect(lightDir,normalDir)));
                half spec=pow(reflectiveFactor,gloss*128);
                return spec;
            }
            half2 rotateUV(float2 uv,float angle)
            {
                float cosAngle=cos(angle);
                float sinAngle=sin(angle);
                float2x2 rotateM=float2x2(cosAngle,-sinAngle,sinAngle,cosAngle);
                return mul(rotateM,uv);
            }
            half4 frag(DomainOut IN):SV_Target
            {
            
                float4 projection=IN.projection;
                float sceneDepth=SAMPLE_TEXTURE2D(_CameraDepthTexture, sampler_CameraDepthTexture, projection.xy / projection.w).r;
                float2 uv0=rotateUV(IN.uv0,_WaveMapAngle);
                float4 animUV=uv0.xyxy*float4(1,1,0.5,0.5)+float4(normalize(_Direction.xy),normalize(_Direction.zw))*_WaveSpeed*_TexWaveSpeed*_Time.y;
                float4 n1=SAMPLE_TEXTURE2D(_BumpMap,sampler_BumpMap,animUV.xy);
                float4 n2=SAMPLE_TEXTURE2D(_BumpMap,sampler_BumpMap,animUV.zy);
                float3 normalTS=UnpackNormalBlend(n1,n2,_TexWaveAmplitude);
                float3 normalWS=(IN.normalWS.xyz);
                float3 binormalWS=(IN.binormalWS.xyz);
                float3 tangentWS=(IN.tangentWS.xyz);
                normalWS=normalize(float3(dot(tangentWS,normalTS),dot(binormalWS,normalTS),dot(normalWS,normalTS)));
                float sceneZ = LinearEyeDepth(sceneDepth, _ZBufferParams);
                float thisZ = LinearEyeDepth(projection.z / projection.w, _ZBufferParams);              
                float far=_DeepWaterDepth;
                float near=1;
                float fadeShallowToDeep = saturate (((sceneZ - near) - thisZ)/(far-near));
                float fadeZeroToShallow=saturate(((sceneZ-0)-thisZ)/(near-0));
                
                float4 waterColor=lerp(_ShallowColor,_DeepColor,fadeShallowToDeep);
                float alpha=lerp(0,waterColor.a,fadeZeroToShallow);
                float3 posWS=float3(IN.binormalWS.w,IN.tangentWS.w,IN.normalWS.w);
                
                float3 viewDirWS=normalize(GetCameraPositionWS()-posWS);
                float3 reflectWS=reflect(-viewDirWS,normalize(float3(normalWS.x,normalWS.y,normalWS.z)));
                half3 reflection=SAMPLE_TEXTURECUBE(_Cube,sampler_Cube,reflectWS).rgb;
                half NdotV=saturate(1.0-dot(viewDirWS,normalWS.xyz));
                half fresnel=pow(NdotV, _RimPower);                              
                Light light=GetMainLight();
                float3 L=normalize(light.direction);
                half3 sceneColor=SAMPLE_TEXTURE2D(_CameraOpaqueTexture, sampler_CameraOpaqueTexture, projection.xy / projection.w+(lerp(0,0.08,alpha)*normalWS.xz)).rgb;
                half3 cleanSceneColor=SAMPLE_TEXTURE2D(_CameraOpaqueTexture, sampler_CameraOpaqueTexture, projection.xy / projection.w).rgb;
                float NdotL=saturate(dot(normalWS.xyz,L));
                float3 diffuseColor=light.color*waterColor.rgb*(NdotL*0.5+0.5);
                float3 specularColor=SpecularFactor(_Smoothness,L,viewDirWS,normalWS)*light.color*_SpecularColor;
                //diffuseColor=lerp(sceneColor,diffuseColor,alpha);
                diffuseColor=lerp(diffuseColor,reflection,fresnel*_Reflection);
                diffuseColor+=specularColor;
                
                half3 resultColor=lerp(sceneColor,diffuseColor,alpha);                
                return half4(resultColor,1);
            }            
            ENDHLSL
        }
    }
}
张林博
关注
  • 4
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
[Unity URP]水体渲染
wyk223344的博客
11-23 3217
unity版本：2019.4.12f urp版本：7.5.1 Shape形状 Shading着色 水体交互 Reference Boat Attack 项目海水技术解析 真实感水体渲染技术总结
Unity URP渲染管线AR阴影
06-04
这个包再URP渲染管辖下实现了AR阴影效果，通过一个Shader，将一个立方体影子投射到一个透明的平面上
Unity中URP实现水体效果（水的深度）
楠溪泽岸的博客
02-23 1829
在之后的文章中，我们在URP下实现水面的效果。在该文章中，我们来看一下水的深度是怎么实现的。
Unity中URP下实现水体（C#动态生成渐变图）
楠溪泽岸的博客
03-02 1295
在之前的文章中，我们已经完成了URP下水体的所有效果。但是，水的颜色用一个变量来控制让水深浅颜色渐变变化，太过于单调。所以，我们可以使用纹理采样的方式来替换水的颜色。
【Unity3D美术】URP渲染管线学习01
最新发布
leoysq的博客
05-18 876
URP渲染管线是Unity3d提供的一种视觉效果更好的渲染模式，类似的还有Built RP（默认最普通的渲染模式）\ HDRP(超高清，对设备要求高)，视觉效果好，而且占用资源少！成为主流渲染管线模式！
【unity shader/风格化水表面渲染/基础笔记】urp代码版03-水表面颜色
FalschxMico
01-24 515
上一节生成了岸边的泡沫。本节主要梳理水表面的上色过程，这部分涉及半透明渲染和fresnel颜色
unity 使用噪音图实现简单水材质
SnoopyNa2Co3的博客
03-13 3575
先上图 原理：就是根据时间算噪音图颜色，来算原图每个像素偏移 比较简单直接上Shader Shader "Effect/Ocean" { Properties { _MainTex("Texture", 2D) = "white" {} //噪音图 _NoiseTex("Texture", 2D) = "white" {} //叠加颜色 _Color("Co.
Unity中URP实现水体效果（泡沫）
楠溪泽岸的博客
02-24 1553
在上篇文章中，我们实现了水体的深度。在这篇文章中，我们来使用上篇文章采样后的深度图来实现水中的泡沫效果。
【unity shader/风格化水表面渲染/基础笔记】urp代码版01-水面与水底的深度判断
FalschxMico
01-22 1077
urp shader水面与水底的深度判断
基于Unity内置渲染管线的 卡通着色器 shader
05-30
基于Unity内置渲染管线的 卡通着色器 shader 不支持URP HDRP
TAA_Unity_URP：Unity通用渲染管线的临时抗锯齿（TAA）
02-06
Unity通用渲染管线的时间反激射此时间抗锯齿包为Unity的Universal Render Pipeline提供了时间抗锯齿。 它会在整个渲染过程之前抖动相机的投影，从而可以对相邻帧之间的不同表面进行采样。 然后，可以使用提供的可...
unity自带水材质.zip
06-25
unity自带水的shader实现的动态水面效果的材质。unity自带水材质。
Unity 水效果Shader
08-09
Unity 水效果Shader
Shader-Graph-Experiments:Unity URP的各种着色器图效果
05-15
着色图实验使用Unity创建的2019.3.13.f1 着色器图v7.3.1 该项目包含各种“ Shader Graph”效果一些着色器使用_CameraOpaqueTexture。 使用这些着色器的Sprite对象不会与具有Sprite点亮/未点亮主节点的着色器“交互”...
URP_Toon：Unity Universal Render管道中的Toon着色器
02-06
URP香椿着色器介绍基于URP的通用卡通着色器，使用URP标准的PBR模型（最低限度的CookTorrance BRDF）进行改造，纯代码实现，没有使用ShaderGraph，兼容SPR Batch。 基于URP的通用Toon着色器，在URP中使用PBR照明...
【unity shader】水体渲染基础-定向流动材质
又渲染又建模的一般通过工科绘画人的BLOG
08-13 920
实现基于uv旋转和Tiled Directional Flow的流体材质
Unity - 通用渲染管线（URP）1.渲染、后处理
FoxGame的专栏
07-13 8897
简介URP是一种预置的可编程渲染管线。可以实现快速的渲染而不需要shader技术。URP使用简化的基于物理的光照和材质。URP继承自’RenderPipelineAsset’，当我们将URP设置到Graphics Setting时，Unity将内置的渲染管线转换到URP。 在URP中可以对下面一些对象进行设置：///这里的一些详细讲解还需要重新看一下Shader的书 General： General设置管线渲染每一帧中的核心部分Quality： 这些设置控制URP的质量级别。通过调整可以控制在不同设备上的性
Unity水资源制作教程（带波浪）
Luncher_Message的博客
08-23 875
想要制作自己的水资源吗？
在Unity中 改变地形（Terrain），并加上水面、树、草地、材质(地板上色）
热门推荐
hu1262340436的博客
11-20 2万+
在Unity中 如何使用地形（Terrain），并加上水面、树、草地、材质(地板上色） 目录在Unity中 如何使用地形（Terrain），并加上水面、树、草地、材质(地板上色）一、水面素材包导入二、地形（Terrain）地貌设置地形上升地形趋于Height值地形圆润地板材质树草水面制作 一、水面素材包 水面要导入Unity自带的素材包，可跳过。包中也有几颗树的模型，下期会详细介绍，并且有手动制作树的过程。 导入 首先在 Assets 里的 Import Package 中导入 Environment 包，
Unity URP渲染管线
05-18
Unity URP（Universal Render Pipeline）是Unity官方提供的一种渲染管线，它旨在提供轻量级、高效率的渲染解决方案。URP支持多平台，包括PC、移动设备和VR/AR设备，可以为游戏和应用程序提供高品质的视觉效果。 URP...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值