OpenGLRenderer.cpp

Go to the documentation of this file.

#include "OpenGLRenderer.h"

// Depth
const int NEVER         = GL_NEVER;
const int LESS          = GL_LESS;
const int EQUAL         = GL_EQUAL;
const int LEQUAL        = GL_LEQUAL;
const int GREATER       = GL_GREATER;
const int NOTEQUAL      = GL_NOTEQUAL;
const int GEQUAL        = GL_GEQUAL;
const int ALWAYS        = GL_ALWAYS;

// Blending
const int ZERO                                  = GL_ZERO;
const int ONE                                   = GL_ONE;
const int SRC_COLOR                             = GL_SRC_COLOR;
const int ONE_MINUS_SRC_COLOR   = GL_ONE_MINUS_SRC_COLOR;
const int DST_COLOR                             = GL_DST_COLOR;
const int ONE_MINUS_DST_COLOR   = GL_ONE_MINUS_DST_COLOR;
const int SRC_ALPHA                             = GL_SRC_ALPHA;
const int ONE_MINUS_SRC_ALPHA   = GL_ONE_MINUS_SRC_ALPHA;
const int DST_ALPHA                             = GL_DST_ALPHA;
const int ONE_MINUS_DST_ALPHA   = GL_ONE_MINUS_DST_ALPHA;
const int SRC_ALPHA_SATURATE    = GL_SRC_ALPHA_SATURATE;

const int BLENDMODE_ADD                                 = GL_FUNC_ADD_EXT;
const int BLENDMODE_SUBTRACT                    = GL_FUNC_SUBTRACT_EXT;
const int BLENDMODE_REVERSE_SUBSTRACT   = GL_FUNC_REVERSE_SUBTRACT_EXT;
const int BLENDMODE_MIN                                 = GL_MIN_EXT;
const int BLENDMOXE_MAX                                 = GL_MAX_EXT;

GLenum OpenGLRenderer::targets[] = { GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_ARB};

OpenGLRenderer::OpenGLRenderer() {
        init();
}

/********************************************************************
 * Init
 */
void OpenGLRenderer::init() {
        if (GL_ARB_multitexture_supported) {
                glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &maxTextures);
                if (maxTextures > MAX_TEXTURES) maxTextures = MAX_TEXTURES;
        }
        else
                maxTextures = 1;

        resetToDefaults();
        setDefaults();
}


/********************************************************************
 * Set defaults
 */
void OpenGLRenderer::setDefaults() {
        glEnable(GL_DEPTH_TEST);
        glDepthFunc(GL_LEQUAL);
        glPixelStorei(GL_PACK_ALIGNMENT, 1);
        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glFrontFace(GL_CW);

        glShadeModel(GL_SMOOTH);
        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
}

/********************************************************************
 * Change depth func
 */
void OpenGLRenderer::changeDepthFunc(const int depthFunc) {
        if (depthFunc != currentDepthFunc) {
                if (depthFunc == DEPTH_NONE) {
                        glDisable(GL_DEPTH_TEST);
                }
                else {
                        if (currentDepthFunc == DEPTH_NONE)
                                glEnable(GL_DEPTH_TEST);
                        glDepthFunc(depthFunc);
                }
                currentDepthFunc = depthFunc;
        }
}

/********************************************************************
 * Change blending
 */
void OpenGLRenderer::changeBlending(const int src, const int dest, const int blendMode) {
        if (src != BLENDING_NONE) {
                if (currentBlendSrc == BLENDING_NONE)
                        glEnable(GL_BLEND);

                if (src != currentBlendSrc || dest != currentBlendDest)
                        glBlendFunc(currentBlendSrc = src, currentBlendDest = dest);

                if (blendMode != currentBlendMode)
                        glBlendEquationEXT(currentBlendMode = blendMode);
        }
        else {
                if (currentBlendSrc != BLENDING_NONE) {
                        glDisable(GL_BLEND);
                        currentBlendSrc = BLENDING_NONE;
                }
        }
}

