Added support for the CMake build system

git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1550 4e206d99-4929-0410-ac5d-dfc041789085

examples/shader/CMakeLists.txt

@@ -0,0 +1,10 @@
+
+set(SRCROOT ${CMAKE_SOURCE_DIR}/examples/shader)
+
+# all source files
+set(SRC ${SRCROOT}/Shader.cpp)
+
+# define the shader target
+sfml_add_example(shader GUI_APP
+                 SOURCES ${SRC}
+                 DEPENDS sfml-graphics sfml-window sfml-system)

examples/shader/Shader.cpp

@@ -0,0 +1,284 @@
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Graphics.hpp>
+#include <map>
+#include <math.h>
+
+
+void DisplayError();
+
+////////////////////////////////////////////////////////////
+/// A class to simplify shader selection
+///
+////////////////////////////////////////////////////////////
+class ShaderSelector
+{
+public :
+
+    // Constructor
+    ShaderSelector(std::map<std::string, sf::Shader>& owner, const std::string& shader) :
+    myOwner   (&owner),
+    myIterator(owner.find(shader))
+    {
+    }
+
+    // Select the previous shader
+    void GotoPrevious()
+    {
+        if (myIterator == myOwner->begin())
+            myIterator = myOwner->end();
+        myIterator--;
+    }
+
+    // Select the next shader
+    void GotoNext()
+    {
+        myIterator++;
+        if (myIterator == myOwner->end())
+            myIterator = myOwner->begin();
+    }
+
+    // Update the shader parameters
+    void Update(float x, float y)
+    {
+        if      (myIterator->first == "blur")     myIterator->second.SetParameter("offset", x * y * 0.03f);
+        else if (myIterator->first == "colorize") myIterator->second.SetParameter("color", 0.3f, x, y);
+        else if (myIterator->first == "edge")     myIterator->second.SetParameter("threshold", x * y);
+        else if (myIterator->first == "fisheye")  myIterator->second.SetParameter("mouse", x, y);
+        else if (myIterator->first == "wave")     myIterator->second.SetParameter("offset", x, y);
+        else if (myIterator->first == "pixelate") myIterator->second.SetParameter("mouse", x, y);
+    }
+
+    // Get the name of the current shader
+    const std::string& GetName() const
+    {
+        return myIterator->first;
+    }
+
+    // Get the current shader
+    const sf::Shader& GetShader() const
+    {
+        return myIterator->second;
+    }
+
+private :
+
+    std::map<std::string, sf::Shader>* myOwner;
+    std::map<std::string, sf::Shader>::iterator myIterator;
+};
+
+
+////////////////////////////////////////////////////////////
+/// Entry point of application
+///
+/// \return Application exit code
+///
+////////////////////////////////////////////////////////////
+int main()
+{
+    // Check that the system can use shaders
+    if (sf::Shader::IsAvailable() == false)
+    {
+        DisplayError();
+        return EXIT_SUCCESS;
+    }
+
+    // Create the main window
+    sf::RenderWindow window(sf::VideoMode(800, 600), "SFML Shader");
+
+    // Create the render image
+    sf::RenderImage image;
+    if (!image.Create(window.GetWidth(), window.GetHeight()))
+        return EXIT_FAILURE;
+
+    // Load a background image to display
+    sf::Image backgroundImage;
+    if (!backgroundImage.LoadFromFile("resources/background.jpg"))
+        return EXIT_FAILURE;
+    sf::Sprite background(backgroundImage);
+    backgroundImage.SetSmooth(false);
+
+    // Load a sprite which we'll move into the scene
+    sf::Image entityImage;
+    if (!entityImage.LoadFromFile("resources/sprite.png"))
+        return EXIT_FAILURE;
+    sf::Sprite entity(entityImage);
+
+    // Load the text font
+    sf::Font font;
+    if (!font.LoadFromFile("resources/sansation.ttf"))
+        return EXIT_FAILURE;
+
+    // Load the image needed for the wave shader
+    sf::Image waveImage;
+    if (!waveImage.LoadFromFile("resources/wave.jpg"))
+        return EXIT_FAILURE;
+
+    // Load all shaders
+    std::map<std::string, sf::Shader> shaders;
+    if (!shaders["nothing"].LoadFromFile("resources/nothing.sfx"))   return EXIT_FAILURE;
+    if (!shaders["blur"].LoadFromFile("resources/blur.sfx"))         return EXIT_FAILURE;
+    if (!shaders["colorize"].LoadFromFile("resources/colorize.sfx")) return EXIT_FAILURE;
+    if (!shaders["edge"].LoadFromFile("resources/edge.sfx"))         return EXIT_FAILURE;
+    if (!shaders["fisheye"].LoadFromFile("resources/fisheye.sfx"))   return EXIT_FAILURE;
+    if (!shaders["wave"].LoadFromFile("resources/wave.sfx"))         return EXIT_FAILURE;
+    if (!shaders["pixelate"].LoadFromFile("resources/pixelate.sfx")) return EXIT_FAILURE;
+    ShaderSelector backgroundShader(shaders, "nothing");
+    ShaderSelector entityShader(shaders, "nothing");
+    ShaderSelector globalShader(shaders, "nothing");
+
+    // Do specific initializations
+    shaders["nothing"].SetTexture("texture", sf::Shader::CurrentTexture);
+    shaders["blur"].SetTexture("texture", sf::Shader::CurrentTexture);
+    shaders["blur"].SetParameter("offset", 0.f);
+    shaders["colorize"].SetTexture("texture", sf::Shader::CurrentTexture);
+    shaders["colorize"].SetParameter("color", 1.f, 1.f, 1.f);
+    shaders["edge"].SetTexture("texture", sf::Shader::CurrentTexture);
+    shaders["fisheye"].SetTexture("texture", sf::Shader::CurrentTexture);
+    shaders["wave"].SetTexture("texture", sf::Shader::CurrentTexture);
+    shaders["wave"].SetTexture("wave", waveImage);
+    shaders["pixelate"].SetTexture("texture", sf::Shader::CurrentTexture);
+
+    // Define a string for displaying the description of the current shader
+    sf::Text shaderStr;
+    shaderStr.SetFont(font);
+    shaderStr.SetCharacterSize(20);
+    shaderStr.SetPosition(5.f, 0.f);
+    shaderStr.SetColor(sf::Color(250, 100, 30));
+    shaderStr.SetString("Background shader: \"" + backgroundShader.GetName() + "\"\n"
+                        "Flower shader: \"" + entityShader.GetName() + "\"\n"
+                        "Global shader: \"" + globalShader.GetName() + "\"\n");
+
+    // Define a string for displaying help
+    sf::Text infoStr;
+    infoStr.SetFont(font);
+    infoStr.SetCharacterSize(20);
+    infoStr.SetPosition(5.f, 500.f);
+    infoStr.SetColor(sf::Color(250, 100, 30));
+    infoStr.SetString("Move your mouse to change the shaders' parameters\n"
+                      "Press numpad 1/4 to change the background shader\n"
+                      "Press numpad 2/5 to change the flower shader\n"
+                      "Press numpad 3/6 to change the global shader");
+
+sf::RenderImage test;
+test.Create(800, 600);
+
+    // Create a clock to measure the total time elapsed
+    sf::Clock clock;
+
+    // Start the game loop
+    while (window.IsOpened())
+    {
+        // Process events
+        sf::Event event;
+        while (window.GetEvent(event))
+        {
+            // Close window : exit
+            if (event.Type == sf::Event::Closed)
+                window.Close();
+
+            if (event.Type == sf::Event::KeyPressed)
+            {
+                // Escape key : exit
+                if (event.Key.Code == sf::Key::Escape)
+                    window.Close();
+
+                // Numpad : switch effect
+                switch (event.Key.Code)
+                {
+                    case sf::Key::Numpad1 : backgroundShader.GotoPrevious(); break;
+                    case sf::Key::Numpad4 : backgroundShader.GotoNext();     break;
+                    case sf::Key::Numpad2 : entityShader.GotoPrevious();     break;
+                    case sf::Key::Numpad5 : entityShader.GotoNext();         break;
+                    case sf::Key::Numpad3 : globalShader.GotoPrevious();     break;
+                    case sf::Key::Numpad6 : globalShader.GotoNext();         break;
+                    default :                                                break;
+                }
+
+                // Update the text
+                shaderStr.SetString("Background shader: \"" + backgroundShader.GetName() + "\"\n"
+                                    "Entity shader: \"" + entityShader.GetName() + "\"\n"
+                                    "Global shader: \"" + globalShader.GetName() + "\"\n");
+            }
+        }
+
+        // Get the mouse position in the range [0, 1]
+        float mouseX = window.GetInput().GetMouseX() / static_cast<float>(window.GetWidth());
+        float mouseY = window.GetInput().GetMouseY() / static_cast<float>(window.GetHeight());
+
+        // Update the shaders
+        backgroundShader.Update(mouseX, mouseY);
+        entityShader.Update(mouseX, mouseY);
+        globalShader.Update(mouseX, mouseY);
+
+        // Animate the entity
+        float entityX = (cos(clock.GetElapsedTime() * 1.3f) + 1.2f) * 300;
+        float entityY = (cos(clock.GetElapsedTime() * 0.8f) + 1.2f) * 200;
+        entity.SetPosition(entityX, entityY);
+        entity.Rotate(window.GetFrameTime() * 100);
+
+        // Draw the background and the moving entity to the render image
+        image.Clear();
+        image.Draw(background, backgroundShader.GetShader());
+        image.Draw(entity, entityShader.GetShader());
+        image.Display();
+
+        // Draw the contents of the render image to the window
+        sf::Sprite screen(image.GetImage());
+        window.Draw(screen, globalShader.GetShader());
+
+        // Draw the interface texts
+        window.Draw(shaderStr);
+        window.Draw(infoStr);
+
+        // Finally, display the rendered frame on screen
+        window.Display();
+    }
+
+    return EXIT_SUCCESS;
+}
+
+
+////////////////////////////////////////////////////////////
+/// Fonction called when the post-effects are not supported ;
+/// Display an error message and wait until the user exits
+///
+////////////////////////////////////////////////////////////
+void DisplayError()
+{
+    // Create the main window
+    sf::RenderWindow window(sf::VideoMode(800, 600), "SFML Shader");
+
+    // Define a string for displaying the error message
+    sf::Text error("Sorry, your system doesn't support shaders");
+    error.SetPosition(100.f, 250.f);
+    error.SetColor(sf::Color(200, 100, 150));
+
+    // Start the game loop
+    while (window.IsOpened())
+    {
+        // Process events
+        sf::Event event;
+        while (window.GetEvent(event))
+        {
+            // Close window : exit
+            if (event.Type == sf::Event::Closed)
+                window.Close();
+
+            // Escape key : exit
+            if ((event.Type == sf::Event::KeyPressed) && (event.Key.Code == sf::Key::Escape))
+                window.Close();
+        }
+
+        // Clear the window
+        window.Clear();
+
+        // Draw the error message
+        window.Draw(error);
+
+        // Finally, display the rendered frame on screen
+        window.Display();
+    }
+}

