ccb 0.0.1

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/shaders/CCGLStateCache.js

@@ -0,0 +1,340 @@
+/****************************************************************************
+ Copyright (c) 2008-2010 Ricardo Quesada
+ Copyright (c) 2011-2012 cocos2d-x.org
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+
+ 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 NO 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.
+ ****************************************************************************/
+
+cc._currentProjectionMatrix = -1;
+cc._vertexAttribPosition = false;
+cc._vertexAttribColor = false;
+cc._vertexAttribTexCoords = false;
+
+if (cc.ENABLE_GL_STATE_CACHE) {
+    cc.MAX_ACTIVETEXTURE = 16;
+
+    cc._currentShaderProgram = -1;
+    cc._currentBoundTexture = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1];
+    cc._blendingSource = -1;
+    cc._blendingDest = -1;
+    cc._GLServerState = 0;
+    if(cc.TEXTURE_ATLAS_USE_VAO)
+        cc._uVAO = 0;
+}
+
+// GL State Cache functions
+
+/**
+ * Invalidates the GL state cache.<br/>
+ * If CC_ENABLE_GL_STATE_CACHE it will reset the GL state cache.
+ * @function
+ */
+cc.glInvalidateStateCache = function () {
+    cc.kmGLFreeAll();
+    cc._currentProjectionMatrix = -1;
+    cc._vertexAttribPosition = false;
+    cc._vertexAttribColor = false;
+    cc._vertexAttribTexCoords = false;
+    if (cc.ENABLE_GL_STATE_CACHE) {
+        cc._currentShaderProgram = -1;
+        for (var i = 0; i < cc.MAX_ACTIVETEXTURE; i++) {
+            cc._currentBoundTexture[i] = -1;
+        }
+        cc._blendingSource = -1;
+        cc._blendingDest = -1;
+        cc._GLServerState = 0;
+    }
+};
+
+/**
+ * Uses the GL program in case program is different than the current one.<br/>
+ * If CC_ENABLE_GL_STATE_CACHE is disabled, it will the glUseProgram() directly.
+ * @function
+ * @param {WebGLProgram} program
+ */
+cc.glUseProgram = function (program) {
+    if (program !== cc._currentShaderProgram) {
+        cc._currentShaderProgram = program;
+        cc._renderContext.useProgram(program);
+    }
+};
+
+if(!cc.ENABLE_GL_STATE_CACHE){
+    cc.glUseProgram = function (program) {
+        cc._renderContext.useProgram(program);
+    }
+}
+
+/**
+ * Deletes the GL program. If it is the one that is being used, it invalidates it.<br/>
+ * If CC_ENABLE_GL_STATE_CACHE is disabled, it will the glDeleteProgram() directly.
+ * @function
+ * @param {WebGLProgram} program
+ */
+cc.glDeleteProgram = function (program) {
+    if (cc.ENABLE_GL_STATE_CACHE) {
+        if (program === cc._currentShaderProgram)
+            cc._currentShaderProgram = -1;
+    }
+    gl.deleteProgram(program);
+};
+
+/**
+ * Uses a blending function in case it not already used.<br/>
+ * If CC_ENABLE_GL_STATE_CACHE is disabled, it will the glBlendFunc() directly.
+ * @function
+ * @param {Number} sfactor
+ * @param {Number} dfactor
+ */
+cc.glBlendFunc = function (sfactor, dfactor) {
+    if ((sfactor !== cc._blendingSource) || (dfactor !== cc._blendingDest)) {
+        cc._blendingSource = sfactor;
+        cc._blendingDest = dfactor;
+        cc.setBlending(sfactor, dfactor);
+    }
+};
+
+/**
+ * @function
+ * @param {Number} sfactor
+ * @param {Number} dfactor
+ */
+cc.setBlending = function (sfactor, dfactor) {
+    var ctx = cc._renderContext;
+    if ((sfactor === ctx.ONE) && (dfactor === ctx.ZERO)) {
+        ctx.disable(ctx.BLEND);
+    } else {
+        ctx.enable(ctx.BLEND);
+        cc._renderContext.blendFunc(sfactor,dfactor);
+        //TODO need fix for WebGL
+        //ctx.blendFuncSeparate(ctx.SRC_ALPHA, dfactor, sfactor, dfactor);
+    }
+};
+
+/**
+ * @function
+ * @param {Number} sfactor
+ * @param {Number} dfactor
+ */
+cc.glBlendFuncForParticle = function(sfactor, dfactor) {
+    if ((sfactor !== cc._blendingSource) || (dfactor !== cc._blendingDest)) {
+        cc._blendingSource = sfactor;
+        cc._blendingDest = dfactor;
+        var ctx = cc._renderContext;
+        if ((sfactor === ctx.ONE) && (dfactor === ctx.ZERO)) {
+            ctx.disable(ctx.BLEND);
+        } else {
+            ctx.enable(ctx.BLEND);
+            //TODO need fix for WebGL
+            ctx.blendFuncSeparate(ctx.SRC_ALPHA, dfactor, sfactor, dfactor);
+        }
+    }
+};
+
+if(!cc.ENABLE_GL_STATE_CACHE){
+    cc.glBlendFunc = cc.setBlending;
+};
+
+/**
+ * Resets the blending mode back to the cached state in case you used glBlendFuncSeparate() or glBlendEquation().<br/>
+ * If CC_ENABLE_GL_STATE_CACHE is disabled, it will just set the default blending mode using GL_FUNC_ADD.
+ * @function
+ */
+cc.glBlendResetToCache = function () {
+    var ctx = cc._renderContext;
+    ctx.blendEquation(ctx.FUNC_ADD);
+    if (cc.ENABLE_GL_STATE_CACHE)
+        cc.setBlending(cc._blendingSource, cc._blendingDest);
+    else
+        cc.setBlending(ctx.BLEND_SRC, ctx.BLEND_DST);
+};
+
+/**
+ * sets the projection matrix as dirty
+ * @function
+ */
+cc.setProjectionMatrixDirty = function () {
+    cc._currentProjectionMatrix = -1;
+};
+
+/**
+ * <p>
+ *    Will enable the vertex attribs that are passed as flags.  <br/>
+ *    Possible flags:                                           <br/>
+ *    cc.VERTEX_ATTRIB_FLAG_POSITION                             <br/>
+ *    cc.VERTEX_ATTRIB_FLAG_COLOR                                <br/>
+ *    cc.VERTEX_ATTRIB_FLAG_TEX_COORDS                            <br/>
+ *                                                              <br/>
+ *    These flags can be ORed. The flags that are not present, will be disabled.
+ * </p>
+ * @function
+ * @param {cc.VERTEX_ATTRIB_FLAG_POSITION | cc.VERTEX_ATTRIB_FLAG_COLOR | cc.VERTEX_ATTRIB_FLAG_TEX_OORDS} flags
+ */
+cc.glEnableVertexAttribs = function (flags) {
+    /* Position */
+    var ctx = cc._renderContext;
+    var enablePosition = ( flags & cc.VERTEX_ATTRIB_FLAG_POSITION );
+    if (enablePosition !== cc._vertexAttribPosition) {
+        if (enablePosition)
+            ctx.enableVertexAttribArray(cc.VERTEX_ATTRIB_POSITION);
+        else
+            ctx.disableVertexAttribArray(cc.VERTEX_ATTRIB_POSITION);
+        cc._vertexAttribPosition = enablePosition;
+    }
+
+    /* Color */
+    var enableColor = (flags & cc.VERTEX_ATTRIB_FLAG_COLOR);
+    if (enableColor !== cc._vertexAttribColor) {
+        if (enableColor)
+            ctx.enableVertexAttribArray(cc.VERTEX_ATTRIB_COLOR);
+        else
+            ctx.disableVertexAttribArray(cc.VERTEX_ATTRIB_COLOR);
+        cc._vertexAttribColor = enableColor;
+    }
+
+    /* Tex Coords */
+    var enableTexCoords = (flags & cc.VERTEX_ATTRIB_FLAG_TEX_COORDS);
+    if (enableTexCoords !== cc._vertexAttribTexCoords) {
+        if (enableTexCoords)
+            ctx.enableVertexAttribArray(cc.VERTEX_ATTRIB_TEX_COORDS);
+        else
+            ctx.disableVertexAttribArray(cc.VERTEX_ATTRIB_TEX_COORDS);
+        cc._vertexAttribTexCoords = enableTexCoords;
+    }
+};
+
+/**
+ * If the texture is not already bound, it binds it.<br/>
+ * If CC_ENABLE_GL_STATE_CACHE is disabled, it will call glBindTexture() directly.
+ * @function
+ * @param {cc.Texture2D} textureId
+ */
+cc.glBindTexture2D = function (textureId) {
+    cc.glBindTexture2DN(0, textureId);
+};
+
+/**
+ * If the texture is not already bound to a given unit, it binds it.<br/>
+ * If CC_ENABLE_GL_STATE_CACHE is disabled, it will call glBindTexture() directly.
+ * @function
+ * @param {Number} textureUnit
+ * @param {cc.Texture2D} textureId
+ */
+cc.glBindTexture2DN = function (textureUnit, textureId) {
+    if (cc._currentBoundTexture[textureUnit] == textureId)
+        return;
+    cc._currentBoundTexture[textureUnit] = textureId;
+
+    var ctx = cc._renderContext;
+    ctx.activeTexture(ctx.TEXTURE0 + textureUnit);
+    if(textureId)
+        ctx.bindTexture(ctx.TEXTURE_2D, textureId._webTextureObj);
+    else
+        ctx.bindTexture(ctx.TEXTURE_2D, null);
+};
+if (!cc.ENABLE_GL_STATE_CACHE){
+    cc.glBindTexture2DN = function (textureUnit, textureId) {
+        var ctx = cc._renderContext;
+        ctx.activeTexture(ctx.TEXTURE0 + textureUnit);
+        if(textureId)
+            ctx.bindTexture(ctx.TEXTURE_2D, textureId._webTextureObj);
+        else
+            ctx.bindTexture(ctx.TEXTURE_2D, null);
+    };
+}
+
+/**
+ * It will delete a given texture. If the texture was bound, it will invalidate the cached. <br/>
+ * If CC_ENABLE_GL_STATE_CACHE is disabled, it will call glDeleteTextures() directly.
+ * @function
+ * @param {WebGLTexture} textureId
+ */
+cc.glDeleteTexture = function (textureId) {
+    cc.glDeleteTextureN(0, textureId);
+};
+
+/**
+ * It will delete a given texture. If the texture was bound, it will invalidate the cached for the given texture unit.<br/>
+ * If CC_ENABLE_GL_STATE_CACHE is disabled, it will call glDeleteTextures() directly.
+ * @function
+ * @param {Number} textureUnit
+ * @param {WebGLTexture} textureId
+ */
+cc.glDeleteTextureN = function (textureUnit, textureId) {
+    if (cc.ENABLE_GL_STATE_CACHE) {
+        if (textureId == cc._currentBoundTexture[ textureUnit ])
+            cc._currentBoundTexture[ textureUnit ] = -1;
+    }
+    cc._renderContext.deleteTexture(textureId);
+};
+
+/**
+ * If the vertex array is not already bound, it binds it.<br/>
+ * If CC_ENABLE_GL_STATE_CACHE is disabled, it will call glBindVertexArray() directly.
+ * @function
+ * @param {Number} vaoId
+ */
+cc.glBindVAO = function (vaoId) {
+    if (!cc.TEXTURE_ATLAS_USE_VAO)
+        return;
+
+    if (cc.ENABLE_GL_STATE_CACHE) {
+        if (cc._uVAO != vaoId) {
+            cc._uVAO = vaoId;
+            //TODO need fixed
+            //glBindVertexArray(vaoId);
+        }
+    } else {
+        //glBindVertexArray(vaoId);
+    }
+};
+
+/**
+ * It will enable / disable the server side GL states.<br/>
+ * If CC_ENABLE_GL_STATE_CACHE is disabled, it will call glEnable() directly.
+ * @function
+ * @param {Number} flags
+ */
+cc.glEnable = function (flags) {
+    if (cc.ENABLE_GL_STATE_CACHE) {
+        /*var enabled;
+
+         */
+        /* GL_BLEND */
+        /*
+         if ((enabled = (flags & cc.GL_BLEND)) != (cc._GLServerState & cc.GL_BLEND)) {
+         if (enabled) {
+         cc._renderContext.enable(cc._renderContext.BLEND);
+         cc._GLServerState |= cc.GL_BLEND;
+         } else {
+         cc._renderContext.disable(cc._renderContext.BLEND);
+         cc._GLServerState &= ~cc.GL_BLEND;
+         }
+         }*/
+    } else {
+        /*if ((flags & cc.GL_BLEND))
+         cc._renderContext.enable(cc._renderContext.BLEND);
+         else
+         cc._renderContext.disable(cc._renderContext.BLEND);*/
+    }
+};
+

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/shaders/CCShaderCache.js

