<?xml version="1.0" encoding="iso-8859-1" ?>
<ZApplication Name="App" Caption="ZGameEditor application" FileVersion="2">
  <OnLoaded>
    <ZLibrary Comment="HSV Library">
      <Source>
<![CDATA[void ZgeVizGetFileNames(string path, string pattern, string[] list) { }

vec3 hsv(float h, float s, float v)
{
  s = clamp(s/100, 0, 1);
  v = clamp(v/100, 0, 1);

  if(!s)return vector3(v, v, v);

  h = h < 0 ? frac(1-abs(frac(h/360)))*6 : frac(h/360)*6;

  float c, f, p, q, t;

  c = floor(h);
  f = h-c;

  p = v*(1-s);
  q = v*(1-s*f);
  t = v*(1-s*(1-f));

  switch(c)
  {
    case 0: return vector3(v, t, p);
    case 1: return vector3(q, v, p);
    case 2: return vector3(p, v, t);
    case 3: return vector3(p, q, v);
    case 4: return vector3(t, p, v);
    case 5: return vector3(v, p, q);
  }
}]]>
      </Source>
    </ZLibrary>
    <ZExpression Expression="totalTime = 0;"/>
    <ZLibrary Comment="Helper Functions">
      <Source>
<![CDATA[vec4 getColor(float alpha, float hue, float saturation, float lightness) {
  vec3 c=hsv(hue*360,saturation*100,(1-lightness)*100);
  vec4 col=vector4(c.x,c.y,c.z,1.0-alpha);
  return col;
}

vec4 getColorSimple(float[] params, int baseIndex) {
  return getColor(params[baseIndex], params[baseIndex + 1], params[baseIndex + 2], params[baseIndex + 3]);
}]]>
      </Source>
    </ZLibrary>
  </OnLoaded>
  <OnUpdate>
    <ZExpression>
      <Expression>
<![CDATA[//Optional: Move  to Constants to ZLibrary before release.
const int
  ALPHA = 0,
  SPEED = 1,
  USE_BEAT = 2,
  GLOW_SIZE = 3,
  GLOW_ALPHA = 4,
  GLOW_HUE = 5,
  GLOW_SATURATION = 6,
  GLOW_LIGHTNESS = 7,
  GLOW_SHIFT_HUE = 8,
  GLOW_SHIFT_SATURATION = 9,
  GLOW_SHIFT_LIGHTNESS = 10,
  TUNNEL_OFFSET = 11,
  TUNNEL_SPAWN_SIZE = 12,
  TUNNEL_ALPHA = 13,
  WALL_ALPHA = 14,
  END_ALPHA = 15,
  STRIPE1_ALPHA = 16,
  STRIPE2_ALPHA = 20,
  STRIPE3_ALPHA = 24,
  STRIPE4_ALPHA = 28;

float UseBeat=round(Parameters[USE_BEAT]);
uAlpha=1.0-Parameters[ALPHA];
uGlowColor=getColor(Parameters[GLOW_ALPHA],Parameters[GLOW_HUE],Parameters[GLOW_SATURATION],Parameters[GLOW_LIGHTNESS]);
uGlowShiftColor=getColor(1.0,Parameters[GLOW_SHIFT_HUE],Parameters[GLOW_SHIFT_SATURATION],Parameters[GLOW_SHIFT_LIGHTNESS]);
uTunnelAlpha=1.0-Parameters[TUNNEL_ALPHA];
uWallAlpha=1.0-Parameters[WALL_ALPHA];
uEndAlpha=1.0-Parameters[END_ALPHA];
uStripeColor1=getColorSimple(Parameters, STRIPE1_ALPHA);
uStripeColor2=getColorSimple(Parameters, STRIPE2_ALPHA);
uStripeColor3=getColorSimple(Parameters, STRIPE3_ALPHA);
uStripeColor4=getColorSimple(Parameters, STRIPE4_ALPHA);
//float speed=1.0;
float Speed=(Parameters[SPEED]-.5)*4.0; //uncomment, editindex to use as a parameter
float delta=app.DeltaTime*Speed; //comment to use other time options
totalTime+=delta;
if (UseBeat) {
  uTime = SongPositionInBeats * Speed / 2.0;
} else {
  uTime = totalTime;
}

//Most used ShaderToy uniform variables
uResolution=vector2(app.ViewportWidth,app.ViewportHeight);
uViewport=vector2(app.ViewportX,app.ViewportY);
uMouse=vector4(0.0,0.0,0.0,0.0);
uGlowSize=Parameters[GLOW_SIZE];
uTunnelOffset=Parameters[TUNNEL_OFFSET];
uTunnelSpawnSize=Parameters[TUNNEL_SPAWN_SIZE];]]>
      </Expression>
    </ZExpression>
  </OnUpdate>
  <OnRender>
    <UseMaterial Material="mCanvas"/>
    <RenderSprite/>
  </OnRender>
  <Content>
    <Shader Name="ShaderToy_Default">
      <VertexShaderSource>
