precision mediump float;
uniform vec3 uColor;
uniform float u_time;

varying vec3 vPosition;
varying vec3 vNormal;

void main()
{
    // Normal
    vec3 normal = normalize(vNormal);
    if(!gl_FrontFacing)
        normal *= - 1.0;

precision mediump float;

uniform vec3 uColor;
uniform sampler2D uTexture;

varying vec2 v_texcoord;

void main() {
    vec4 textureColor = texture2D(uTexture, v_texcoord);
    gl_FragColor = textureColor;
}

precision mediump float;
varying vec3 vColor;

void main()
{
    vec2 uv = gl_PointCoord;
    float distanceToCenter = distance(uv, vec2(0.5));
    if(distanceToCenter > 0.5){
        discard;
    }

    gl_FragColor = vec4(vColor, 1.0);
    #include <tonemapping_fragment>
    #include <colorspace_fragment>

precision mediump float;
uniform float u_time;
varying vec2 v_texcoord;

#include "./3DPerlinNoise.glsl";

void main()
{
    // Adding patterns
    float pattern = sin(0.01);
    pattern -= abs(cnoise(vec3(v_texcoord * 5.0, u_time * 0.2)) * 0.15);

    // Colors
    vec3 color1 = vec3(1.0, 0.0, 0.35);

precision mediump float;
uniform sampler2D uTexture;
uniform float uTextureFrequency;
uniform float u_time;
uniform float uHslTimeFrequency;
uniform float uHslHue;
uniform float uHslHueOffset;
uniform float uHslHueFrequency; 
uniform float uHslLightness; 
uniform float uHslLightnessVariation; 
uniform float uHslLightnessFrequency; 
uniform float uTextureOffset; 

precision mediump float;
varying vec2 v_texcoord;
uniform float u_time;
uniform float uFrequency;
uniform float uAmplitude;

float random(vec2 st) {
    return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453123);
}

//	Classic Perlin 2D Noise 
//	by Stefan Gustavson
//
vec2 fade(vec2 t) {

precision mediump float;
uniform vec3 uColor;
uniform float uOffset;
uniform float uMultiplier;


varying vec2 v_texcoord;

void main(){
    float distanceToCenter = smoothstep(0.0, 1.0,length(v_texcoord - 0.5));
    float alpha = distanceToCenter * uMultiplier + uOffset;
    gl_FragColor = vec4(uColor, alpha);
}

precision mediump float;
uniform float u_time;
uniform float uRandomFloat;
uniform vec2 u_resolution;
varying vec2 v_texcoord;

#include "./helpers/utils.glsl";
const float DAY_LENGTH = 60.0;

// Background Colors
const vec3 MORNING_COLOR1 = vec3(1.0, 0.89, 0.79);
const vec3 MORNING_COLOR2 = vec3(1.0, 0.77, 0.59);
const vec3 MIDDAY_COLOR1 = vec3(0.64, 0.93, 1.0);
const vec3 MIDDAY_COLOR2 = vec3(0.3, 0.66, 1.0);

precision mediump float;
uniform vec3 uColorA;
uniform vec3 uColorB;

varying float vWobble;

void main()
{
    float colorMix = smoothstep(-1.0, 1.0, vWobble);
    csm_DiffuseColor.rgb = mix(uColorA, uColorB, colorMix);
}

precision mediump float;
uniform float u_time;
varying vec2 v_texcoord;
varying vec3 vNormal;

#define TAU 2.0 * 3.142857

// Hash function uniforms
uniform vec2 uHashFract;
uniform float uHashDot;

// Rand01 uniforms
uniform vec3 uRandFract;
uniform float uRandDot;

precision highp float;
#define O gl_FragColor
uniform float time;
uniform vec2 resolution;
#define FC gl_FragCoord.xy
#define R resolution
#define T time
#define MN min(R.x,R.y)
#define S smoothstep
#define SE(v,a) S(fwidth(a),-.35,v-a)
#define PI radians(180.)
#define lum(a) dot(a,vec3(.21,.71,.07))
#define hue(a)(.5+.5*sin(PI*(a)+vec3(1,2,3)))
vec3 watermark() {

precision mediump float;
varying vec2 v_texcoord;
varying vec3 vNormal;
varying float vDisplacement;
uniform float u_time;

uniform vec3 uBaseColor;
uniform vec3 uGlowColor;
uniform vec3 uAccentColor;

float fresnel(vec3 viewDirection, vec3 normal, float power) {
    return pow(1.0 - dot(viewDirection, normal), power);
}

precision mediump float;
uniform float u_time;
varying vec2 v_texcoord;
varying vec3 vNormal;

#define TAU 2.0 * 3.142857

// Hash function uniforms
uniform vec2 uHashFract;
uniform float uHashDot;

// Rand01 uniforms
uniform vec3 uRandFract;
uniform float uRandDot;

precision mediump float;
uniform float uRedShift;
uniform float uGreenShift;
uniform float uBlueShift;
varying vec2 v_texcoord;

void main() {
    gl_FragColor = vec4(v_texcoord.x * uRedShift, v_texcoord.y * uGreenShift, uBlueShift, 1.0);
}

precision mediump float;
varying vec2 v_texcoord;
uniform float u_time;
uniform float uAmplitude;
uniform float uScrollSpeed;

uniform sampler2D uDiffuse;

float inverseLerp(float v, float minVal, float maxVal) {
    return (v - minVal) / (maxVal - minVal);
}

float remap(float v, float inMin, float inMax, float outMin, float outMax) {
    float t = inverseLerp(v, inMin, inMax);

precision mediump float;
uniform float u_time;
varying vec2 v_tex_coord;
varying vec4 v_color_mix;
vec4 SKDefaultShading(){ return vec4(1.0); }
//
// Creates moving grayscale noise.
//
// This works using a simple (but brilliant!) and well-known trick: if you
// calculate the dot product of a texture coordinate with a vec2 containing
// two numbers that are unlikely to repeat, then calculate the sine of that
// and multiply it by a large number, you'll end up with what looks more or
// less like random numbers in the fraction digits – i.e., everything after
// the decimal place.

precision mediump float;
uniform float u_time;
varying vec2 v_tex_coord;
varying vec4 v_color_mix;
vec4 SKDefaultShading(){ return vec4(1.0); }
//
// Creates moving multi-colored noise.
//
// This works using a simple (but brilliant!) and well-known trick: if you
// calculate the dot product of a texture coordinate with a vec2 containing
// two numbers that are unlikely to repeat, then calculate the sine of that
// and multiply it by a large number, you'll end up with what looks more or
// less like random numbers in the fraction digits – i.e., everything after
// the decimal place.

precision mediump float;
varying vec2 v_tex_coord;
varying vec4 v_color_mix;
vec4 SKDefaultShading(){ return vec4(1.0); }
//
// Creates fixed grayscale noise.
//
// This works using a simple (but brilliant!) and well-known trick: if you
// calculate the dot product of a texture coordinate with a vec2 containing
// two numbers that are unlikely to repeat, then calculate the sine of that
// and multiply it by a large number, you'll end up with what looks more or
// less like random numbers in the fraction digits – i.e., everything after
// the decimal place.
//

precision mediump float;
varying vec2 v_tex_coord;
varying vec4 v_color_mix;
vec4 SKDefaultShading(){ return vec4(1.0); }
//
// Creates fixed multi-colored noise.
//
// This works using a simple (but brilliant!) and well-known trick: if you
// calculate the dot product of a texture coordinate with a vec2 containing
// two numbers that are unlikely to repeat, then calculate the sine of that
// and multiply it by a large number, you'll end up with what looks more or
// less like random numbers in the fraction digits – i.e., everything after
// the decimal place.
//

precision mediump float;
uniform float u_time;
uniform sampler2D u_texture;
varying vec2 v_tex_coord;
varying vec4 v_color_mix;
//
// Warps a textured node to create a water rippling effect.
// NOTE: This must be applied to something that has a texture.
// Uniform: u_speed, how many fast to make the water ripple. Ranges from 0.5 to 10 work best; try starting with 3.
// Uniform: u_strength, how pronounced the rippling effect should be. Ranges from 1 to 5 work best; try starting with 3.
// Uniform: u_frequency, how often ripples should be created. Ranges from 5 to 25 work best; try starting with 10.
//
// This works by using a nearby pixel color rather than the original pixel color. Which neighbour is
// chosen depends on the algorithm: we pass the original coordinate, speed, and frequency