*修改shader名和内建变量名

6 files changed, 61 insertions, 68 deletions

diff --git a/src/libjin/Graphics/Drawable.cpp b/src/libjin/Graphics/Drawable.cpp
index 9f52f0a..abe2dc8 100644
--- a/src/libjin/Graphics/Drawable.cpp
+++ b/src/libjin/Graphics/Drawable.cpp
@@ -42,9 +42,9 @@ namespace graphics
     {
         gl.ModelMatrix.setTransformation(x, y, r, sx, sy, anchor.x, anchor.y);
 
-		Shader* shader = Shader::getCurrentJSL();
-		shader->sendMatrix4(Shader::MODEL_MATRIX, &gl.ModelMatrix);
-		shader->sendMatrix4(Shader::PROJECTION_MATRIX, &gl.ProjectionMatrix);
+		Shader* shader = Shader::getCurrentShader();
+		shader->sendMatrix4(Shader::SHADER_MODEL_MATRIX, &gl.ModelMatrix);
+		shader->sendMatrix4(Shader::SHADER_PROJECTION_MATRIX, &gl.ProjectionMatrix);
 		shader->bindVertexPointer(2, GL_FLOAT, 0, vertex_coords);
 		shader->bindUVPointer(2, GL_FLOAT, 0, texture_coords);
 
diff --git a/src/libjin/Graphics/Font.cpp b/src/libjin/Graphics/Font.cpp
index 72be567..77d48f7 100644
--- a/src/libjin/Graphics/Font.cpp
+++ b/src/libjin/Graphics/Font.cpp
@@ -201,12 +201,12 @@ namespace graphics
 
     void Font::print(const Page* page, int x, int y)
     {
-        Shader* shader = Shader::getCurrentJSL();
+        Shader* shader = Shader::getCurrentShader();
         const vector<GlyphArrayDrawInfo>& glyphinfolist = page->glyphinfolist;
         const vector<GlyphVertex>& glyphvertices = page->glyphvertices;
 		gl.ModelMatrix.setTransformation(x, y, 0, 1, 1, 0, 0);
-		shader->sendMatrix4(Shader::MODEL_MATRIX, &gl.ModelMatrix);
-		shader->sendMatrix4(Shader::PROJECTION_MATRIX, &gl.ProjectionMatrix);
+		shader->sendMatrix4(Shader::SHADER_MODEL_MATRIX, &gl.ModelMatrix);
+		shader->sendMatrix4(Shader::SHADER_PROJECTION_MATRIX, &gl.ProjectionMatrix);
         for (int i = 0; i < glyphinfolist.size(); ++i)
         {
             const GlyphArrayDrawInfo& info = glyphinfolist[i];
diff --git a/src/libjin/Graphics/Shader.cpp b/src/libjin/Graphics/Shader.cpp
index 6c8e3b5..a45fcf0 100644
--- a/src/libjin/Graphics/Shader.cpp
+++ b/src/libjin/Graphics/Shader.cpp
@@ -24,11 +24,11 @@ namespace graphics
     #include "Shaders/base.shader.h"
     #include "Shaders/default.shader.h"
 
-	const char* Shader::PROJECTION_MATRIX = "_projectionMatrix_";
-	const char* Shader::MODEL_MATRIX = "_modelMatrix_";
-	const char* Shader::MAIN_TEXTURE = "_main_texture_";
-	const char* Shader::VERTEX_COORDS = "_vert_coord_";
-	const char* Shader::TEXTURE_COORDS = "_tex_coord_";
+	const char* Shader::SHADER_PROJECTION_MATRIX = "jin_ProjectionMatrix";
+	const char* Shader::SHADER_MODEL_MATRIX = "jin_ModelMatrix";
+	const char* Shader::SHADER_MAIN_TEXTURE = "jin_MainTexture";
+	const char* Shader::SHADER_VERTEX_COORDS = "jin_VertexCoords";
+	const char* Shader::SHADER_TEXTURE_COORDS = "jin_TextureCoords";
 
     /**
      * https://stackoverflow.com/questions/27941496/use-sampler-without-passing-through-value
@@ -86,6 +86,7 @@ namespace graphics
 
     bool Shader::compile(const string& program)
     {
+        /* parse shader source, need some optimizations */
         int loc_VERTEX_SHADER = program.find("#VERTEX_SHADER");
         int loc_END_VERTEX_SHADER = program.find("#END_VERTEX_SHADER");
         int loc_FRAGMENT_SHADER = program.find("#FRAGMENT_SHADER");
@@ -96,12 +97,13 @@ namespace graphics
          || loc_END_FRAGMENT_SHADER == string::npos
         )
             return false;
-        int p = loc_VERTEX_SHADER + strlen("#VERTEX_SHADER");
-        string vertex_shader = program.substr(p, loc_END_VERTEX_SHADER - p);
+        /* load vertex and fragment shader source into buffers */
+        int start = loc_VERTEX_SHADER + strlen("#VERTEX_SHADER");
+        string vertex_shader = program.substr(start, loc_END_VERTEX_SHADER - start);
         Buffer vbuffer = Buffer(vertex_shader.length() + BASE_VERTEX_SHADER_SIZE);
         formatVertexShader((char*)vbuffer.data, vertex_shader.c_str());
-        p = loc_FRAGMENT_SHADER + strlen("#FRAGMENT_SHADER");
-        string fragment_shader = program.substr(p, loc_END_FRAGMENT_SHADER - p);
+        start = loc_FRAGMENT_SHADER + strlen("#FRAGMENT_SHADER");
+        string fragment_shader = program.substr(start, loc_END_FRAGMENT_SHADER - start);
         Buffer fbuffer = Buffer(fragment_shader.length() + BASE_FRAGMENT_SHADER_SIZE);
         formatFragmentShader((char*)fbuffer.data, fragment_shader.c_str());
         /* compile */
@@ -110,18 +112,12 @@ namespace graphics
         glShaderSource(vshader, 1, (const GLchar**)&vbuffer.data, NULL);
         glCompileShader(vshader);
         glGetShaderiv(vshader, GL_COMPILE_STATUS, &success);
-        //std::cout << (char*)vbuffer.data << std::endl;
-        //Buffer log = Buffer(1024);
-        //int len;
-        //glGetShaderInfoLog(vshader, sizeof(log), &len, (GLchar*)log.data);
-        //std::cout << (char*)log.data << std::endl;
         if (success == GL_FALSE)
             return false;
         GLuint fshader = glCreateShader(GL_FRAGMENT_SHADER);
         glShaderSource(fshader, 1, (const GLchar**)&fbuffer.data, NULL);
         glCompileShader(fshader);
         glGetShaderiv(fshader, GL_COMPILE_STATUS, &success);
-        //std::cout << (char*)fbuffer.data << std::endl;
         if (success == GL_FALSE)
             return false;
         pid = glCreateProgram();
@@ -129,8 +125,6 @@ namespace graphics
         glAttachShader(pid, fshader);
         glLinkProgram(pid);
         glGetProgramiv(pid, GL_LINK_STATUS, &success);
-        //glGetProgramInfoLog(pid, 1024, &len, (GLchar*)log.data);
-        //std::cout << (char*)log.data << std::endl;
         if (success == GL_FALSE)
             throw false;
     }
@@ -141,12 +135,12 @@ namespace graphics
         glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits); 
         return maxTextureUnits; 
     }