examples/shader/resources/blur.sfx

@@ -0,0 +1,20 @@
+uniform sampler2D texture;
+uniform float offset;
+
+void main()
+{
+	vec2 offx = vec2(offset, 0.0);
+	vec2 offy = vec2(0.0, offset);
+
+	vec4 pixel = texture2D(texture, gl_TexCoord[0].xy)               * 1 +
+                 texture2D(texture, gl_TexCoord[0].xy - offx)        * 2 +
+                 texture2D(texture, gl_TexCoord[0].xy + offx)        * 2 +
+                 texture2D(texture, gl_TexCoord[0].xy - offy)        * 2 +
+                 texture2D(texture, gl_TexCoord[0].xy + offy)        * 2 +
+                 texture2D(texture, gl_TexCoord[0].xy - offx - offy) * 1 +
+                 texture2D(texture, gl_TexCoord[0].xy - offx + offy) * 1 +
+                 texture2D(texture, gl_TexCoord[0].xy + offx - offy) * 1 +
+                 texture2D(texture, gl_TexCoord[0].xy + offx + offy) * 1;
+
+	gl_FragColor =  gl_Color * (pixel / 13.0);
+}

examples/shader/resources/colorize.sfx

@@ -0,0 +1,11 @@
+uniform sampler2D texture;
+uniform vec3 color;
+
+void main()
+{
+	vec4 pixel = texture2D(texture, gl_TexCoord[0].xy) * gl_Color;
+	float gray = pixel.r * 0.39 + pixel.g * 0.50 + pixel.b * 0.11;
+
+	gl_FragColor = vec4(gray * color, 1.0) * 0.6 + pixel * 0.4;
+	gl_FragColor.a = pixel.a;
+}

