*修改文件名

1 files changed, 284 insertions, 0 deletions

diff --git a/src/libjin/Graphics/Shader/je_shader.cpp b/src/libjin/Graphics/Shader/je_shader.cpp
new file mode 100644
index 0000000..686f2b9
--- /dev/null
+++ b/src/libjin/Graphics/Shader/je_shader.cpp
@@ -0,0 +1,284 @@
+#include <regex>
+#include "../../core/je_configuration.h"
+#if defined(jin_graphics_shader)
+
+#include <iostream>
+
+#include "../../filesystem/je_buffer.h"
+#include "../../utils/je_macros.h"
+
+#include "je_shader.h"
+
+namespace jin
+{
+	namespace graphics
+	{
+
+		using namespace jin::filesystem;
+		using namespace std;
+
+		// 
+		// default_texture
+		// base_shader
+		// SHADER_FORMAT_SIZE
+		// formatShader
+		// 
+		#include "je_default.shader.h"
+
+		// 
+		// https://stackoverflow.com/questions/27941496/use-sampler-without-passing-through-value
+		// The default value of a sampler variable is 0. From the GLSL 3.30 spec,
+		//     section "4.3.5 Uniforms":
+		// 
+		// The link time initial value is either the value of the variable's 
+		// initializer, if present, or 0 if no initializer is present.Sampler
+		// types cannot have initializers.
+		// 
+		// Since a value of 0 means that it's sampling from texture unit 0, it will 
+		// work without ever setting the value as long as you bind your textures to
+		// unit 0. This is well defined behavior.
+		// 
+		// Since texture unit 0 is also the default until you call glActiveTexture()
+		// with a value other than GL_TEXTURE0, it's very common to always use unit 
+		// 0 as long as shaders do not need more than one texture.Which means that
+		// often times, setting the sampler uniforms is redundant for simple
+		// applications.
+		// 
+		// I would still prefer to always set the values.If nothing else, it makes
+		// it clear to anybody reading your code that you really mean to sample from
+		// texture unit 0, and did not just forget to set the value.
+		// 
+		const int DEFAULT_TEXTURE_UNIT = 0;
+
+		/*static*/ Shader* Shader::CurrentShader = nullptr; 
+
+		Shader* Shader::createShader(const string& program)
+		{
+			Shader* shader = nullptr;
+			try
+			{
+				shader = new Shader(program);
+			}
+			catch(...)
+			{
+				return nullptr;
+			}
+			return shader;
+		}
+
+		Shader::Shader(const string& program)
+			: mCurrentTextureUnit(DEFAULT_TEXTURE_UNIT)
+		{
+			if (!compile(program))
+				throw 0;
+		}
+
+		Shader::~Shader()
+		{
+			if (CurrentShader == this)
+				unuse();
+		}
+
+		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");
+			int loc_END_FRAGMENT_SHADER = program.find("#END_FRAGMENT_SHADER");
+			if (loc_VERTEX_SHADER == string::npos 
+			 || loc_END_VERTEX_SHADER == string::npos
+			 || loc_FRAGMENT_SHADER == string::npos 
+			 || loc_END_FRAGMENT_SHADER == string::npos
+			)
+				return false;
+			// 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());
+			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 
+			GLint success;
+			GLuint vshader = glCreateShader(GL_VERTEX_SHADER);
+			glShaderSource(vshader, 1, (const GLchar**)&vbuffer.data, NULL);
+			glCompileShader(vshader);
+			glGetShaderiv(vshader, GL_COMPILE_STATUS, &success);
+			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);
+			if (success == GL_FALSE)
+				return false;
+			mPID = glCreateProgram();
+			glAttachShader(mPID, vshader);
+			glAttachShader(mPID, fshader);
+			glLinkProgram(mPID);
+			glGetProgramiv(mPID, GL_LINK_STATUS, &success);
+			if (success == GL_FALSE)
+				throw false;
+		}
+
+		static inline GLint getMaxTextureUnits()
+		{
+			GLint maxTextureUnits = 0;
+			glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits); 
+			return maxTextureUnits; 
+		}
+    
+		void Shader::use()
+		{
+			glUseProgram(mPID);
+			CurrentShader = this;
+			sendInt(SHADER_MAIN_TEXTURE, DEFAULT_TEXTURE_UNIT);
+		}
+
+		/*static*/ void Shader::unuse()
+		{
+			glUseProgram(0);
+			CurrentShader = nullptr;
+		}
+
+		GLint Shader::claimTextureUnit(const std::string& name)
+		{
+			std::map<std::string, GLint>::iterator unit = mTextureUnits.find(name);
+			if (unit != mTextureUnits.end())
+				return unit->second;
+			static GLint MAX_TEXTURE_UNITS = getMaxTextureUnits();
+			if (++mCurrentTextureUnit >= MAX_TEXTURE_UNITS)
+				return 0;
+			mTextureUnits[name] = mCurrentTextureUnit;
+			return mCurrentTextureUnit;
+		}
+
+	#define checkJSL() \
+		if (CurrentShader != this) \
+			 return
+
+		void Shader::sendInt(const char* name, int value)
+		{
+			checkJSL();
+			int loc = glGetUniformLocation(mPID, name);
+			glUniform1i(loc, value);
+		}
+
+		void Shader::sendFloat(const char* variable, float number)
+		{
+			checkJSL();
+			int loc = glGetUniformLocation(mPID, variable); 
+			glUniform1f(loc, number);
+		}
+
+		// 
+		// https://www.douban.com/note/627332677/
+		// struct TextureUnit
+		// {
+		//     GLuint targetTexture1D;
+		//     GLuint targetTexture2D;
+		//     GLuint targetTexture3D;
+		//     GLuint targetTextureCube;
+		//     ...
+		// };
+		// 
+		// TextureUnit mTextureUnits[GL_MAX_TEXTURE_IMAGE_UNITS]
+		// GLuint mCurrentTextureUnit = 0;
+		// 
+		void Shader::sendTexture(const char* variable, const Texture* tex)
+		{
+			checkJSL();
+			GLint location = glGetUniformLocation(mPID, variable);
+			if (location == -1)
+				return;
+			GLint unit = claimTextureUnit(variable);
+			if (unit == 0)
+			{
+				// TODO: �쳣�������󶨵����������������
+				return;
+			}
+			gl.activeTexUnit(unit);
+			glUniform1i(location, unit);
+			gl.bindTexture(tex->getTexture());
+			gl.activeTexUnit(0);
+		}
+
+		void Shader::sendCanvas(const char* variable, const Canvas* canvas)
+		{
+			checkJSL();
+			GLint location = glGetUniformLocation(mPID, variable);
+			if (location == -1)
+				return; 
+			GLint unit = claimTextureUnit(variable);
+			if (unit == 0)
+			{
+				// TODO: �쳣�������󶨵����������������
+				return;
+			}
+			glUniform1i(location, unit);
+			glActiveTexture(GL_TEXTURE0 + unit);
+			gl.bindTexture(canvas->getTexture());
+
+			glActiveTexture(GL_TEXTURE0);
+		}
+
+		void Shader::sendVec2(const char* name, float x, float y)
+		{
+			checkJSL();
+			int loc = glGetUniformLocation(mPID, name);
+			glUniform2f(loc, x, y);
+		}
+
+		void Shader::sendVec3(const char* name, float x, float y, float z)
+		{
+			checkJSL();
+			int loc = glGetUniformLocation(mPID, name);
+			glUniform3f(loc, x, y, z);
+		}
+
+		void Shader::sendVec4(const char* name, float x, float y, float z, float w)
+		{
+			checkJSL();
+			int loc = glGetUniformLocation(mPID, name);
+			glUniform4f(loc, x, y, z, w);
+		}
+    
+		void Shader::sendColor(const char* name, const Color* col) 
+		{
+			checkJSL();
+			int loc = glGetUniformLocation(mPID, name);
+			glUniform4f(loc,
+				col->r / 255.f,
+				col->g / 255.f,
+				col->b / 255.f,
+				col->a / 255.f
+			);
+		}
+
+		void Shader::sendMatrix4(const char* name, const math::Matrix* mat4)
+		{
+			int loc = glGetUniformLocation(mPID, name);
+			glUniformMatrix4fv(loc, 1, GL_FALSE, mat4->getElements());
+		}
+
+		void Shader::bindVertexPointer(int n, GLenum type, GLsizei stride, const GLvoid * pointers)
+		{
+			GLint loc = glGetAttribLocation(mPID, 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(mPID, SHADER_TEXTURE_COORDS);
+			glEnableVertexAttribArray(1);
+			glVertexAttribPointer(loc, n, type, GL_FALSE, stride, pointers);
+		}
+
+	} // namespace graphics
+} // namespace jin
+
+#endif // jin_graphics_shader
\ No newline at end of file