Renderer.cpp

Go to the documentation of this file.

#include "Renderer.h"

/********************************************************************
 * Constructor
 */
Renderer::Renderer() {
        lockFlags = 0xFFFFFFFF;
}

/********************************************************************
 * Destructor
 */
Renderer::~Renderer() {
}

/********************************************************************
 * Lock
 */
void Renderer::lock(const unsigned int flag) {
        lockFlags &= ~flag;
}

/********************************************************************
 * Unlock
 */
void Renderer::unlock(const unsigned int flag) {
        lockFlags |= flag;
}

/********************************************************************
 * Apply
 */
void Renderer::apply() {
        if (lockFlags & LF_SHADING) changeShader(selectedShader);

        assignNamedTextures();

        for (int tex = 0; tex < maxTextures; tex++) {
                changeTextureUnit(tex);
                changeTexture(selectedTextures[tex]);
        }

        changeBlending(selectedBlendSrc, selectedBlendDest, selectedBlendMode);
        changeDepthFunc(selectedDepthFunc);
        changeMask(selectedMask);

        reset();
}

/********************************************************************
 * Reset to defaults
 */
void Renderer::resetToDefaults() {
        for (int tex = 0; tex < maxTextures; tex++) {
                currentTextures[tex] = TEXTURE_NONE;
        }

        currentTextureUnit      = 0;

        currentBlendSrc         = BLENDING_NONE;
        currentBlendDest        = BLENDING_NONE;
        currentBlendMode        = BLENDMODE_ADD;
        currentDepthFunc        = LEQUAL;
        currentMask                     = ALL;

        currentShader           = SHADER_NONE;

        reset();
}

/********************************************************************
 * Reset
 */
void Renderer::reset() {
        for (int tex = 0; tex < maxTextures; tex++) {
                selectedTextures[tex] = TEXTURE_NONE;
        }

        nNamedTextures          = 0;

        selectedBlendSrc        = BLENDING_NONE;
        selectedBlendDest       = BLENDING_NONE;
        selectedBlendMode       = BLENDMODE_ADD;
        selectedDepthFunc       = LEQUAL;
        selectedMask            = ALL;

        selectedShader          = SHADER_NONE;
}

/********************************************************************
 * Add texture (file)
 */
TextureID Renderer::addTexture(const char *filename, unsigned int flags) {
        Image *image = new Image();

        if (image->loadImage(filename)) {
                return addTexture(image, flags);
        }

        delete image;
        return TEXTURE_NONE;
}

/********************************************************************
 * Add texture (image)
 */
TextureID Renderer::addTexture(Image *image, unsigned int flags) {
        Texture texture;

        if (flags & TEXTURE_NORMALMAP) {
                image->toGrayScale();
                image->toNormalMap(true, (flags & TEXTURE_HEIGHTMAP) != 0);
        }

        texture.clampS = ((flags & TEXTURE_CLAMP_S) != 0);
        texture.clampT = ((flags & TEXTURE_CLAMP_T) != 0);

        texture.textureKind     = TEXTURE_2D;
        texture.height          = image->getHeight();
        texture.width           = image->getWidth();
        texture.depth           = 1;
        texture.images[0]       = image;
        texture.format          = image->getFormat();

        if (createTexture(texture))
                return insertTexture(texture);

        delete image;
        return TEXTURE_NONE;
}

/********************************************************************
 * Add cubemap (files)
 */
TextureID Renderer::addCubemap(const char *fNegX, const char *fPosX, const char *fNegY, const char *fPosY, const char *fNegZ, const char *fPosZ) {
        const char *filenames[] = { fPosX, fNegX, fNegY, fPosY, fPosZ, fNegZ };
        //const char *filenames[] = { fNegX, fPosX, fNegY, fPosY, fNegZ, fPosZ };
        Image *images[6];

        for (int i=0; i<6; i++) {
                images[i] = new Image();

                if (!images[i]->loadImage(filenames[i])) {
                        do {
                                delete images[i];
                        } while (i--);

                        LOG_ERROR(("Unable to load cubemap images"));
                        return TEXTURE_NONE;
                }
        }

        return addCubemap(images);
}

