Simplify shader creation functions

src/CSFML/Graphics/Shader.cpp

@@ -37,41 +37,28 @@ sfShader* sfShader_createFromFile(const char* vertexShaderFilename,
                                   const char* geometryShaderFilename,
                                   const char* fragmentShaderFilename)
 {
+    // At least one shader must be provided
+    if (!(vertexShaderFilename || geometryShaderFilename || fragmentShaderFilename))
+        return nullptr;
+
     bool success = false;
     auto shader  = std::make_unique<sfShader>();
-    if (vertexShaderFilename || geometryShaderFilename || fragmentShaderFilename)
+
+    if (!geometryShaderFilename)
     {
-        if (!geometryShaderFilename)
+        if (!vertexShaderFilename) // fragment shader only
-        {
+            success = shader->loadFromFile(fragmentShaderFilename, sf::Shader::Type::Fragment);
-            if (!vertexShaderFilename)
+        else if (!fragmentShaderFilename) // vertex shader only
-            {
+            success = shader->loadFromFile(vertexShaderFilename, sf::Shader::Type::Vertex);
-                // fragment shader only
+        else // vertex + fragment shaders
-                success = shader->loadFromFile(fragmentShaderFilename, sf::Shader::Type::Fragment);
+            success = shader->loadFromFile(vertexShaderFilename, fragmentShaderFilename);
-            }
+    }
-            else if (!fragmentShaderFilename)
+    else
-            {
+    {
-                // vertex shader only
+        if (!vertexShaderFilename && !fragmentShaderFilename) // geometry shader only
-                success = shader->loadFromFile(vertexShaderFilename, sf::Shader::Type::Vertex);
+            success = shader->loadFromFile(geometryShaderFilename, sf::Shader::Type::Geometry);
-            }
+        else // vertex + geometry + fragment shaders
-            else
+            success = shader->loadFromFile(vertexShaderFilename, geometryShaderFilename, fragmentShaderFilename);
-            {
-                // vertex + fragment shaders
-                success = shader->loadFromFile(vertexShaderFilename, fragmentShaderFilename);
-            }
-        }
-        else
-        {
-            if (!vertexShaderFilename && !fragmentShaderFilename)
-            {
-                // geometry shader only
-                success = shader->loadFromFile(geometryShaderFilename, sf::Shader::Type::Geometry);
-            }
-            else
-            {
-                // vertex + geometry + fragment shaders
-                success = shader->loadFromFile(vertexShaderFilename, geometryShaderFilename, fragmentShaderFilename);
-            }
-        }
     }
 
     if (!success)
@@ -84,41 +71,28 @@ sfShader* sfShader_createFromFile(const char* vertexShaderFilename,
 ////////////////////////////////////////////////////////////
 sfShader* sfShader_createFromMemory(const char* vertexShader, const char* geometryShader, const char* fragmentShader)
 {
+    // At least one shader must be provided
+    if (!(vertexShader || geometryShader || fragmentShader))
+        return nullptr;
+
     bool success = false;
     auto shader  = std::make_unique<sfShader>();
-    if (vertexShader || geometryShader || fragmentShader)
+
+    if (!geometryShader)
     {
-        if (!geometryShader)
+        if (!vertexShader) // fragment shader only
-        {
+            success = shader->loadFromMemory(fragmentShader, sf::Shader::Type::Fragment);
-            if (!vertexShader)
+        else if (!fragmentShader) // vertex shader only
-            {
+            success = shader->loadFromMemory(vertexShader, sf::Shader::Type::Vertex);
-                // fragment shader only
+        else // vertex + fragment shaders
-                success = shader->loadFromMemory(fragmentShader, sf::Shader::Type::Fragment);
+            success = shader->loadFromMemory(vertexShader, fragmentShader);
-            }
+    }
-            else if (!fragmentShader)
+    else
-            {
+    {
-                // vertex shader only
+        if (!vertexShader && !fragmentShader) // geometry shader only
-                success = shader->loadFromMemory(vertexShader, sf::Shader::Type::Vertex);
+            success = shader->loadFromMemory(geometryShader, sf::Shader::Type::Geometry);
-            }
+        else // vertex + geometry + fragment shaders
-            else
+            success = shader->loadFromMemory(vertexShader, geometryShader, fragmentShader);
-            {
-                // vertex + fragment shaders
-                success = shader->loadFromMemory(vertexShader, fragmentShader);
-            }
-        }
-        else
-        {
-            if (!vertexShader && !fragmentShader)
-            {
-                // geometry shader only
-                success = shader->loadFromMemory(geometryShader, sf::Shader::Type::Geometry);
-            }
-            else
-            {
-                // vertex + geometry + fragment shaders
-                success = shader->loadFromMemory(vertexShader, geometryShader, fragmentShader);
-            }
-        }
     }
 
     if (!success)
@@ -133,47 +107,44 @@ sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream,
                                     sfInputStream* geometryShaderStream,
                                     sfInputStream* fragmentShaderStream)
 {
+    // At least one shader must be provided
+    if (!(vertexShaderStream || geometryShaderStream || fragmentShaderStream))
+        return nullptr;
+
     bool success = false;
     auto shader  = std::make_unique<sfShader>();
-    if (vertexShaderStream || geometryShaderStream || fragmentShaderStream)
+
+    if (!geometryShaderStream)
     {
-        if (!geometryShaderStream)
+        if (!vertexShaderStream) // fragment shader only
         {
-            if (!vertexShaderStream)
+            CallbackStream stream(fragmentShaderStream);
-            {
+            success = shader->loadFromStream(stream, sf::Shader::Type::Fragment);
-                // fragment shader only
-                CallbackStream stream(fragmentShaderStream);
-                success = shader->loadFromStream(stream, sf::Shader::Type::Fragment);
-            }
-            else if (!fragmentShaderStream)
-            {
-                // vertex shader only
-                CallbackStream stream(vertexShaderStream);
-                success = shader->loadFromStream(stream, sf::Shader::Type::Vertex);
-            }
-            else
-            {
-                // vertex + fragment shaders
-                CallbackStream vertexStream(vertexShaderStream);
-                CallbackStream fragmentStream(fragmentShaderStream);
-                success = shader->loadFromStream(vertexStream, fragmentStream);
-            }
         }
-        else
+        else if (!fragmentShaderStream) // vertex shader only
         {
-            CallbackStream geometryStream(geometryShaderStream);
+            CallbackStream stream(vertexShaderStream);
-            if (!vertexShaderStream && !fragmentShaderStream)
+            success = shader->loadFromStream(stream, sf::Shader::Type::Vertex);
-            {
+        }
-                // geometry shader only
+        else // vertex + fragment shaders
-                success = shader->loadFromStream(geometryStream, sf::Shader::Type::Geometry);
+        {
-            }
+            CallbackStream vertexStream(vertexShaderStream);
-            else
+            CallbackStream fragmentStream(fragmentShaderStream);
-            {
+            success = shader->loadFromStream(vertexStream, fragmentStream);
-                // vertex + geometry + fragment shaders
+        }
-                CallbackStream vertexStream(vertexShaderStream);
+    }
-                CallbackStream fragmentStream(fragmentShaderStream);
+    else
-                success = shader->loadFromStream(vertexStream, geometryStream, fragmentStream);
+    {
-            }
+        CallbackStream geometryStream(geometryShaderStream);
+        if (!vertexShaderStream && !fragmentShaderStream) // geometry shader only
+        {
+            success = shader->loadFromStream(geometryStream, sf::Shader::Type::Geometry);
+        }
+        else // vertex + geometry + fragment shaders
+        {
+            CallbackStream vertexStream(vertexShaderStream);
+            CallbackStream fragmentStream(fragmentShaderStream);
+            success = shader->loadFromStream(vertexStream, geometryStream, fragmentStream);
         }
     }