-
+    
     void Shader::use()
     {
         glUseProgram(pid);
         currentShader = this;
-        sendInt(Shader::MAIN_TEXTURE, DEFAULT_TEXTURE_UNIT);
+        sendInt(Shader::SHADER_MAIN_TEXTURE, DEFAULT_TEXTURE_UNIT);
     }
 
     /*static*/ void Shader::unuse()
@@ -277,14 +271,14 @@ namespace graphics
 
 	void Shader::bindVertexPointer(int n, GLenum type, GLsizei stride, const GLvoid * pointers)
 	{
-		GLint loc = glGetAttribLocation(pid, VERTEX_COORDS);
+		GLint loc = glGetAttribLocation(pid, SHADER_VERTEX_COORDS);
 		glEnableVertexAttribArray(0);
 		glVertexAttribPointer(loc, n, type, GL_FALSE, stride, pointers);
 	}
 
 	void Shader::bindUVPointer(int n, GLenum type, GLsizei stride, const GLvoid * pointers)
 	{
-		GLint loc = glGetAttribLocation(pid, TEXTURE_COORDS);
+		GLint loc = glGetAttribLocation(pid, SHADER_TEXTURE_COORDS);
 		glEnableVertexAttribArray(1);
 		glVertexAttribPointer(loc, n, type, GL_FALSE, stride, pointers);
 	}
