278 lines
10 KiB
GLSL
278 lines
10 KiB
GLSL
// This shader draws a texture on the mesh.
|
|
Shader "custom/obstacle"
|
|
{
|
|
// The _BaseMap variable is visible in the Material's Inspector, as a field
|
|
// called Base Map.
|
|
Properties
|
|
{
|
|
[HDR] _Color1("Color1", Color) = (1,1,1,1)
|
|
[HDR] _Color2("Color2", Color) = (1,1,1,1)
|
|
[HDR] _FarColor("Far Color", Color) = (1,1,1,1)
|
|
|
|
_Alpha("Alpha", Float) = 1.0
|
|
// [HDR] _Color2("Color 2", Color) = (1,1,1,1)
|
|
// _FadeStrength("Fade Strength", Float) = 0.1
|
|
// _VertexScale("Vertex Scale", Float) = 0
|
|
_PulseIntensity("Pulse Intensity", Float) = 1.0
|
|
_TrackWidth("Track Width", Float) = 20
|
|
_RadiusWithDistance("Radius with Distance", Float) = 0.003
|
|
_SpeedMultiplier("Speed Multiplier", Float) = 2.0
|
|
|
|
_HorizontalScale("Horizontal Scale", Float) = 0.1
|
|
_VerticalScale("Vertical Scale", Float) = 10
|
|
|
|
_M("M", Float) = 0.5
|
|
_C("C", Float) = 0.0
|
|
|
|
_NoiseMap("Noise Map", 2D) = "black"
|
|
}
|
|
|
|
SubShader
|
|
{
|
|
Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalRenderPipeline" }
|
|
|
|
Pass
|
|
{
|
|
Blend OneMinusDstColor OneMinusSrcAlpha
|
|
// Blend SrcAlpha
|
|
|
|
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;
|
|
half3 normal : NORMAL;
|
|
};
|
|
|
|
struct Varyings
|
|
{
|
|
float4 positionHCS : SV_POSITION;
|
|
// The uv variable contains the UV coordinate on the texture for the
|
|
// given vertex.
|
|
float2 uv : TEXCOORD0;
|
|
float3 wpos : TEXCOORD1;
|
|
half3 normal : NORMAL;
|
|
float2 polar : TEXCOORD2; // TODO!!
|
|
};
|
|
|
|
float _M = 0.5;
|
|
float _C = 0.0;
|
|
float4 _Color1;
|
|
float4 _Color2;
|
|
float4 _FarColor;
|
|
float _Alpha;
|
|
float _PulseIntensity;
|
|
|
|
float _SpeedMultiplier;
|
|
float _RadiusWithDistance;
|
|
|
|
float _TrackWidth;
|
|
float _PlayerXPos;
|
|
|
|
float _DistanceToNextBeat;
|
|
float _DistanceSinceLastBeat;
|
|
|
|
float _HorizontalScale;
|
|
float _VerticalScale;
|
|
|
|
float _BaseTubeRadius;
|
|
float _Intensity;
|
|
|
|
// float _VertexScale;
|
|
// float _FadeStrength;
|
|
|
|
// This macro declares _BaseMap as a Texture2D object.
|
|
TEXTURE2D(_BaseMap);
|
|
// This macro declares the sampler for the _BaseMap texture.
|
|
SAMPLER(sampler_BaseMap);
|
|
TEXTURE2D(_NoiseMap);
|
|
SAMPLER(sampler_NoiseMap);
|
|
|
|
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 _BaseMap_ST;
|
|
float4 _NoiseMap_ST;
|
|
CBUFFER_END
|
|
|
|
//random hash
|
|
float4 hash42(float2 p) {
|
|
|
|
float4 p4 = frac(float4(p.xyxy) * float4(443.8975, 397.2973, 491.1871, 470.7827));
|
|
p4 += dot(p4.wzxy, p4 + 19.19);
|
|
return frac(float4(p4.x * p4.y, p4.x * p4.z, p4.y * p4.w, p4.x * p4.w));
|
|
}
|
|
|
|
float hash(float n) {
|
|
return frac(sin(n) * 43758.5453123);
|
|
}
|
|
|
|
float n(in float3 x) {
|
|
float3 p = floor(x);
|
|
float3 f = frac(x);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
float n = p.x + p.y * 57.0 + 113.0 * p.z;
|
|
float res = lerp(lerp(lerp(hash(n + 0.0), hash(n + 1.0), f.x),
|
|
lerp(hash(n + 57.0), hash(n + 58.0), f.x), f.y),
|
|
lerp(lerp(hash(n + 113.0), hash(n + 114.0), f.x),
|
|
lerp(hash(n + 170.0), hash(n + 171.0), f.x), f.y), f.z);
|
|
return res;
|
|
}
|
|
|
|
//tape noise
|
|
float tape_noise(float2 p) {
|
|
|
|
float y = p.y;
|
|
float s = _Time.x + 200;
|
|
|
|
float v = (n(float3(y * .01 + s, 1., 1.0)) + .0)
|
|
* (n(float3(y * .011 + 1000.0 + s, 1., 1.0)) + .0)
|
|
* (n(float3(y * .51 + 421.0 + s, 1., 1.0)) + .0)
|
|
;
|
|
|
|
v *= hash42(float2(p.x + _Time.y + 200, p.y)).x + 2;
|
|
|
|
|
|
v = abs(pow(v + .3, 1.));
|
|
if (v < .5) v = 0.; //threshold
|
|
return v;
|
|
}
|
|
|
|
|
|
Varyings vert(Attributes IN)
|
|
{
|
|
Varyings OUT;
|
|
float radius = _BaseTubeRadius;
|
|
float d = _TrackWidth;
|
|
|
|
float3 vpos = IN.positionOS.xyz;
|
|
vpos*=3;
|
|
OUT.normal = IN.normal;
|
|
|
|
// position of the model's origin in world space
|
|
float3 mo_wpos = TransformObjectToWorld(float3(0,0,0));
|
|
|
|
float beat = _DistanceToNextBeat*_DistanceToNextBeat;
|
|
vpos *= 1.0+beat*_PulseIntensity;
|
|
|
|
// float3 wpos = TransformObjectToWorld(vpos);
|
|
float wpz = mo_wpos.z;
|
|
float r = length(radius) + wpz*wpz*wpz*_RadiusWithDistance;
|
|
|
|
// compress horiztonally
|
|
// vpos.x = vpos.x * _HorizontalScale;
|
|
// vpos.y = vpos.y * _VerticalScale * 1.0-(r-radius);
|
|
// vpos = mul(UNITY_MATRIX_P,
|
|
// mul(UNITY_MATRIX_MV, float4(0,0,0,1))
|
|
// + float4(vpos.x, vpos.y, 0,0)
|
|
// + float4(1, 1,1,1));
|
|
|
|
// recalculate wpos with updated vpos
|
|
// wpos = TransformObjectToWorld(vpos);
|
|
|
|
// matrix m = GetObjectToWorldMatrix();
|
|
|
|
//float d = 1.0+length(wpos)*0.5;
|
|
//float2 uv = wpos.zx;
|
|
// vpos += _VertexScale*float3(0,0,5)*d;
|
|
// vpos += sin(180)*sin(1800)*float3(0,0,5)*d;
|
|
// noise *= d*d * 0.1;
|
|
// vpos *= lerp (0.9,1.1,noise);
|
|
|
|
// float3 owpos = TransformObjectToWorld(float3(0,0,0));
|
|
|
|
// calculate position on circle
|
|
|
|
// float3 object_origin = TransformObjectToWorld(float3(0,0,0));
|
|
// float r_origin = float
|
|
|
|
// float wpz = abs(mo_wpos.z-6); // offset due to player position
|
|
// // wpz *= wpz;
|
|
// r += wpz*_RadiusWithDistance;
|
|
// mo_wpos.z *= _SpeedMultiplier;
|
|
|
|
float x = mo_wpos;
|
|
// float x = mo_wpos.x+vpos.x;
|
|
x -= _PlayerXPos;
|
|
// x += 0.5*PI;
|
|
|
|
float a = 2*PI*(x/d);
|
|
a -= 0.5*PI;
|
|
// a *= (radius - r) * -1.0;
|
|
|
|
// vpos.y += 0.5*radius*cos(a);
|
|
|
|
float3 wpos = float3(cos(a)*r,sin(a)*r,mo_wpos.z);
|
|
|
|
float x_p = vpos.x*cos(a)-vpos.y*sin(a);
|
|
float y_p = vpos.x*sin(a)+vpos.y*cos(a);
|
|
vpos.x = x_p;
|
|
vpos.y = y_p;
|
|
|
|
float noise1 = SAMPLE_TEXTURE2D_LOD(_NoiseMap, sampler_NoiseMap, wpos.yz, 0) - 0.5;
|
|
float noise2 = SAMPLE_TEXTURE2D_LOD(_NoiseMap, sampler_NoiseMap, wpos.xy, 0) - 0.5;
|
|
wpos += float3(noise1, noise2, 0) * 2.0;
|
|
|
|
wpos += float3(vpos.xy,0);
|
|
wpos.y += radius;
|
|
|
|
float boundsStrength = 5.0*_Intensity;
|
|
float bounce = (_SpeedMultiplier+boundsStrength*(_DistanceToNextBeat*_DistanceSinceLastBeat));
|
|
wpos.z *= bounce;
|
|
|
|
vpos = TransformWorldToObject(wpos);
|
|
|
|
// TransformWorldToObject()
|
|
// vpos += wposOffset;
|
|
|
|
// float x_with_distance = normalize(wpos.x)*wpos.z*0.1;
|
|
// x_with_distance = abs(x_with_distance);
|
|
// vpos += float3(x_with_distance,0,0);
|
|
|
|
OUT.wpos = wpos;
|
|
OUT.positionHCS = TransformObjectToHClip(vpos);
|
|
// The TRANSFORM_TEX macro performs the tiling and offset
|
|
// transformation.
|
|
OUT.uv = TRANSFORM_TEX(IN.uv, _BaseMap);
|
|
return OUT;
|
|
}
|
|
|
|
half4 frag(Varyings IN) : SV_Target
|
|
{
|
|
// calculate pixel
|
|
float2 res = _ScreenParams;
|
|
float2 p = -1.0+2.0*IN.positionHCS.xy/res.xy;
|
|
|
|
float2 toCentre = TransformObjectToWorld(-IN.wpos).xy;
|
|
toCentre = normalize(toCentre);
|
|
|
|
float t = dot(IN.normal, toCentre) * 0.5 + 0.5;
|
|
|
|
// float t = dot(IN.normal, float3(0,1,0)) * 0.5 + 0.5;
|
|
|
|
// float t = length(p);
|
|
// return lerp(_Color1,_Color2,t * _FadeStrength);
|
|
float normalised = IN.wpos.z/500.0;
|
|
// float4 c = float4(lerp(_Color1, _Color2, t).xyz, _Alpha);
|
|
float4 c = _Color1;
|
|
//c *= tape_noise(IN.polar/0.00005);
|
|
float noise = SAMPLE_TEXTURE2D(_NoiseMap, sampler_NoiseMap, IN.wpos.yz);
|
|
// c *= noise;
|
|
|
|
c = lerp(c, _FarColor, _DistanceToNextBeat + noise);
|
|
c.a = 0.0;
|
|
|
|
return c;
|
|
}
|
|
ENDHLSL
|
|
}
|
|
}
|
|
} |