<![CDATA[#version 120

void main(){
  vec4 vertex = gl_Vertex;
  vertex.xy *= 2.0;
  gl_Position = vertex;
}]]>
      </VertexShaderSource>
      <FragmentShaderSource>
<![CDATA[#version 120
#define PI 3.1415926538

uniform vec2 iResolution,iViewport;
uniform float iTime;
uniform float iAlpha;
uniform float iGlowSize;
uniform vec4 iGlowColor;
uniform vec4 iGlowShiftColor;
uniform float iTunnelOffset;
uniform float iTunnelSpawnSize;
uniform float iTunnelAlpha;
uniform float iWallAlpha;
uniform float iEndAlpha;
uniform vec4 iStripeColor1;
uniform vec4 iStripeColor2;
uniform vec4 iStripeColor3;
uniform vec4 iStripeColor4;
//uniform sampler2D tex1; //ZGE material texture uniforn
//#define iChannel0 tex1  //Define shadertoy variable to elimnate code editing.

vec3 rgb2hsv(vec3 c)
{
    vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
    vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
    vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));

    float d = q.x - min(q.w, q.y);
    float e = 1.0e-10;
    return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
}

vec3 hsv2rgb(vec3 c)
{
    vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
    vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
}

vec4 getColor(vec4 col) {
  return col * col.a;
}

vec2 getRatio() {
    vec2 ratio = vec2(1.0, 1.0);

    if (iResolution.x < iResolution.y) {
        ratio.y = iResolution.x / iResolution.y;
    } else if (iResolution.y < iResolution.x) {
        ratio.x = iResolution.y / iResolution.x;
    }
    return ratio;
}

vec4 centerGlow(vec2 uv) {
    vec2 ratio = getRatio();

    vec4 col = vec4(0.0, 0.0, 0.0, 0.0);

    vec4 box = 0.5 + vec4(-ratio.x, -ratio.y, ratio.x, ratio.y) * iGlowSize;

    if (uv.x >= box.x && uv.x <= box.z && uv.y >= box.y && uv.y <= box.w) {
        vec2 miniUV = uv;
        miniUV-= box.xy;
        miniUV/= ratio * 2.0 * iGlowSize;
        float angle = atan(miniUV.y - 0.5, miniUV.x - 0.5);
        vec2 pos = vec2(cos(angle), sin(angle));
        float mag = distance(miniUV, vec2(0.5, 0.5));
        mag += sin(angle * 3.0 + iTime * 24.0) * cos(angle * 5.0 - iTime * 26.0) * sin(angle * 4.0 + iTime * 48.0) * 0.02;
        mag += sin(angle * 3.0 + 0.2 + iTime * 32.0) * cos(angle * 7.0 - iTime * 40.0) * sin(angle * 4.0 - iTime * 68.0) * 0.01;
        mag += sin(angle * 7.0 + 0.3 + iTime * 20.0) * cos(angle * 2.0 - iTime * 24.0) * sin(angle * 4.0 + iTime * 88.0) * 0.03;
        float dist = 2.0 * (0.5 - mag);
        dist = smoothstep(0.1, 1.14, dist) * 2.0;
        col = vec4(dist);
        float colorRatio = (1.0 - clamp(dist, 0.0, 1.0));
        vec4 realColor = iGlowColor * (1.0 - colorRatio) + iGlowShiftColor * colorRatio;
        col*= realColor;
    }

    return col * iGlowColor.a;
}