diff --git a/src/libjin/Graphics/Shader.h b/src/libjin/Graphics/Shader.h
index 2ea9e04..d27d538 100644
--- a/src/libjin/Graphics/Shader.h
+++ b/src/libjin/Graphics/Shader.h
@@ -15,19 +15,18 @@ namespace jin
 namespace graphics
 {
 
-    /* Jin Shading Language Program*/
     class Shader
     {
     public:
         static Shader* createShader(const std::string& program);
-        static inline Shader* getCurrentJSL() { return currentShader; }
+        static inline Shader* getCurrentShader() { return currentShader; }
         static void unuse();
 
-		static const char* PROJECTION_MATRIX;
-		static const char* MODEL_MATRIX;
-		static const char* MAIN_TEXTURE;
-		static const char* VERTEX_COORDS;
-		static const char* TEXTURE_COORDS;
+		static const char* SHADER_PROJECTION_MATRIX;
+		static const char* SHADER_MODEL_MATRIX;
+		static const char* SHADER_MAIN_TEXTURE;
+		static const char* SHADER_VERTEX_COORDS;
+		static const char* SHADER_TEXTURE_COORDS;
 
         virtual ~Shader();
 
diff --git a/src/libjin/Graphics/Shaders/base.shader.h b/src/libjin/Graphics/Shaders/base.shader.h
index 3790a47..b449008 100644
--- a/src/libjin/Graphics/Shaders/base.shader.h
+++ b/src/libjin/Graphics/Shaders/base.shader.h
@@ -51,26 +51,26 @@ static const char* base_vertex = R"(
 
 %s
 
-uniform mat4 _projectionMatrix_;
-uniform mat4 _modelMatrix_;
+uniform mat4 jin_ProjectionMatrix;
+uniform mat4 jin_ModelMatrix;
 
-in vec2 _vert_coord_;
-in vec2 _tex_coord_;
+in vec2 jin_VertexCoords;
+in vec2 jin_TextureCoords;
 
-out vec4 _color;
-out vec2 _xy;
-out vec2 _uv;
+out vec4 jin_Color;
+out vec2 jin_XY;
+out vec2 jin_UV;
 
 %s
 
 void main()
 {
-	vec4 v = _modelMatrix_ * vec4(_vert_coord_, 0, 1.0);
-    Vertex _v = vert(Vertex(v.xy, _tex_coord_));
-	gl_Position = _projectionMatrix_ * vec4(_v.xy, 0, 1.0f);
-	_color = gl_Color;
-    _xy = _v.xy;
-    _uv = _v.uv;
+	vec4 v = jin_ModelMatrix * vec4(jin_VertexCoords, 0, 1.0);
+    Vertex _v = vert(Vertex(v.xy, jin_TextureCoords));
+	gl_Position = jin_ProjectionMatrix * vec4(_v.xy, 0, 1.0f);
+	jin_Color = gl_Color;
+    jin_XY = _v.xy;
+    jin_UV = _v.uv;
 }
 )";
 
@@ -83,19 +83,19 @@ static const char* base_fragment = R"(
 
 %s
 
-uniform Texture _main_texture_;
+uniform Texture jin_MainTexture;
 
-in vec4 _color;
-in vec2 _xy; 
-in vec2 _uv;
+in vec4 jin_Color;
+in vec2 jin_XY; 
+in vec2 jin_UV;
 
-out vec4 _outColor_;
+out vec4 jin_OutColor;
 
 %s
 
 void main()
 {
-    _outColor_ = frag(_color, _main_texture_, Vertex(_xy, _uv));
+    jin_OutColor = frag(jin_Color, jin_MainTexture, Vertex(jin_XY, jin_UV));
 }
 )";
 