/********************************************************************
 * Add cubemap (images)
 */
TextureID Renderer::addCubemap(Image *images[6]) {
        Texture texture;

        texture.textureKind     = TEXTURE_CUBEMAP;
        texture.width           = images[0]->getWidth();
        texture.height          = images[0]->getHeight();
        texture.depth           = 1;
        texture.format          = images[0]->getFormat();

        memcpy(texture.images, images, 6*sizeof(Image *));

        if (createTexture(texture)) {
                LOG_SUCCESS(("Cubemap created"));
                return insertTexture(texture);
        }

        LOG_ERROR(("Unable to create cubemap"));
        return TEXTURE_NONE;
}

/********************************************************************
 * Insert texture
 */
TextureID Renderer::insertTexture(Texture &texture) {
        int len = textures.getCount();
        for (unsigned int i = 0; i < len; i++) {
                if (textures[i].textureID == UNDEFINED) {
                        textures[i] = texture;
                        break;
                }
        }

        if (i == len) i = textures.add(texture);

        texture.images[0]->clear();

        return i;
}

/********************************************************************
 * Delete texture
 */
void Renderer::deleteTexture(const int i) {
        if (textures[i].textureID != UNDEFINED) {
                removeTexture(textures[i]);

                switch (textures[i].textureKind) {
                        case TEXTURE_2D:
                                delete textures[i].images[0];
                                break;
                        case TEXTURE_CUBEMAP:
                                for (int n=0; n<6; n++) delete textures[i].images[n];
                                break;
                }

                textures[i].textureID = UNDEFINED;

                LOG_SUCCESS(("Texture (%d) removed", i));
                return;
        }

        LOG_ERROR(("Unable to unload texture (%d)", i));
}

/********************************************************************
 * Add shader
 */
ShaderID Renderer::addShader(const char *fileName, const char *extraDefines) {
        FILE *file = fopen(fileName, "rb");
        if (file == NULL) {

        }
        else {
                fseek(file, 0, SEEK_END);
                int length = ftell(file);
                fseek(file, 0, SEEK_SET);

                char *shaderText = new char[length+1];
                fread(shaderText, length, 1, file);
                fclose(file);
                shaderText[length] = '\0';

                char *vertexShader = strstr(shaderText, "[Vertex shader]");
                char *fragmentShader = strstr(shaderText, "[Fragment shader]");

                if (vertexShader != NULL) {
                        *vertexShader = '\0';
                        vertexShader += 15;
                }

                if (fragmentShader != NULL) {
                        *fragmentShader = '\0';
                        fragmentShader += 17;
                }

                String vShaderString, fShaderString;
                if (vertexShader != NULL) {
                        int n = 0;
                        char *str = shaderText;
                        while (str < vertexShader) {
                                if (*str == '\n') n++;
                                str++;
                        }
                        if (extraDefines) vShaderString = extraDefines;
                        vShaderString += vertexShader;
                }

                if (fragmentShader != NULL) {
                        int n = 0;
                        char *str = shaderText;
                        while (str < fragmentShader) {
                                if (*str == '\n') n++;
                                str++;
                        }
                        if (extraDefines) fShaderString = extraDefines;
                        fShaderString += fragmentShader;
                }

                Shader shader;
                bool res = createShader(shader, (vertexShader ? (const char *)vShaderString : NULL), (fragmentShader ? (const char *)fShaderString : NULL));

                if (res) {
                        LOG_SUCCESS(("Shader << %s >> loaded", fileName));
                        return insertShader(shader);
                }
        }

        LOG_ERROR(("Could not load shader << %s >>", fileName));
        return SHADER_NONE;
}

/********************************************************************
 * Insert shader
 */