vec4 plaid(vec2 uv, float yPos) {
    vec4 plaidCol = vec4(0.0);
    float brightness = 1.2 - yPos * 0.6;
    float alphaMultiplier = 1.0;

    if ((uv.x > 0.025 && uv.x < 0.1) || (uv.x > 0.9 && uv.x < 0.975)) {
        plaidCol+= getColor(iStripeColor1) * 0.9 * brightness;
        alphaMultiplier = 1.0 - iStripeColor1.a;
    }
    float darkMultiplier = 1.0;
    if (yPos > iTunnelOffset) {
        if ((uv.y > 0.025 && uv.y < 0.1) || (uv.y > 0.9 && uv.y < 0.975)) {
            plaidCol+= getColor(iStripeColor1) * 0.7 * alphaMultiplier;
        }
        if ((uv.y > 0.65 && uv.y < 0.725) || (uv.y > 0.775 && uv.y < 0.85)) {
            plaidCol+= getColor(iStripeColor2) * 0.7 * alphaMultiplier;
        }
        brightness = 1.6 - yPos * 1.2;
    } else {
        darkMultiplier = 0.75;
        brightness = 1.0;
    }
    if ((uv.x > 0.15 && uv.x < 0.225) || (uv.x > 0.275 && uv.x < 0.35)) {
        plaidCol+= getColor(iStripeColor2) * 0.5 * darkMultiplier * alphaMultiplier;
    }
    if ((uv.x > 0.525 && uv.x < 0.6) || (uv.x > 0.775 && uv.x < 0.85)) {
        plaidCol+= getColor(iStripeColor3) * 0.5 * darkMultiplier * alphaMultiplier;
    }
    if ((uv.x > 0.4 && uv.x < 0.475) || (uv.x > 0.65 && uv.x < 0.725)) {
        plaidCol+= getColor(iStripeColor4) * 0.5 * darkMultiplier * alphaMultiplier;
    }

    return plaidCol * brightness;
}

vec4 wall(vec2 uv, float angle) {
    // For now horizon isn't used.
    // float horizon = max(iResolution.x, iResolution.y);

    // Initialize the ratio, as well as the ratio adjusted UV.
    vec2 ratio = getRatio();
    vec2 newUV = -(uv - 0.5) / ratio;

    // We'll calculate the distance from origin, as well as the angle relative to origin.
    float dist = distance(newUV, vec2(0.0, 0.0));
    float cAngle = atan(newUV.y, newUV.x);

    // Convert the angle in degrees to radians.
    float rad = angle / 180.0 * PI;

    // Now we'll rotate the UV accordingly.
    newUV.x = dist * cos(cAngle + rad);
    newUV.y = dist * sin(cAngle + rad);

    float yPos = newUV.y;

    // Originally we defined the horizon, from which we'd calculate the Z.
    // float z = newUV.y * horizon;
    float scale = 0.0;
    if (newUV.y > 0.0) {
        scale = 1.0 / newUV.y;
    }

    if (newUV.x < -newUV.y) {
        return vec4(0.0);
    }

    if (newUV.x > newUV.y) {
        return vec4(0.0);
    }

    float invScale = 0.0;
    if (newUV.y < 1.0) {
        invScale = 1.0 / (1.0 - newUV.y);
    }

    newUV.x*= 1.3;

    newUV.x = mod(newUV.x * scale + 0.3, 1.0);
    newUV.y = mod(newUV.y + iTime + scale * 4.0, 1.0);

    return plaid(newUV, yPos);
}

