More optimizations in glUseProgram this time

src/Renderer/GlStateMachine.cpp

@@ -0,0 +1,12 @@
+#include "GlStateMachine.h"
+
+
+//======================================================================================================================
+// sync                                                                                                                =
+//======================================================================================================================
+void GlStateMachine::sync()
+{
+	depthTestEnabledFlag = glIsEnabled(GL_DEPTH_TEST);
+	blendingEnabledFlag = glIsEnabled(GL_BLEND);
+	sProgGlId = getCurrentProgramGlId();
+}

src/Renderer/GlStateMachine.h

@@ -23,14 +23,22 @@ class GlStateMachine
 
 		bool isBlendingEnabled() const {return getFlag(GL_BLEND, blendingEnabledFlag);}
 		void setBlendingEnabled(bool enable) {setFlag(GL_BLEND, enable, blendingEnabledFlag);}
+
+		void useShaderProg(GLuint id);
 		/// @}
 
 	private:
+		/// @name The GL state
+		/// @{
 		bool depthTestEnabledFlag;
 		bool blendingEnabledFlag;
+		GLuint sProgGlId;
+		/// @}
 
 		static bool getFlag(GLenum glFlag, bool myFlag);
 		static void setFlag(GLenum glFlag, bool enable, bool& myFlag);
+
+		static GLuint getCurrentProgramGlId();
 };
 
 
@@ -38,13 +46,6 @@ class GlStateMachine
 // Inlines                                                                                                             =
 //======================================================================================================================
 
-inline void GlStateMachine::sync()
-{
-	depthTestEnabledFlag = glIsEnabled(GL_DEPTH_TEST);
-	blendingEnabledFlag = glIsEnabled(GL_BLEND);
-}
-
-
 inline bool GlStateMachine::getFlag(GLenum glFlag, bool myFlag)
 {
 	ASSERT(glIsEnabled(glFlag) == myFlag);
@@ -71,6 +72,26 @@ inline void GlStateMachine::setFlag(GLenum glFlag, bool enable, bool& myFlag)
 }
 
 
+inline void GlStateMachine::useShaderProg(GLuint id)
+{
+	ASSERT(getCurrentProgramGlId() == sProgGlId);
+
+	if(sProgGlId != id)
+	{
+		glUseProgram(id);
+		sProgGlId = id;
+	}
+}
+
+
+inline GLuint GlStateMachine::getCurrentProgramGlId()
+{
+	int i;
+	glGetIntegerv(GL_CURRENT_PROGRAM, &i);
+	return i;
+}
+
+
 //======================================================================================================================
 // Other                                                                                                               =
 //======================================================================================================================

src/Renderer/Renderer.h

@@ -54,7 +54,7 @@ class Renderer
 		GETTER_R_BY_VAL(uint, framesNum, getFramesNum)
 		GETTER_R(Mat4, viewProjectionMat, getViewProjectionMat)
 		const Camera& getCamera() const {return *cam;}
-		GETTER_R(SceneDrawer, sceneDrawer, getSceneDrawer)
+		GETTER_RW(SceneDrawer, sceneDrawer, getSceneDrawer)
 		GETTER_RW(SkinsDeformer, skinsDeformer, getSkinsDeformer)
 		/// @}
 

src/Resources/ShaderProg/SProgUniVar.cpp

@@ -35,14 +35,29 @@ void SProgUniVar::set(const Vec2 v2[], uint size) const
 {
 	STD_SET_UNI_CHECK();
 	ASSERT(getGlDataType() == GL_FLOAT_VEC2);
-	glUniform2fv(getLoc(), size, &(const_cast<Vec2&>(v2[0]))[0]);
+	if(size == 1)
+	{
+		glUniform2f(getLoc(), v2[0].x(), v2[0].y());
+	}
+	else
+	{
+		glUniform2fv(getLoc(), size, &(const_cast<Vec2&>(v2[0]))[0]);
+	}
 }
 
 void SProgUniVar::set(const Vec3 v3[], uint size) const
 {
 	STD_SET_UNI_CHECK();
 	ASSERT(getGlDataType() == GL_FLOAT_VEC3);
-	glUniform3fv(getLoc(), size, &(const_cast<Vec3&>(v3[0]))[0]);
+
+	if(size == 1)
+	{
+		glUniform3f(getLoc(), v3[0].x(), v3[0].y(), v3[0].z());
+	}
+	else
+	{
+		glUniform3fv(getLoc(), size, &(const_cast<Vec3&>(v3[0]))[0]);
+	}
 }
 
 void SProgUniVar::set(const Vec4 v4[], uint size) const

src/Resources/ShaderProg/ShaderProg.h

@@ -9,6 +9,7 @@
 #include "SProgUniVar.h"
 #include "SProgAttribVar.h"
 #include "Vec.h"
+#include "GlStateMachine.h"
 
 
 /// Shader program @ref Resource
@@ -134,7 +135,7 @@ inline GLuint ShaderProg::getGlId() const
 inline void ShaderProg::bind() const
 {
 	ASSERT(glId != std::numeric_limits<uint>::max());
-	glUseProgram(glId);
+	GlStateMachineSingleton::getInstance().useShaderProg(glId);
 }