372 lines
10 KiB
HLSL
372 lines
10 KiB
HLSL
#ifndef XUANXUAN_UTILITY
|
||
#define XUANXUAN_UTILITY
|
||
|
||
|
||
|
||
//引入自UnityCG.cginc
|
||
#define UNITY_PI 3.14159265359f
|
||
#define UNITY_TWO_PI 6.28318530718f
|
||
#define UNITY_FOUR_PI 12.56637061436f
|
||
#define UNITY_INV_PI 0.31830988618f
|
||
#define UNITY_INV_TWO_PI 0.15915494309f
|
||
#define UNITY_INV_FOUR_PI 0.07957747155f
|
||
#define UNITY_HALF_PI 1.57079632679f
|
||
#define UNITY_INV_HALF_PI 0.636619772367f
|
||
|
||
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
|
||
|
||
inline half NB_Remap(half x, half inMin, half inMax, half outMin, half outMax)
|
||
{
|
||
// x= clamp(x,inMin,inMax);
|
||
return saturate((x - inMin) / (inMax - inMin)) * (outMax - outMin) + outMin;
|
||
}
|
||
|
||
inline half NB_Remap01(half x, half inMin, half inMax)
|
||
{
|
||
// x= clamp(x,inMin,inMax);
|
||
return saturate((x - inMin) / (inMax - inMin));
|
||
}
|
||
|
||
inline half NB_RemapNoClamp(half x, half inMin, half inMax, half outMin, half outMax)
|
||
{
|
||
// x= clamp(x,inMin,inMax);
|
||
return ((x - inMin) / (inMax - inMin)) * (outMax - outMin) + outMin;
|
||
}
|
||
|
||
//原生SmoothStep开销很大：https://zhuanlan.zhihu.com/p/34629262
|
||
//在很多时候可以用简单线性映射代替。
|
||
half SimpleSmoothstep(half min,half max,half interp)
|
||
{
|
||
return saturate((interp - min)/(max-min));
|
||
}
|
||
|
||
half4 TryLinearize(half4 color)
|
||
{
|
||
#if defined(UNITY_COLORSPACE_GAMMA)
|
||
return pow(color, 2.2f);
|
||
#else
|
||
return color;
|
||
#endif
|
||
}
|
||
|
||
half4 TryLinearizeWithoutAlpha(half4 color)
|
||
{
|
||
#if defined(UNITY_COLORSPACE_GAMMA)
|
||
return half4(pow(color.rgb, 2.2f), color.a);
|
||
#else
|
||
return color;
|
||
#endif
|
||
}
|
||
|
||
half3 TryLinearize(half3 color)
|
||
{
|
||
#if defined(UNITY_COLORSPACE_GAMMA)
|
||
return pow(color, 2.2f);
|
||
#else
|
||
return color;
|
||
#endif
|
||
}
|
||
|
||
half2 TryLinearize(half2 color)
|
||
{
|
||
#if defined(UNITY_COLORSPACE_GAMMA)
|
||
return pow(color, 2.2f);
|
||
#else
|
||
return color;
|
||
#endif
|
||
}
|
||
|
||
half TryLinearize(half color)
|
||
{
|
||
#if defined(UNITY_COLORSPACE_GAMMA)
|
||
return pow(color, 2.2f);
|
||
#else
|
||
return color;
|
||
#endif
|
||
}
|
||
|
||
half4 tex2D_TryLinearizeWithoutAlpha(sampler2D tex, float2 uv)
|
||
{
|
||
#if defined(UNITY_COLORSPACE_GAMMA)
|
||
return TryLinearizeWithoutAlpha(tex2D(tex, uv));
|
||
#else
|
||
return tex2D(tex, uv);
|
||
#endif
|
||
}
|
||
|
||
inline float LinearToGammaSpaceExact (float value)
|
||
{
|
||
if (value <= 0.0F)
|
||
return 0.0F;
|
||
else if (value <= 0.0031308F)
|
||
return 12.92F * value;
|
||
else if (value < 1.0F)
|
||
return 1.055F * pow(value, 0.4166667F) - 0.055F;
|
||
else
|
||
return pow(value, 0.45454545F);
|
||
}
|
||
|
||
// real FastSRGBToLinear(real c)
|
||
// {
|
||
// return c * (c * (c * 0.305306011 + 0.682171111) + 0.012522878);
|
||
// }
|
||
|
||
float2 Rotate_Radians_float(float2 UV, float2 Center, float Rotation)
|
||
{
|
||
if(Rotation == 0)
|
||
{
|
||
return UV;
|
||
}
|
||
|
||
// Rotation = Rotation / 180 * 3.14; //从角度转为弧度。
|
||
Rotation *= 0.01745329222; //从角度转为弧度。
|
||
UV -= Center;
|
||
float s = sin(Rotation);
|
||
float c = cos(Rotation);
|
||
float2x2 rMatrix = float2x2(c, -s, s, c);
|
||
rMatrix *= 0.5;
|
||
rMatrix += 0.5;
|
||
rMatrix = rMatrix * 2 - 1;
|
||
UV.xy = mul(UV.xy, rMatrix);
|
||
UV += Center;
|
||
return UV;
|
||
}
|
||
|
||
inline half luminance(half3 color)
|
||
{
|
||
return dot(color, float3(0.2126f, 0.7152f, 0.0722f));
|
||
}
|
||
|
||
inline half DepthFactor(float Z, float near, float far)
|
||
{
|
||
Z = saturate((Z-near)/(far - near));
|
||
return Z;
|
||
}
|
||
|
||
//抽自Unity.cginc
|
||
inline half3 LinearToGammaSpace (half3 linRGB)
|
||
{
|
||
linRGB = max(linRGB, half3(0.h, 0.h, 0.h));
|
||
// An almost-perfect approximation from http://chilliant.blogspot.com.au/2012/08/srgb-approximations-for-hlsl.html?m=1
|
||
return max(1.055h * pow(linRGB, 0.416666667h) - 0.055h, 0.h);
|
||
|
||
// Exact version, useful for debugging.
|
||
//return half3(LinearToGammaSpaceExact(linRGB.r), LinearToGammaSpaceExact(linRGB.g), LinearToGammaSpaceExact(linRGB.b));
|
||
}
|
||
|
||
//ASE
|
||
float2 voronoihash1( float2 p )
|
||
{
|
||
|
||
p = float2( dot( p, float2( 127.1, 311.7 ) ), dot( p, float2( 269.5, 183.3 ) ) );
|
||
return frac( sin( p ) *43758.5453);
|
||
}
|
||
|
||
//ASE
|
||
float voronoi1( float2 v, float time, inout float2 id, inout float2 mr, float smoothness )
|
||
{
|
||
float2 n = floor( v );
|
||
float2 f = frac( v );
|
||
float F1 = 8.0;
|
||
float F2 = 8.0; float2 mg = 0;
|
||
for ( int j = -1; j <= 1; j++ )
|
||
{
|
||
for ( int i = -1; i <= 1; i++ )
|
||
{
|
||
float2 g = float2( i, j );
|
||
float2 o = voronoihash1( n + g );
|
||
o = ( sin( time + o * 6.2831 ) * 0.5 + 0.5 ); float2 r = f - g - o;
|
||
float d = 0.5 * dot( r, r );
|
||
if( d<F1 ) {
|
||
F2 = F1;
|
||
F1 = d; mg = g; mr = r; id = o;
|
||
} else if( d<F2 ) {
|
||
F2 = d;
|
||
}
|
||
}
|
||
}
|
||
return F2 - F1;
|
||
}
|
||
|
||
void voroniForgraphfunc_half(half2 uv,half angle,half scale,out float outVoroni1 )
|
||
{
|
||
uv = uv*scale;
|
||
float2 id1 = 0;
|
||
float2 uv1 = 0;
|
||
outVoroni1 = voronoi1( uv, angle, id1, uv1, 0 );
|
||
|
||
}
|
||
|
||
inline float2 unity_voronoi_noise_randomVector (float2 UV, float offset)
|
||
{
|
||
float2x2 m = float2x2(15.27, 47.63, 99.41, 89.98);
|
||
UV = frac(sin(mul(UV, m)) * 46839.32);
|
||
return float2(sin(UV.y*+offset)*0.5+0.5, cos(UV.x*offset)*0.5+0.5);
|
||
}
|
||
|
||
void Unity_Voronoi_float(float2 UV, float AngleOffset, float CellDensity, out float Out, out float Cells)
|
||
{
|
||
float2 g = floor(UV * CellDensity);
|
||
float2 f = frac(UV * CellDensity);
|
||
float t = 8.0;
|
||
float3 res = float3(8.0, 0.0, 0.0);
|
||
|
||
for(int y=-1; y<=1; y++)
|
||
{
|
||
for(int x=-1; x<=1; x++)
|
||
{
|
||
float2 lattice = float2(x,y);
|
||
float2 offset = unity_voronoi_noise_randomVector(lattice + g, AngleOffset);
|
||
float d = distance(lattice + offset, f);
|
||
if(d < res.x)
|
||
{
|
||
res = float3(d, offset.x, offset.y);
|
||
Out = res.x;
|
||
Cells = res.y;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void Unity_Blend_Overlay_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
|
||
{
|
||
float4 result1 = 1.0 - 2.0 * (1.0 - Base) * (1.0 - Blend);
|
||
float4 result2 = 2.0 * Base * Blend;
|
||
float4 zeroOrOne = step(Base, 0.5);
|
||
Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
|
||
Out = lerp(Base, Out, Opacity);
|
||
}
|
||
|
||
void Unity_Blend_HardLight_half(half Base, half Blend, half Opacity, out half Out)
|
||
{
|
||
half result1 = 1.0 - 2.0 * (1.0 - Base) * (1.0 - Blend);
|
||
half result2 = 2.0 * Base * Blend;
|
||
half zeroOrOne = step(Blend, 0.5);
|
||
Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
|
||
Out = lerp(Base, Out, Opacity);
|
||
}
|
||
|
||
void Blend_HardLight_half(half Base, half Blend, out half Out)
|
||
{
|
||
half result1 = 1.0 - 2.0 * (1.0 - Base) * (1.0 - Blend);
|
||
half result2 = 2.0 * Base * Blend;
|
||
half zeroOrOne = step(Blend, 0.5);
|
||
Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
|
||
}
|
||
|
||
float2 randomGradient(float2 p) {
|
||
p = p + 0.02;
|
||
float x = dot(p, float2(123.4, 234.5));
|
||
float y = dot(p, float2(234.5, 345.6));
|
||
float2 gradient = float2(x, y);
|
||
gradient = sin(gradient);
|
||
gradient = gradient * 43758.5453;
|
||
|
||
// part 4.5 - update noise function with time
|
||
// gradient = sin(gradient + u_time);
|
||
return gradient;
|
||
|
||
// gradient = sin(gradient);
|
||
// return gradient;
|
||
}
|
||
|
||
#include "./jp.keijiro.noiseshader/Shader/SimplexNoise3D.hlsl"
|
||
half SimplexNoise(float2 uv,float time)
|
||
{
|
||
return SimplexNoise(float3(uv,time))*0.5+0.5;
|
||
}
|
||
|
||
#include "./jp.keijiro.noiseshader/Shader/ClassicNoise3D.hlsl"
|
||
half PerlinNoise(float2 uv,float time)
|
||
{
|
||
return ClassicNoise(float3(uv,time))*0.5+0.5;
|
||
}
|
||
|
||
float2 PolarCoordinates(float2 UV, float2 _PCCenter)
|
||
{
|
||
// float2 uvsource = float2(0, 0);
|
||
|
||
float2 delta = UV - _PCCenter.xy;//校准UV到中心
|
||
float radius = length(delta) * 2;
|
||
float angle = atan2(delta.x, delta.y) * UNITY_INV_TWO_PI ;
|
||
return float2(angle, radius);//翻转可以调整横向和纵向。
|
||
}
|
||
|
||
float2 PolarCoordinatesStrengthAndST(float2 UVBeforPollarCoord,float2 UVAfterPolarCoord,float polarStrenth ,float4 tex_ST)
|
||
{
|
||
UVAfterPolarCoord = UVAfterPolarCoord*tex_ST.xy + tex_ST.zw;//利用相应功能贴图的坐标对ST进行修改。
|
||
UVAfterPolarCoord = lerp(UVBeforPollarCoord, UVAfterPolarCoord, polarStrenth);
|
||
return UVAfterPolarCoord;
|
||
}
|
||
|
||
|
||
//极坐标//transformation为极坐标强度
|
||
float2 PolarCoordinates(float2 UV, float3 _PCCenter, float4 tex_ST)
|
||
{
|
||
// float2 uvsource = float2(0, 0);
|
||
//
|
||
// float2 delta = UV - _PCCenter.xy;//校准UV到中心
|
||
// float radius = length(delta) * 2;
|
||
// float angle = atan2(delta.x, delta.y) * UNITY_INV_TWO_PI ;
|
||
// uvsource = float2(angle, radius);//翻转可以调整横向和纵向。
|
||
// uvsource = uvsource*tex_ST.xy + tex_ST.zw;//利用相应功能贴图的坐标对ST进行修改。
|
||
// uvsource = lerp(UV, uvsource, _PCCenter.z);
|
||
// return uvsource;
|
||
|
||
//拆分成两步，第一步求极坐标太耗（atan），一般源UV都是一样的，只是ST不同。
|
||
float2 uvsource = PolarCoordinates(UV,_PCCenter.xy);
|
||
uvsource = PolarCoordinatesStrengthAndST(UV,uvsource,_PCCenter.z,tex_ST);
|
||
return uvsource;
|
||
|
||
}
|
||
|
||
float2 CylinderCoordinate(float3 positionOS)
|
||
{
|
||
float angle = atan2(positionOS.x,positionOS.z)* UNITY_INV_TWO_PI ;
|
||
return float2(angle,positionOS.y);
|
||
}
|
||
|
||
|
||
float2 UVOffsetAnimaiton(float2 UV,half2 OffsetSpeed,float time)
|
||
{
|
||
float2 newUV = float2(OffsetSpeed.x*time+UV.x,OffsetSpeed.y*time+UV.y);
|
||
return newUV;
|
||
}
|
||
|
||
half3 rgb2hsv(half3 c)
|
||
{
|
||
half4 K = half4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
|
||
half4 p = lerp(half4(c.bg, K.wz), half4(c.gb, K.xy), step(c.b, c.g));
|
||
half4 q = lerp(half4(p.xyw, c.r), half4(c.r, p.yzx), step(p.x, c.r));
|
||
|
||
float d = q.x - min(q.w, q.y);
|
||
float e = 1.0e-10;
|
||
return float3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
|
||
}
|
||
|
||
half3 hsv2rgb(half3 c)
|
||
{
|
||
half4 K = half4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
|
||
half3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
|
||
return c.z * lerp(K.xxx, saturate(p - K.xxx), c.y);
|
||
}
|
||
|
||
half3 ColorSaturate(half3 color, half colorSaturation)
|
||
{
|
||
half3 lum = luminance(color);
|
||
return max(0, lerp(lum, color, colorSaturation));
|
||
}
|
||
|
||
half2 Rotate(half2 v, half cos0, half sin0)
|
||
{
|
||
return half2(v.x * cos0 - v.y * sin0,
|
||
v.x * sin0 + v.y * cos0);
|
||
}
|
||
|
||
half SmoothStep01(half interval)//让01线性过渡变成SmoothStep过渡，但是控制计算量。
|
||
{
|
||
interval = saturate(interval);
|
||
return interval * interval * ( 3 - 2 * interval );
|
||
}
|
||
#endif
|