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,11 +34,13 @@
 
 
 ////////////////////////////////////////////////////////////
-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 (!geometryShaderFilename)
         {
             if (!vertexShaderFilename)
             {
@@ -56,6 +58,12 @@ sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char*
                 success = shader->This.loadFromFile(vertexShaderFilename, fragmentShaderFilename);
             }
         }
+        else
+        {
+            // vertex + geometry + fragment shaders
+            success = shader->This.loadFromFile(vertexShaderFilename, geometryShaderFilename, fragmentShaderFilename);
+        }
+    }
 
     if (!success)
     {
@@ -68,11 +76,13 @@ 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 (!geometryShader)
         {
             if (!vertexShader)
             {
@@ -90,6 +100,12 @@ sfShader* sfShader_createFromMemory(const char* vertexShader, const char* fragme
                 success = shader->This.loadFromMemory(vertexShader, fragmentShader);
             }
         }
+        else
+        {
+            // vertex + geometry + fragment shaders
+            success = shader->This.loadFromMemory(vertexShader, geometryShader, fragmentShader);
+        }
+    }
 
     if (!success)
     {
@@ -102,11 +118,13 @@ 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 (!geometryShaderStream)
         {
             if (!vertexShaderStream)
             {
@@ -128,6 +146,15 @@ sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputSt
                 success = shader->This.loadFromStream(vertexStream, fragmentStream);
             }
         }
+        else
+        {
+            // vertex + geometry + fragment shaders
+            CallbackStream vertexStream(vertexShaderStream);
+            CallbackStream geometryStream(geometryShaderStream);
+            CallbackStream fragmentStream(fragmentShaderStream);
+            success = shader->This.loadFromStream(vertexStream, geometryStream, fragmentStream);
+        }
+    }
 
     if (!success)
     {