/********************************************************************
 * Change mask
 */
void OpenGLRenderer::changeMask(const int mask) {
        if (mask != currentMask) {
                if ((mask & DEPTH) != (currentMask & DEPTH))
                        glDepthMask(mask & DEPTH);

                if ((mask & COLOR) != (currentMask & COLOR))
                        glColorMask(((mask & RED) >> 1) & 1, ((mask & GREEN) >> 2) & 1, ((mask & BLUE) >> 3) & 1, ((mask & ALPHA) >> 4 & 1));

                currentMask = mask;
        }
}

/********************************************************************
 * Create texture
 */
bool OpenGLRenderer::createTexture(Texture &texture) {
        GLenum target = targets[texture.textureKind];
        int nImages = 1;

        glGenTextures(1, &texture.textureID);
        glBindTexture(target, texture.textureID);

        switch (texture.textureKind) {
                case TEXTURE_2D:
                        glTexParameteri(target, GL_TEXTURE_WRAP_S, (texture.clampS ? GL_CLAMP_TO_EDGE_EXT : GL_REPEAT));
                        glTexParameteri(target, GL_TEXTURE_WRAP_T, (texture.clampT ? GL_CLAMP_TO_EDGE_EXT : GL_REPEAT));
                        break;

                case TEXTURE_CUBEMAP:
                        nImages = 6;
                        glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE_EXT);
                        glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE_EXT);
                        break;

                default:
                        return false;
        }

        glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

        glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

        for (int i=0; i<nImages; i++) {
                Image *image = texture.images[i];

                GLenum imgTarget = (texture.textureKind == TEXTURE_2D) ? GL_TEXTURE_2D : GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + i;

                gluBuild2DMipmaps(imgTarget, 3, image->getWidth(), image->getHeight(), image->getFormat(), GL_UNSIGNED_BYTE, image->getData());
        }

        return true;
}

/********************************************************************
 * Remove texture
 */
void OpenGLRenderer::removeTexture(Texture &texture) {
        glDeleteTextures(1, &texture.textureID);
}

/********************************************************************
 * Change texture unit
 */
void OpenGLRenderer::changeTextureUnit(const int tex) {
        if (tex != currentTextureUnit)
                glActiveTextureARB(GL_TEXTURE0_ARB + (currentTextureUnit =tex));
}

/********************************************************************
 * Change texture
 */
void OpenGLRenderer::changeTexture(const TextureID textureID) {
        TextureID currTex = currentTextures[currentTextureUnit];

        if (textureID != currTex) {
                if (textureID == TEXTURE_NONE) {
                        glDisable(targets[textures[currTex].textureKind]);
                }
                else {
                        GLenum target = targets[textures[textureID].textureKind];

                        if (currTex == TEXTURE_NONE) {
                                glEnable(target);
                        }
                        else {
                                if (textures[textureID].textureKind != textures[currTex].textureKind) {
                                        glDisable(targets[textures[currTex].textureKind]);
                                        glEnable(target);
                                }
                        }

                        glBindTexture(target, textures[textureID].textureID);
                }
                currentTextures[currentTextureUnit] = textureID;
        }

}

/********************************************************************
 * Assign named textures
 */
void OpenGLRenderer::assignNamedTextures() {
        if (currentShader != SHADER_NONE) {
                for (int i=0; i<nNamedTextures; i++) {
                        int location = glGetUniformLocationARB(shaders[currentShader].programObj, selectedTextureNames[i]);
                        if (location >= 0) glUniform1iARB(location, i);
                }
        }
}

/********************************************************************
 * Create shader
 */
