Implemented new setUniform API for shaders.

Deprecated old setParameter API.

include/SFML/Graphics/Glsl.h

@@ -36,8 +36,8 @@ typedef sfVector2i sfGlslIvec2;
 
 typedef struct
 {
-	bool x;
-	bool y;
+    bool x;
+    bool y;
 } sfGlslBvec2;
 
 // 3D vectors
@@ -45,52 +45,52 @@ typedef sfVector3f sfGlslVec3;
 
 typedef struct
 {
-	int x;
-	int y;
-	int z;
+    int x;
+    int y;
+    int z;
 } sfGlslIvec3;
 
 typedef struct
 {
-	bool x;
-	bool y;
-	bool z;
+    bool x;
+    bool y;
+    bool z;
 } sfGlslBvec3;
 
 // 4D vectors
 typedef struct
 {
-	float x;
-	float y;
-	float z;
-	float w;
+    float x;
+    float y;
+    float z;
+    float w;
 } sfGlslVec4;
 
 typedef struct
 {
-	int x;
-	int y;
-	int z;
-	int w;
+    int x;
+    int y;
+    int z;
+    int w;
 } sfGlslIvec4;
 
 typedef struct
 {
-	bool x;
-	bool y;
-	bool z;
-	bool w;
+    bool x;
+    bool y;
+    bool z;
+    bool w;
 } sfGlslBvec4;
 
 // matrices
 typedef struct
 {
-	float array[3 * 3];
+    float array[3 * 3];
 } sfGlslMat3;
 
 typedef struct
 {
-	float array[4 * 4];
+    float array[4 * 4];
 } sfGlslMat4;
 
 #endif // SFML_GLSL_H

include/SFML/Graphics/Shader.h

@@ -30,6 +30,7 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Graphics/Export.h>
 #include <SFML/Graphics/Color.h>
+#include <SFML/Graphics/Glsl.h>
 #include <SFML/Graphics/Transform.h>
 #include <SFML/Graphics/Types.h>
 #include <SFML/System/InputStream.h>
