mirror of
https://github.com/KevinMidboe/linguist.git
synced 2025-10-28 17:20:22 +00:00
Add ShaderLab language (#3490)
* Add ShaderLab language * Update HLSL and ShaderLab grammars to latest version * Add .shader extension back to GLSL language * Add sample GLSL .shader files Note that these are copies of existing GLSL samples, renamed to have the .shader extension.
This commit is contained in:
Tim Jones
Colin Seymour
@@ -4014,6 +4014,13 @@ Self:
|
||||
tm_scope: none
|
||||
ace_mode: text
|
||||
language_id: 345
|
||||
ShaderLab:
|
||||
type: programming
|
||||
extensions:
|
||||
- ".shader"
|
||||
ace_mode: text
|
||||
tm_scope: source.shaderlab
|
||||
language_id: 664257356
|
||||
Shell:
|
||||
type: programming
|
||||
color: "#89e051"
|
||||
|
||||
161
samples/GLSL/SyLens.shader
Normal file
161
samples/GLSL/SyLens.shader
Normal file
@@ -0,0 +1,161 @@
|
||||
#version 120
|
||||
|
||||
/*
|
||||
Original Lens Distortion Algorithm from SSontech (Syntheyes)
|
||||
http://www.ssontech.com/content/lensalg.htm
|
||||
|
||||
r2 is radius squared.
|
||||
|
||||
r2 = image_aspect*image_aspect*u*u + v*v
|
||||
f = 1 + r2*(k + kcube*sqrt(r2))
|
||||
u' = f*u
|
||||
v' = f*v
|
||||
|
||||
*/
|
||||
|
||||
// Controls
|
||||
uniform float kCoeff, kCube, uShift, vShift;
|
||||
uniform float chroma_red, chroma_green, chroma_blue;
|
||||
uniform bool apply_disto;
|
||||
|
||||
// Uniform inputs
|
||||
uniform sampler2D input1;
|
||||
uniform float adsk_input1_w, adsk_input1_h, adsk_input1_aspect, adsk_input1_frameratio;
|
||||
uniform float adsk_result_w, adsk_result_h;
|
||||
|
||||
float distortion_f(float r) {
|
||||
float f = 1 + (r*r)*(kCoeff + kCube * r);
|
||||
return f;
|
||||
}
|
||||
|
||||
|
||||
float inverse_f(float r)
|
||||
{
|
||||
|
||||
// Build a lookup table on the radius, as a fixed-size table.
|
||||
// We will use a vec3 since we will store the multipled number in the Z coordinate.
|
||||
// So to recap: x will be the radius, y will be the f(x) distortion, and Z will be x * y;
|
||||
vec3[48] lut;
|
||||
|
||||
// Since out LUT is shader-global check if it's been computed alrite
|
||||
// Flame has no overflow bbox so we can safely max out at the image edge, plus some cushion
|
||||
float max_r = sqrt((adsk_input1_frameratio * adsk_input1_frameratio) + 1) + 0.1;
|
||||
float incr = max_r / 48;
|
||||
float lut_r = 0;
|
||||
float f;
|
||||
for(int i=0; i < 48; i++) {
|
||||
f = distortion_f(lut_r);
|
||||
lut[i] = vec3(lut_r, f, lut_r * f);
|
||||
lut_r += incr;
|
||||
}
|
||||
|
||||
float t;
|
||||
// Now find the nehgbouring elements
|
||||
// only iterate to 46 since we will need
|
||||
// 47 as i+1
|
||||
for(int i=0; i < 47; i++) {
|
||||
if(lut[i].z < r && lut[i+1].z > r) {
|
||||
// BAM! our value is between these two segments
|
||||
// get the T interpolant and mix
|
||||
t = (r - lut[i].z) / (lut[i+1].z - lut[i]).z;
|
||||
return mix(lut[i].y, lut[i+1].y, t );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
float aberrate(float f, float chroma)
|
||||
{
|
||||
return f + (f * chroma);
|
||||
}
|
||||
|
||||
vec3 chromaticize_and_invert(float f)
|
||||
{
|
||||
vec3 rgb_f = vec3(aberrate(f, chroma_red), aberrate(f, chroma_green), aberrate(f, chroma_blue));
|
||||
// We need to DIVIDE by F when we redistort, and x / y == x * (1 / y)
|
||||
if(apply_disto) {
|
||||
rgb_f = 1 / rgb_f;
|
||||
}
|
||||
return rgb_f;
|
||||
}
|
||||
|
||||
void main(void)
|
||||
{
|
||||
vec2 px, uv;
|
||||
float f = 1;
|
||||
float r = 1;
|
||||
|
||||
px = gl_FragCoord.xy;
|
||||
|
||||
// Make sure we are still centered
|
||||
px.x -= (adsk_result_w - adsk_input1_w) / 2;
|
||||
px.y -= (adsk_result_h - adsk_input1_h) / 2;
|
||||
|
||||
// Push the destination coordinates into the [0..1] range
|
||||
uv.x = px.x / adsk_input1_w;
|
||||
uv.y = px.y / adsk_input1_h;
|
||||
|
||||
|
||||
// And to Syntheyes UV which are [1..-1] on both X and Y
|
||||
uv.x = (uv.x *2 ) - 1;
|
||||
uv.y = (uv.y *2 ) - 1;
|
||||
|
||||
// Add UV shifts
|
||||
uv.x += uShift;
|
||||
uv.y += vShift;
|
||||
|
||||
// Make the X value the aspect value, so that the X coordinates go to [-aspect..aspect]
|
||||
uv.x = uv.x * adsk_input1_frameratio;
|
||||
|
||||
// Compute the radius
|
||||
r = sqrt(uv.x*uv.x + uv.y*uv.y);
|
||||
|
||||
// If we are redistorting, account for the oversize plate in the input, assume that
|
||||
// the input aspect is the same
|
||||
if(apply_disto) {
|
||||
r = r / (float(adsk_input1_w) / float(adsk_result_w));
|
||||
}
|
||||
|
||||
// Apply or remove disto, per channel honoring chromatic aberration
|
||||
if(apply_disto) {
|
||||
f = inverse_f(r);
|
||||
} else {
|
||||
f = distortion_f(r);
|
||||
}
|
||||
|
||||
vec2[3] rgb_uvs = vec2[](uv, uv, uv);
|
||||
|
||||
// Compute distortions per component
|
||||
vec3 rgb_f = chromaticize_and_invert(f);
|
||||
|
||||
// Apply the disto coefficients, per component
|
||||
rgb_uvs[0] = rgb_uvs[0] * rgb_f.rr;
|
||||
rgb_uvs[1] = rgb_uvs[1] * rgb_f.gg;
|
||||
rgb_uvs[2] = rgb_uvs[2] * rgb_f.bb;
|
||||
|
||||
// Convert all the UVs back to the texture space, per color component
|
||||
for(int i=0; i < 3; i++) {
|
||||
uv = rgb_uvs[i];
|
||||
|
||||
// Back from [-aspect..aspect] to [-1..1]
|
||||
uv.x = uv.x / adsk_input1_frameratio;
|
||||
|
||||
// Remove UV shifts
|
||||
uv.x -= uShift;
|
||||
uv.y -= vShift;
|
||||
|
||||
// Back to OGL UV
|
||||
uv.x = (uv.x + 1) / 2;
|
||||
uv.y = (uv.y + 1) / 2;
|
||||
|
||||
rgb_uvs[i] = uv;
|
||||
}
|
||||
|
||||
// Sample the input plate, per component
|
||||
vec4 sampled;
|
||||
sampled.r = texture2D(input1, rgb_uvs[0]).r;
|
||||
sampled.g = texture2D(input1, rgb_uvs[1]).g;
|
||||
sampled.b = texture2D(input1, rgb_uvs[2]).b;
|
||||
|
||||
// and assign to the output
|
||||
gl_FragColor.rgba = vec4(sampled.rgb, 1.0 );
|
||||
}
|
||||
630
samples/GLSL/islandScene.shader
Normal file
630
samples/GLSL/islandScene.shader
Normal file
@@ -0,0 +1,630 @@
|
||||
//// High quality (Some browsers may freeze or crash)
|
||||
//#define HIGHQUALITY
|
||||
|
||||
//// Medium quality (Should be fine on all systems, works on Intel HD2000 on Win7 but quite slow)
|
||||
//#define MEDIUMQUALITY
|
||||
|
||||
//// Defaults
|
||||
//#define REFLECTIONS
|
||||
#define SHADOWS
|
||||
//#define GRASS
|
||||
//#define SMALL_WAVES
|
||||
#define RAGGED_LEAVES
|
||||
//#define DETAILED_NOISE
|
||||
//#define LIGHT_AA // 2 sample SSAA
|
||||
//#define HEAVY_AA // 2x2 RG SSAA
|
||||
//#define TONEMAP
|
||||
|
||||
//// Configurations
|
||||
#ifdef MEDIUMQUALITY
|
||||
#define SHADOWS
|
||||
#define SMALL_WAVES
|
||||
#define RAGGED_LEAVES
|
||||
#define TONEMAP
|
||||
#endif
|
||||
|
||||
#ifdef HIGHQUALITY
|
||||
#define REFLECTIONS
|
||||
#define SHADOWS
|
||||
//#define GRASS
|
||||
#define SMALL_WAVES
|
||||
#define RAGGED_LEAVES
|
||||
#define DETAILED_NOISE
|
||||
#define LIGHT_AA
|
||||
#define TONEMAP
|
||||
#endif
|
||||
|
||||
// Constants
|
||||
const float eps = 1e-5;
|
||||
const float PI = 3.14159265359;
|
||||
|
||||
const vec3 sunDir = vec3(0.79057,-0.47434, 0.0);
|
||||
const vec3 skyCol = vec3(0.3, 0.5, 0.8);
|
||||
const vec3 sandCol = vec3(0.9, 0.8, 0.5);
|
||||
const vec3 treeCol = vec3(0.8, 0.65, 0.3);
|
||||
const vec3 grassCol = vec3(0.4, 0.5, 0.18);
|
||||
const vec3 leavesCol = vec3(0.3, 0.6, 0.2);
|
||||
const vec3 leavesPos = vec3(-5.1,13.4, 0.0);
|
||||
|
||||
#ifdef TONEMAP
|
||||
const vec3 sunCol = vec3(1.8, 1.7, 1.6);
|
||||
#else
|
||||
const vec3 sunCol = vec3(0.9, 0.85, 0.8);
|
||||
#endif
|
||||
|
||||
const float exposure = 1.1; // Only used when tonemapping
|
||||
|
||||
// Description : Array and textureless GLSL 2D/3D/4D simplex
|
||||
// noise functions.
|
||||
// Author : Ian McEwan, Ashima Arts.
|
||||
// License : Copyright (C) 2011 Ashima Arts. All rights reserved.
|
||||
// Distributed under the MIT License. See LICENSE file.
|
||||
// https://github.com/ashima/webgl-noise
|
||||
vec3 mod289(vec3 x) {
|
||||
return x - floor(x * (1.0 / 289.0)) * 289.0;
|
||||
}
|
||||
|
||||
vec4 mod289(vec4 x) {
|
||||
return x - floor(x * (1.0 / 289.0)) * 289.0;
|
||||
}
|
||||
|
||||
vec4 permute(vec4 x) {
|
||||
return mod289(((x*34.0)+1.0)*x);
|
||||
}
|
||||
|
||||
vec4 taylorInvSqrt(vec4 r) {
|
||||
return 1.79284291400159 - 0.85373472095314 * r;
|
||||
}
|
||||
|
||||
float snoise(vec3 v) {
|
||||
const vec2 C = vec2(1.0/6.0, 1.0/3.0) ;
|
||||
const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
|
||||
|
||||
// First corner
|
||||
vec3 i = floor(v + dot(v, C.yyy) );
|
||||
vec3 x0 = v - i + dot(i, C.xxx) ;
|
||||
|
||||
// Other corners
|
||||
vec3 g = step(x0.yzx, x0.xyz);
|
||||
vec3 l = 1.0 - g;
|
||||
vec3 i1 = min( g.xyz, l.zxy );
|
||||
vec3 i2 = max( g.xyz, l.zxy );
|
||||
|
||||
// x0 = x0 - 0.0 + 0.0 * C.xxx;
|
||||
// x1 = x0 - i1 + 1.0 * C.xxx;
|
||||
// x2 = x0 - i2 + 2.0 * C.xxx;
|
||||
// x3 = x0 - 1.0 + 3.0 * C.xxx;
|
||||
vec3 x1 = x0 - i1 + C.xxx;
|
||||
vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
|
||||
vec3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y
|
||||
|
||||
// Permutations
|
||||
i = mod289(i);
|
||||
vec4 p = permute( permute( permute(
|
||||
i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
|
||||
+ i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
|
||||
+ i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
|
||||
|
||||
// Gradients: 7x7 points over a square, mapped onto an octahedron.
|
||||
// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
|
||||
float n_ = 0.142857142857; // 1.0/7.0
|
||||
vec3 ns = n_ * D.wyz - D.xzx;
|
||||
|
||||
vec4 j = p - 49.0 * floor(p * ns.z * ns.z); // mod(p,7*7)
|
||||
|
||||
vec4 x_ = floor(j * ns.z);
|
||||
vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N)
|
||||
|
||||
vec4 x = x_ *ns.x + ns.yyyy;
|
||||
vec4 y = y_ *ns.x + ns.yyyy;
|
||||
vec4 h = 1.0 - abs(x) - abs(y);
|
||||
|
||||
vec4 b0 = vec4( x.xy, y.xy );
|
||||
vec4 b1 = vec4( x.zw, y.zw );
|
||||
|
||||
//vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
|
||||
//vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
|
||||
vec4 s0 = floor(b0)*2.0 + 1.0;
|
||||
vec4 s1 = floor(b1)*2.0 + 1.0;
|
||||
vec4 sh = -step(h, vec4(0.0));
|
||||
|
||||
vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
|
||||
vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
|
||||
|
||||
vec3 p0 = vec3(a0.xy,h.x);
|
||||
vec3 p1 = vec3(a0.zw,h.y);
|
||||
vec3 p2 = vec3(a1.xy,h.z);
|
||||
vec3 p3 = vec3(a1.zw,h.w);
|
||||
|
||||
//Normalise gradients
|
||||
vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
|
||||
p0 *= norm.x;
|
||||
p1 *= norm.y;
|
||||
p2 *= norm.z;
|
||||
p3 *= norm.w;
|
||||
|
||||
// Mix final noise value
|
||||
vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
|
||||
m = m * m;
|
||||
return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),
|
||||
dot(p2,x2), dot(p3,x3) ) );
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Main
|
||||
float fbm(vec3 p)
|
||||
{
|
||||
float final = snoise(p);
|
||||
p *= 1.94; final += snoise(p) * 0.5;
|
||||
#ifdef DETAILED_NOISE
|
||||
p *= 3.75; final += snoise(p) * 0.25;
|
||||
return final / 1.75;
|
||||
#else
|
||||
return final / 1.5;
|
||||
#endif
|
||||
}
|
||||
|
||||
float waterHeight(vec3 p)
|
||||
{
|
||||
float d = length(p.xz);
|
||||
float h = sin(d * 1.5 + iGlobalTime * 3.0) * 12.0 / d; // Island waves
|
||||
#ifdef SMALL_WAVES
|
||||
h += fbm(p*0.5); // Other waves
|
||||
#endif
|
||||
return h;
|
||||
}
|
||||
|
||||
vec3 bump(vec3 pos, vec3 rayDir)
|
||||
{
|
||||
float s = 2.0;
|
||||
|
||||
// Fade out waves to reduce aliasing
|
||||
float dist = dot(pos, rayDir);
|
||||
s *= dist < 2.0 ? 1.0 : 1.4142 / sqrt(dist);
|
||||
|
||||
// Calculate normal from heightmap
|
||||
vec2 e = vec2(1e-2, 0.0);
|
||||
vec3 p = vec3(pos.x, iGlobalTime*0.5, pos.z)*0.7;
|
||||
float m = waterHeight(p)*s;
|
||||
return normalize(vec3(
|
||||
waterHeight(p+e.xyy)*s-m,
|
||||
1.0,
|
||||
waterHeight(p+e.yxy)*s-m
|
||||
));
|
||||
}
|
||||
|
||||
// Ray intersections
|
||||
vec4 intersectSphere(vec3 rpos, vec3 rdir, vec3 pos, float rad)
|
||||
{
|
||||
vec3 op = pos - rpos;
|
||||
float b = dot(op, rdir);
|
||||
float det = b*b - dot(op, op) + rad*rad;
|
||||
|
||||
if (det > 0.0)
|
||||
{
|
||||
det = sqrt(det);
|
||||
float t = b - det;
|
||||
if (t > eps)
|
||||
return vec4(-normalize(rpos+rdir*t-pos), t);
|
||||
}
|
||||
|
||||
return vec4(0.0);
|
||||
}
|
||||
|
||||
vec4 intersectCylinder(vec3 rpos, vec3 rdir, vec3 pos, float rad)
|
||||
{
|
||||
vec3 op = pos - rpos;
|
||||
vec2 rdir2 = normalize(rdir.yz);
|
||||
float b = dot(op.yz, rdir2);
|
||||
float det = b*b - dot(op.yz, op.yz) + rad*rad;
|
||||
|
||||
if (det > 0.0)
|
||||
{
|
||||
det = sqrt(det);
|
||||
float t = b - det;
|
||||
if (t > eps)
|
||||
return vec4(-normalize(rpos.yz+rdir2*t-pos.yz), 0.0, t);
|
||||
t = b + det;
|
||||
if (t > eps)
|
||||
return vec4(-normalize(rpos.yz+rdir2*t-pos.yz), 0.0, t);
|
||||
}
|
||||
|
||||
return vec4(0.0);
|
||||
}
|
||||
|
||||
vec4 intersectPlane(vec3 rayPos, vec3 rayDir, vec3 n, float d)
|
||||
{
|
||||
float t = -(dot(rayPos, n) + d) / dot(rayDir, n);
|
||||
return vec4(n * sign(dot(rayDir, n)), t);
|
||||
}
|
||||
|
||||
// Helper functions
|
||||
vec3 rotate(vec3 p, float theta)
|
||||
{
|
||||
float c = cos(theta), s = sin(theta);
|
||||
return vec3(p.x * c + p.z * s, p.y,
|
||||
p.z * c - p.x * s);
|
||||
}
|
||||
|
||||
float impulse(float k, float x) // by iq
|
||||
{
|
||||
float h = k*x;
|
||||
return h * exp(1.0 - h);
|
||||
}
|
||||
|
||||
// Raymarched parts of scene
|
||||
float grass(vec3 pos)
|
||||
{
|
||||
float h = length(pos - vec3(0.0, -7.0, 0.0)) - 8.0;
|
||||
|
||||
if (h > 2.0) return h; // Optimization (Avoid noise if too far away)
|
||||
|
||||
return h + snoise(pos * 3.0) * 0.1 + pos.y * 0.9;
|
||||
}
|
||||
|
||||
float tree(vec3 pos)
|
||||
{
|
||||
pos.y -= 0.5;
|
||||
float s = sin(pos.y*0.03);
|
||||
float c = cos(pos.y*0.03);
|
||||
mat2 m = mat2(c, -s, s, c);
|
||||
vec3 p = vec3(m*pos.xy, pos.z);
|
||||
|
||||
float width = 1.0 - pos.y * 0.02 - clamp(sin(pos.y * 8.0) * 0.1, 0.05, 0.1);
|
||||
|
||||
return max(length(p.xz) - width, pos.y - 12.5);
|
||||
}
|
||||
|
||||
vec2 scene(vec3 pos)
|
||||
{
|
||||
float vtree = tree(pos);
|
||||
#ifdef GRASS
|
||||
float vgrass = grass(pos);
|
||||
float v = min(vtree, vgrass);
|
||||
#else
|
||||
float v = vtree;
|
||||
#endif
|
||||
return vec2(v, v == vtree ? 2.0 : 1.0);
|
||||
}
|
||||
|
||||
vec3 normal(vec3 pos)
|
||||
{
|
||||
vec2 eps = vec2(1e-3, 0.0);
|
||||
float h = scene(pos).x;
|
||||
return normalize(vec3(
|
||||
scene(pos-eps.xyy).x-h,
|
||||
scene(pos-eps.yxy).x-h,
|
||||
scene(pos-eps.yyx).x-h
|
||||
));
|
||||
}
|
||||
|
||||
float plantsShadow(vec3 rayPos, vec3 rayDir)
|
||||
{
|
||||
// Soft shadow taken from iq
|
||||
float k = 6.0;
|
||||
float t = 0.0;
|
||||
float s = 1.0;
|
||||
for (int i = 0; i < 30; i++)
|
||||
{
|
||||
vec3 pos = rayPos+rayDir*t;
|
||||
vec2 res = scene(pos);
|
||||
if (res.x < 0.001) return 0.0;
|
||||
s = min(s, k*res.x/t);
|
||||
t += max(res.x, 0.01);
|
||||
}
|
||||
|
||||
return s*s*(3.0 - 2.0*s);
|
||||
}
|
||||
|
||||
// Ray-traced parts of scene
|
||||
vec4 intersectWater(vec3 rayPos, vec3 rayDir)
|
||||
{
|
||||
float h = sin(20.5 + iGlobalTime * 2.0) * 0.03;
|
||||
float t = -(rayPos.y + 2.5 + h) / rayDir.y;
|
||||
return vec4(0.0, 1.0, 0.0, t);
|
||||
}
|
||||
|
||||
vec4 intersectSand(vec3 rayPos, vec3 rayDir)
|
||||
{
|
||||
return intersectSphere(rayPos, rayDir, vec3(0.0,-24.1,0.0), 24.1);
|
||||
}
|
||||
|
||||
vec4 intersectTreasure(vec3 rayPos, vec3 rayDir)
|
||||
{
|
||||
return vec4(0.0);
|
||||
}
|
||||
|
||||
vec4 intersectLeaf(vec3 rayPos, vec3 rayDir, float openAmount)
|
||||
{
|
||||
vec3 dir = normalize(vec3(0.0, 1.0, openAmount));
|
||||
float offset = 0.0;
|
||||
|
||||
vec4 res = intersectPlane(rayPos, rayDir, dir, 0.0);
|
||||
vec3 pos = rayPos+rayDir*res.w;
|
||||
#ifdef RAGGED_LEAVES
|
||||
offset = snoise(pos*0.8) * 0.3;
|
||||
#endif
|
||||
if (pos.y > 0.0 || length(pos * vec3(0.9, 2.0, 1.0)) > 4.0 - offset) res.w = 0.0;
|
||||
|
||||
vec4 res2 = intersectPlane(rayPos, rayDir, vec3(dir.xy, -dir.z), 0.0);
|
||||
pos = rayPos+rayDir*res2.w;
|
||||
#ifdef RAGGED_LEAVES
|
||||
offset = snoise(pos*0.8) * 0.3;
|
||||
#endif
|
||||
if (pos.y > 0.0 || length(pos * vec3(0.9, 2.0, 1.0)) > 4.0 - offset) res2.w = 0.0;
|
||||
|
||||
if (res2.w > 0.0 && res2.w < res.w || res.w <= 0.0)
|
||||
res = res2;
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
vec4 leaves(vec3 rayPos, vec3 rayDir)
|
||||
{
|
||||
float t = 1e20;
|
||||
vec3 n = vec3(0.0);
|
||||
|
||||
rayPos -= leavesPos;
|
||||
|
||||
float sway = impulse(15.0, fract(iGlobalTime / PI * 0.125));
|
||||
float upDownSway = sway * -sin(iGlobalTime) * 0.06;
|
||||
float openAmount = sway * max(-cos(iGlobalTime) * 0.4, 0.0);
|
||||
|
||||
float angleOffset = -0.1;
|
||||
for (float k = 0.0; k < 6.2; k += 0.75)
|
||||
{
|
||||
// Left-right
|
||||
float alpha = k + (k - PI) * sway * 0.015;
|
||||
vec3 p = rotate(rayPos, alpha);
|
||||
vec3 d = rotate(rayDir, alpha);
|
||||
|
||||
// Up-down
|
||||
angleOffset *= -1.0;
|
||||
float theta = -0.4 +
|
||||
angleOffset +
|
||||
cos(k) * 0.35 +
|
||||
upDownSway +
|
||||
sin(iGlobalTime+k*10.0) * 0.03 * (sway + 0.2);
|
||||
|
||||
p = rotate(p.xzy, theta).xzy;
|
||||
d = rotate(d.xzy, theta).xzy;
|
||||
|
||||
// Shift
|
||||
p -= vec3(5.4, 0.0, 0.0);
|
||||
|
||||
// Intersect individual leaf
|
||||
vec4 res = intersectLeaf(p, d, 1.0+openAmount);
|
||||
if (res.w > 0.0 && res.w < t)
|
||||
{
|
||||
t = res.w;
|
||||
n = res.xyz;
|
||||
}
|
||||
}
|
||||
|
||||
return vec4(n, t);
|
||||
}
|
||||
|
||||
// Lighting
|
||||
float shadow(vec3 rayPos, vec3 rayDir)
|
||||
{
|
||||
float s = 1.0;
|
||||
|
||||
// Intersect sand
|
||||
//vec4 resSand = intersectSand(rayPos, rayDir);
|
||||
//if (resSand.w > 0.0) return 0.0;
|
||||
|
||||
// Intersect plants
|
||||
s = min(s, plantsShadow(rayPos, rayDir));
|
||||
if (s < 0.0001) return 0.0;
|
||||
|
||||
// Intersect leaves
|
||||
vec4 resLeaves = leaves(rayPos, rayDir);
|
||||
if (resLeaves.w > 0.0 && resLeaves.w < 1e7) return 0.0;
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
vec3 light(vec3 p, vec3 n)
|
||||
{
|
||||
float s = 1.0;
|
||||
|
||||
#ifdef SHADOWS
|
||||
s = shadow(p-sunDir*0.01, -sunDir);
|
||||
#endif
|
||||
|
||||
vec3 col = sunCol * min(max(dot(n, sunDir), 0.0), s);
|
||||
col += skyCol * (-n.y * 0.5 + 0.5) * 0.3;
|
||||
return col;
|
||||
}
|
||||
|
||||
vec3 lightLeaves(vec3 p, vec3 n)
|
||||
{
|
||||
float s = 1.0;
|
||||
|
||||
#ifdef SHADOWS
|
||||
s = shadow(p-sunDir*0.01, -sunDir);
|
||||
#endif
|
||||
|
||||
float ao = min(length(p - leavesPos) * 0.1, 1.0);
|
||||
|
||||
float ns = dot(n, sunDir);
|
||||
float d = sqrt(max(ns, 0.0));
|
||||
vec3 col = sunCol * min(d, s);
|
||||
col += sunCol * max(-ns, 0.0) * vec3(0.3, 0.3, 0.1) * ao;
|
||||
col += skyCol * (-n.y * 0.5 + 0.5) * 0.3 * ao;
|
||||
return col;
|
||||
}
|
||||
|
||||
vec3 sky(vec3 n)
|
||||
{
|
||||
return skyCol * (1.0 - n.y * 0.8);
|
||||
}
|
||||
|
||||
// Ray-marching
|
||||
vec4 plants(vec3 rayPos, vec3 rayDir)
|
||||
{
|
||||
float t = 0.0;
|
||||
|
||||
for (int i = 0; i < 40; i++)
|
||||
{
|
||||
vec3 pos = rayPos+rayDir*t;
|
||||
vec2 res = scene(pos);
|
||||
float h = res.x;
|
||||
|
||||
if (h < 0.001)
|
||||
{
|
||||
vec3 col = res.y == 2.0 ? treeCol : grassCol;
|
||||
float uvFact = res.y == 2.0 ? 1.0 : 10.0;
|
||||
|
||||
vec3 n = normal(pos);
|
||||
vec2 uv = vec2(n.x, pos.y * 0.5) * 0.2 * uvFact;
|
||||
vec3 tex = texture2D(iChannel0, uv).rgb * 0.6 + 0.4;
|
||||
float ao = min(length(pos - leavesPos) * 0.1, 1.0);
|
||||
return vec4(col * light(pos, n) * ao * tex, t);
|
||||
}
|
||||
|
||||
t += h;
|
||||
}
|
||||
|
||||
return vec4(sky(rayDir), 1e8);
|
||||
}
|
||||
|
||||
// Final combination
|
||||
vec3 traceReflection(vec3 rayPos, vec3 rayDir)
|
||||
{
|
||||
vec3 col = vec3(0.0);
|
||||
float t = 1e20;
|
||||
|
||||
// Intersect plants
|
||||
vec4 resPlants = plants(rayPos, rayDir);
|
||||
if (resPlants.w > 0.0 && resPlants.w < t)
|
||||
{
|
||||
t = resPlants.w;
|
||||
col = resPlants.xyz;
|
||||
}
|
||||
|
||||
// Intersect leaves
|
||||
vec4 resLeaves = leaves(rayPos, rayDir);
|
||||
if (resLeaves.w > 0.0 && resLeaves.w < t)
|
||||
{
|
||||
vec3 pos = rayPos + rayDir * resLeaves.w;
|
||||
vec2 uv = (pos.xz - leavesPos.xz) * 0.3;
|
||||
float tex = texture2D(iChannel0, uv).r * 0.6 + 0.5;
|
||||
|
||||
t = resLeaves.w;
|
||||
col = leavesCol * lightLeaves(pos, resLeaves.xyz) * tex;
|
||||
}
|
||||
|
||||
if (t > 1e7) return sky(rayDir);
|
||||
|
||||
return col;
|
||||
}
|
||||
|
||||
vec3 trace(vec3 rayPos, vec3 rayDir)
|
||||
{
|
||||
vec3 col = vec3(0.0);
|
||||
float t = 1e20;
|
||||
|
||||
// Intersect sand
|
||||
vec4 resSand = intersectSand(rayPos, rayDir);
|
||||
if (resSand.w > 0.0)
|
||||
{
|
||||
vec3 pos = rayPos + rayDir * resSand.w;
|
||||
t = resSand.w;
|
||||
|
||||
col = sandCol * light(pos, resSand.xyz);
|
||||
}
|
||||
|
||||
// Intersect treasure chest
|
||||
vec4 resTreasure = intersectTreasure(rayPos, rayDir);
|
||||
if (resTreasure.w > 0.0 && resTreasure.w < t)
|
||||
{
|
||||
vec3 pos = rayPos + rayDir * resTreasure.w;
|
||||
t = resTreasure.w;
|
||||
col = leavesCol * light(pos, resTreasure.xyz);
|
||||
}
|
||||
|
||||
// Intersect leaves
|
||||
vec4 resLeaves = leaves(rayPos, rayDir);
|
||||
if (resLeaves.w > 0.0 && resLeaves.w < t)
|
||||
{
|
||||
vec3 pos = rayPos + rayDir * resLeaves.w;
|
||||
vec2 uv = (pos.xz - leavesPos.xz) * 0.3;
|
||||
float tex = texture2D(iChannel0, uv).r * 0.6 + 0.5;
|
||||
|
||||
t = resLeaves.w;
|
||||
col = leavesCol * lightLeaves(pos, resLeaves.xyz) * tex;
|
||||
}
|
||||
|
||||
// Intersect plants
|
||||
vec4 resPlants = plants(rayPos, rayDir);
|
||||
if (resPlants.w > 0.0 && resPlants.w < t)
|
||||
{
|
||||
t = resPlants.w;
|
||||
col = resPlants.xyz;
|
||||
}
|
||||
|
||||
// Intersect water
|
||||
vec4 resWater = intersectWater(rayPos, rayDir);
|
||||
if (resWater.w > 0.0 && resWater.w < t)
|
||||
{
|
||||
vec3 pos = rayPos + rayDir * resWater.w;
|
||||
float dist = t - resWater.w;
|
||||
vec3 n = bump(pos, rayDir);
|
||||
|
||||
float ct = -min(dot(n,rayDir), 0.0);
|
||||
float fresnel = 0.9 - 0.9 * pow(1.0 - ct, 5.0);
|
||||
|
||||
vec3 trans = col * exp(-dist * vec3(1.0, 0.7, 0.4) * 3.0);
|
||||
vec3 reflDir = normalize(reflect(rayDir, n));
|
||||
vec3 refl = sky(reflDir);
|
||||
|
||||
#ifdef REFLECTIONS
|
||||
if (dot(pos, rayDir) < -2.0)
|
||||
refl = traceReflection(pos, reflDir).rgb;
|
||||
#endif
|
||||
|
||||
t = resWater.t;
|
||||
col = mix(refl, trans, fresnel);
|
||||
}
|
||||
|
||||
if (t > 1e7) return sky(rayDir);
|
||||
|
||||
return col;
|
||||
}
|
||||
|
||||
// Ray-generation
|
||||
vec3 camera(vec2 px)
|
||||
{
|
||||
vec2 rd = (px / iResolution.yy - vec2(iResolution.x/iResolution.y*0.5-0.5, 0.0)) * 2.0 - 1.0;
|
||||
float t = sin(iGlobalTime * 0.1) * 0.2;
|
||||
vec3 rayDir = normalize(vec3(rd.x, rd.y, 1.0));
|
||||
vec3 rayPos = vec3(0.0, 3.0, -18.0);
|
||||
return trace(rayPos, rayDir);
|
||||
}
|
||||
|
||||
void main(void)
|
||||
{
|
||||
#ifdef HEAVY_AA
|
||||
vec3 col = camera(gl_FragCoord.xy+vec2(0.0,0.5))*0.25;
|
||||
col += camera(gl_FragCoord.xy+vec2(0.25,0.0))*0.25;
|
||||
col += camera(gl_FragCoord.xy+vec2(0.5,0.75))*0.25;
|
||||
col += camera(gl_FragCoord.xy+vec2(0.75,0.25))*0.25;
|
||||
#else
|
||||
vec3 col = camera(gl_FragCoord.xy);
|
||||
#ifdef LIGHT_AA
|
||||
col = col * 0.5 + camera(gl_FragCoord.xy+vec2(0.5,0.5))*0.5;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef TONEMAP
|
||||
// Optimized Haarm-Peter Duiker’s curve
|
||||
vec3 x = max(vec3(0.0),col*exposure-0.004);
|
||||
col = (x*(6.2*x+.5))/(x*(6.2*x+1.7)+0.06);
|
||||
#else
|
||||
col = pow(col, vec3(0.4545));
|
||||
#endif
|
||||
|
||||
gl_FragColor = vec4(col, 1.0);
|
||||
}
|
||||
95
samples/ShaderLab/DepthOfField.shader
Normal file
95
samples/ShaderLab/DepthOfField.shader
Normal file
@@ -0,0 +1,95 @@
|
||||
// From https://github.com/Unity-Technologies/PostProcessing,
|
||||
// licensed under MIT licence.
|
||||
|
||||
Shader "Hidden/Post FX/Depth Of Field"
|
||||
{
|
||||
Properties
|
||||
{
|
||||
_MainTex ("", 2D) = "black"
|
||||
}
|
||||
|
||||
CGINCLUDE
|
||||
#pragma exclude_renderers d3d11_9x
|
||||
#pragma target 3.0
|
||||
ENDCG
|
||||
|
||||
SubShader
|
||||
{
|
||||
Cull Off ZWrite Off ZTest Always
|
||||
|
||||
// (0) Downsampling, prefiltering & CoC
|
||||
Pass
|
||||
{
|
||||
CGPROGRAM
|
||||
#pragma multi_compile __ UNITY_COLORSPACE_GAMMA
|
||||
#pragma vertex VertDOF
|
||||
#pragma fragment FragPrefilter
|
||||
#include "DepthOfField.cginc"
|
||||
ENDCG
|
||||
}
|
||||
|
||||
// (1) Pass 0 + temporal antialiasing
|
||||
Pass
|
||||
{
|
||||
CGPROGRAM
|
||||
#pragma vertex VertDOF
|
||||
#pragma fragment FragPrefilter
|
||||
#define PREFILTER_TAA
|
||||
#include "DepthOfField.cginc"
|
||||
ENDCG
|
||||
}
|
||||
|
||||
// (2-5) Bokeh filter with disk-shaped kernels
|
||||
Pass
|
||||
{
|
||||
CGPROGRAM
|
||||
#pragma vertex VertDOF
|
||||
#pragma fragment FragBlur
|
||||
#define KERNEL_SMALL
|
||||
#include "DepthOfField.cginc"
|
||||
ENDCG
|
||||
}
|
||||
|
||||
Pass
|
||||
{
|
||||
CGPROGRAM
|
||||
#pragma vertex VertDOF
|
||||
#pragma fragment FragBlur
|
||||
#define KERNEL_MEDIUM
|
||||
#include "DepthOfField.cginc"
|
||||
ENDCG
|
||||
}
|
||||
|
||||
Pass
|
||||
{
|
||||
CGPROGRAM
|
||||
#pragma vertex VertDOF
|
||||
#pragma fragment FragBlur
|
||||
#define KERNEL_LARGE
|
||||
#include "DepthOfField.cginc"
|
||||
ENDCG
|
||||
}
|
||||
|
||||
Pass
|
||||
{
|
||||
CGPROGRAM
|
||||
#pragma vertex VertDOF
|
||||
#pragma fragment FragBlur
|
||||
#define KERNEL_VERYLARGE
|
||||
#include "DepthOfField.cginc"
|
||||
ENDCG
|
||||
}
|
||||
|
||||
// (6) Postfilter blur
|
||||
Pass
|
||||
{
|
||||
CGPROGRAM
|
||||
#pragma vertex VertDOF
|
||||
#pragma fragment FragPostBlur
|
||||
#include "DepthOfField.cginc"
|
||||
ENDCG
|
||||
}
|
||||
}
|
||||
|
||||
FallBack Off
|
||||
}
|
||||
112
samples/ShaderLab/Fog.shader
Normal file
112
samples/ShaderLab/Fog.shader
Normal file
@@ -0,0 +1,112 @@
|
||||
// From https://github.com/Unity-Technologies/PostProcessing,
|
||||
// licensed under MIT licence.
|
||||
|
||||
Shader "Hidden/Post FX/Fog"
|
||||
{
|
||||
Properties
|
||||
{
|
||||
_MainTex("Main Texture", 2D) = "white" {}
|
||||
}
|
||||
|
||||
CGINCLUDE
|
||||
|
||||
#pragma multi_compile __ FOG_LINEAR FOG_EXP FOG_EXP2
|
||||
#include "UnityCG.cginc"
|
||||
#include "Common.cginc"
|
||||
|
||||
#define SKYBOX_THREASHOLD_VALUE 0.9999
|
||||
|
||||
struct Varyings
|
||||
{
|
||||
float2 uv : TEXCOORD0;
|
||||
float4 vertex : SV_POSITION;
|
||||
};
|
||||
|
||||
Varyings VertFog(AttributesDefault v)
|
||||
{
|
||||
Varyings o;
|
||||
o.vertex = UnityObjectToClipPos(v.vertex);
|
||||
o.uv = UnityStereoScreenSpaceUVAdjust(v.texcoord, _MainTex_ST);
|
||||
return o;
|
||||
}
|
||||
|
||||
sampler2D _CameraDepthTexture;
|
||||
|
||||
half4 _FogColor;
|
||||
float _Density;
|
||||
float _Start;
|
||||
float _End;
|
||||
|
||||
half ComputeFog(float z)
|
||||
{
|
||||
half fog = 0.0;
|
||||
#if FOG_LINEAR
|
||||
fog = (_End - z) / (_End - _Start);
|
||||
#elif FOG_EXP
|
||||
fog = exp2(-_Density * z);
|
||||
#else // FOG_EXP2
|
||||
fog = _Density * z;
|
||||
fog = exp2(-fog * fog);
|
||||
#endif
|
||||
return saturate(fog);
|
||||
}
|
||||
|
||||
float ComputeDistance(float depth)
|
||||
{
|
||||
float dist = depth * _ProjectionParams.z;
|
||||
dist -= _ProjectionParams.y;
|
||||
return dist;
|
||||
}
|
||||
|
||||
half4 FragFog(Varyings i) : SV_Target
|
||||
{
|
||||
half4 color = tex2D(_MainTex, i.uv);
|
||||
|
||||
float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv);
|
||||
depth = Linear01Depth(depth);
|
||||
float dist = ComputeDistance(depth) - _Start;
|
||||
half fog = 1.0 - ComputeFog(dist);
|
||||
|
||||
return lerp(color, _FogColor, fog);
|
||||
}
|
||||
|
||||
half4 FragFogExcludeSkybox(Varyings i) : SV_Target
|
||||
{
|
||||
half4 color = tex2D(_MainTex, i.uv);
|
||||
|
||||
float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv);
|
||||
depth = Linear01Depth(depth);
|
||||
float skybox = depth < SKYBOX_THREASHOLD_VALUE;
|
||||
float dist = ComputeDistance(depth) - _Start;
|
||||
half fog = 1.0 - ComputeFog(dist);
|
||||
|
||||
return lerp(color, _FogColor, fog * skybox);
|
||||
}
|
||||
|
||||
ENDCG
|
||||
|
||||
SubShader
|
||||
{
|
||||
Cull Off ZWrite Off ZTest Always
|
||||
|
||||
Pass
|
||||
{
|
||||
CGPROGRAM
|
||||
|
||||
#pragma vertex VertFog
|
||||
#pragma fragment FragFog
|
||||
|
||||
ENDCG
|
||||
}
|
||||
|
||||
Pass
|
||||
{
|
||||
CGPROGRAM
|
||||
|
||||
#pragma vertex VertFog
|
||||
#pragma fragment FragFogExcludeSkybox
|
||||
|
||||
ENDCG
|
||||
}
|
||||
}
|
||||
}
|
||||
337
samples/ShaderLab/Uber.shader
Normal file
337
samples/ShaderLab/Uber.shader
Normal file
@@ -0,0 +1,337 @@
|
||||
// From https://github.com/Unity-Technologies/PostProcessing,
|
||||
// licensed under MIT licence.
|
||||
|
||||
Shader "Hidden/Post FX/Uber Shader"
|
||||
{
|
||||
Properties
|
||||
{
|
||||
_MainTex ("Texture", 2D) = "white" {}
|
||||
_AutoExposure ("", 2D) = "" {}
|
||||
_BloomTex ("", 2D) = "" {}
|
||||
_Bloom_DirtTex ("", 2D) = "" {}
|
||||
_GrainTex ("", 2D) = "" {}
|
||||
_LogLut ("", 2D) = "" {}
|
||||
_UserLut ("", 2D) = "" {}
|
||||
_Vignette_Mask ("", 2D) = "" {}
|
||||
_ChromaticAberration_Spectrum ("", 2D) = "" {}
|
||||
_DitheringTex ("", 2D) = "" {}
|
||||
}
|
||||
|
||||
CGINCLUDE
|
||||
|
||||
#pragma target 3.0
|
||||
|
||||
#pragma multi_compile __ UNITY_COLORSPACE_GAMMA
|
||||
#pragma multi_compile __ EYE_ADAPTATION
|
||||
#pragma multi_compile __ CHROMATIC_ABERRATION
|
||||
#pragma multi_compile __ DEPTH_OF_FIELD DEPTH_OF_FIELD_COC_VIEW
|
||||
#pragma multi_compile __ BLOOM
|
||||
#pragma multi_compile __ BLOOM_LENS_DIRT
|
||||
#pragma multi_compile __ COLOR_GRADING COLOR_GRADING_LOG_VIEW
|
||||
#pragma multi_compile __ USER_LUT
|
||||
#pragma multi_compile __ GRAIN
|
||||
#pragma multi_compile __ VIGNETTE_CLASSIC VIGNETTE_ROUND VIGNETTE_MASKED
|
||||
#pragma multi_compile __ DITHERING
|
||||
|
||||
#include "UnityCG.cginc"
|
||||
#include "Bloom.cginc"
|
||||
#include "ColorGrading.cginc"
|
||||
#include "UberSecondPass.cginc"
|
||||
|
||||
// Auto exposure / eye adaptation
|
||||
sampler2D _AutoExposure;
|
||||
|
||||
// Chromatic aberration
|
||||
half _ChromaticAberration_Amount;
|
||||
sampler2D _ChromaticAberration_Spectrum;
|
||||
|
||||
// Depth of field
|
||||
sampler2D_float _CameraDepthTexture;
|
||||
sampler2D _DepthOfFieldTex;
|
||||
float4 _DepthOfFieldTex_TexelSize;
|
||||
float2 _DepthOfFieldParams; // x: distance, y: f^2 / (N * (S1 - f) * film_width * 2)
|
||||
|
||||
// Bloom
|
||||
sampler2D _BloomTex;
|
||||
float4 _BloomTex_TexelSize;
|
||||
half2 _Bloom_Settings; // x: sampleScale, y: bloom.intensity
|
||||
|
||||
sampler2D _Bloom_DirtTex;
|
||||
half _Bloom_DirtIntensity;
|
||||
|
||||
// Color grading & tonemapping
|
||||
sampler2D _LogLut;
|
||||
half3 _LogLut_Params; // x: 1 / lut_width, y: 1 / lut_height, z: lut_height - 1
|
||||
half _ExposureEV; // EV (exp2)
|
||||
|
||||
// User lut
|
||||
sampler2D _UserLut;
|
||||
half4 _UserLut_Params; // @see _LogLut_Params
|
||||
|
||||
// Vignette
|
||||
half3 _Vignette_Color;
|
||||
half2 _Vignette_Center; // UV space
|
||||
half3 _Vignette_Settings; // x: intensity, y: smoothness, z: roundness
|
||||
sampler2D _Vignette_Mask;
|
||||
half _Vignette_Opacity; // [0;1]
|
||||
|
||||
struct VaryingsFlipped
|
||||
{
|
||||
float4 pos : SV_POSITION;
|
||||
float2 uv : TEXCOORD0;
|
||||
float2 uvSPR : TEXCOORD1; // Single Pass Stereo UVs
|
||||
float2 uvFlipped : TEXCOORD2; // Flipped UVs (DX/MSAA/Forward)
|
||||
float2 uvFlippedSPR : TEXCOORD3; // Single Pass Stereo flipped UVs
|
||||
};
|
||||
|
||||
VaryingsFlipped VertUber(AttributesDefault v)
|
||||
{
|
||||
VaryingsFlipped o;
|
||||
o.pos = UnityObjectToClipPos(v.vertex);
|
||||
o.uv = v.texcoord.xy;
|
||||
o.uvSPR = UnityStereoScreenSpaceUVAdjust(v.texcoord.xy, _MainTex_ST);
|
||||
o.uvFlipped = v.texcoord.xy;
|
||||
|
||||
#if UNITY_UV_STARTS_AT_TOP
|
||||
if (_MainTex_TexelSize.y < 0.0)
|
||||
o.uvFlipped.y = 1.0 - o.uvFlipped.y;
|
||||
#endif
|
||||
|
||||
o.uvFlippedSPR = UnityStereoScreenSpaceUVAdjust(o.uvFlipped, _MainTex_ST);
|
||||
|
||||
return o;
|
||||
}
|
||||
|
||||
half4 FragUber(VaryingsFlipped i) : SV_Target
|
||||
{
|
||||
float2 uv = i.uv;
|
||||
half autoExposure = 1.0;
|
||||
|
||||
// Store the auto exposure value for later
|
||||
#if EYE_ADAPTATION
|
||||
{
|
||||
autoExposure = tex2D(_AutoExposure, uv).r;
|
||||
}
|
||||
#endif
|
||||
|
||||
half3 color = (0.0).xxx;
|
||||
#if DEPTH_OF_FIELD && CHROMATIC_ABERRATION
|
||||
half4 dof = (0.0).xxxx;
|
||||
#endif
|
||||
|
||||
//
|
||||
// HDR effects
|
||||
// ---------------------------------------------------------
|
||||
|
||||
// Chromatic Aberration
|
||||
// Inspired by the method described in "Rendering Inside" [Playdead 2016]
|
||||
// https://twitter.com/pixelmager/status/717019757766123520
|
||||
#if CHROMATIC_ABERRATION
|
||||
{
|
||||
float2 coords = 2.0 * uv - 1.0;
|
||||
float2 end = uv - coords * dot(coords, coords) * _ChromaticAberration_Amount;
|
||||
|
||||
float2 diff = end - uv;
|
||||
int samples = clamp(int(length(_MainTex_TexelSize.zw * diff / 2.0)), 3, 16);
|
||||
float2 delta = diff / samples;
|
||||
float2 pos = uv;
|
||||
half3 sum = (0.0).xxx, filterSum = (0.0).xxx;
|
||||
|
||||
#if DEPTH_OF_FIELD
|
||||
float2 dofDelta = delta;
|
||||
float2 dofPos = pos;
|
||||
if (_MainTex_TexelSize.y < 0.0)
|
||||
{
|
||||
dofDelta.y = -dofDelta.y;
|
||||
dofPos.y = 1.0 - dofPos.y;
|
||||
}
|
||||
half4 dofSum = (0.0).xxxx;
|
||||
#endif
|
||||
|
||||
for (int i = 0; i < samples; i++)
|
||||
{
|
||||
half t = (i + 0.5) / samples;
|
||||
half3 s = tex2Dlod(_MainTex, float4(UnityStereoScreenSpaceUVAdjust(pos, _MainTex_ST), 0, 0)).rgb;
|
||||
half3 filter = tex2Dlod(_ChromaticAberration_Spectrum, float4(t, 0, 0, 0)).rgb;
|
||||
|
||||
sum += s * filter;
|
||||
filterSum += filter;
|
||||
pos += delta;
|
||||
|
||||
#if DEPTH_OF_FIELD
|
||||
half4 sdof = tex2Dlod(_DepthOfFieldTex, float4(UnityStereoScreenSpaceUVAdjust(dofPos, _MainTex_ST), 0, 0)).rgba;
|
||||
dofSum += sdof * half4(filter, 1);
|
||||
dofPos += dofDelta;
|
||||
#endif
|
||||
}
|
||||
|
||||
color = sum / filterSum;
|
||||
#if DEPTH_OF_FIELD
|
||||
dof = dofSum / half4(filterSum, samples);
|
||||
#endif
|
||||
}
|
||||
#else
|
||||
{
|
||||
color = tex2D(_MainTex, i.uvSPR).rgb;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Apply auto exposure if any
|
||||
color *= autoExposure;
|
||||
|
||||
// Gamma space... Gah.
|
||||
#if UNITY_COLORSPACE_GAMMA
|
||||
{
|
||||
color = GammaToLinearSpace(color);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Depth of field
|
||||
#if DEPTH_OF_FIELD
|
||||
{
|
||||
#if !CHROMATIC_ABERRATION
|
||||
half4 dof = tex2D(_DepthOfFieldTex, i.uvFlippedSPR);
|
||||
#endif
|
||||
color = color * dof.a + dof.rgb * autoExposure;
|
||||
}
|
||||
#elif DEPTH_OF_FIELD_COC_VIEW
|
||||
{
|
||||
// Calculate the radiuses of CoC.
|
||||
half4 src = tex2D(_DepthOfFieldTex, uv);
|
||||
float depth = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uvFlippedSPR));
|
||||
float coc = (depth - _DepthOfFieldParams.x) * _DepthOfFieldParams.y / depth;
|
||||
coc *= 80;
|
||||
|
||||
// Visualize CoC (white -> red -> gray)
|
||||
half3 rgb = lerp(half3(1, 0, 0), half3(1.0, 1.0, 1.0), saturate(-coc));
|
||||
rgb = lerp(rgb, half3(0.4, 0.4, 0.4), saturate(coc));
|
||||
|
||||
// Black and white image overlay
|
||||
rgb *= AcesLuminance(color) + 0.5;
|
||||
|
||||
// Gamma correction
|
||||
#if !UNITY_COLORSPACE_GAMMA
|
||||
{
|
||||
rgb = GammaToLinearSpace(rgb);
|
||||
}
|
||||
#endif
|
||||
|
||||
color = rgb;
|
||||
}
|
||||
#endif
|
||||
|
||||
// HDR Bloom
|
||||
#if BLOOM
|
||||
{
|
||||
half3 bloom = UpsampleFilter(_BloomTex, i.uvFlippedSPR, _BloomTex_TexelSize.xy, _Bloom_Settings.x) * _Bloom_Settings.y;
|
||||
color += bloom;
|
||||
|
||||
#if BLOOM_LENS_DIRT
|
||||
{
|
||||
half3 dirt = tex2D(_Bloom_DirtTex, i.uvFlipped).rgb * _Bloom_DirtIntensity;
|
||||
color += bloom * dirt;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
// Procedural vignette
|
||||
#if VIGNETTE_CLASSIC
|
||||
{
|
||||
half2 d = abs(uv - _Vignette_Center) * _Vignette_Settings.x;
|
||||
d = pow(d, _Vignette_Settings.z); // Roundness
|
||||
half vfactor = pow(saturate(1.0 - dot(d, d)), _Vignette_Settings.y);
|
||||
color *= lerp(_Vignette_Color, (1.0).xxx, vfactor);
|
||||
}
|
||||
|
||||
// Perfectly round vignette
|
||||
#elif VIGNETTE_ROUND
|
||||
{
|
||||
half2 d = abs(uv - _Vignette_Center) * _Vignette_Settings.x;
|
||||
d.x *= _ScreenParams.x / _ScreenParams.y;
|
||||
half vfactor = pow(saturate(1.0 - dot(d, d)), _Vignette_Settings.y);
|
||||
color *= lerp(_Vignette_Color, (1.0).xxx, vfactor);
|
||||
}
|
||||
|
||||
// Masked vignette
|
||||
#elif VIGNETTE_MASKED
|
||||
{
|
||||
half vfactor = tex2D(_Vignette_Mask, uv).a;
|
||||
half3 new_color = color * lerp(_Vignette_Color, (1.0).xxx, vfactor);
|
||||
color = lerp(color, new_color, _Vignette_Opacity);
|
||||
}
|
||||
#endif
|
||||
|
||||
// HDR color grading & tonemapping
|
||||
#if COLOR_GRADING
|
||||
{
|
||||
color *= _ExposureEV; // Exposure is in ev units (or 'stops')
|
||||
|
||||
half3 colorLogC = saturate(LinearToLogC(color));
|
||||
color = ApplyLut2d(_LogLut, colorLogC, _LogLut_Params);
|
||||
}
|
||||
#elif COLOR_GRADING_LOG_VIEW
|
||||
{
|
||||
color *= _ExposureEV;
|
||||
color = saturate(LinearToLogC(color));
|
||||
}
|
||||
#endif
|
||||
|
||||
//
|
||||
// All the following effects happen in LDR
|
||||
// ---------------------------------------------------------
|
||||
|
||||
color = saturate(color);
|
||||
|
||||
// Back to gamma space if needed
|
||||
#if UNITY_COLORSPACE_GAMMA
|
||||
{
|
||||
color = LinearToGammaSpace(color);
|
||||
}
|
||||
#endif
|
||||
|
||||
// LDR user lut
|
||||
#if USER_LUT
|
||||
{
|
||||
color = saturate(color);
|
||||
half3 colorGraded;
|
||||
|
||||
#if !UNITY_COLORSPACE_GAMMA
|
||||
{
|
||||
colorGraded = ApplyLut2d(_UserLut, LinearToGammaSpace(color), _UserLut_Params.xyz);
|
||||
colorGraded = GammaToLinearSpace(colorGraded);
|
||||
}
|
||||
#else
|
||||
{
|
||||
colorGraded = ApplyLut2d(_UserLut, color, _UserLut_Params.xyz);
|
||||
}
|
||||
#endif
|
||||
|
||||
color = lerp(color, colorGraded, _UserLut_Params.w);
|
||||
}
|
||||
#endif
|
||||
|
||||
color = UberSecondPass(color, uv);
|
||||
|
||||
// Done !
|
||||
return half4(color, 1.0);
|
||||
}
|
||||
|
||||
ENDCG
|
||||
|
||||
SubShader
|
||||
{
|
||||
Cull Off ZWrite Off ZTest Always
|
||||
|
||||
// (0)
|
||||
Pass
|
||||
{
|
||||
CGPROGRAM
|
||||
|
||||
#pragma vertex VertUber
|
||||
#pragma fragment FragUber
|
||||
|
||||
ENDCG
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user