vec4 plaidSquare(vec2 uv) {
    vec2 ratio = getRatio();

    vec4 col = vec4(0.0, 0.0, 0.0, 0.0);

    vec4 box = 0.5 + vec4(-ratio.x, -ratio.y, ratio.x, ratio.y) * iTunnelOffset;

    float tunnelSpawnOffset = 1.0 - iTunnelSpawnSize;

    if (uv.x >= box.x && uv.x <= box.z && uv.y >= box.y && uv.y <= box.w) {
        vec2 miniUV = uv;
        miniUV-= box.xy;
        miniUV/= ratio * 2.0 * iTunnelOffset;

        vec2 boxUV = abs((miniUV.xy * 2.0) - 1.0);

        float maxDist = max(boxUV.x, boxUV.y);

        float distVal = clamp((maxDist - tunnelSpawnOffset) / iTunnelSpawnSize, 0.0, 1.0);
        distVal = 1.0 - mod(distVal - iTime, 1.0);

        if (maxDist < tunnelSpawnOffset) {
          distVal = 0.0;
        }

        if ((distVal > 0.0 && distVal < 0.015) || (distVal > 0.02 && distVal < 0.035)) {
            col = getColor(iStripeColor2);
        }
        if ((distVal > 0.04 && distVal < 0.055) || (distVal > 0.06 && distVal < 0.075)) {
            col = getColor(iStripeColor1);
        }
    }

    return col;
}

//copy-paste ShaderToy code here.
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    // Normalized pixel coordinates (from 0 to 1)
    vec2 uv = fragCoord/iResolution.xy;

    vec4 glowCol = centerGlow(uv);
    vec4 wallCol = (wall(uv, 0.0) + wall(uv, 90.0) + wall(uv, 180.0) + wall(uv, 270.0)) * iWallAlpha * iTunnelAlpha;

    vec4 endCol = plaidSquare(uv) * iEndAlpha * iTunnelAlpha;

    // Output to screen
    vec4 combineColor = clamp(glowCol + wallCol - endCol, 0.0, 1.0) + endCol;

    fragColor = combineColor * iAlpha;
}
//copy-paste ShaderToy code here.

void main(){
    //ZGE does not use mainImage( out vec4 fragColor, in vec2 fragCoord )
    //Rededefined fragCoord as gl_FragCoord.xy-iViewport(dynamic window)
    mainImage(gl_FragColor,gl_FragCoord.xy-iViewport);
}]]>
      </FragmentShaderSource>
      <UniformVariables>
        <ShaderVariable VariableName="iResolution" VariableRef="uResolution"/>
        <ShaderVariable VariableName="iViewport" VariableRef="uViewport"/>
        <ShaderVariable VariableName="iTime" VariableRef="uTime"/>
        <ShaderVariable VariableName="iAlpha" Value="1" VariableRef="uAlpha"/>
        <ShaderVariable VariableName="iGlowSize" VariableRef="uGlowSize"/>
        <ShaderVariable VariableName="iGlowColor" VariableRef="uGlowColor"/>
        <ShaderVariable VariableName="iGlowShiftColor" VariableRef="uGlowShiftColor"/>
        <ShaderVariable VariableName="iTunnelOffset" VariableRef="uTunnelOffset"/>
        <ShaderVariable VariableName="iTunnelSpawnSize" VariableRef="uTunnelSpawnSize"/>
        <ShaderVariable VariableName="iTunnelAlpha" VariableRef="uTunnelAlpha"/>
        <ShaderVariable VariableName="iWallAlpha" VariableRef="uWallAlpha"/>
        <ShaderVariable VariableName="iEndAlpha" VariableRef="uEndAlpha"/>
        <ShaderVariable VariableName="iStripeColor1" VariableRef="uStripeColor1"/>
        <ShaderVariable VariableName="iStripeColor2" VariableRef="uStripeColor2"/>
        <ShaderVariable VariableName="iStripeColor3" VariableRef="uStripeColor3"/>
        <ShaderVariable VariableName="iStripeColor4" VariableRef="uStripeColor4"/>
      </UniformVariables>
    </Shader>
    <Group Comment="Default ShaderToy Uniform Variable Inputs">
      <Children>
        <Variable Name="uResolution" Type="6"/>
        <Variable Name="uTime"/>
        <Variable Name="uTimeDelta"/>
        <Variable Name="uFrame" Type="1"/>
        <Variable Name="uFrameRate"/>
        <Variable Name="uMouse" Type="8"/>
        <Variable Name="uDate" Type="8"/>
      </Children>
    </Group>
    <Group Comment="FL Studio Variables">
      <Children>
        <Array Name="Parameters" SizeDim1="32" Persistent="255">
          <Values>