diff --git a/src/libjin/Graphics/Shapes.cpp b/src/libjin/Graphics/Shapes.cpp
index cf47e00..1befd11 100644
--- a/src/libjin/Graphics/Shapes.cpp
+++ b/src/libjin/Graphics/Shapes.cpp
@@ -18,22 +18,22 @@ namespace graphics
     {
         float verts[] = { x + 0.5f , y + 0.5f };
 
-		Shader* shader = Shader::getCurrentJSL();
+		Shader* shader = Shader::getCurrentShader();
 		shader->bindVertexPointer(2, GL_FLOAT, 0, verts);
         gl.ModelMatrix.setIdentity();
-		shader->sendMatrix4(Shader::MODEL_MATRIX, &gl.ModelMatrix);
-		shader->sendMatrix4(Shader::PROJECTION_MATRIX, &gl.ProjectionMatrix);
+		shader->sendMatrix4(Shader::SHADER_MODEL_MATRIX, &gl.ModelMatrix);
+		shader->sendMatrix4(Shader::SHADER_PROJECTION_MATRIX, &gl.ProjectionMatrix);
 
         glDrawArrays(GL_POINTS, 0, 1);
     }
 
     void points(int n, GLshort* p)
     {
-		Shader* shader = Shader::getCurrentJSL();
+		Shader* shader = Shader::getCurrentShader();
 		shader->bindVertexPointer(2, GL_SHORT, 0, p);
         gl.ModelMatrix.setIdentity();
-		shader->sendMatrix4(Shader::MODEL_MATRIX, &gl.ModelMatrix);
-		shader->sendMatrix4(Shader::PROJECTION_MATRIX, &gl.ProjectionMatrix);
+		shader->sendMatrix4(Shader::SHADER_MODEL_MATRIX, &gl.ModelMatrix);
+		shader->sendMatrix4(Shader::SHADER_PROJECTION_MATRIX, &gl.ProjectionMatrix);
         
 		glDrawArrays(GL_POINTS, 0, n);
     }
@@ -45,11 +45,11 @@ namespace graphics
             x2, y2
         };
 		
-		Shader* shader = Shader::getCurrentJSL();
+		Shader* shader = Shader::getCurrentShader();
 		shader->bindVertexPointer(2, GL_FLOAT, 0, verts);
         gl.ModelMatrix.setIdentity();
-		shader->sendMatrix4(Shader::MODEL_MATRIX, &gl.ModelMatrix);
-		shader->sendMatrix4(Shader::PROJECTION_MATRIX, &gl.ProjectionMatrix);
+		shader->sendMatrix4(Shader::SHADER_MODEL_MATRIX, &gl.ModelMatrix);
+		shader->sendMatrix4(Shader::SHADER_PROJECTION_MATRIX, &gl.ProjectionMatrix);
         
 		glDrawArrays(GL_LINES, 0, 2);
     }
@@ -93,10 +93,10 @@ namespace graphics
 
     void polygon_line(float* p, int count)
     {
-		Shader* shader = Shader::getCurrentJSL();
+		Shader* shader = Shader::getCurrentShader();
         gl.ModelMatrix.setIdentity();
-		shader->sendMatrix4(Shader::MODEL_MATRIX, &gl.ModelMatrix);
-		shader->sendMatrix4(Shader::PROJECTION_MATRIX, &gl.ProjectionMatrix);
+		shader->sendMatrix4(Shader::SHADER_MODEL_MATRIX, &gl.ModelMatrix);
+		shader->sendMatrix4(Shader::SHADER_PROJECTION_MATRIX, &gl.ProjectionMatrix);
 		shader->bindVertexPointer(2, GL_FLOAT, 0, p);
 
         glDrawArrays(GL_LINE_LOOP, 0, count);
@@ -110,10 +110,10 @@ namespace graphics
         }
         else if (mode == FILL)
         {
-			Shader* shader = Shader::getCurrentJSL();
+			Shader* shader = Shader::getCurrentShader();
             gl.ModelMatrix.setIdentity();
-			shader->sendMatrix4(Shader::MODEL_MATRIX, &gl.ModelMatrix);
-			shader->sendMatrix4(Shader::PROJECTION_MATRIX, &gl.ProjectionMatrix);
+			shader->sendMatrix4(Shader::SHADER_MODEL_MATRIX, &gl.ModelMatrix);
+			shader->sendMatrix4(Shader::SHADER_PROJECTION_MATRIX, &gl.ProjectionMatrix);
 			shader->bindVertexPointer(2, GL_FLOAT, 0, p);
 
             glDrawArrays(GL_POLYGON, 0, count);