Categories

# Simple Jade Shader for mobile devices.

Simple Jade Shader for mobile devices.

I shared the Unity shader code we made in 2018.
I remember using a Surface Shader at that time because it was a time when a Built-In pipeline was used.
Still, I think you can check the part that I thought was the key in the code below.

Because it was used for mobile game development, advanced technologies such as BSRDF could not be used.
In general, the key to processing such SSS shading is Blur normal.
The mobile SSS that is recently added to UE5 (that is, 2022, when I am posting this now) uses Blur5. Anyway, the key is the characteristics of SSS.
Because the scattering of light occurs inside, these surfaces become very blurry (in other words, they appear smooth).
So let’s focus on how to calculate similarly.
SSS is more emphasized from backlight. Also, since it is most likely to occur on the opposite side of the main light, you can use NdotL and use this part as a Blur Normal area mask after adding weights.
If pixel normal is burdensome, you can use Vertex Normal for Blur Normal. (It is not recommended, but…)

```Shader "X2M/Object/Object_Jade_SSS"
{
Properties
{
_Roughness("Roughness", Range( 0 , 1)) = 0
_BaseColor("Base Color", Color) = (0,0,0,0)
_Albedo("Albedo", 2D) = "white" {}
_Normal("Normal", 2D) = "bump" {}
_BlurredNormal("Blurred Normal", 2D) = "bump" {}
[Header(Translucency)]
_Translucency("Strength", Range( 0 , 50)) = 1
_TransNormalDistortion("Normal Distortion", Range( 0 , 1)) = 0.1
_TransScattering("Scaterring Falloff", Range( 1 , 50)) = 2
_TransDirect("Direct", Range( 0 , 1)) = 1
_TransAmbient("Ambient", Range( 0 , 1)) = 0.2
_TransShadow("Shadow", Range( 0 , 1)) = 0.9
_SctterColorA("Sctter Color A", Color) = (0,0,0,1)
_ScatterColorB("Scatter Color B", Color) = (0,0,0,1)
_Depth("Depth", 2D) = "white" {}
_DepthScale("Depth Scale", Float) = 0
[HideInInspector] _texcoord( "", 2D ) = "white" {}
[HideInInspector] __dirty( "", Int ) = 1
}

SubShader
{
Tags{ "RenderType" = "Opaque"  "Queue" = "Geometry+0" }
Cull Back
ZTest LEqual
CGINCLUDE
#include "UnityShaderVariables.cginc"
#include "UnityPBSLighting.cginc"
#include "Lighting.cginc"
#pragma target 3.0
#ifdef UNITY_PASS_SHADOWCASTER
#undef INTERNAL_DATA
#undef WorldReflectionVector
#undef WorldNormalVector
#define INTERNAL_DATA half3 internalSurfaceTtoW0; half3 internalSurfaceTtoW1; half3 internalSurfaceTtoW2;
#define WorldReflectionVector(data,normal) reflect (data.worldRefl, half3(dot(data.internalSurfaceTtoW0,normal), dot(data.internalSurfaceTtoW1,normal), dot(data.internalSurfaceTtoW2,normal)))
#define WorldNormalVector(data,normal) half3(dot(data.internalSurfaceTtoW0,normal), dot(data.internalSurfaceTtoW1,normal), dot(data.internalSurfaceTtoW2,normal))
#endif
struct Input
{
float2 uv_texcoord;
half3 worldNormal;
INTERNAL_DATA
};

struct SurfaceOutputStandardCustom
{
half3 Albedo;
half3 Normal;
half3 Emission;
half Metallic;
half Smoothness;
half Occlusion;
half Alpha;
half3 Translucency;
};

uniform sampler2D _BlurredNormal;
uniform half4 _BlurredNormal_ST;
uniform sampler2D _Normal;
uniform sampler2D _Albedo;
uniform float4 _Albedo_ST;
uniform sampler2D _Depth;
uniform half4 _Depth_ST;
uniform half _DepthScale;
uniform float4 _BaseColor;
uniform float _Roughness;
uniform half _Translucency;
uniform half _TransNormalDistortion;
uniform half _TransScattering;
uniform half _TransDirect;
uniform half _TransAmbient;
uniform half _TransShadow;
uniform half4 _ScatterColorB;
uniform float4 _SctterColorA;

inline half4 LightingStandardCustom(SurfaceOutputStandardCustom s, half3 viewDir, UnityGI gi )
{

float3 lightAtten = lerp( _LightColor0.rgb, gi.light.color, _TransShadow );

half3 lightDir = gi.light.dir;
half3 H = (lightDir + s.Normal * _TransNormalDistortion);
half transVdoth = pow( saturate( dot( viewDir, -H ) ), _TransScattering );
half3 translucency = lightAtten * (transVdoth * _TransDirect + gi.indirect.diffuse * _TransAmbient) * s.Translucency;
half4 c = half4( s.Albedo * translucency * _Translucency, 0 );

SurfaceOutputStandard r;
r.Albedo = s.Albedo;
r.Normal = s.Normal;
r.Emission = s.Emission;
r.Metallic = s.Metallic;
r.Smoothness = s.Smoothness;
r.Occlusion = s.Occlusion;
r.Alpha = s.Alpha;
return LightingStandard (r, viewDir, gi) + c;
}

inline void LightingStandardCustom_GI(SurfaceOutputStandardCustom s, UnityGIInput data, inout UnityGI gi )
{
#if defined(UNITY_PASS_DEFERRED) && UNITY_ENABLE_REFLECTION_BUFFERS
gi = UnityGlobalIllumination(data, s.Occlusion, s.Normal);
#else
UNITY_GLOSSY_ENV_FROM_SURFACE( g, s, data );
gi = UnityGlobalIllumination( data, s.Occlusion, s.Normal, g );
#endif
}

void surf( Input i , inout SurfaceOutputStandardCustom o )
{
float2 uv_BlurredNormal = i.uv_texcoord * _BlurredNormal_ST.xy + _BlurredNormal_ST.zw;
half3 BlurrleyNormal_Var = UnpackNormal( tex2D( _BlurredNormal, uv_BlurredNormal ) );
float2 uv0_Albedo = i.uv_texcoord * _Albedo_ST.xy + _Albedo_ST.zw;
float2 uv_Depth = i.uv_texcoord * _Depth_ST.xy + _Depth_ST.zw;
half4 depth_Var = pow( tex2D( _Depth, uv_Depth ) , _DepthScale);
half3 BlendedNormal = lerp( BlurrleyNormal_Var , UnpackNormal( tex2D( _Normal, uv0_Albedo ) ) , depth_Var.rgb);
o.Normal = BlendedNormal;
o.Albedo = _BaseColor * tex2D( _Albedo, uv0_Albedo ).rgb;
o.Smoothness = _Roughness;
o.Translucency = lerp( _ScatterColorB , _SctterColorA , depth_Var);
o.Alpha = 1;
}

ENDCG
CGPROGRAM
#pragma surface surf StandardCustom keepalpha fullforwardshadows exclude_path:deferred

ENDCG
Pass
{
Name "ShadowCaster"
Tags{ "LightMode" = "ShadowCaster" }
ZWrite On
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma target 3.0
#pragma multi_compile_shadowcaster
#pragma multi_compile UNITY_PASS_SHADOWCASTER
#pragma skip_variants FOG_LINEAR FOG_EXP FOG_EXP2
#include "HLSLSupport.cginc"
#if ( SHADER_API_D3D11 || SHADER_API_GLCORE || SHADER_API_GLES || SHADER_API_GLES3 || SHADER_API_METAL || SHADER_API_VULKAN )
#define CAN_SKIP_VPOS
#endif
#include "UnityCG.cginc"
#include "Lighting.cginc"
#include "UnityPBSLighting.cginc"
struct v2f
{
V2F_SHADOW_CASTER;
float2 customPack1 : TEXCOORD1;
float4 tSpace0 : TEXCOORD2;
float4 tSpace1 : TEXCOORD3;
float4 tSpace2 : TEXCOORD4;
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
v2f vert( appdata_full v )
{
v2f o;
UNITY_SETUP_INSTANCE_ID( v );
UNITY_INITIALIZE_OUTPUT( v2f, o );
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO( o );
UNITY_TRANSFER_INSTANCE_ID( v, o );
Input customInputData;
float3 worldPos = mul( unity_ObjectToWorld, v.vertex ).xyz;
half3 worldNormal = UnityObjectToWorldNormal( v.normal );
half3 worldTangent = UnityObjectToWorldDir( v.tangent.xyz );
half tangentSign = v.tangent.w * unity_WorldTransformParams.w;
half3 worldBinormal = cross( worldNormal, worldTangent ) * tangentSign;
o.tSpace0 = float4( worldTangent.x, worldBinormal.x, worldNormal.x, worldPos.x );
o.tSpace1 = float4( worldTangent.y, worldBinormal.y, worldNormal.y, worldPos.y );
o.tSpace2 = float4( worldTangent.z, worldBinormal.z, worldNormal.z, worldPos.z );
o.customPack1.xy = customInputData.uv_texcoord;
o.customPack1.xy = v.texcoord;
TRANSFER_SHADOW_CASTER_NORMALOFFSET( o )
return o;
}
half4 frag( v2f IN
#if !defined( CAN_SKIP_VPOS )
, UNITY_VPOS_TYPE vpos : VPOS
#endif
) : SV_Target
{
UNITY_SETUP_INSTANCE_ID( IN );
Input surfIN;
UNITY_INITIALIZE_OUTPUT( Input, surfIN );
surfIN.uv_texcoord = IN.customPack1.xy;
float3 worldPos = float3( IN.tSpace0.w, IN.tSpace1.w, IN.tSpace2.w );
half3 worldViewDir = normalize( UnityWorldSpaceViewDir( worldPos ) );
surfIN.worldNormal = float3( IN.tSpace0.z, IN.tSpace1.z, IN.tSpace2.z );
surfIN.internalSurfaceTtoW0 = IN.tSpace0.xyz;
surfIN.internalSurfaceTtoW1 = IN.tSpace1.xyz;
surfIN.internalSurfaceTtoW2 = IN.tSpace2.xyz;
SurfaceOutputStandardCustom o;
UNITY_INITIALIZE_OUTPUT( SurfaceOutputStandardCustom, o )
surf( surfIN, o );
#if defined( CAN_SKIP_VPOS )
float2 vpos = IN.pos;
#endif
SHADOW_CASTER_FRAGMENT( IN )
}
ENDCG
}
}
Fallback "Diffuse"

}

```

## 2 replies on “Simple Jade Shader for mobile devices.”

qingfengsays:

How can I get this shader?