ShaderID Renderer::insertShader(Shader &shader) {
        int i, len = shaders.getCount();
        for (i=0; i<len; i++) {
                if (shaders[i].programObj == UNDEFINED) {
                        shaders[i] = shader;
                        return i;
                }
        }

        return shaders.add(shader);
}

/********************************************************************
 * Delete shader
 */
void Renderer::deleteShader(const int i) {
        if (shaders[i].programObj != UNDEFINED) {
                removeShader(shaders[i]);
                shaders[i].programObj = UNDEFINED;
                LOG_SUCCESS(("Shader (%d) removed", i));
        }
}

/********************************************************************
 * Add fragment shader (file)
 */
ShaderID Renderer::addFragmentShader(unsigned int type, char *filename) {
        FragmentShader fragmentShader;
        fragmentShader.type = type;

        createFragmentShader(fragmentShader);

        if (filename != NULL) {
                FILE *file = fopen(filename, "rb");

                if (file == NULL) return SHADER_NONE;

                fseek(file, 0, SEEK_END);
                fragmentShader.length = ftell(file);
                fseek(file, 0, SEEK_SET);

                fragmentShader.program = new char[fragmentShader.length];
                fread(fragmentShader.program, fragmentShader.length, 1, file);
                fclose(file);

                uploadFragmentShader(fragmentShader);
                delete fragmentShader.program;

                LOG_SUCCESS(("Fragment shader << %s >> added", filename));
        }
        else {
                LOG_SUCCESS(("Unable to find fragment shader file << %s >>", filename));
        }

        return insertFragmentShader(fragmentShader);
}

/********************************************************************
 * Add fragment shader (shaderID)
 */
ShaderID Renderer::addFragmentShader(unsigned int type, unsigned int shaderID) {
        FragmentShader fragmentShader;
        fragmentShader.type = type;
        fragmentShader.shaderID = shaderID;

        return insertFragmentShader(fragmentShader);
}

/********************************************************************
 * Add vertex shader (file)
 */
ShaderID Renderer::addVertexShader(char *filename) {
        VertexShader vertexShader;

        createVertexShader(vertexShader);

        FILE *file;
        if ((file = fopen(filename, "rb")) != NULL) {
                fseek(file, 0, SEEK_END);
                vertexShader.length = ftell(file);
                fseek(file, 0, SEEK_SET);

                vertexShader.program = new char[vertexShader.length];
                fread(vertexShader.program, vertexShader.length, 1, file);
                fclose(file);

                uploadVertexShader(vertexShader);
                delete vertexShader.program;
                return insertVertexShader(vertexShader);
        }

        return SHADER_NONE;
}

/********************************************************************
 * Insert fragment shader
 */
ShaderID Renderer::insertFragmentShader(FragmentShader &fragmentShader) {
        int i, len = fragmentShaders.getCount();
        for (i = 0; i<len; i++) {
                if (fragmentShaders[i].shaderID == UNDEFINED) {
                        fragmentShaders[i] = fragmentShader;
                        return i;
                }
        }

        return fragmentShaders.add(fragmentShader);
}

/********************************************************************
 * Delete fragment shader
 */
void Renderer::deleteFragmentShader(const int index) {
        if (fragmentShaders[index].shaderID != UNDEFINED) {
                removeFragmentShader(fragmentShaders[index]);
                fragmentShaders[index].shaderID = UNDEFINED;
        }
}

/********************************************************************
 * Insert vertex shader
 */
ShaderID Renderer::insertVertexShader(VertexShader &vertexShader) {
        int i, len = vertexShaders.getCount();
        for (i=0; i<len; i++) {
                if (vertexShaders[i].shaderID == UNDEFINED) {
                        vertexShaders[i] = vertexShader;
                        return i;
                }
        }

        return vertexShaders.add(vertexShader);
}

/********************************************************************
 * Delete vertex shader
 */
void Renderer::deleteVertexShader(const int index) {
        if (vertexShaders[index].shaderID == UNDEFINED) {
                removeVertexShader(vertexShaders[index]);
                vertexShaders[index].shaderID = UNDEFINED;
        }
}

---