bool OpenGLRenderer::createShader(Shader &shader, const char *vertexShaderText, const char *fragmentShaderText) {
        const char *shaderStrings[2];
        int vResult, fResult, lResult;
        char str[4096];

        shaderStrings[0] = "#define saturate(x) clamp(x,0.0,1.0)\n"
                                           "#define lerp mix\n";

        shader.programObj = glCreateProgramObjectARB();

        shader.vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
        shaderStrings[1] = vertexShaderText;
        glShaderSourceARB(shader.vertexShader, 2, shaderStrings, NULL);
        glCompileShaderARB(shader.vertexShader);
        glGetObjectParameterivARB(shader.vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &vResult);
        if (vResult) {
                glAttachObjectARB(shader.programObj, shader.vertexShader);
        }
        else {
                glGetInfoLogARB(shader.vertexShader, sizeof(str), NULL, str);
                LOG_ERROR(("Vertex shader error! Log:\n%s", str));
        }

        shader.fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
        shaderStrings[1] = fragmentShaderText;
        glShaderSourceARB(shader.fragmentShader, 2, shaderStrings, NULL);
        glCompileShaderARB(shader.fragmentShader);
        glGetObjectParameterivARB(shader.fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &fResult);
        if (fResult) {
                glAttachObjectARB(shader.programObj, shader.fragmentShader);
        }
        else {
                glGetInfoLogARB(shader.fragmentShader, sizeof(str), NULL, str);
                LOG_ERROR(("Fragment shader error! Log:\n%s", str));
        }


        if (vResult && fResult) {
                glLinkProgramARB(shader.programObj);
                glGetObjectParameterivARB(shader.programObj, GL_OBJECT_LINK_STATUS_ARB, &lResult);

                //glGetInfoLogARB(shader.programObj, sizeof(str), NULL, str);
                //LOG_ERROR(("Program ARB error! Log:\n%s", str));

                if (lResult) {
                        return true;
                }
                else {
                        glGetInfoLogARB(shader.programObj, sizeof(str), NULL, str);
                        LOG_ERROR(("Program object error! Log:\n%s", str));
                }
        }

        removeShader(shader);
        return false;
}

/********************************************************************
 * Remove shader
 */
void OpenGLRenderer::removeShader(Shader &shader) {
        glDeleteObjectARB(shader.vertexShader);
        glDeleteObjectARB(shader.fragmentShader);
        glDeleteObjectARB(shader.programObj);
}

/********************************************************************
 * Change shader
 */
void OpenGLRenderer::changeShader(const ShaderID shader) {
        if (shader != currentShader) {
                if (shader == SHADER_NONE)
                        glUseProgramObjectARB(0);
                else
                        glUseProgramObjectARB(shaders[shader].programObj);

                currentShader = shader;
        }
}

/********************************************************************
 * Change shader constant 1f
 */
void OpenGLRenderer::changeShaderConstant1f(const char *name, const float constant) {
        if (currentShader != SHADER_NONE) {
                int location = glGetUniformLocationARB(shaders[currentShader].programObj, name);
                if (location >= 0) glUniform1fARB(location, constant);
        }
}

/********************************************************************
 * Change shader constant 2f
 */
void OpenGLRenderer::changeShaderConstant2f(const char *name, const Vec2 &constant) {
        if (currentShader != SHADER_NONE) {
                int location = glGetUniformLocationARB(shaders[currentShader].programObj, name);
                //if (location >= 0) glUniform2fvARB(location, 1, (float *)&constant);
                if (location >= 0) glUniform2fARB(location, constant.x, constant.y);
        }
}

/********************************************************************
 * Change shader constant 3f
 */
void OpenGLRenderer::changeShaderConstant3f(const char *name, const Vec3 &constant) {
        if (currentShader != SHADER_NONE) {
                int location = glGetUniformLocationARB(shaders[currentShader].programObj, name);
                //if (location >= 0) glUniform3fvARB(location, 1, (float *)&constant);
                if (location >= 0) glUniform3fARB(location, constant.x, constant.y, constant.z);
        }
}

/********************************************************************
 * Change shader constant 4f
 */
