uniform sampler2D texture;

uniform sampler2D displacementMap;

uniform sampler2D paletteMap;

uniform sampler2D gradientMap;



void main() {

	vec4 displacementPixel = texture2D(displacementMap, gl_TexCoord[0]);

	vec4 palettePixel = texture2D(paletteMap, gl_TexCoord[0]);



	vec2 pos = gl_TexCoord[0];

	pos.x += (displacementPixel.r * 2.0 - 1.0) * 0.025 * displacementPixel.a;

	pos.y -= (displacementPixel.g * 2.0 - 1.0) * 0.025 * displacementPixel.a;



	// Get the displaced pixel.

	vec4 pixel = texture2D(texture, pos);



	// Proper grayscale conversion.

	float gray = dot(pixel.rgb, vec3(0.299, 0.587, 0.114));



	// Get the color from the gradient.

	float gradientPos = mod(gray + palettePixel.g, 1);

	

	vec4 gradientMapPixel = texture2D(gradientMap, new vec2(gradientPos, palettePixel.r));



	// Mix the gradient with the pixel color based on the palette pixel.

	pixel = mix(pixel, gradientMapPixel, palettePixel.a);



	gl_FragColor = pixel * gl_Color;

}

using Otter;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace ShaderTesting {

    class Program {

        static void Main(string[] args) {

            var image = new Image("pic.jpg");

            var game = new Game("ShaderZ", image.Width, image.Height);



            game.FirstScene = new TestScene();



            game.Start();

        }

    }



    class TestScene : Scene {



        Image image = new Image("pic.jpg");

        Image circle = new Image("circle.png");

        Surface distortion;



        public TestScene() {

            AddGraphic(image);

            distortion = new Surface(image.Width, image.Height);

            circle.CenterOrigin();

            circle.Blend = BlendMode.Add;

            AddGraphic(distortion);

            circle.Alpha = 0.1f;

            distortion.Visible = false;

            distortion.AutoClear = false;

        }



        public override void Update() {

            base.Update();



            if (Timer % 30 == 0) {

                try {

                    image.Shader = new Shader("../../shader.frag");

                }

                catch(Exception e) {

                    Console.WriteLine("Shader error:");

                    Console.WriteLine(e.Message);

                }

                image.Shader.SetParameter("gradient", new Texture("gradient.png"));

            }

            if (Input.MouseButtonPressed(MouseButton.Right)) {

                distortion.Clear();

            }

            image.Shader.SetParameter("time", Timer);

            image.Shader.SetParameter("distortion", distortion.Texture);

            image.Shader.SetParameter("offset", Util.SinScale(Timer, 0, 1));



            if (Input.MouseButtonDown(MouseButton.Left)) {

                Draw.SetTarget(distortion);

                Draw.Graphic(circle, MouseX, image.Height - MouseY);

                Draw.ResetTarget();

            }

        }



        public override void Render() {

            base.Render();



            Draw.Circle(MouseX - 15, MouseY - 15, 30, Color.None, Color.Red, 2);

        }

    }

}

sampler2D texture;

sampler2D gradient;

sampler2D distortion;

uniform float offset;

uniform float time;

uniform float mixfactor;



void main() {

	vec2 pos = gl_TexCoord[0];

	vec2 distortColor = texture2D(distortion, pos);

	pos.x += distortColor.r * (sin(time * 0.1 + pos.x * 10) * 0.05);

	pos.y -= distortColor.g * (cos(time * 0.1 + pos.y * 10) * 0.05);

	vec4 color = texture2D(texture, pos);



	float gray = (color.r + color.g + color.b) / 3;



	vec4 gradientColor = texture2D(gradient, vec2(gray, offset));



	gl_FragColor = mix(color, gradientColor, distortColor.r + distortColor.g);

}