Added geometry shader support.

include/SFML/Graphics/Shader.h

@@ -38,61 +38,64 @@
 
 
 ////////////////////////////////////////////////////////////
-/// \brief Load both the vertex and fragment shaders from files
+/// \brief Load the vertex, geometry and fragment shaders from files
 ///
-/// This function can load both the vertex and the fragment
+/// This function loads the vertex, geometry and fragment
-/// shaders, or only one of them: pass NULL if you don't want to load
+/// shaders. Pass NULL if you don't want to load
-/// either the vertex shader or the fragment shader.
+/// a specific shader.
 /// The sources must be text files containing valid shaders
 /// in GLSL language. GLSL is a C-like language dedicated to
 /// OpenGL shaders; you'll probably need to read a good documentation
 /// for it before writing your own shaders.
 ///
 /// \param vertexShaderFilename   Path of the vertex shader file to load, or NULL to skip this shader
+/// \param geometryShaderFilename Path of the geometry shader file to load, or NULL to skip this shader
 /// \param fragmentShaderFilename Path of the fragment shader file to load, or NULL to skip this shader
 ///
 /// \return A new sfShader object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char* fragmentShaderFilename);
+CSFML_GRAPHICS_API sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char* geometryShaderFilename, const char* fragmentShaderFilename);
 
 ////////////////////////////////////////////////////////////
-/// \brief Load both the vertex and fragment shaders from source codes in memory
+/// \brief Load the vertex, geometry and fragment shaders from source code in memory
 ///
-/// This function can load both the vertex and the fragment
+/// This function loads the vertex, geometry and fragment
-/// shaders, or only one of them: pass NULL if you don't want to load
+/// shaders. Pass NULL if you don't want to load
-/// either the vertex shader or the fragment shader.
+/// a specific shader.
 /// The sources must be valid shaders in GLSL language. GLSL is
 /// a C-like language dedicated to OpenGL shaders; you'll
 /// probably need to read a good documentation for it before
 /// writing your own shaders.
 ///
 /// \param vertexShader   String containing the source code of the vertex shader, or NULL to skip this shader
+/// \param geometryShader String containing the source code of the geometry shader, or NULL to skip this shader
 /// \param fragmentShader String containing the source code of the fragment shader, or NULL to skip this shader
 ///
 /// \return A new sfShader object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfShader* sfShader_createFromMemory(const char* vertexShader, const char* fragmentShader);
+CSFML_GRAPHICS_API sfShader* sfShader_createFromMemory(const char* vertexShader, const char* geometryShader, const char* fragmentShader);
 
 ////////////////////////////////////////////////////////////
-/// \brief Load both the vertex and fragment shaders from custom streams
+/// \brief Load the vertex, geometry and fragment shaders from custom streams
 ///
-/// This function can load both the vertex and the fragment
+/// This function loads the vertex, geometry and fragment
-/// shaders, or only one of them: pass NULL if you don't want to load
+/// shaders. Pass NULL if you don't want to load
-/// either the vertex shader or the fragment shader.
+/// a specific shader.
 /// The source codes must be valid shaders in GLSL language.
 /// GLSL is a C-like language dedicated to OpenGL shaders;
 /// you'll probably need to read a good documentation for
 /// it before writing your own shaders.
 ///
 /// \param vertexShaderStream   Source stream to read the vertex shader from, or NULL to skip this shader
+/// \param geometryShaderStream Source stream to read the geometry shader from, or NULL to skip this shader
 /// \param fragmentShaderStream Source stream to read the fragment shader from, or NULL to skip this shader
 ///
 /// \return A new sfShader object, or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputStream* fragmentShaderStream);
+CSFML_GRAPHICS_API sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputStream* geometryShaderStream, sfInputStream* fragmentShaderStream);
 
 ////////////////////////////////////////////////////////////
 /// \brief Destroy an existing shader
@@ -122,7 +125,7 @@ CSFML_GRAPHICS_API void sfShader_destroy(sfShader* shader);
 /// \param x      Value to assign
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_setFloatParameter(sfShader* shader, const char* name, float x);
+CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setFloatParameter(sfShader* shader, const char* name, float x);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a 2-components vector parameter of a shader

src/SFML/Graphics/Shader.cpp

@@ -34,30 +34,30 @@
 
 
 ////////////////////////////////////////////////////////////
-sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char* fragmentShaderFilename)
+sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char* geometryShaderFilename, const char* fragmentShaderFilename)
 {
-    bool success = false;
+    bool vertexSuccess = false;
+    bool geometrySuccess = false;
+    bool fragmentSuccess = false;
+
     sfShader* shader = new sfShader;
-    if (vertexShaderFilename || fragmentShaderFilename)
+    
+    if (vertexShaderFilename)
     {
-        if (!vertexShaderFilename)
+        vertexSuccess = shader->This.loadFromFile(vertexShaderFilename, sf::Shader::Vertex);
-        {
-            // fragment shader only
-            success = shader->This.loadFromFile(fragmentShaderFilename, sf::Shader::Fragment);
-        }
-        else if (!fragmentShaderFilename)
-        {
-            // vertex shader only
-            success = shader->This.loadFromFile(vertexShaderFilename, sf::Shader::Vertex);
-        }
-        else
-        {
-            // vertex + fragment shaders
-            success = shader->This.loadFromFile(vertexShaderFilename, fragmentShaderFilename);
-        }
     }
 
-    if (!success)
+    if (geometryShaderFilename)
+    {
+        geometrySuccess = shader->This.loadFromFile(geometryShaderFilename, sf::Shader::Geometry);
+    }
+
+    if (fragmentShaderFilename)
+    {
+        fragmentSuccess = shader->This.loadFromFile(fragmentShaderFilename, sf::Shader::Fragment);
+    }
+
+    if (!(vertexSuccess || geometrySuccess || fragmentSuccess))
     {
         delete shader;
         shader = NULL;
@@ -68,30 +68,30 @@ sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char*
 
 
 ////////////////////////////////////////////////////////////
-sfShader* sfShader_createFromMemory(const char* vertexShader, const char* fragmentShader)
+sfShader* sfShader_createFromMemory(const char* vertexShader, const char* geometryShader, const char* fragmentShader)
 {
-    bool success = false;
+    bool vertexSuccess = false;
+    bool geometrySuccess = false;
+    bool fragmentSuccess = false;
+
     sfShader* shader = new sfShader;
-    if (vertexShader || fragmentShader)
+
+    if (vertexShader)
     {
-        if (!vertexShader)
+        vertexSuccess = shader->This.loadFromMemory(vertexShader, sf::Shader::Vertex);
-        {
-            // fragment shader only
-            success = shader->This.loadFromMemory(fragmentShader, sf::Shader::Fragment);
-        }
-        else if (!fragmentShader)
-        {
-            // vertex shader only
-            success = shader->This.loadFromMemory(vertexShader, sf::Shader::Vertex);
-        }
-        else
-        {
-            // vertex + fragment shaders
-            success = shader->This.loadFromMemory(vertexShader, fragmentShader);
-        }
     }
 
-    if (!success)
+    if (geometryShader)
+    {
+        geometrySuccess = shader->This.loadFromMemory(geometryShader, sf::Shader::Geometry);
+    }
+
+    if (fragmentShader)
+    {
+        fragmentSuccess = shader->This.loadFromMemory(fragmentShader, sf::Shader::Fragment);
+    }
+
+    if (!(vertexSuccess || geometrySuccess || fragmentSuccess))
     {
         delete shader;
         shader = NULL;
@@ -102,34 +102,33 @@ sfShader* sfShader_createFromMemory(const char* vertexShader, const char* fragme
 
 
 ////////////////////////////////////////////////////////////
-sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputStream* fragmentShaderStream)
+sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputStream* geometryShaderStream, sfInputStream* fragmentShaderStream)
 {
-    bool success = false;
+    bool vertexSuccess = false;
+    bool geometrySuccess = false;
+    bool fragmentSuccess = false;
+
     sfShader* shader = new sfShader;
-    if (vertexShaderStream || fragmentShaderStream)
+
+    if (vertexShaderStream)
     {
-        if (!vertexShaderStream)
+        CallbackStream stream(vertexShaderStream);
-        {
+        vertexSuccess = shader->This.loadFromStream(stream, sf::Shader::Vertex);
-            // fragment shader only
-            CallbackStream stream(fragmentShaderStream);
-            success = shader->This.loadFromStream(stream, sf::Shader::Fragment);
-        }
-        else if (!fragmentShaderStream)
-        {
-            // vertex shader only
-            CallbackStream stream(vertexShaderStream);
-            success = shader->This.loadFromStream(stream, sf::Shader::Vertex);
-        }
-        else
-        {
-            // vertex + fragment shaders
-            CallbackStream vertexStream(vertexShaderStream);
-            CallbackStream fragmentStream(fragmentShaderStream);
-            success = shader->This.loadFromStream(vertexStream, fragmentStream);
-        }
     }
 
-    if (!success)
+    if (geometryShaderStream)
+    {
+        CallbackStream stream(geometryShaderStream);
+        geometrySuccess = shader->This.loadFromStream(stream, sf::Shader::Geometry);
+    }
+
+    if (fragmentShaderStream)
+    {
+        CallbackStream stream(fragmentShaderStream);
+        fragmentSuccess = shader->This.loadFromStream(stream, sf::Shader::Fragment);
+    }
+
+    if (!(vertexSuccess || geometrySuccess || fragmentSuccess))
     {
         delete shader;
         shader = NULL;