Modified sfShader_createFromFile, sfShader_createFromMemory and sfShader_createFromStream functions to allow loading of all three vertex + geometry + fragment shaders

include/SFML/Graphics/Shader.h

@@ -40,59 +40,62 @@
 ////////////////////////////////////////////////////////////
 /// \brief Load both the vertex and fragment shaders from files
 ///
-/// This function can load both the vertex and the fragment
+/// This function can load the vertex, the geometry and the fragment
-/// shaders, or only one of them: pass NULL if you don't want to load
+/// shaders, or only one or two of them: pass NULL if you don't want to load
-/// either the vertex shader or the fragment shader.
+/// the vertex shader, the geometry shader or the fragment 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
 ///
-/// This function can load both the vertex and the fragment
+/// This function can load the vertex, the geometry and the fragment
-/// shaders, or only one of them: pass NULL if you don't want to load
+/// shaders, or only one or two of them: pass NULL if you don't want to load
-/// either the vertex shader or the fragment shader.
+/// the vertex shader, the geometry shader or the fragment 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
 ///
-/// This function can load both the vertex and the fragment
+/// This function can load the vertex, the geometry and the fragment
-/// shaders, or only one of them: pass NULL if you don't want to load
+/// shaders, or only one or two of them: pass NULL if you don't want to load
-/// either the vertex shader or the fragment shader.
+/// the vertex shader, the geometry shader or the fragment 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

src/SFML/Graphics/Shader.cpp

@@ -34,26 +34,34 @@
 
 
 ////////////////////////////////////////////////////////////
-sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char* fragmentShaderFilename)
+sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char* geometryShaderFilename, const char* fragmentShaderFilename)
 {
     bool success = false;
     sfShader* shader = new sfShader;
-    if (vertexShaderFilename || fragmentShaderFilename)
+    if (vertexShaderFilename || geometryShaderFilename || fragmentShaderFilename)
     {
-        if (!vertexShaderFilename)
+        if (!geometryShaderFilename)
         {
-            // fragment shader only
+            if (!vertexShaderFilename)
-            success = shader->This.loadFromFile(fragmentShaderFilename, sf::Shader::Fragment);
+            {
-        }
+                // fragment shader only
-        else if (!fragmentShaderFilename)
+                success = shader->This.loadFromFile(fragmentShaderFilename, sf::Shader::Fragment);
-        {
+            }
-            // vertex shader only
+            else if (!fragmentShaderFilename)
-            success = shader->This.loadFromFile(vertexShaderFilename, sf::Shader::Vertex);
+            {
+                // vertex shader only
+                success = shader->This.loadFromFile(vertexShaderFilename, sf::Shader::Vertex);
+            }
+            else
+            {
+                // vertex + fragment shaders
+                success = shader->This.loadFromFile(vertexShaderFilename, fragmentShaderFilename);
+            }
         }
         else
         {
-            // vertex + fragment shaders
+            // vertex + geometry + fragment shaders
-            success = shader->This.loadFromFile(vertexShaderFilename, fragmentShaderFilename);
+            success = shader->This.loadFromFile(vertexShaderFilename, geometryShaderFilename, fragmentShaderFilename);
         }
     }
 
@@ -68,26 +76,34 @@ 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;
     sfShader* shader = new sfShader;
-    if (vertexShader || fragmentShader)
+    if (vertexShader || geometryShader || fragmentShader)
     {
-        if (!vertexShader)
+        if (!geometryShader)
         {
-            // fragment shader only
+            if (!vertexShader)
-            success = shader->This.loadFromMemory(fragmentShader, sf::Shader::Fragment);
+            {
-        }
+                // fragment shader only
-        else if (!fragmentShader)
+                success = shader->This.loadFromMemory(fragmentShader, sf::Shader::Fragment);
-        {
+            }
-            // vertex shader only
+            else if (!fragmentShader)
-            success = shader->This.loadFromMemory(vertexShader, sf::Shader::Vertex);
+            {
+                // vertex shader only
+                success = shader->This.loadFromMemory(vertexShader, sf::Shader::Vertex);
+            }
+            else
+            {
+                // vertex + fragment shaders
+                success = shader->This.loadFromMemory(vertexShader, fragmentShader);
+            }
         }
         else
         {
-            // vertex + fragment shaders
+            // vertex + geometry + fragment shaders
-            success = shader->This.loadFromMemory(vertexShader, fragmentShader);
+            success = shader->This.loadFromMemory(vertexShader, geometryShader, fragmentShader);
         }
     }
 
@@ -102,30 +118,41 @@ 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;
     sfShader* shader = new sfShader;
-    if (vertexShaderStream || fragmentShaderStream)
+    if (vertexShaderStream || geometryShaderStream || fragmentShaderStream)
     {
-        if (!vertexShaderStream)
+        if (!geometryShaderStream)
         {
-            // fragment shader only
+            if (!vertexShaderStream)
-            CallbackStream stream(fragmentShaderStream);
+            {
-            success = shader->This.loadFromStream(stream, sf::Shader::Fragment);
+                // fragment shader only
-        }
+                CallbackStream stream(fragmentShaderStream);
-        else if (!fragmentShaderStream)
+                success = shader->This.loadFromStream(stream, sf::Shader::Fragment);
-        {
+            }
-            // vertex shader only
+            else if (!fragmentShaderStream)
-            CallbackStream stream(vertexShaderStream);
+            {
-            success = shader->This.loadFromStream(stream, sf::Shader::Vertex);
+                // 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);
+            }
         }
         else
         {
-            // vertex + fragment shaders
+            // vertex + geometry + fragment shaders
             CallbackStream vertexStream(vertexShaderStream);
+            CallbackStream geometryStream(geometryShaderStream);
             CallbackStream fragmentStream(fragmentShaderStream);
-            success = shader->This.loadFromStream(vertexStream, fragmentStream);
+            success = shader->This.loadFromStream(vertexStream, geometryStream, fragmentStream);
         }
     }