SHARE
TWEET

Untitled

a guest Aug 24th, 2019 72 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. Shader "JP-PBR-BASE-EXPERIMENTAL"
  2. {
  3.     Properties
  4.     {
  5.         _Color("Main Color", Color) = (1,1,1,1)
  6.         _MainTex("Base Color", 2D) = "white" {}
  7.         _Roughness("Roughness",Range(0,1)) = 1
  8.         _NormalTex("Normal", 2D) = "bump" {}
  9.         _Anisotropic("Anisotropic",  Range(-20,1)) = 0
  10.         _Metallic("Metalness",Range(0,1)) = 0
  11.         _Emissive("Emissive", Float) = 1
  12.         [Header(Artist Lighting)]
  13.         [PerRendererData]_DeviationRange("Devitation Direction XYZ", Vector) = (1,1,1)
  14.         [NoScaleOffset]_EmissiveTex("Emissive Tex", 2D) = "black" {}
  15.         [ToggleOff] _SpecularHighlights("Specular Highlights(遙섇뀎)", Float) = 0
  16.         [ToggleOff] _GlossyReflections("Glossy Reflections(?띶컙)", Float) = 0
  17.         [Toggle] _NonMetal("NonMetal", Float) = 1
  18.     }
  19.         SubShader{
  20.                 Tags{"RenderType" = "Opaque"  "Queue" = "Geometry" "PerformanceChecks"="False"}
  21.                 Pass{
  22.                     Name "FORWARD"
  23.                     Tags{
  24.                     "LightMode" = "ForwardBase"
  25.     }
  26.                     CGPROGRAM
  27.                     #pragma vertex vert
  28.                     #pragma fragment frag
  29.                     #include "UnityCG.cginc"
  30.                     #include "AutoLight.cginc"
  31.                     #include "Lighting.cginc"
  32.                     #include "UnityPBSLighting.cginc"
  33.                     #include "UnityStandardBRDF.cginc"
  34.                     #include "UnityStandardCore.cginc"
  35.                     #include "X2mIncludes/X2mCommon.cginc"
  36.                     #pragma multi_compile_fwdbase_fullshadows
  37.                     #pragma shader_feature _SPECULARHIGHLIGHTS_OFF
  38.                     #pragma shader_feature _GLOSSYREFLECTIONS_OFF
  39.                     #pragma shader_feature _NONMETAL
  40.                     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
  41.                     #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
  42.                     #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
  43.                     #pragma multi_compile_fog
  44.                     #pragma only_renderers d3d9 d3d11 glcore gles gles3 metal d3d11_9x xboxone ps4 psp2 n3ds wiiu vulkan
  45.                     #pragma target 3.5
  46.                     #define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )
  47.                     #define UNITY_PASS_FORWARDBASE
  48.                     #define _NORMALMAP 1
  49.                     #define _CAMERA_LIGHT_ON
  50.  
  51.                     uniform half _Anisotropic;
  52.                     uniform half _Roughness;
  53.                     uniform half _Emissive;
  54.                     uniform sampler2D _EmissiveTex;
  55.                     uniform sampler2D _NormalTex; uniform half4 _NormalTex_ST;
  56.                     uniform half _NonMetal;
  57.                     uniform float3 _DeviationRange;
  58.  
  59.                     struct VertexBaseInput
  60.                     {
  61.                         float4 vertex   : POSITION;
  62.                         float4 color    : COLOR;
  63.                         half3 normal    : NORMAL;
  64.                         float4 texcoord0      : TEXCOORD0;
  65.                         float4 texcoord1      : TEXCOORD1;
  66.                         float4 texcoord2      : TEXCOORD2;
  67.                         half4 tangent   : TANGENT;
  68.                         UNITY_VERTEX_INPUT_INSTANCE_ID
  69.                     };
  70.  
  71.                     struct VertexOutput
  72.                     {
  73.                         float4 pos                          : SV_POSITION;
  74.                         float4 uv0                          : TEXCOORD0;
  75.                         float4 uv1                          : TEXCOORD1;
  76.                         float4 uv2                          : TEXCOORD2;
  77.                         float3 viewDir                      : TEXCOORD3;
  78.                         half3 normalDir                     : TEXCOORD4;
  79.                         half3 tangentDir                    : TEXCOORD5;
  80.                         half3 bitangentDir                  : TEXCOORD6;
  81.                         half4 ambientOrLightmapUV           : TEXCOORD7;    // SH or Lightmap UV
  82.                         float4 posWorld                     : TEXCOORD8;
  83.                         UNITY_SHADOW_COORDS(9)
  84.                         UNITY_VERTEX_INPUT_INSTANCE_ID
  85.                         UNITY_VERTEX_OUTPUT_STEREO
  86.                     };
  87.  
  88.                     VertexOutput vert(VertexBaseInput v)
  89.                     {
  90.                         UNITY_SETUP_INSTANCE_ID(v);
  91.                
  92.                         VertexOutput o = (VertexOutput)0; //초기화
  93.                         UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
  94.                         o.normalDir = UnityObjectToWorldNormal(v.normal);
  95.                         o.tangentDir = normalize(mul(unity_ObjectToWorld, float4(v.tangent.xyz, 0.0)).xyz);
  96.                         o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * v.tangent.w * unity_WorldTransformParams.w);
  97.                         o.pos = UnityObjectToClipPos(v.vertex);
  98.                         o.uv0.xy = TRANSFORM_TEX(v.texcoord0.xy , _MainTex);
  99.                         o.uv0.zw = v.texcoord0.zw;
  100.                         o.uv1 = v.texcoord1;
  101.                         o.uv2 = v.texcoord2;
  102.                         float3 lightColor = _LightColor0.rgb;
  103.                         o.posWorld = mul(unity_ObjectToWorld, v.vertex);
  104.                         UNITY_TRANSFER_FOG(o,o.pos);
  105.                         TRANSFER_VERTEX_TO_FRAGMENT(o)
  106.                        
  107.                         return o;
  108.                     }
  109.    
  110.                     //Since many other light model test function here.
  111.                     float sqr(float x){ return x*x; }
  112.                    
  113.                     //Blinn-Phong NDF function here
  114.                         float BlinnPhongNormalDistribution(float NdotH, float specularpower, float speculargloss){
  115.                         float Distribution = pow(NdotH,speculargloss) * specularpower;
  116.                         Distribution *= (2+specularpower) / (2*3.1415926535);
  117.                         return Distribution;
  118.                     }
  119.                     //end of the Blinn-Phong NDF function
  120.                    
  121.                     //Phong NDF function here
  122.                     float PhongNormalDistribution(float RdotV, float specularpower, float speculargloss){
  123.                         float Distribution = pow(RdotV,speculargloss) * specularpower;
  124.                         Distribution *= (2+specularpower) / (2*3.1415926535);
  125.                         return Distribution;
  126.                     }
  127.                     //end of the Phong NDF function
  128.                    
  129.                     //BackMann NDF function here
  130.                     float BeckmannNormalDistribution(float roughness, float NdotH)
  131.                     {
  132.                         float roughnessSqr = roughness*roughness;
  133.                         float NdotHSqr = NdotH*NdotH;
  134.                         return max(0.000001,(1.0 / (3.1415926535*roughnessSqr*NdotHSqr*NdotHSqr)) * exp((NdotHSqr-1)/(roughnessSqr*NdotHSqr)));
  135.                     }
  136.                     //end of the BackMann NDF function
  137.                     //GaussianNormalNDF function here
  138.                     float GaussianNormalDistribution(float roughness, float NdotH)
  139.                     {
  140.                         float roughnessSqr = roughness*roughness;
  141.                         float thetaH = acos(NdotH);
  142.                         return exp(-thetaH*thetaH/roughnessSqr);
  143.                     }
  144.                     //end of GaussianNormalNDF function
  145.                     //GGX NDF function here
  146.                     float GGXNormalDistribution(float roughness, float NdotH)
  147.                     {
  148.                         float roughnessSqr = roughness * roughness;
  149.                         float NdotHSqr = NdotH * NdotH;
  150.                         float TanNdotHSqr = (1-NdotHSqr)/NdotHSqr;
  151.                         return (1.0/3.1415926535) * sqrt(roughness/(NdotHSqr * (roughnessSqr + TanNdotHSqr)));
  152.                     }
  153.                     //end of GGX function
  154.                     //TrowbridgeReitzNormal NDF here
  155.                     float TrowbridgeReitzNormalDistribution(float roughness, float NdotH)
  156.                     {
  157.                         float roughnessSqr = roughness * roughness;
  158.                         float Distribution = NdotH * NdotH * (roughnessSqr-1.0) + 1.0;
  159.                         return roughnessSqr / (3.1415926535 * Distribution*Distribution);
  160.                     }
  161.                     //end of TrowbridgeReitzNormal NDF
  162.                    
  163.                     //WardAnisotropicNormal NDF here
  164.                     float WardAnisotropicNormalDistribution(float anisotropic, float NdotL, float NdotV, float NdotH, float HdotX, float HdotY){
  165.                         float aspect = sqrt(1.0h-anisotropic * 0.9h);
  166.                         float X = max(.001, sqr(1.0-_Glossiness)/aspect) * 5;
  167.                         float Y = max(.001, sqr(1.0-_Glossiness)*aspect) * 5;
  168.                         float exponent = -(sqr(HdotX/X) + sqr(HdotY/Y)) / sqr(NdotH);
  169.                         float Distribution = 1.0 / ( 3.14159265 * X * Y * sqrt(NdotL * NdotV));
  170.                         Distribution *= exp(exponent);
  171.                         return Distribution;
  172.                     }
  173.                     //end of WardAnisotropicNormal NDF
  174.                    
  175.                     //Geometric Shadowing function Here.
  176.                     //Implicit GSF here
  177.                     float ImplicitGeometricShadowingFunction (float NdotL, float NdotV)
  178.                     {
  179.                         float Gs =  (NdotL * NdotV);      
  180.                         return Gs;
  181.                     }
  182.                     //end of Implicit GSF
  183.  
  184.                     float4 frag(VertexOutput i) : COLOR{
  185.                         UNITY_SETUP_INSTANCE_ID(i);
  186.                         i.normalDir = normalize(i.normalDir);
  187.                         float3x3 tangentW = float3x3(i.tangentDir, i.bitangentDir, i.normalDir);
  188.                         half3 Normal_var = UnpackNormal(tex2D(_NormalTex , i.uv0));
  189.                         half3 tangentSpaceNormal = Normal_var.xyz;
  190.                         float3 normalWorld = normalize(mul(tangentSpaceNormal, tangentW));
  191.                         i.viewDir = normalize(i.posWorld.xyz - _WorldSpaceCameraPos);
  192.                         float3 viewReflectDirection = normalize(reflect(-i.viewDir, normalWorld));
  193.                         //float3 lightDir = normalize(_WorldSpaceLightPos0.xyz);
  194.                         float3 lightDir = normalize(lerp(_WorldSpaceLightPos0.xyz, _WorldSpaceLightPos0.xyz - i.posWorld.xyz,_WorldSpaceLightPos0.w));
  195.                         float3 lightReflectDirection = reflect(-lightDir, normalWorld);
  196.                         float3 halfDirection = normalize(i.viewDir + lightDir);
  197.                        
  198.                     //Extention data sets
  199.                         float NdotL = max(0.0, dot(normalWorld, lightDir));
  200.                         float NdotH = max(0.0, dot(normalWorld, halfDirection));
  201.                         float NdotV = max(0.0, dot(normalWorld, i.viewDir));
  202.                         float VdotH = max(0.0, dot(i.viewDir, halfDirection));
  203.                         float LdotH = max(0.0, dot(lightDir, halfDirection));
  204.                         float LdotV = max(0.0, dot(lightDir, i.viewDir));
  205.                         float RdotV = max(0.0, dot(lightReflectDirection, i.viewDir));
  206.                         float HdotX = dot(halfDirection,i.tangentDir);
  207.                         float HdotY = dot(halfDirection, i.bitangentDir);
  208.                         UNITY_LIGHT_ATTENUATION(attenuation, i, i.posWorld.xyz);
  209.                         float3 attenColor = attenuation * _LightColor0.rgb;
  210.                     //End of Extention data
  211.                        
  212.                         half oneMinusReflectivity;
  213.                         half outputAlpha;
  214.                         half occlusion=1;
  215.                        
  216.                         FragmentCommonData s = (FragmentCommonData)0;
  217.                         s.alpha;
  218.                         s.diffColor = tex2D(_MainTex, TRANSFORM_TEX(i.uv0, _MainTex));
  219.                         s.diffColor = DiffuseAndSpecularFromMetallic(s.diffColor, _Metallic, /*out*/ _SpecColor.rgb, /*out*/ oneMinusReflectivity);;
  220.                         s.diffColor = PreMultiplyAlpha (s.diffColor, s.alpha, oneMinusReflectivity, /*out*/ outputAlpha);
  221.                         s.specColor = _SpecColor;
  222.                         s.oneMinusReflectivity = oneMinusReflectivity;
  223.                         s.eyeVec = i.viewDir;
  224.                         s.smoothness = 1-_Roughness;
  225.                         s.normalWorld = normalWorld;
  226.                         s.posWorld = i.posWorld.xyz;
  227.                        
  228.                        
  229.                         UnityLight light = MainLight();
  230.                         light.color = _LightColor0;
  231.                         light.dir = lightDir;
  232.                        
  233.                         UnityGI gi = FragmentGI(s, occlusion, i.ambientOrLightmapUV, attenuation, light , 1);
  234.                        
  235.                         half4 c = BRDF1_Unity_PBS(s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness , s.normalWorld, s.eyeVec, gi.light, gi.indirect);
  236.                         c.a = 1;
  237.                         return OutputForward( c, c.a );
  238.                        
  239.                     }
  240.         ENDCG
  241.     }
  242.     }
  243.         FallBack "Legacy Shaders/Diffuse"
  244. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top