examples/shader/resources/edge.sfx

@@ -0,0 +1,31 @@
+uniform sampler2D texture;
+uniform float threshold;
+
+void main()
+{
+    const float offset = 1.0 / 512.0;
+	vec2 offx = vec2(offset, 0.0);
+	vec2 offy = vec2(0.0, offset);
+
+	vec4 hEdge = texture2D(texture, gl_TexCoord[0].xy - offy)        * -2.0 +
+                 texture2D(texture, gl_TexCoord[0].xy + offy)        *  2.0 +
+                 texture2D(texture, gl_TexCoord[0].xy - offx - offy) * -1.0 +
+                 texture2D(texture, gl_TexCoord[0].xy - offx + offy) *  1.0 +
+                 texture2D(texture, gl_TexCoord[0].xy + offx - offy) * -1.0 +
+                 texture2D(texture, gl_TexCoord[0].xy + offx + offy) *  1.0;
+
+	vec4 vEdge = texture2D(texture, gl_TexCoord[0].xy - offx)        *  2.0 +
+                 texture2D(texture, gl_TexCoord[0].xy + offx)        * -2.0 +
+                 texture2D(texture, gl_TexCoord[0].xy - offx - offy) *  1.0 +
+                 texture2D(texture, gl_TexCoord[0].xy - offx + offy) * -1.0 +
+                 texture2D(texture, gl_TexCoord[0].xy + offx - offy) *  1.0 +
+                 texture2D(texture, gl_TexCoord[0].xy + offx + offy) * -1.0;
+
+    vec3 result = sqrt(hEdge.rgb * hEdge.rgb + vEdge.rgb * vEdge.rgb);
+    float edge = length(result);
+    if (edge > threshold)
+        gl_FragColor.rgb = vec3(0, 0, 0);
+    else
+        gl_FragColor.rgb = vec3(1, 1, 1);
+	gl_FragColor.a = gl_Color.a * texture2D(texture, gl_TexCoord[0].xy).a;
+}

