274 lines
7.9 KiB
HLSL
274 lines
7.9 KiB
HLSL
#ifndef POI_HELPER
|
|
#define POI_HELPER
|
|
#ifndef pi
|
|
#define pi float(3.14159265359)
|
|
#endif
|
|
float linearSin(float x)
|
|
{
|
|
return pow(min(cos(pi * x / 2.0), 1.0 - abs(x)), 1.0);
|
|
}
|
|
float random(float2 p)
|
|
{
|
|
return frac(sin(dot(p, float2(12.9898, 78.2383))) * 43758.5453123);
|
|
}
|
|
float2 random2(float2 p)
|
|
{
|
|
return frac(sin(float2(dot(p, float2(127.1, 311.7)), dot(p, float2(269.5, 183.3)))) * 43758.5453);
|
|
}
|
|
float3 random3(float3 p)
|
|
{
|
|
return frac(sin(float3(dot(p, float3(127.1, 311.7, 248.6)), dot(p, float3(269.5, 183.3, 423.3)), dot(p, float3(248.3, 315.9, 184.2)))) * 43758.5453);
|
|
}
|
|
float3 mod(float3 x, float y)
|
|
{
|
|
return x - y * floor(x / y);
|
|
}
|
|
float2 mod(float2 x, float y)
|
|
{
|
|
return x - y * floor(x / y);
|
|
}
|
|
#define K 0.142857142857
|
|
#define Ko 0.428571428571
|
|
float3 Permutation(float3 x)
|
|
{
|
|
return mod((34.0 * x + 1.0) * x, 289.0);
|
|
}
|
|
bool IsInMirror()
|
|
{
|
|
return unity_CameraProjection[2][0] != 0.f || unity_CameraProjection[2][1] != 0.f;
|
|
}
|
|
float3 BoxProjection(float3 direction, float3 position, float4 cubemapPosition, float3 boxMin, float3 boxMax)
|
|
{
|
|
#if UNITY_SPECCUBE_BOX_PROJECTION
|
|
|
|
if (cubemapPosition.w > 0)
|
|
{
|
|
float3 factors = ((direction > 0 ? boxMax : boxMin) - position) / direction;
|
|
float scalar = min(min(factors.x, factors.y), factors.z);
|
|
direction = direction * scalar + (position - cubemapPosition.xyz);
|
|
}
|
|
#endif
|
|
return direction;
|
|
}
|
|
float3 getCameraPosition()
|
|
{
|
|
#ifdef USING_STEREO_MATRICES
|
|
return lerp(unity_StereoWorldSpaceCameraPos[0], unity_StereoWorldSpaceCameraPos[1], 0.5);
|
|
#endif
|
|
return _WorldSpaceCameraPos;
|
|
}
|
|
float3 getCameraForward()
|
|
{
|
|
#if UNITY_SINGLE_PASS_STEREO
|
|
float3 p1 = mul(unity_StereoCameraToWorld[0], float4(0, 0, 1, 1));
|
|
float3 p2 = mul(unity_StereoCameraToWorld[0], float4(0, 0, 0, 1));
|
|
#else
|
|
float3 p1 = mul(unity_CameraToWorld, float4(0, 0, 1, 1)).xyz;
|
|
float3 p2 = mul(unity_CameraToWorld, float4(0, 0, 0, 1)).xyz;
|
|
#endif
|
|
return normalize(p2 - p1);
|
|
}
|
|
float3 grayscale_vector_node()
|
|
{
|
|
return float3(0, 0.3823529, 0.01845836);
|
|
}
|
|
float3 grayscale_for_light()
|
|
{
|
|
return float3(0.298912, 0.586611, 0.114478);
|
|
}
|
|
float remap(float x, float minOld, float maxOld, float minNew, float maxNew)
|
|
{
|
|
return minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld);
|
|
}
|
|
float2 remap(float2 x, float2 minOld, float2 maxOld, float2 minNew, float2 maxNew)
|
|
{
|
|
return minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld);
|
|
}
|
|
float3 remap(float3 x, float3 minOld, float3 maxOld, float3 minNew, float3 maxNew)
|
|
{
|
|
return minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld);
|
|
}
|
|
float4 remap(float4 x, float4 minOld, float4 maxOld, float4 minNew, float4 maxNew)
|
|
{
|
|
return minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld);
|
|
}
|
|
float remapClamped(float x, float minOld, float maxOld, float minNew, float maxNew)
|
|
{
|
|
return clamp(minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld), minNew, maxNew);
|
|
}
|
|
float2 remapClamped(float2 x, float2 minOld, float2 maxOld, float2 minNew, float2 maxNew)
|
|
{
|
|
return clamp(minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld), minNew, maxNew);
|
|
}
|
|
float3 remapClamped(float3 x, float3 minOld, float3 maxOld, float3 minNew, float3 maxNew)
|
|
{
|
|
return clamp(minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld), minNew, maxNew);
|
|
}
|
|
float4 remapClamped(float4 x, float4 minOld, float4 maxOld, float4 minNew, float4 maxNew)
|
|
{
|
|
return clamp(minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld), minNew, maxNew);
|
|
}
|
|
float poiMax(float2 i)
|
|
{
|
|
return max(i.x, i.y);
|
|
}
|
|
float poiMax(float3 i)
|
|
{
|
|
return max(max(i.x, i.y), i.z);
|
|
}
|
|
float poiMax(float4 i)
|
|
{
|
|
return max(max(max(i.x, i.y), i.z), i.w);
|
|
}
|
|
float4x4 poiAngleAxisRotationMatrix(float angle, float3 axis)
|
|
{
|
|
axis = normalize(axis);
|
|
float s = sin(angle);
|
|
float c = cos(angle);
|
|
float oc = 1.0 - c;
|
|
return float4x4(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s, 0.0,
|
|
oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s, 0.0,
|
|
oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c, 0.0,
|
|
0.0, 0.0, 0.0, 1.0);
|
|
}
|
|
float4x4 poiRotationMatrixFromAngles(float x, float y, float z)
|
|
{
|
|
float angleX = radians(x);
|
|
float c = cos(angleX);
|
|
float s = sin(angleX);
|
|
float4x4 rotateXMatrix = float4x4(1, 0, 0, 0,
|
|
0, c, -s, 0,
|
|
0, s, c, 0,
|
|
0, 0, 0, 1);
|
|
float angleY = radians(y);
|
|
c = cos(angleY);
|
|
s = sin(angleY);
|
|
float4x4 rotateYMatrix = float4x4(c, 0, s, 0,
|
|
0, 1, 0, 0,
|
|
- s, 0, c, 0,
|
|
0, 0, 0, 1);
|
|
float angleZ = radians(z);
|
|
c = cos(angleZ);
|
|
s = sin(angleZ);
|
|
float4x4 rotateZMatrix = float4x4(c, -s, 0, 0,
|
|
s, c, 0, 0,
|
|
0, 0, 1, 0,
|
|
0, 0, 0, 1);
|
|
return mul(mul(rotateXMatrix, rotateYMatrix), rotateZMatrix);
|
|
}
|
|
float4x4 poiRotationMatrixFromAngles(float3 angles)
|
|
{
|
|
float angleX = radians(angles.x);
|
|
float c = cos(angleX);
|
|
float s = sin(angleX);
|
|
float4x4 rotateXMatrix = float4x4(1, 0, 0, 0,
|
|
0, c, -s, 0,
|
|
0, s, c, 0,
|
|
0, 0, 0, 1);
|
|
float angleY = radians(angles.y);
|
|
c = cos(angleY);
|
|
s = sin(angleY);
|
|
float4x4 rotateYMatrix = float4x4(c, 0, s, 0,
|
|
0, 1, 0, 0,
|
|
- s, 0, c, 0,
|
|
0, 0, 0, 1);
|
|
float angleZ = radians(angles.z);
|
|
c = cos(angleZ);
|
|
s = sin(angleZ);
|
|
float4x4 rotateZMatrix = float4x4(c, -s, 0, 0,
|
|
s, c, 0, 0,
|
|
0, 0, 1, 0,
|
|
0, 0, 0, 1);
|
|
return mul(mul(rotateXMatrix, rotateYMatrix), rotateZMatrix);
|
|
}
|
|
#endif
|
|
half2 calcScreenUVs(half4 grabPos)
|
|
{
|
|
half2 uv = grabPos.xy / (grabPos.w + 0.0000000001);
|
|
#if UNITY_SINGLE_PASS_STEREO
|
|
uv.xy *= half2(_ScreenParams.x * 2, _ScreenParams.y);
|
|
#else
|
|
uv.xy *= _ScreenParams.xy;
|
|
#endif
|
|
return uv;
|
|
}
|
|
float inverseLerp(float A, float B, float T)
|
|
{
|
|
return(T - A) / (B - A);
|
|
}
|
|
float inverseLerp2(float2 a, float2 b, float2 value)
|
|
{
|
|
float2 AB = b - a;
|
|
float2 AV = value - a;
|
|
return dot(AV, AB) / dot(AB, AB);
|
|
}
|
|
float inverseLerp3(float3 a, float3 b, float3 value)
|
|
{
|
|
float3 AB = b - a;
|
|
float3 AV = value - a;
|
|
return dot(AV, AB) / dot(AB, AB);
|
|
}
|
|
float inverseLerp4(float4 a, float4 b, float4 value)
|
|
{
|
|
float4 AB = b - a;
|
|
float4 AV = value - a;
|
|
return dot(AV, AB) / dot(AB, AB);
|
|
}
|
|
inline half Dither8x8Bayer(int x, int y)
|
|
{
|
|
const half dither[ 64 ] = {
|
|
1, 49, 13, 61, 4, 52, 16, 64,
|
|
33, 17, 45, 29, 36, 20, 48, 32,
|
|
9, 57, 5, 53, 12, 60, 8, 56,
|
|
41, 25, 37, 21, 44, 28, 40, 24,
|
|
3, 51, 15, 63, 2, 50, 14, 62,
|
|
35, 19, 47, 31, 34, 18, 46, 30,
|
|
11, 59, 7, 55, 10, 58, 6, 54,
|
|
43, 27, 39, 23, 42, 26, 38, 22
|
|
};
|
|
int r = y * 8 + x;
|
|
return dither[r] / 64;
|
|
}
|
|
float2 TransformUV(half2 offset, half rotation, half2 scale, float2 uv)
|
|
{
|
|
float theta = radians(rotation);
|
|
scale = 1 - scale;
|
|
float cs = cos(theta);
|
|
float sn = sin(theta);
|
|
float2 centerPoint = offset + .5;
|
|
uv = float2((uv.x - centerPoint.x) * cs - (uv.y - centerPoint.y) * sn + centerPoint.x, (uv.x - centerPoint.x) * sn + (uv.y - centerPoint.y) * cs + centerPoint.y);
|
|
return remap(uv, float2(0, 0) + offset + (scale * .5), float2(1, 1) + offset - (scale * .5), float2(0, 0), float2(1, 1));
|
|
}
|
|
bool isVR()
|
|
{
|
|
#if UNITY_SINGLE_PASS_STEREO
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
bool isVRHandCamera()
|
|
{
|
|
return !isVR() && abs(UNITY_MATRIX_V[0].y) > 0.0000005;
|
|
}
|
|
bool isDesktop()
|
|
{
|
|
return !isVRHandCamera();
|
|
}
|
|
bool isVRHandCameraPreview()
|
|
{
|
|
return isVRHandCamera() && _ScreenParams.y == 720;
|
|
}
|
|
bool isVRHandCameraPicture()
|
|
{
|
|
return isVRHandCamera() && _ScreenParams.y == 1080;
|
|
}
|
|
bool isPanorama()
|
|
{
|
|
return unity_CameraProjection[1][1] == 1 && _ScreenParams.x == 1075 && _ScreenParams.y == 1025;
|
|
}
|
|
float calculateluminance(float3 color)
|
|
{
|
|
return color.r * 0.299 + color.g * 0.587 + color.b * 0.114;
|
|
}
|