<![CDATA[789C63600081067B10D97FE8AB2D883E7BE60C88B687B07D6C61F2B3664ADA31301CB063400310F5103508D0600FD40B562BDFAA6D8FCC47E8F3B107000D2017E4]]>
          </Values>
        </Array>
        <Constant Name="ParamHelpConst" Type="2">
          <StringValue>
<![CDATA[Alpha
Speed
Use Beat @checkbox
Glow Size
Glow Alpha
Glow Hue
Glow Saturation
Glow Lightness
Glow Shift Hue
Glow Shift Saturation
Glow Shift Lightness
Tunnel Offset
Tunnel Spawn Size
Tunnel Alpha
Walls Alpha
End Alpha
Stripe 1 Alpha
Stripe 1 Hue
Stripe 1 Saturation
Stripe 1 Lightness
Stripe 2 Alpha
Stripe 2 Hue
Stripe 2 Saturation
Stripe 2 Lightness
Stripe 3 Alpha
Stripe 3 Hue
Stripe 3 Saturation
Stripe 3 Lightness
Stripe 4 Alpha
Stripe 4 Hue
Stripe 4 Saturation
Stripe 4 Lightness]]>
          </StringValue>
        </Constant>
        <Constant Name="AuthorInfo" Type="2">
          <StringValue>
<![CDATA[GaryCXJk
https://area91.garycxjk.com/]]>
          </StringValue>
        </Constant>
        <Variable Name="SongPositionInBeats"/>
      </Children>
    </Group>
    <Group Comment="Unique Uniform Variable Inputs">
      <Children>
        <Variable Name="uViewport" Type="6"/>
        <Variable Name="uGlowSize"/>
        <Variable Name="uGlowColor" Type="8"/>
        <Variable Name="uGlowShiftColor" Type="8"/>
        <Variable Name="uTunnelOffset"/>
        <Variable Name="uTunnelSpawnSize"/>
        <Variable Name="uStripeColor1" Type="8"/>
        <Variable Name="uStripeColor2" Type="8"/>
        <Variable Name="uStripeColor3" Type="8"/>
        <Variable Name="uStripeColor4" Type="8"/>
        <Variable Name="uAlpha"/>
        <Variable Name="uTunnelAlpha"/>
        <Variable Name="uWallAlpha"/>
        <Variable Name="uEndAlpha"/>
      </Children>
    </Group>
    <Group Comment="Materials and Textures">
      <Children>
        <Material Name="mCanvas" Blend="1" Shader="ShaderToy_Default"/>
      </Children>
    </Group>
    <Group Comment="Persistent Variables">
      <Children>
        <Variable Name="totalTime"/>
      </Children>
    </Group>
  </Content>
</ZApplication>
