I am porting the following shader into Godot. The results seem not correct though. Apart from the wrong colours there seems to be no change with time. What is the problem with it?

```
shader_type canvas_item;
const float DELTA = 0.00001;
const float TAU = 6.28318530718;
const float NOISE_TEXTURE_SIZE = 256.0;
const float NOISE_TEXTURE_PIXEL_COUNT = (NOISE_TEXTURE_SIZE * NOISE_TEXTURE_SIZE);
uniform vec4 vColor: color;
// MAIN CONTROLLER UNIFORMS
uniform float intensity = 1.; // overall effect intensity, 0-1 (no upper limit)
uniform float rngSeed = .0; // seed offset (changes configuration around)
uniform sampler2D noiseTexture; // noise texture sampler
//TUNING
uniform float lineSpeed = .01; // line speed
uniform float lineDrift = .1; // horizontal line drifting
uniform float lineResolution = 1.; // line resolution
uniform float lineVertShift = .0; // wave phase offset of horizontal lines
uniform float lineShift = .004; // horizontal shift
uniform float jumbleness = .2; // amount of "block" glitchiness
uniform float jumbleResolution = .2; // resolution of blocks
uniform float jumbleShift = .15; // texture shift by blocks
uniform float jumbleSpeed = 1.; // speed of block variation
uniform float dispersion = .0025; // color channel horizontal dispersion
uniform float channelShift = .004; // horizontal RGB shift
uniform float noiseLevel = .5; // level of noise
uniform float shakiness = .5; // horizontal shakiness
//
float rand(vec2 co){
return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
}
vec4 extractRed(vec4 col){
return vec4(col.r, 0., 0., col.a);
}
vec4 extractGreen(vec4 col){
return vec4(0., col.g, 0., col.a);
}
vec4 extractBlue(vec4 col){
return vec4(0., 0., col.b, col.a);
}
// Replacement for the mirror address mode, hopefully nobody needs filtering.
vec2 mirror(vec2 v) {
return abs((fract((v * 0.5) + 0.5) * 2.0) - 1.0);
}
vec2 downsample(vec2 v, vec2 res) {
// Division by zero protected by uniform getters.
return floor(v * res) / res;
}
// Fetches four random values from an RGBA noise texture
vec4 whiteNoise(vec2 coord, vec2 texelOffset, vec2 resolution) {
vec2 offset = downsample(vec2(rngSeed * NOISE_TEXTURE_SIZE, rngSeed) + texelOffset, vec2(NOISE_TEXTURE_SIZE));
vec2 ratio = resolution / vec2(NOISE_TEXTURE_SIZE);
return texture(noiseTexture, (coord * ratio) + offset);
}
// Fetch noise texture texel based on single offset in the (0-1) range
vec4 random(float dataOffset) {
vec2 halfTexelSize = vec2((0.5 / NOISE_TEXTURE_SIZE));
float offset = rngSeed + dataOffset;
return texture(noiseTexture, vec2(offset * NOISE_TEXTURE_SIZE, offset) + halfTexelSize);
}
// Jumble coord generation
vec2 jumble(vec2 coord, float time, vec2 resolution){
// Static branch.
if ((jumbleShift * jumbleness * jumbleResolution) < DELTA) {
return vec2(0.0);
}
vec2 gridCoords = (coord * jumbleResolution) / (NOISE_TEXTURE_SIZE * 0.0245);
float jumbleTime = mod(floor(time * 0.02 * jumbleSpeed), NOISE_TEXTURE_PIXEL_COUNT);
vec2 offset = random(jumbleTime / NOISE_TEXTURE_PIXEL_COUNT).ga * jumbleResolution;
vec4 cellRandomValues = whiteNoise(gridCoords, vec2(jumbleResolution * -10.0) + offset, resolution);
return (cellRandomValues.ra - 0.5) * jumbleShift * floor(min(0.99999, cellRandomValues.b) + jumbleness);
}
// Horizontal line offset generation
float lineOffset(vec2 coord, vec2 uv, float time, vec2 resolution) {
// Static branch.
if (lineShift < DELTA) {
return 0.0;
}
// Wave offsets
vec2 waveHeights = vec2(50.0 * lineResolution, 25.0 * lineResolution);
vec4 lineRandom = whiteNoise(downsample(uv.yy, waveHeights), vec2(0.0), resolution);
float driftTime = uv.y * resolution.y * 2.778;
// XY: big waves, ZW: drift waves
vec4 waveTimes = (vec4(downsample(lineRandom.ra * TAU, waveHeights) * 80.0, driftTime + 2.0, (driftTime * 0.1) + 1.0) + (time * lineSpeed)) + (lineVertShift * TAU);
vec4 waveLineOffsets = vec4(sin(waveTimes.x), cos(waveTimes.y), sin(waveTimes.z), cos(waveTimes.w));
waveLineOffsets.xy *= ((whiteNoise(waveTimes.xy, vec2(0.0), resolution).gb - 0.5) * shakiness) + 1.0;
waveLineOffsets.zw *= lineDrift;
return dot(waveLineOffsets, vec4(1.0));
}
void fragment()
{
vec3 randomValues = vec3(rand(vec2(TIME, 0.0)), rand(vec2(TIME, 0.0)), rand(vec2(TIME, 0.0)));
vec2 resolution = 1.0 / SCREEN_PIXEL_SIZE;
vec2 uv = FRAGCOORD.xy / (1.0 / SCREEN_PIXEL_SIZE).xy;
// Sample random high-frequency noise
vec4 randomHiFreq = whiteNoise(uv, randomValues.xy, resolution);
// Apply line offsets
vec2 offsetCoords = uv;
offsetCoords.x += ((((2.0 * randomValues.z) - 1.0) * shakiness * lineSpeed) + lineOffset(offsetCoords, uv, TIME, resolution)) * lineShift * intensity;
// Apply jumbles
offsetCoords += jumble(offsetCoords, TIME, resolution) * intensity * intensity * 0.25;
// Channel split
vec2 shiftFactors = (channelShift + (randomHiFreq.rg * dispersion)) * intensity;
vec4 outColour;
// Static branch.
if (((channelShift + dispersion) * intensity) < DELTA) {
outColour = texture(SCREEN_TEXTURE, mirror(offsetCoords));
} else {
outColour = extractRed(texture(SCREEN_TEXTURE, mirror(offsetCoords + vec2(shiftFactors.r, 0.0)))) + extractBlue(texture(SCREEN_TEXTURE, mirror(offsetCoords + vec2(-shiftFactors.g, 0.0)))) + extractGreen(texture(SCREEN_TEXTURE, mirror(offsetCoords)));
}
// Add noise
outColour.rgb *= (vec3(.55, .5, .4) * randomHiFreq.gab * intensity * noiseLevel) + 1.0;
// COLOR = vColor * outColour;
COLOR = outColour;
}
```