lucid-super-dream/Assets/Shaders/tunnel.shader

404 lines
15 KiB
GLSL

// This shader draws a texture on the mesh.
Shader "custom/tunnel"
{
// The _BaseMap variable is visible in the Material's Inspector, as a field
// called Base Map.
Properties
{
[HDR] _BackgroundColor("Background Color", Color) = (0,0,0,0)
[HDR] _NebulaColor1("Nebula Color 1", Color) = (1,1,1,1)
[HDR] _NebulaColor2("Nebula Color 2", Color) = (1,1,1,1)
[HDR] _FractalColor("Fractal Color", Color) = (1,1,1,1)
[HDR] _GroundColor("Ground Color", Color) = (1,1,1,1)
[HDR] _CoreColor("Core Color", Color) = (1,1,1,1)
[HDR] _BarsColor("Bars Color", Color) = (1,1,1,1)
[HDR] _StarsColor("Stars Color", Color) = (1,1,1,1)
[HDR] _CloudColor("Cloud Clolor", Color) = (0,0,0,0)
[HDR] _UiColor("UI Clolor", Color) = (1,1,1,1)
_SkyWeight("Sky Weight", Float) = 1.0
_FractalWeight("Fractal Weight", Range(0.0,1.0)) = 1.0
_BarsWeight("Bars Weight", Float) = 1.0
_StarsWeight("Stars Weight", Range(0.0,1.0)) = 1.0
_GroundWeight("Ground Weight", Float) = 1.0
_GroundMaskAngle("Ground Mask Angle", Float) = 1.0
_FractalScale("Fractal Scale", Float) = 6.0
_FractalRotateSpeed("Fractal Rotate Speed", Float) = 20.0
_FractalPower("Fractal Power", Float) = 1.0
_FractalInner("Fractal Inner", Float) = 0.2
_FractalFadeHeight("Fractal Fade Height", Float) = 0.25
_Nebula1Power("Nebula 1 Power", Float) = 1.0
_Nebula2Power("Nebula 2 Power", Float) = 1.0
_CoreRadius("Core Radius", Range(0, 1.0)) = 1.0
_CoreThiccness("Core Thiccness", Range(0,1.0)) = 1.0
_CoreYOffset("Core Offset", Float) = -4.0
_OuterCircleRadius("Outer Circle Radius", Range(0,10)) = 0.5
_OuterCircleThickness("Outer Circle Thickness", Range(0,1.0)) = 0.1
_Intensity("Intensity", Range(0,1.0)) = 1.0
_NebulaMap("Nebula Map", 2D) = "black"
_StarMap("Star Map", 2D) = "black"
_FractalMap("Fractal Map", 2D) = "black"
// _ShakeStrength("Shake Strength", Float) = 0.01
}
SubShader
{
Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalRenderPipeline" }
Pass
{
HLSLPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
struct Attributes
{
float4 positionOS : POSITION;
// The uv variable contains the UV coordinate on the texture for the
// given vertex.
float2 uv : TEXCOORD0;
};
struct Varyings
{
float4 positionHCS : SV_POSITION;
// The uv variable contains the UV coordinate on the texture for the
// given vertex.
float2 uv : TEXCOORD0;
};
float4 _BackgroundColor;
float4 _NebulaColor1;
float4 _NebulaColor2;
float4 _FractalColor;
float4 _GroundColor;
float4 _CoreColor;
float4 _BarsColor;
float4 _StarsColor;
float4 _CloudColor;
float4 _UiColor;
float _FractalScale = 6.0;
float _FractalRotateSpeed = 20.0;
float _FractalPower = 1.0;
float _FractalInner = 0.2;
float _FractalWeight = 1.0;
float _FractalFadeHeight = 0.25;
float _Nebula1Power = 1.0;
float _Nebula2Power = 1.0;
float _SkyWeight;
float _BarsWeight;
float _StarsWeight;
float _GroundWeight;
float _GroundMaskAngle;
// circles
float _CoreRadius;
float _CoreThiccness;
float _CoreYOffset;
float _OuterCircleRadius;
float _OuterCircleThickness;
float _Intensity;
float _CameraShake = 0.0;
float _DistanceToNextBeat;
float _DistanceSinceLastBeat;
float _PlayerXPos;
float _PlayerXMove;
float _TrackWidth = 20;
TEXTURE2D(_NebulaMap);
SAMPLER(sampler_NebulaMap);
TEXTURE2D(_StarMap);
SAMPLER(sampler_StarMap);
TEXTURE2D(_FractalMap);
SAMPLER(sampler_FractalMap);
CBUFFER_START(UnityPerMaterial)
// The following line declares the _BaseMap_ST variable, so that you
// can use the _BaseMap variable in the fragment shader. The _ST
// suffix is necessary for the tiling and offset function to work.
float4 _NebulaMap_ST;
float4 _StarMap_ST;
float4 _FractalMap_ST;
CBUFFER_END
Varyings vert(Attributes IN)
{
Varyings OUT;
OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
OUT.uv = IN.uv;
return OUT;
}
float2 rotateUV(float2 uv, float rotation)
{
float mid = 0.5;
return float2(
cos(rotation) * (uv.x - mid) + sin(rotation) * (uv.y - mid) + mid,
cos(rotation) * (uv.y - mid) - sin(rotation) * (uv.x - mid) + mid
);
}
float4 nebula(float r, float a)
{
// sample nebula 1
float n1_stretch = 1.0/50.0;
float n1_speed = 20.0;
float n1_spin = 10.0;
// float n1_power = 2.0;
float n1_cutoff = 0.5;
float2 nuv1;
nuv1.x = n1_stretch/(r*r) + _Time * n1_speed;
nuv1.y = a/PI + _Time * n1_spin;
half4 nebula1 = SAMPLE_TEXTURE2D(_NebulaMap, sampler_NebulaMap, nuv1);
nebula1 *= _NebulaColor1;
nebula1 *= max(0,_Nebula1Power*r-n1_cutoff);
// sample nebula 2 - same as nebula 1 but in another direction
float n2_stretch = 1.0/100.0;
float n2_speed = 30.0;
float n2_spin = -5.0;
// float n2_power = 4.0;
float n2_cutoff = 0.5;
float2 nuv2;
nuv2.x = n2_stretch/(r*r) + _Time * n2_speed;
nuv2.y = a/PI + _Time * n2_spin;
half4 nebula2 = SAMPLE_TEXTURE2D(_NebulaMap, sampler_NebulaMap, nuv2.yx);
nebula2 *= _NebulaColor2;
nebula2 *= max(0,_Nebula2Power*r - n2_cutoff);
return (nebula1 + nebula2) * _Intensity;
}
float4 stars(float r, float a)
{
// sample stars
float starStretch = 1.0/100.0;
float starSpeed = 10.0 * _Intensity;
float starWrap = 3.5f;
// star uv
float2 suv;
// use the root to make them into radial lines instead of a tunnel
suv.x = starStretch/sqrt(r) + _Time * starSpeed;
suv.y = (float)starWrap*a/PI;
half4 star = SAMPLE_TEXTURE2D(_StarMap, sampler_StarMap, suv);
star *= r * r * 2.0;
return star * _Intensity * _StarsWeight;
}
// same as fractals but calling it from a function turns them into bars??
float4 bars(float r, float p)
{
// fractal uv
float2 fuv1 = p / _FractalScale + float2(0.5,0.5);
fuv1 = rotateUV(fuv1,_Time*_FractalRotateSpeed);
half4 fractal1 = SAMPLE_TEXTURE2D(_FractalMap, sampler_FractalMap, fuv1);
fractal1 *= _FractalColor;
fractal1 *= _FractalPower;
// fractal 2
float2 fuv2 = p / _FractalScale + float2(0.5,0.5);
fuv2 = rotateUV(fuv2,-_Time*_FractalRotateSpeed*3.561);
fuv2.x=1.0-fuv2.x;
half4 fractal2 = SAMPLE_TEXTURE2D(_FractalMap, sampler_FractalMap, fuv2);
fractal2 *= _FractalColor * sin(_Time*3);
fractal2 *= _FractalPower;
half4 fractal = max(fractal1,fractal2) * _Intensity;
return fractal * _Intensity * _BarsWeight;
}
float4 ground(float2 p, float r, float a)
{
float4 nothing = float4(0,0,0,0);
float t = (abs(a/PI)*PI) * -min(p.y, 0);
t = min(r, t);
// float angle = PI;
// t *= -abs(p.y);
// t += ;
// t *= (1.0-r*0.5);
// float y = -p.y;
return lerp(nothing, _GroundColor, t) * _GroundWeight;
}
float4 blurry_circle(float2 p, float2 c, float radius, float thickness)
{
float r_p = length(p-c);
// outer circle is white/circle color
// inner circle is black and a bit smaller
float d =abs(radius-r_p)*1.0/thickness;
d*=d;
float4 color = max(d, 0);
color.a = 1.0;
// color -= max((_CircleRadius-_CircleThickness)-r, 0);
color = 1.0-color;
float b = _DistanceToNextBeat;
b*=b;
color *= 1.0+b;
return max(color, 0);
}
float4 filled_circle(float2 p, float2 c, float r)
{
float inside = step(length(p),r);
return lerp(float4(0,0,0,0),float4(1,1,1,1),inside);
}
float4 frag(Varyings IN) : SV_Target
{
float2 res = _ScreenParams;
float2 p = -1.0+2.0*IN.positionHCS.xy/res.xy;
p.x *= res.x/res.y;
float2 cameraShake;
float shake = _Time*50;
cameraShake.x = cos(shake*12.3341)+sin(shake*19.231057);
cameraShake.y = cos(shake*17.12311)+sin(shake*14.2315165);
cameraShake*=_CameraShake;
p += cameraShake;
// shared tunnel vars
float r = length(p);
float a = atan(p.y/p.x);
// for some reason trying to sample the fractal in a function turns it into bars
// looks cool but no idea why it happens so these fractals are inline
float2 fuv1 = p / _FractalScale + float2(0.5,0.5);
fuv1 = rotateUV(fuv1,_Time*_FractalRotateSpeed);
half4 fractal1 = SAMPLE_TEXTURE2D(_FractalMap, sampler_FractalMap, fuv1);
fractal1 *= _FractalColor;
// fractal1 *= max(0, r-_CoreRadius);
fractal1 *= _FractalWeight;
fractal1 *= _Intensity;
float2 fuv2 = p / _FractalScale + float2(0.5,0.5);
fuv2 = rotateUV(fuv2,PI*-(_PlayerXPos/20.0));
// fuv2.x=1.0-fuv2.x;
half4 fractal2 = SAMPLE_TEXTURE2D(_FractalMap, sampler_FractalMap, fuv2);
fractal2 *= _FractalColor * sin(_Time*3);
// fractal2 *= max(0, r-_CoreRadius);
fractal2 *= _FractalWeight;
fractal2 *= _Intensity;
float4 color = float4(0,0,0,0);
// precalc some stuff
float4 f = fractal1 + fractal2;
// float f = fractal2;
float4 g = ground(p, r, a);
// float g_mask = step(_GroundMaskAngle,g);
float4 n = nebula(r, a);
float4 s = stars(r, a);
float4 b = bars(r, p);
// fractal
// color += fractal_both;
// nebula
// float4 normal_bars = normalize(bars(r,p));
// color += normal_bars;
// float4 nebula_bars = bars(r, p) * _DistanceSinceLastBeat * 5;
// color += stars(r, a);
// color += circle(p, r);
// float4 neb = nebula(r, a);
// color += neb;
// sky
float4 sky = _BackgroundColor;
sky += f * _FractalColor; // fractal
sky += s * _StarsColor; // stars
float4 clouds = n * _CloudColor;
clouds *= (1.0-g); // mask out ground
sky += clouds;
sky *= (1.0-g); // mask out ground
color += sky;
// sky = max(f,s);
// stars masked by ground
// color += max(0,s,g_mask);
// ground
float4 ground_color = g;
// hazy ground base
// ground_color += g;
// speedy boye
float4 ground_fast = n * g;
// ground_color = lerp(ground_color, ground_fast, ground_fast);
ground_color+= ground_fast;
ground_color *= _GroundColor;
color = max(color, ground_color);
// bars
float4 bars_color = b;
bars_color = lerp(bars_color,ground_color,g);
bars_color *= _BarsColor;
bars_color *= lerp(0, bars_color, _DistanceToNextBeat);
bars_color = lerp(bars_color, _GroundColor, g);
color = max(bars_color, color);
// core
float2 core_c = float2(0, _CoreYOffset);
float4 core_color = blurry_circle(p, core_c, _CoreRadius, _CoreThiccness);
core_color *= _CoreColor;
color = lerp(color, core_color, core_color);
// color = lerp(color, core_color, step(0.001,core_color));
// rays
float4 rays_colour;
// spee
// color += lerp(sky, n, g);
// float4 outer_circle = blurry_circle(p,_OuterCircleRadius,_OuterCircleThickness);
// color += lerp(0,outer_circle,ground(p,r,a));
// float4 core = filled_circle(p,_CoreRadius);
// color += core;
// color = float4(1,1,1,1)*outer_circle;
// bars, nebula, fractal,
// average across all fx
// score bar
color += blurry_circle(p, float2(0,5.25), 4.0, 0.5)*_UiColor;
return color;
}
ENDHLSL
}
}
}