@@ -105,6 +106,297 @@ CSFML_GRAPHICS_API sfShader* sfShader_createFromStream(sfInputStream* vertexShad
 ////////////////////////////////////////////////////////////
 CSFML_GRAPHICS_API void sfShader_destroy(sfShader* shader);
 
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p float uniform
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param x      Value of the float scalar
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setFloatUniform(sfShader* shader, const char* name, float x);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p vec2 uniform
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param vector Value of the vec2 vector
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setVec2Uniform(sfShader* shader, const char* name, sfGlslVec2 vector);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p vec3 uniform
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param vector Value of the vec3 vector
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setVec3Uniform(sfShader* shader, const char* name, sfGlslVec3 vector);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p vec4 uniform
+///
+/// sfColor objects can be passed to this function via 
+/// the use of sfGlslVec4_fromsfColor(sfColor);
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param vector Value of the vec4 vector
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setVec4Uniform(sfShader* shader, const char* name, sfGlslVec4 vector);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p vec4 uniform
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param color  Value of the vec4 vector
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setColorUniform(sfShader* shader, const char* name, sfColor color);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p int uniform
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param x      Value of the integer scalar
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setIntUniform(sfShader* shader, const char* name, int x);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p ivec2 uniform
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param vector Value of the ivec2 vector
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setIvec2Uniform(sfShader* shader, const char* name, sfGlslIvec2 vector);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p ivec3 uniform
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param vector Value of the ivec3 vector
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setIvec3Uniform(sfShader* shader, const char* name, sfGlslIvec3 vector);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p ivec4 uniform
+///
+/// sfColor objects can be passed to this function via 
+/// the use of sfGlslIvec4_fromsfColor(sfColor);
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param vector Value of the ivec4 vector
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setIvec4Uniform(sfShader* shader, const char* name, sfGlslIvec4 vector);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p ivec4 uniform
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param color  Value of the ivec4 vector
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setIntColorUniform(sfShader* shader, const char* name, sfColor color);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p bool uniform
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param x      Value of the bool scalar
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setBoolUniform(sfShader* shader, const char* name, sfBool x);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p bvec2 uniform
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param vector Value of the bvec2 vector
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setBvec2Uniform(sfShader* shader, const char* name, sfGlslBvec2 vector);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p Bvec3 uniform
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param vector Value of the Bvec3 vector
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setBvec3Uniform(sfShader* shader, const char* name, sfGlslBvec3 vector);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p bvec4 uniform
+///
+/// sfColor objects can be passed to this function via 
+/// the use of sfGlslIvec4_fromsfColor(sfColor);
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param vector Value of the bvec4 vector
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setBvec4Uniform(sfShader* shader, const char* name, sfGlslBvec4 vector);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p mat3 matrix
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param matrix Value of the mat3 matrix
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setMat3Uniform(sfShader* shader, const char* name, const sfGlslMat3* matrix);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify value for \p mat4 matrix
+///
+/// \param shader Shader object
+/// \param name   Name of the uniform variable in GLSL
+/// \param matrix Value of the mat4 matrix
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setMat4Uniform(sfShader* shader, const char* name, const sfGlslMat4* matrix);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify a texture as \p sampler2D uniform
+///
+/// \a name is the name of the variable to change in the shader.
+/// The corresponding parameter in the shader must be a 2D texture
+/// (\p sampler2D GLSL type).
+///
+/// Example:
+/// \code
+/// uniform sampler2D the_texture; // this is the variable in the shader
+/// \endcode
+/// \code
+/// sfTexture texture;
+/// ...
+/// sfShader_setTextureUniform(shader, "the_texture", &texture);
+/// \endcode
+/// It is important to note that \a texture must remain alive as long
+/// as the shader uses it, no copy is made internally.
+///
+/// To use the texture of the object being drawn, which cannot be
+/// known in advance, you can pass the special value
+/// sf::Shader::CurrentTexture:
+/// \code
+/// shader.setUniform("the_texture", sf::Shader::CurrentTexture).
+/// \endcode
+///
+/// \param shader  Shader object
+/// \param name    Name of the texture in the shader
+/// \param texture Texture to assign
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setTextureUniform(sfShader* shader, const char* name, const sfTexture* texture);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify current texture as \p sampler2D uniform
+///
+/// This overload maps a shader texture variable to the
+/// texture of the object being drawn, which cannot be
+/// known in advance.
+/// The corresponding parameter in the shader must be a 2D texture
+/// (\p sampler2D GLSL type).
+///
+/// Example:
+/// \code
+/// uniform sampler2D current; // this is the variable in the shader
+/// \endcode
+/// \code
+/// sfShader_setCurrentTextureUniform(shader, "current");
+/// \endcode
+///
+/// \param shader Shader object
+/// \param name   Name of the texture in the shader
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setCurrentTextureUniform(sfShader* shader, const char* name);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify values for \p float[] array uniform
+///
+/// \param shader      Shader object
+/// \param name        Name of the uniform variable in GLSL
+/// \param scalarArray pointer to array of \p float values
+/// \param length      Number of elements in the array
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setFloatUniformArray(sfShader* shader, const char* name, const float* scalarArray, size_t length);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify values for \p vec2[] array uniform
+///
+/// \param shader      Shader object
+/// \param name        Name of the uniform variable in GLSL
+/// \param vectorArray pointer to array of \p vec2 values
+/// \param length      Number of elements in the array
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setVec2UniformArray(sfShader* shader, const char* name, const sfGlslVec2* vectorArray, size_t length);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify values for \p vec3[] array uniform
+///
+/// \param shader      Shader object
+/// \param name        Name of the uniform variable in GLSL
+/// \param vectorArray pointer to array of \p vec3 values
+/// \param length      Number of elements in the array
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setVec3UniformArray(sfShader* shader, const char* name, const sfGlslVec3* vectorArray, size_t length);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify values for \p vec4[] array uniform
+///
+/// \param shader      Shader object
+/// \param name        Name of the uniform variable in GLSL
+/// \param vectorArray pointer to array of \p vec4 values
+/// \param length      Number of elements in the array
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setVec4UniformArray(sfShader* shader, const char* name, const sfGlslVec4* vectorArray, size_t length);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify values for \p mat3[] array uniform
+///
+/// \param shader      Shader object
+/// \param name        Name of the uniform variable in GLSL
+/// \param matrixArray pointer to array of \p mat3 values
+/// \param length      Number of elements in the array
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setMat3UniformArray(sfShader* shader, const char* name, const sfGlslMat3* matrixArray, size_t length);
+
+////////////////////////////////////////////////////////////
+/// \brief Specify values for \p mat4[] array uniform
+///
+/// \param shader      Shader object
+/// \param name        Name of the uniform variable in GLSL
+/// \param matrixArray pointer to array of \p mat4 values
+/// \param length      Number of elements in the array
+///
+////////////////////////////////////////////////////////////
+CSFML_GRAPHICS_API void sfShader_setMat4UniformArray(sfShader* shader, const char* name, const sfGlslMat4* matrixArray, size_t length);
+
 ////////////////////////////////////////////////////////////
 /// \brief Change a float parameter of a shader
 ///
@@ -148,7 +440,7 @@ CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setFloatParameter(sfShader* sh
 /// \param y      Second component of the value to assign
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_setFloat2Parameter(sfShader* shader, const char* name, float x, float y);
+CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setFloat2Parameter(sfShader* shader, const char* name, float x, float y);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a 3-components vector parameter of a shader
@@ -172,7 +464,7 @@ CSFML_GRAPHICS_API void sfShader_setFloat2Parameter(sfShader* shader, const char
 /// \param z      Third component of the value to assign
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_setFloat3Parameter(sfShader* shader, const char* name, float x, float y, float z);
+CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setFloat3Parameter(sfShader* shader, const char* name, float x, float y, float z);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a 4-components vector parameter of a shader
@@ -197,7 +489,7 @@ CSFML_GRAPHICS_API void sfShader_setFloat3Parameter(sfShader* shader, const char
 /// \param w      Fourth component of the value to assign
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_setFloat4Parameter(sfShader* shader, const char* name, float x, float y, float z, float w);
+CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setFloat4Parameter(sfShader* shader, const char* name, float x, float y, float z, float w);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a 2-components vector parameter of a shader
@@ -220,7 +512,7 @@ CSFML_GRAPHICS_API void sfShader_setFloat4Parameter(sfShader* shader, const char
 /// \param vector Vector to assign
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_setVector2Parameter(sfShader* shader, const char* name, sfVector2f vector);
+CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setVector2Parameter(sfShader* shader, const char* name, sfVector2f vector);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a 3-components vector parameter of a shader
@@ -243,7 +535,7 @@ CSFML_GRAPHICS_API void sfShader_setVector2Parameter(sfShader* shader, const cha
 /// \param vector Vector to assign
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_setVector3Parameter(sfShader* shader, const char* name, sfVector3f vector);
+CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setVector3Parameter(sfShader* shader, const char* name, sfVector3f vector);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a color parameter of a shader
@@ -271,7 +563,7 @@ CSFML_GRAPHICS_API void sfShader_setVector3Parameter(sfShader* shader, const cha
 /// \param color  Color to assign
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_setColorParameter(sfShader* shader, const char* name, sfColor color);
+CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setColorParameter(sfShader* shader, const char* name, sfColor color);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a matrix parameter of a shader
@@ -294,7 +586,7 @@ CSFML_GRAPHICS_API void sfShader_setColorParameter(sfShader* shader, const char*
 /// \param transform Transform to assign
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_setTransformParameter(sfShader* shader, const char* name, sfTransform transform);
+CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setTransformParameter(sfShader* shader, const char* name, sfTransform transform);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a texture parameter of a shader
@@ -327,7 +619,7 @@ CSFML_GRAPHICS_API void sfShader_setTransformParameter(sfShader* shader, const c
 /// \param texture Texture to assign
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_setTextureParameter(sfShader* shader, const char* name, const sfTexture* texture);
+CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setTextureParameter(sfShader* shader, const char* name, const sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a texture parameter of a shader
@@ -350,7 +642,7 @@ CSFML_GRAPHICS_API void sfShader_setTextureParameter(sfShader* shader, const cha
 /// \param name   Name of the texture in the shader
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_setCurrentTextureParameter(sfShader* shader, const char* name);
+CSFML_GRAPHICS_API CSFML_DEPRECATED void sfShader_setCurrentTextureParameter(sfShader* shader, const char* name);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the underlying OpenGL handle of the shader.

src/SFML/Graphics/Shader.cpp

@@ -36,202 +36,380 @@
 ////////////////////////////////////////////////////////////
 sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char* geometryShaderFilename, const char* fragmentShaderFilename)
 {
-    bool vertexSuccess = false;
-    bool geometrySuccess = false;
-    bool fragmentSuccess = false;
+	bool vertexSuccess = false;
+	bool geometrySuccess = false;
+	bool fragmentSuccess = false;
 
-    sfShader* shader = new sfShader;
-    
-    if (vertexShaderFilename)
-    {
-        vertexSuccess = shader->This.loadFromFile(vertexShaderFilename, sf::Shader::Vertex);
-    }
+	sfShader* shader = new sfShader;
+	
+	if (vertexShaderFilename)
+	{
+		vertexSuccess = shader->This.loadFromFile(vertexShaderFilename, sf::Shader::Vertex);
+	}
 
-    if (geometryShaderFilename)
-    {
-        geometrySuccess = shader->This.loadFromFile(geometryShaderFilename, sf::Shader::Geometry);
-    }
+	if (geometryShaderFilename)
+	{
+		geometrySuccess = shader->This.loadFromFile(geometryShaderFilename, sf::Shader::Geometry);
+	}
 
-    if (fragmentShaderFilename)
-    {
-        fragmentSuccess = shader->This.loadFromFile(fragmentShaderFilename, sf::Shader::Fragment);
-    }
+	if (fragmentShaderFilename)
+	{
+		fragmentSuccess = shader->This.loadFromFile(fragmentShaderFilename, sf::Shader::Fragment);
+	}
 
-    if (!(vertexSuccess || geometrySuccess || fragmentSuccess))
-    {
-        delete shader;
-        shader = NULL;
-    }
+	if (!(vertexSuccess || geometrySuccess || fragmentSuccess))
+	{
+		delete shader;
+		shader = NULL;
+	}
 
-    return shader;
+	return shader;
 }
 
 
 ////////////////////////////////////////////////////////////
 sfShader* sfShader_createFromMemory(const char* vertexShader, const char* geometryShader, const char* fragmentShader)
 {
-    bool vertexSuccess = false;
-    bool geometrySuccess = false;
-    bool fragmentSuccess = false;
+	bool vertexSuccess = false;
+	bool geometrySuccess = false;
+	bool fragmentSuccess = false;
 
-    sfShader* shader = new sfShader;
+	sfShader* shader = new sfShader;
 
-    if (vertexShader)
-    {
-        vertexSuccess = shader->This.loadFromMemory(vertexShader, sf::Shader::Vertex);
-    }
+	if (vertexShader)
+	{
+		vertexSuccess = shader->This.loadFromMemory(vertexShader, sf::Shader::Vertex);
+	}
 
-    if (geometryShader)
-    {
-        geometrySuccess = shader->This.loadFromMemory(geometryShader, sf::Shader::Geometry);
-    }
+	if (geometryShader)
+	{
+		geometrySuccess = shader->This.loadFromMemory(geometryShader, sf::Shader::Geometry);
+	}
 
-    if (fragmentShader)
-    {
-        fragmentSuccess = shader->This.loadFromMemory(fragmentShader, sf::Shader::Fragment);
-    }
+	if (fragmentShader)
+	{
+		fragmentSuccess = shader->This.loadFromMemory(fragmentShader, sf::Shader::Fragment);
+	}
 
-    if (!(vertexSuccess || geometrySuccess || fragmentSuccess))
-    {
-        delete shader;
-        shader = NULL;
-    }
+	if (!(vertexSuccess || geometrySuccess || fragmentSuccess))
+	{
+		delete shader;
+		shader = NULL;
+	}
 
-    return shader;
+	return shader;
 }
 
 
 ////////////////////////////////////////////////////////////
 sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputStream* geometryShaderStream, sfInputStream* fragmentShaderStream)
 {
-    bool vertexSuccess = false;
-    bool geometrySuccess = false;
-    bool fragmentSuccess = false;
+	bool vertexSuccess = false;
+	bool geometrySuccess = false;
+	bool fragmentSuccess = false;
 
-    sfShader* shader = new sfShader;
+	sfShader* shader = new sfShader;
 
-    if (vertexShaderStream)
-    {
-        CallbackStream stream(vertexShaderStream);
-        vertexSuccess = shader->This.loadFromStream(stream, sf::Shader::Vertex);
-    }
+	if (vertexShaderStream)
+	{
+		CallbackStream stream(vertexShaderStream);
+		vertexSuccess = shader->This.loadFromStream(stream, sf::Shader::Vertex);
+	}
 
-    if (geometryShaderStream)
-    {
-        CallbackStream stream(geometryShaderStream);
-        geometrySuccess = shader->This.loadFromStream(stream, sf::Shader::Geometry);
-    }
+	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 (fragmentShaderStream)
+	{
+		CallbackStream stream(fragmentShaderStream);
+		fragmentSuccess = shader->This.loadFromStream(stream, sf::Shader::Fragment);
+	}
 
-    if (!(vertexSuccess || geometrySuccess || fragmentSuccess))
-    {
-        delete shader;
-        shader = NULL;
-    }
+	if (!(vertexSuccess || geometrySuccess || fragmentSuccess))
+	{
+		delete shader;
+		shader = NULL;
+	}
 
-    return shader;
+	return shader;
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_destroy(sfShader* shader)
 {
-    delete shader;
+	delete shader;
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setFloatUniform(sfShader* shader, const char* name, float x)
+{
+	CSFML_CALL(shader, setUniform(name, x));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setVec2Uniform(sfShader* shader, const char* name, sfGlslVec2 vector)
+{
+	CSFML_CALL(shader, setUniform(name, sf::Glsl::Vec2(vector.x, vector.y)));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setVec3Uniform(sfShader* shader, const char* name, sfGlslVec3 vector)
+{
+	CSFML_CALL(shader, setUniform(name, sf::Glsl::Vec3(vector.x, vector.y, vector.z)));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setVec4Uniform(sfShader* shader, const char* name, sfGlslVec4 vector)
+{
+	CSFML_CALL(shader, setUniform(name, sf::Glsl::Vec4(vector.x, vector.y, vector.z, vector.w)));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setColorUniform(sfShader* shader, const char* name, sfColor color)
+{
+	sfGlslVec4 vec4;
+	vec4.x = color.r / 255.f;
+	vec4.y = color.g / 255.f;
+	vec4.z = color.b / 255.f;
+	vec4.w = color.a / 255.f;
+
+	sfShader_setVec4Uniform(shader, name, vec4);
+}
+
+////////////////////////////////////////////////////////////
+void sfShader_setIntUniform(sfShader* shader, const char* name, int x)
+{
+	CSFML_CALL(shader, setUniform(name, x));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setIvec2Uniform(sfShader* shader, const char* name, sfGlslIvec2 vector)
+{
+	CSFML_CALL(shader, setUniform(name, sf::Glsl::Ivec2(vector.x, vector.y)));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setIvec3Uniform(sfShader* shader, const char* name, sfGlslIvec3 vector)
+{
+	CSFML_CALL(shader, setUniform(name, sf::Glsl::Ivec3(vector.x, vector.y, vector.z)));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setIvec4Uniform(sfShader* shader, const char* name, sfGlslIvec4 vector)
+{
+	CSFML_CALL(shader, setUniform(name, sf::Glsl::Ivec4(vector.x, vector.y, vector.z, vector.w)));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setIntColorUniform(sfShader* shader, const char* name, sfColor color)
+{
+	sfGlslIvec4 ivec4;
+	ivec4.x = (int)color.r;
+	ivec4.y = (int)color.g;
+	ivec4.z = (int)color.b;
+	ivec4.w = (int)color.a;
+
+	sfShader_setIvec4Uniform(shader, name, ivec4);
+}
+
+////////////////////////////////////////////////////////////
+void sfShader_setBoolUniform(sfShader* shader, const char* name, sfBool x)
+{
+	CSFML_CALL(shader, setUniform(name, x));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setBvec2Uniform(sfShader* shader, const char* name, sfGlslBvec2 vector)
+{
+	CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec2(vector.x, vector.y)));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setBvec3Uniform(sfShader* shader, const char* name, sfGlslBvec3 vector)
+{
+	CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec3(vector.x, vector.y, vector.z)));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setBvec4Uniform(sfShader* shader, const char* name, sfGlslBvec4 vector)
+{
+	CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec4(vector.x, vector.y, vector.z, vector.w)));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setMat3Uniform(sfShader* shader, const char* name, const sfGlslMat3* matrix)
+{
+	CSFML_CALL(shader, setUniform(name, sf::Glsl::Mat3(matrix->array)));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setMat4Uniform(sfShader* shader, const char* name, const sfGlslMat4* matrix)
+{
+	CSFML_CALL(shader, setUniform(name, sf::Glsl::Mat4(matrix->array)));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setTextureUniform(sfShader* shader, const char* name, const sfTexture* texture)
+{
+	CSFML_CALL(shader, setUniform(name, *texture->This));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setCurrentTextureUniform(sfShader* shader, const char* name)
+{
+	CSFML_CALL(shader, setUniform(name, sf::Shader::CurrentTexture));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setFloatUniformArray(sfShader* shader, const char* name, const float* scalarArray, size_t length)
+{
+	CSFML_CALL(shader, setUniformArray(name, scalarArray, length));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setVec2UniformArray(sfShader* shader, const char* name, const sfGlslVec2* vectorArray, size_t length)
+{
+	CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec2*>(vectorArray), length));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setVec3UniformArray(sfShader* shader, const char* name, const sfGlslVec3* vectorArray, size_t length)
+{
+	CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec3*>(vectorArray), length));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setVec4UniformArray(sfShader* shader, const char* name, const sfGlslVec4* vectorArray, size_t length)
+{
+	CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec4*>(vectorArray), length));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setMat3UniformArray(sfShader* shader, const char* name, const sfGlslMat3* matrixArray, size_t length)
+{
+	CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Mat3*>(matrixArray), length));
+}
+
+
+////////////////////////////////////////////////////////////
+void sfShader_setMat4UniformArray(sfShader* shader, const char* name, const sfGlslMat4* matrixArray, size_t length)
+{
+	CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Mat4*>(matrixArray), length));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setFloatParameter(sfShader* shader, const char* name, float x)
 {
-    CSFML_CALL(shader, setParameter(name, x));
+	CSFML_CALL(shader, setParameter(name, x));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setFloat2Parameter(sfShader* shader, const char* name, float x, float y)
 {
-    CSFML_CALL(shader, setParameter(name, x, y));
+	CSFML_CALL(shader, setParameter(name, x, y));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setFloat3Parameter(sfShader* shader, const char* name, float x, float y, float z)
 {
-    CSFML_CALL(shader, setParameter(name, x, y, z));
+	CSFML_CALL(shader, setParameter(name, x, y, z));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setFloat4Parameter(sfShader* shader, const char* name, float x, float y, float z, float w)
 {
-    CSFML_CALL(shader, setParameter(name, x, y, z, w));
+	CSFML_CALL(shader, setParameter(name, x, y, z, w));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVector2Parameter(sfShader* shader, const char* name, sfVector2f vector)
 {
-    CSFML_CALL(shader, setParameter(name, sf::Vector2f(vector.x, vector.y)));
+	CSFML_CALL(shader, setParameter(name, sf::Vector2f(vector.x, vector.y)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVector3Parameter(sfShader* shader, const char* name, sfVector3f vector)
 {
-    CSFML_CALL(shader, setParameter(name, sf::Vector3f(vector.x, vector.y, vector.z)));
+	CSFML_CALL(shader, setParameter(name, sf::Vector3f(vector.x, vector.y, vector.z)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setColorParameter(sfShader* shader, const char* name, sfColor color)
 {
-    CSFML_CALL(shader, setParameter(name, sf::Color(color.r, color.g, color.b, color.a)));
+	CSFML_CALL(shader, setParameter(name, sf::Color(color.r, color.g, color.b, color.a)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setTransformParameter(sfShader* shader, const char* name, sfTransform transform)
 {
-    CSFML_CALL(shader, setParameter(name, convertTransform(transform)));
+	CSFML_CALL(shader, setParameter(name, convertTransform(transform)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setTextureParameter(sfShader* shader, const char* name, const sfTexture* texture)
 {
-    CSFML_CHECK(texture);
-    CSFML_CALL(shader, setParameter(name, *texture->This));
+	CSFML_CHECK(texture);
+	CSFML_CALL(shader, setParameter(name,*texture->This));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setCurrentTextureParameter(sfShader* shader, const char* name)
 {
-    CSFML_CALL(shader, setParameter(name, sf::Shader::CurrentTexture));
+	CSFML_CALL(shader, setParameter(name, sf::Shader::CurrentTexture));
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfShader_getNativeHandle(const sfShader* shader)
 {
-    CSFML_CALL_RETURN(shader, getNativeHandle(), 0);
+	CSFML_CALL_RETURN(shader, getNativeHandle(), 0);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_bind(const sfShader* shader)
 {
-    sf::Shader::bind(shader ? &shader->This : NULL);
+	sf::Shader::bind(shader ? &shader->This : NULL);
 }
 
 
 ////////////////////////////////////////////////////////////
 sfBool sfShader_isAvailable(void)
 {
-    return sf::Shader::isAvailable() ? sfTrue : sfFalse;
+	return sf::Shader::isAvailable() ? sfTrue : sfFalse;
 }