/**************************************************************************** Copyright 2012 cocos2d-x.org Copyright 2011 Jeff Lamarche Copyright 2012 Goffredo Marocchi Copyright 2012 Ricardo Quesada http://www.cocos2d-x.org Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN false EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ****************************************************************************/ #include "CCDirector.h" #include "CCGLProgram.h" #include "ccGLStateCache.h" #include "ccMacros.h" #include "platform/CCFileUtils.h" #include "support/data_support/uthash.h" #include "cocoa/CCString.h" // extern #include "kazmath/GL/matrix.h" #include "kazmath/kazmath.h" NS_CC_BEGIN typedef struct _hashUniformEntry { GLvoid* value; // value unsigned int location; // Key UT_hash_handle hh; // hash entry } tHashUniformEntry; GLProgram::GLProgram() : _program(0) , _vertShader(0) , _fragShader(0) , _hashForUniforms(NULL) , _usesTime(false) { memset(_uniforms, 0, sizeof(_uniforms)); } GLProgram::~GLProgram() { CCLOGINFO("cocos2d: %s %d deallocing %p", __FUNCTION__, __LINE__, this); // there is no need to delete the shaders. They should have been already deleted. CCASSERT(_vertShader == 0, "Vertex Shaders should have been already deleted"); CCASSERT(_fragShader == 0, "Fragment Shaders should have been already deleted"); if (_program) { ccGLDeleteProgram(_program); } tHashUniformEntry *current_element, *tmp; // Purge uniform hash HASH_ITER(hh, _hashForUniforms, current_element, tmp) { HASH_DEL(_hashForUniforms, current_element); free(current_element->value); free(current_element); } } bool GLProgram::initWithVertexShaderByteArray(const GLchar* vShaderByteArray, const GLchar* fShaderByteArray) { _program = glCreateProgram(); CHECK_GL_ERROR_DEBUG(); _vertShader = _fragShader = 0; if (vShaderByteArray) { if (!compileShader(&_vertShader, GL_VERTEX_SHADER, vShaderByteArray)) { CCLOG("cocos2d: ERROR: Failed to compile vertex shader"); } } // Create and compile fragment shader if (fShaderByteArray) { if (!compileShader(&_fragShader, GL_FRAGMENT_SHADER, fShaderByteArray)) { CCLOG("cocos2d: ERROR: Failed to compile fragment shader"); } } if (_vertShader) { glAttachShader(_program, _vertShader); } CHECK_GL_ERROR_DEBUG(); if (_fragShader) { glAttachShader(_program, _fragShader); } _hashForUniforms = NULL; CHECK_GL_ERROR_DEBUG(); return true; } bool GLProgram::initWithVertexShaderFilename(const char* vShaderFilename, const char* fShaderFilename) { const GLchar * vertexSource = (GLchar*) String::createWithContentsOfFile(FileUtils::getInstance()->fullPathForFilename(vShaderFilename).c_str())->getCString(); const GLchar * fragmentSource = (GLchar*) String::createWithContentsOfFile(FileUtils::getInstance()->fullPathForFilename(fShaderFilename).c_str())->getCString(); return initWithVertexShaderByteArray(vertexSource, fragmentSource); } const char* GLProgram::description() const { return String::createWithFormat("<GLProgram = " CC_FORMAT_PRINTF_SIZE_T " | Program = %i, VertexShader = %i, FragmentShader = %i>", (size_t)this, _program, _vertShader, _fragShader)->getCString(); } bool GLProgram::compileShader(GLuint * shader, GLenum type, const GLchar* source) { GLint status; if (!source) { return false; } const GLchar *sources[] = { #if (CC_TARGET_PLATFORM != CC_PLATFORM_WIN32 && CC_TARGET_PLATFORM != CC_PLATFORM_LINUX && CC_TARGET_PLATFORM != CC_PLATFORM_MAC) (type == GL_VERTEX_SHADER ? "precision highp float;\n" : "precision mediump float;\n"), #endif "uniform mat4 CC_PMatrix;\n" "uniform mat4 CC_MVMatrix;\n" "uniform mat4 CC_MVPMatrix;\n" "uniform vec4 CC_Time;\n" "uniform vec4 CC_SinTime;\n" "uniform vec4 CC_CosTime;\n" "uniform vec4 CC_Random01;\n" "//CC INCLUDES END\n\n", source, }; *shader = glCreateShader(type); glShaderSource(*shader, sizeof(sources)/sizeof(*sources), sources, NULL); glCompileShader(*shader); glGetShaderiv(*shader, GL_COMPILE_STATUS, &status); if (! status) { GLsizei length; glGetShaderiv(*shader, GL_SHADER_SOURCE_LENGTH, &length); GLchar* src = (GLchar *)malloc(sizeof(GLchar) * length); glGetShaderSource(*shader, length, NULL, src); CCLOG("cocos2d: ERROR: Failed to compile shader:\n%s", src); if (type == GL_VERTEX_SHADER) { CCLOG("cocos2d: %s", vertexShaderLog()); } else { CCLOG("cocos2d: %s", fragmentShaderLog()); } free(src); abort(); } return (status == GL_TRUE); } void GLProgram::addAttribute(const char* attributeName, GLuint index) { glBindAttribLocation(_program, index, attributeName); } void GLProgram::updateUniforms() { _uniforms[kUniformPMatrix] = glGetUniformLocation(_program, kUniformPMatrix_s); _uniforms[kUniformMVMatrix] = glGetUniformLocation(_program, kUniformMVMatrix_s); _uniforms[kUniformMVPMatrix] = glGetUniformLocation(_program, kUniformMVPMatrix_s); _uniforms[kUniformTime] = glGetUniformLocation(_program, kUniformTime_s); _uniforms[kUniformSinTime] = glGetUniformLocation(_program, kUniformSinTime_s); _uniforms[kUniformCosTime] = glGetUniformLocation(_program, kUniformCosTime_s); _usesTime = ( _uniforms[kUniformTime] != -1 || _uniforms[kUniformSinTime] != -1 || _uniforms[kUniformCosTime] != -1 ); _uniforms[kUniformRandom01] = glGetUniformLocation(_program, kUniformRandom01_s); _uniforms[kUniformSampler] = glGetUniformLocation(_program, kUniformSampler_s); this->use(); // Since sample most probably won't change, set it to 0 now. this->setUniformLocationWith1i(_uniforms[kUniformSampler], 0); } bool GLProgram::link() { CCASSERT(_program != 0, "Cannot link invalid program"); GLint status = GL_TRUE; glLinkProgram(_program); if (_vertShader) { glDeleteShader(_vertShader); } if (_fragShader) { glDeleteShader(_fragShader); } _vertShader = _fragShader = 0; #if COCOS2D_DEBUG glGetProgramiv(_program, GL_LINK_STATUS, &status); if (status == GL_FALSE) { CCLOG("cocos2d: ERROR: Failed to link program: %i", _program); ccGLDeleteProgram(_program); _program = 0; } #endif return (status == GL_TRUE); } void GLProgram::use() { ccGLUseProgram(_program); } const char* GLProgram::logForOpenGLObject(GLuint object, GLInfoFunction infoFunc, GLLogFunction logFunc) const { GLint logLength = 0, charsWritten = 0; infoFunc(object, GL_INFO_LOG_LENGTH, &logLength); if (logLength < 1) return 0; char *logBytes = (char*)malloc(logLength); logFunc(object, logLength, &charsWritten, logBytes); String* log = String::create(logBytes); free(logBytes); return log->getCString(); } const char* GLProgram::vertexShaderLog() const { return this->logForOpenGLObject(_vertShader, (GLInfoFunction)&glGetShaderiv, (GLLogFunction)&glGetShaderInfoLog); } const char* GLProgram::fragmentShaderLog() const { return this->logForOpenGLObject(_fragShader, (GLInfoFunction)&glGetShaderiv, (GLLogFunction)&glGetShaderInfoLog); } const char* GLProgram::programLog() const { return this->logForOpenGLObject(_program, (GLInfoFunction)&glGetProgramiv, (GLLogFunction)&glGetProgramInfoLog); } // Uniform cache bool GLProgram::updateUniformLocation(GLint location, GLvoid* data, unsigned int bytes) { if (location < 0) { return false; } bool updated = true; tHashUniformEntry *element = NULL; HASH_FIND_INT(_hashForUniforms, &location, element); if (! element) { element = (tHashUniformEntry*)malloc( sizeof(*element) ); // key element->location = location; // value element->value = malloc( bytes ); memcpy(element->value, data, bytes ); HASH_ADD_INT(_hashForUniforms, location, element); } else { if (memcmp(element->value, data, bytes) == 0) { updated = false; } else { memcpy(element->value, data, bytes); } } return updated; } GLint GLProgram::getUniformLocationForName(const char* name) const { CCASSERT(name != NULL, "Invalid uniform name" ); CCASSERT(_program != 0, "Invalid operation. Cannot get uniform location when program is not initialized"); return glGetUniformLocation(_program, name); } void GLProgram::setUniformLocationWith1i(GLint location, GLint i1) { bool updated = updateUniformLocation(location, &i1, sizeof(i1)*1); if( updated ) { glUniform1i( (GLint)location, i1); } } void GLProgram::setUniformLocationWith2i(GLint location, GLint i1, GLint i2) { GLint ints[2] = {i1,i2}; bool updated = updateUniformLocation(location, ints, sizeof(ints)); if( updated ) { glUniform2i( (GLint)location, i1, i2); } } void GLProgram::setUniformLocationWith3i(GLint location, GLint i1, GLint i2, GLint i3) { GLint ints[3] = {i1,i2,i3}; bool updated = updateUniformLocation(location, ints, sizeof(ints)); if( updated ) { glUniform3i( (GLint)location, i1, i2, i3); } } void GLProgram::setUniformLocationWith4i(GLint location, GLint i1, GLint i2, GLint i3, GLint i4) { GLint ints[4] = {i1,i2,i3,i4}; bool updated = updateUniformLocation(location, ints, sizeof(ints)); if( updated ) { glUniform4i( (GLint)location, i1, i2, i3, i4); } } void GLProgram::setUniformLocationWith2iv(GLint location, GLint* ints, unsigned int numberOfArrays) { bool updated = updateUniformLocation(location, ints, sizeof(int)*2*numberOfArrays); if( updated ) { glUniform2iv( (GLint)location, (GLsizei)numberOfArrays, ints ); } } void GLProgram::setUniformLocationWith3iv(GLint location, GLint* ints, unsigned int numberOfArrays) { bool updated = updateUniformLocation(location, ints, sizeof(int)*3*numberOfArrays); if( updated ) { glUniform3iv( (GLint)location, (GLsizei)numberOfArrays, ints ); } } void GLProgram::setUniformLocationWith4iv(GLint location, GLint* ints, unsigned int numberOfArrays) { bool updated = updateUniformLocation(location, ints, sizeof(int)*4*numberOfArrays); if( updated ) { glUniform4iv( (GLint)location, (GLsizei)numberOfArrays, ints ); } } void GLProgram::setUniformLocationWith1f(GLint location, GLfloat f1) { bool updated = updateUniformLocation(location, &f1, sizeof(f1)*1); if( updated ) { glUniform1f( (GLint)location, f1); } } void GLProgram::setUniformLocationWith2f(GLint location, GLfloat f1, GLfloat f2) { GLfloat floats[2] = {f1,f2}; bool updated = updateUniformLocation(location, floats, sizeof(floats)); if( updated ) { glUniform2f( (GLint)location, f1, f2); } } void GLProgram::setUniformLocationWith3f(GLint location, GLfloat f1, GLfloat f2, GLfloat f3) { GLfloat floats[3] = {f1,f2,f3}; bool updated = updateUniformLocation(location, floats, sizeof(floats)); if( updated ) { glUniform3f( (GLint)location, f1, f2, f3); } } void GLProgram::setUniformLocationWith4f(GLint location, GLfloat f1, GLfloat f2, GLfloat f3, GLfloat f4) { GLfloat floats[4] = {f1,f2,f3,f4}; bool updated = updateUniformLocation(location, floats, sizeof(floats)); if( updated ) { glUniform4f( (GLint)location, f1, f2, f3,f4); } } void GLProgram::setUniformLocationWith2fv(GLint location, GLfloat* floats, unsigned int numberOfArrays) { bool updated = updateUniformLocation(location, floats, sizeof(float)*2*numberOfArrays); if( updated ) { glUniform2fv( (GLint)location, (GLsizei)numberOfArrays, floats ); } } void GLProgram::setUniformLocationWith3fv(GLint location, GLfloat* floats, unsigned int numberOfArrays) { bool updated = updateUniformLocation(location, floats, sizeof(float)*3*numberOfArrays); if( updated ) { glUniform3fv( (GLint)location, (GLsizei)numberOfArrays, floats ); } } void GLProgram::setUniformLocationWith4fv(GLint location, GLfloat* floats, unsigned int numberOfArrays) { bool updated = updateUniformLocation(location, floats, sizeof(float)*4*numberOfArrays); if( updated ) { glUniform4fv( (GLint)location, (GLsizei)numberOfArrays, floats ); } } void GLProgram::setUniformLocationWithMatrix4fv(GLint location, GLfloat* matrixArray, unsigned int numberOfMatrices) { bool updated = updateUniformLocation(location, matrixArray, sizeof(float)*16*numberOfMatrices); if( updated ) { glUniformMatrix4fv( (GLint)location, (GLsizei)numberOfMatrices, GL_FALSE, matrixArray); } } void GLProgram::setUniformsForBuiltins() { kmMat4 matrixP; kmMat4 matrixMV; kmMat4 matrixMVP; kmGLGetMatrix(KM_GL_PROJECTION, &matrixP); kmGLGetMatrix(KM_GL_MODELVIEW, &matrixMV); kmMat4Multiply(&matrixMVP, &matrixP, &matrixMV); setUniformLocationWithMatrix4fv(_uniforms[kUniformPMatrix], matrixP.mat, 1); setUniformLocationWithMatrix4fv(_uniforms[kUniformMVMatrix], matrixMV.mat, 1); setUniformLocationWithMatrix4fv(_uniforms[kUniformMVPMatrix], matrixMVP.mat, 1); if(_usesTime) { Director *director = Director::getInstance(); // This doesn't give the most accurate global time value. // Cocos2D doesn't store a high precision time value, so this will have to do. // Getting Mach time per frame per shader using time could be extremely expensive. float time = director->getTotalFrames() * director->getAnimationInterval(); setUniformLocationWith4f(_uniforms[kUniformTime], time/10.0, time, time*2, time*4); setUniformLocationWith4f(_uniforms[kUniformSinTime], time/8.0, time/4.0, time/2.0, sinf(time)); setUniformLocationWith4f(_uniforms[kUniformCosTime], time/8.0, time/4.0, time/2.0, cosf(time)); } if (_uniforms[kUniformRandom01] != -1) { setUniformLocationWith4f(_uniforms[kUniformRandom01], CCRANDOM_0_1(), CCRANDOM_0_1(), CCRANDOM_0_1(), CCRANDOM_0_1()); } } void GLProgram::reset() { _vertShader = _fragShader = 0; memset(_uniforms, 0, sizeof(_uniforms)); // it is already deallocated by android //ccGLDeleteProgram(_program); _program = 0; tHashUniformEntry *current_element, *tmp; // Purge uniform hash HASH_ITER(hh, _hashForUniforms, current_element, tmp) { HASH_DEL(_hashForUniforms, current_element); free(current_element->value); free(current_element); } _hashForUniforms = NULL; } NS_CC_END