examples/shader/resources/fisheye.sfx

@@ -0,0 +1,13 @@
+uniform sampler2D texture;
+uniform vec2 mouse;
+
+void main()
+{
+	float len = distance(gl_TexCoord[0].xy, mouse) * 7.0;
+
+    vec2 coords = gl_TexCoord[0].xy;
+	if (len < 1.0)
+		coords += (gl_TexCoord[0].xy - mouse) * len;
+
+    gl_FragColor = texture2D(texture, coords) * gl_Color;	
+}

examples/shader/resources/nothing.sfx

@@ -0,0 +1,6 @@
+uniform sampler2D texture;
+
+void main()
+{
+	gl_FragColor = texture2D(texture, gl_TexCoord[0].xy) * gl_Color;
+}

examples/shader/resources/pixelate.sfx

@@ -0,0 +1,10 @@
+uniform sampler2D texture;
+uniform vec2 mouse;
+
+void main()
+{
+	float factor = 5 + 100 * length(mouse);
+	vec2 pos = floor(gl_TexCoord[0].xy * factor + 0.5) / factor;
+
+	gl_FragColor = texture2D(texture, pos) * gl_Color;	
+}

examples/shader/resources/wave.sfx

@@ -0,0 +1,12 @@
+uniform sampler2D texture;
+uniform sampler2D wave;
+uniform vec2 offset;
+
+void main()
+{
+	vec2 texoffset = vec2(texture2D(wave, (gl_TexCoord[0].xy * offset).xy));
+	texoffset -= vec2(0.5, 0.5);
+	texoffset *= 0.05;
+
+	gl_FragColor = texture2D(texture, gl_TexCoord[0].xy + texoffset) * gl_Color;
+}