void OpenGLRenderer::changeShaderConstant4f(const char *name, const Vec4 &constant) {
        if (currentShader != SHADER_NONE) {
                int location = glGetUniformLocationARB(shaders[currentShader].programObj, name);
                //if (location >= 0) glUniform4fvARB(location, 1, (float *)&constant);
                if (location >= 0) glUniform4fARB(location, constant.x, constant.y, constant.z, constant.w);
        }
}


/********************************************************************
 * Create fragment shader
 */
void OpenGLRenderer::createFragmentShader(FragmentShader &fragmentShader) {
        //if (fragmentShader.type == GL_FRAGMENT_SHADER_GL2) {

        //}if (fragmentShader.type == GL_FRAGMENT_PROGRAM_ARB) {
                glGenProgramsARB(1, &fragmentShader.shaderID);
                glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, fragmentShader.shaderID);
        }
        //else if (fragmentShader.type == GL_FRAGMENT_SHADER_ATI) {
        //      fragmentShader.shaderID = glGenFragmentShadersATI(1);
        //      glBindFragmentShaderATI(fragmentShader.shaderID);
        //}
}

/********************************************************************
 * Remove fragment shader
 */
void OpenGLRenderer::removeFragmentShader(FragmentShader &fragmentShader) {
        if (fragmentShader.type == GL_FRAGMENT_PROGRAM_ARB) {
                glDeleteProgramsARB(1, &fragmentShader.shaderID);
        }
        //else if (fragmentShader.type == GL_FRAGMENT_SHADER_ATI) {
        //      glDeleteFragmentShaderATI(fragmentShader.shaderID);
        //}
        //else if (fragmentShader.type == GL_REGISTER_COMBINERS_NV) {
        //      glDeleteLists(fragmentShader.shaderID, 1);
        //}
}

/********************************************************************
 * Upload fragment shader
 */
void OpenGLRenderer::uploadFragmentShader(FragmentShader &fragmentShader) {
        glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, fragmentShader.length, fragmentShader.program);
}

/********************************************************************
 * Create vertex shader
 */
void OpenGLRenderer::createVertexShader(VertexShader &vertexShader) {
        glGenProgramsARB(1, &vertexShader.shaderID);
        glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vertexShader.shaderID);
}

/********************************************************************
 * Remove vertex shader
 */
void OpenGLRenderer::removeVertexShader(VertexShader &vertexShader) {
        glDeleteProgramsARB(1, &vertexShader.shaderID);
}

/********************************************************************
 * Upload vertex shader
 */
void OpenGLRenderer::uploadVertexShader(VertexShader &vertexShader) {
        glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, vertexShader.length, vertexShader.program);
}

/********************************************************************
 * Change fragment shader
 */
void OpenGLRenderer::changeFragmentShader(const ShaderID shader) {
        if (currentFragmentShader != shader) {
                if (shader == SHADER_NONE) {
                        glDisable(fragmentShaders[currentFragmentShader].type);
                }
                else {
                        if (currentFragmentShader == SHADER_NONE) {
                                glEnable(fragmentShaders[shader].type);
                        }
                        else if (fragmentShaders[currentFragmentShader].type != fragmentShaders[shader].type) {
                                glDisable(fragmentShaders[currentFragmentShader].type);
                                glEnable(fragmentShaders[shader].type);
                        }

                        if (fragmentShaders[shader].type == GL_FRAGMENT_PROGRAM_ARB) {
                                glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, fragmentShaders[shader].shaderID);
                        }
                }

                currentFragmentShader = shader;
        }
}

/********************************************************************
 * Change vertex shader
 */
void OpenGLRenderer::changeVertexShader(const ShaderID shader) {
        if (currentVertexShader != shader) {
                if (shader == SHADER_NONE) {
                        glDisable(GL_VERTEX_PROGRAM_ARB);
                }
                else {
                        if (currentVertexShader == SHADER_NONE) {
                                glEnable(GL_VERTEX_PROGRAM_ARB);
                        }

                        glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vertexShaders[shader].shaderID);
                }

                currentVertexShader = shader;
        }
}

---