@@ -0,0 +1,301 @@
+/****************************************************************************
+ Copyright (c) 2008-2010 Ricardo Quesada
+ Copyright (c) 2011-2012 cocos2d-x.org
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+
+ 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 NO 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.
+ ****************************************************************************/
+
+/**
+ * cc.shaderCache is a singleton object that stores manages GL shaders
+ * @class
+ * @name cc.shaderCache
+ */
+cc.shaderCache = /** @lends cc.shaderCache# */{
+
+	/**
+	 * @public
+	 * @constant
+	 * @type {Number}
+	 */
+	TYPE_POSITION_TEXTURECOLOR: 0,
+	/**
+	 * @public
+	 * @constant
+	 * @type {Number}
+	 */
+	TYPE_POSITION_TEXTURECOLOR_ALPHATEST: 1,
+	/**
+	 * @public
+	 * @constant
+	 * @type {Number}
+	 */
+	TYPE_POSITION_COLOR: 2,
+	/**
+	 * @public
+	 * @constant
+	 * @type {Number}
+	 */
+	TYPE_POSITION_TEXTURE: 3,
+	/**
+	 * @public
+	 * @constant
+	 * @type {Number}
+	 */
+	TYPE_POSITION_TEXTURE_UCOLOR: 4,
+	/**
+	 * @public
+	 * @constant
+	 * @type {Number}
+	 */
+	TYPE_POSITION_TEXTURE_A8COLOR: 5,
+	/**
+	 * @public
+	 * @constant
+	 * @type {Number}
+	 */
+	TYPE_POSITION_UCOLOR: 6,
+	/**
+	 * @public
+	 * @constant
+	 * @type {Number}
+	 */
+	TYPE_POSITION_LENGTH_TEXTURECOLOR: 7,
+	/**
+	 * @public
+	 * @constant
+	 * @type {Number}
+	 */
+	TYPE_MAX: 8,
+
+    _programs: {},
+
+    _init: function () {
+        this.loadDefaultShaders();
+        return true;
+    },
+
+    _loadDefaultShader: function (program, type) {
+        switch (type) {
+            case this.TYPE_POSITION_TEXTURECOLOR:
+                program.initWithVertexShaderByteArray(cc.SHADER_POSITION_TEXTURE_COLOR_VERT, cc.SHADER_POSITION_TEXTURE_COLOR_FRAG);
+
+                program.addAttribute(cc.ATTRIBUTE_NAME_POSITION, cc.VERTEX_ATTRIB_POSITION);
+                program.addAttribute(cc.ATTRIBUTE_NAME_COLOR, cc.VERTEX_ATTRIB_COLOR);
+                program.addAttribute(cc.ATTRIBUTE_NAME_TEX_COORD, cc.VERTEX_ATTRIB_TEX_COORDS);
+                break;
+            case this.TYPE_POSITION_TEXTURECOLOR_ALPHATEST:
+                program.initWithVertexShaderByteArray(cc.SHADER_POSITION_TEXTURE_COLOR_VERT, cc.SHADER_POSITION_TEXTURE_COLOR_ALPHATEST_FRAG);
+
+                program.addAttribute(cc.ATTRIBUTE_NAME_POSITION, cc.VERTEX_ATTRIB_POSITION);
+                program.addAttribute(cc.ATTRIBUTE_NAME_COLOR, cc.VERTEX_ATTRIB_COLOR);
+                program.addAttribute(cc.ATTRIBUTE_NAME_TEX_COORD, cc.VERTEX_ATTRIB_TEX_COORDS);
+                break;
+            case this.TYPE_POSITION_COLOR:
+                program.initWithVertexShaderByteArray(cc.SHADER_POSITION_COLOR_VERT, cc.SHADER_POSITION_COLOR_FRAG);
+
+                program.addAttribute(cc.ATTRIBUTE_NAME_POSITION, cc.VERTEX_ATTRIB_POSITION);
+                program.addAttribute(cc.ATTRIBUTE_NAME_COLOR, cc.VERTEX_ATTRIB_COLOR);
+                break;
+            case this.TYPE_POSITION_TEXTURE:
+                program.initWithVertexShaderByteArray(cc.SHADER_POSITION_TEXTURE_VERT, cc.SHADER_POSITION_TEXTURE_FRAG);
+
+                program.addAttribute(cc.ATTRIBUTE_NAME_POSITION, cc.VERTEX_ATTRIB_POSITION);
+                program.addAttribute(cc.ATTRIBUTE_NAME_TEX_COORD, cc.VERTEX_ATTRIB_TEX_COORDS);
+                break;
+            case this.TYPE_POSITION_TEXTURE_UCOLOR:
+                program.initWithVertexShaderByteArray(cc.SHADER_POSITION_TEXTURE_UCOLOR_VERT, cc.SHADER_POSITION_TEXTURE_UCOLOR_FRAG);
+
+                program.addAttribute(cc.ATTRIBUTE_NAME_POSITION, cc.VERTEX_ATTRIB_POSITION);
+                program.addAttribute(cc.ATTRIBUTE_NAME_TEX_COORD, cc.VERTEX_ATTRIB_TEX_COORDS);
+                break;
+            case this.TYPE_POSITION_TEXTURE_A8COLOR:
+                program.initWithVertexShaderByteArray(cc.SHADER_POSITION_TEXTURE_A8COLOR_VERT, cc.SHADER_POSITION_TEXTURE_A8COLOR_FRAG);
+
+                program.addAttribute(cc.ATTRIBUTE_NAME_POSITION, cc.VERTEX_ATTRIB_POSITION);
+                program.addAttribute(cc.ATTRIBUTE_NAME_COLOR, cc.VERTEX_ATTRIB_COLOR);
+                program.addAttribute(cc.ATTRIBUTE_NAME_TEX_COORD, cc.VERTEX_ATTRIB_TEX_COORDS);
+                break;
+            case this.TYPE_POSITION_UCOLOR:
+                program.initWithVertexShaderByteArray(cc.SHADER_POSITION_UCOLOR_VERT, cc.SHADER_POSITION_UCOLOR_FRAG);
+                program.addAttribute("aVertex", cc.VERTEX_ATTRIB_POSITION);
+                break;
+            case this.TYPE_POSITION_LENGTH_TEXTURECOLOR:
+                program.initWithVertexShaderByteArray(cc.SHADER_POSITION_COLOR_LENGTH_TEXTURE_VERT, cc.SHADER_POSITION_COLOR_LENGTH_TEXTURE_FRAG);
+
+                program.addAttribute(cc.ATTRIBUTE_NAME_POSITION, cc.VERTEX_ATTRIB_POSITION);
+                program.addAttribute(cc.ATTRIBUTE_NAME_TEX_COORD, cc.VERTEX_ATTRIB_TEX_COORDS);
+                program.addAttribute(cc.ATTRIBUTE_NAME_COLOR, cc.VERTEX_ATTRIB_COLOR);
+                break;
+            default:
+                cc.log("cocos2d: cc.shaderCache._loadDefaultShader, error shader type");
+                return;
+        }
+
+        program.link();
+        program.updateUniforms();
+
+        //cc.checkGLErrorDebug();
+    },
+
+    /**
+     * loads the default shaders
+     */
+    loadDefaultShaders: function () {
+        // Position Texture Color shader
+        var program = new cc.GLProgram();
+        this._loadDefaultShader(program, this.TYPE_POSITION_TEXTURECOLOR);
+        this._programs[cc.SHADER_POSITION_TEXTURECOLOR] = program;
+        this._programs["ShaderPositionTextureColor"] = program;
+
+        // Position Texture Color alpha test
+        program = new cc.GLProgram();
+        this._loadDefaultShader(program, this.TYPE_POSITION_TEXTURECOLOR_ALPHATEST);
+        this._programs[cc.SHADER_POSITION_TEXTURECOLORALPHATEST] = program;
+        this._programs["ShaderPositionTextureColorAlphaTest"] = program;
+
+        //
+        // Position, Color shader
+        //
+        program = new cc.GLProgram();
+        this._loadDefaultShader(program, this.TYPE_POSITION_COLOR);
+        this._programs[cc.SHADER_POSITION_COLOR] = program;
+        this._programs["ShaderPositionColor"] = program;
+
+        //
+        // Position Texture shader
+        //
+        program = new cc.GLProgram();
+        this._loadDefaultShader(program, this.TYPE_POSITION_TEXTURE);
+        this._programs[cc.SHADER_POSITION_TEXTURE] = program;
+        this._programs["ShaderPositionTexture"] = program;
+
+        //
+        // Position, Texture attribs, 1 Color as uniform shader
+        //
+        program = new cc.GLProgram();
+        this._loadDefaultShader(program, this.TYPE_POSITION_TEXTURE_UCOLOR);
+        this._programs[cc.SHADER_POSITION_TEXTURE_UCOLOR] = program;
+        this._programs["ShaderPositionTextureUColor"] = program;
+
+        //
+        // Position Texture A8 Color shader
+        //
+        program = new cc.GLProgram();
+        this._loadDefaultShader(program, this.TYPE_POSITION_TEXTURE_A8COLOR);
+        this._programs[cc.SHADER_POSITION_TEXTUREA8COLOR] = program;
+        this._programs["ShaderPositionTextureA8Color"] = program;
+
+        //
+        // Position and 1 color passed as a uniform (to similate glColor4ub )
+        //
+        program = new cc.GLProgram();
+        this._loadDefaultShader(program, this.TYPE_POSITION_UCOLOR);
+        this._programs[cc.SHADER_POSITION_UCOLOR] = program;
+        this._programs["ShaderPositionUColor"] = program;
+
+        //
+        // Position, Legth(TexCoords, Color (used by Draw Node basically )
+        //
+        program = new cc.GLProgram();
+        this._loadDefaultShader(program, this.TYPE_POSITION_LENGTH_TEXTURECOLOR);
+        this._programs[cc.SHADER_POSITION_LENGTHTEXTURECOLOR] = program;
+        this._programs["ShaderPositionLengthTextureColor"] = program;
+    },
+
+    /**
+     * reload the default shaders
+     */
+    reloadDefaultShaders: function () {
+        // reset all programs and reload them
+
+        // Position Texture Color shader
+        var program = this.programForKey(cc.SHADER_POSITION_TEXTURECOLOR);
+        program.reset();
+        this._loadDefaultShader(program, this.TYPE_POSITION_TEXTURECOLOR);
+
+        // Position Texture Color alpha test
+        program = this.programForKey(cc.SHADER_POSITION_TEXTURECOLORALPHATEST);
+        program.reset();
+        this._loadDefaultShader(program, this.TYPE_POSITION_TEXTURECOLOR_ALPHATEST);
+
+        //
+        // Position, Color shader
+        //
+        program = this.programForKey(cc.SHADER_POSITION_COLOR);
+        program.reset();
+        this._loadDefaultShader(program, this.TYPE_POSITION_COLOR);
+
+        //
+        // Position Texture shader
+        //
+        program = this.programForKey(cc.SHADER_POSITION_TEXTURE);
+        program.reset();
+        this._loadDefaultShader(program, this.TYPE_POSITION_TEXTURE);
+
+        //
+        // Position, Texture attribs, 1 Color as uniform shader
+        //
+        program = this.programForKey(cc.SHADER_POSITION_TEXTURE_UCOLOR);
+        program.reset();
+        this._loadDefaultShader(program, this.TYPE_POSITION_TEXTURE_UCOLOR);
+
+        //
+        // Position Texture A8 Color shader
+        //
+        program = this.programForKey(cc.SHADER_POSITION_TEXTUREA8COLOR);
+        program.reset();
+        this._loadDefaultShader(program, this.TYPE_POSITION_TEXTURE_A8COLOR);
+
+        //
+        // Position and 1 color passed as a uniform (to similate glColor4ub )
+        //
+        program = this.programForKey(cc.SHADER_POSITION_UCOLOR);
+        program.reset();
+        this._loadDefaultShader(program, this.TYPE_POSITION_UCOLOR);
+    },
+
+    /**
+     * returns a GL program for a given key
+     * @param {String} key
+     */
+    programForKey: function (key) {
+        return this._programs[key];
+    },
+
+    /**
+     * returns a GL program for a shader name
+     * @param {String} shaderName
+     * @return {cc.GLProgram}
+     */
+    getProgram: function (shaderName) {
+        return this._programs[shaderName];
+    },
+
+    /**
+     * adds a CCGLProgram to the cache for a given name
+     * @param {cc.GLProgram} program
+     * @param {String} key
+     */
+    addProgram: function (program, key) {
+        this._programs[key] = program;
+    }
+};