Renderer.h

Go to the documentation of this file.

#ifndef _RENDERER_H_
#define _RENDERER_H_

#include "../Common/Globals.h"
#include "../Util/Set.h"
#include "../Util/String.h"
#include "../Math/Vector.h"
#include "Image.h"

typedef int TextureID;
typedef int ShaderID;

enum TEXTUREKIND {
        TEXTURE_2D              = 0,
        TEXTURE_CUBEMAP = 1,
};

struct Texture {
        unsigned int textureID;
        unsigned int width, height, depth;
        unsigned int format;
        TEXTUREKIND textureKind;
        bool clampS, clampT, clampR;
        Image *images[6];
};

struct Shader {
        unsigned int programObj;
        unsigned int vertexShader;
        unsigned int fragmentShader;
        void *vertexShaderConstants;
        void *fragmentShaderConstants;
};

struct FragmentShader {
        unsigned int shaderID;
        char *program;
        unsigned int length;
        unsigned int type;
};

struct VertexShader {
        unsigned int shaderID;
        char *program;
        unsigned int length;
};

#define MAX_TEXTURES    16

#define TEXTURE_NONE    (-1)
#define DEPTH_NONE              (-1)
#define BLENDING_NONE   (-1)
#define SHADER_NONE             (-1)

#define UNDEFINED               0

// Texture flags
#define TEXTURE_CLAMP_S 0x1
#define TEXTURE_CLAMP_T 0x2
#define TEXTURE_CLAMP_R 0x4
#define TEXTURE_CLAMP   (TEXTURE_CLAMP_S | TEXTURE_CLAMP_T | TEXTURE_CLAMP_R)

#define TEXTURE_NORMALMAP       0x10
#define TEXTURE_HEIGHTMAP       0x20
#define TEXTURE_NORMALHEIGHTMAP (TEXTURE_NORMALMAP | TEXTURE_HEIGHTMAP)

// Mask flags
// Mask
#define DEPTH   0x01
#define RED             0x02
#define GREEN   0x04
#define BLUE    0x08
#define ALPHA   0x10

#define COLOR (RED | GREEN | BLUE | ALPHA)
#define ALL (DEPTH | COLOR)
#define NONE 0

// Depth
extern const int NEVER;
extern const int LESS;
extern const int EQUAL;
extern const int LEQUAL;
extern const int GREATER;
extern const int NOTEQUAL;
extern const int GEQUAL;
extern const int ALWAYS;

// Blending
extern const int ZERO;
extern const int ONE;
extern const int SRC_COLOR;
extern const int ONE_MINUS_SRC_COLOR;
extern const int DST_COLOR;
extern const int ONE_MINUS_DST_COLOR;
extern const int SRC_ALPHA;
extern const int ONE_MINUS_SRC_ALPHA;
extern const int DST_ALPHA;
extern const int ONE_MINUS_DST_ALPHA;
extern const int SRC_ALPHA_SATURATE;

extern const int BLENDMODE_ADD;
extern const int BLENDMODE_SUBTRACT;
extern const int BLENDMODE_REVERSE_SUBSTRACT;
extern const int BLENDMODE_MIN;
extern const int BLENDMOXE_MAX;

// Lock flags
#define LF_SHADING      0x1


class Renderer {
        public:
                Renderer();
                virtual ~Renderer();
                void reset();
                void resetToDefaults();
                void apply();

                void lock(const unsigned int flag);
                void unlock(const unsigned int flag);

                virtual void setDefaults() = 0;

                // Texture
                TextureID addTexture(const char *filename, unsigned int flags = 0);
                TextureID addTexture(Image *image, unsigned int flags = 0);
                TextureID addCubemap(const char *fNegX, const char *fPosX, const char *fNegY, const char *fPosY, const char *fNegZ, const char *fPosZ);
                TextureID addCubemap(Image *images[6]);
                void deleteTexture(const int i);

                // Shader
                ShaderID addShader(const char *filename, const char *extraDefines = NULL);
                void deleteShader(const int i);

                virtual void changeShaderConstant1f(const char *name, const float constant) = 0;
                virtual void changeShaderConstant2f(const char *name, const Vec2 &constant) = 0;
                virtual void changeShaderConstant3f(const char *name, const Vec3 &constant) = 0;
                virtual void changeShaderConstant4f(const char *name, const Vec4 &constant) = 0;

                // depth, blending, mask
                virtual void changeDepthFunc(const int depthFunc) = 0;
                virtual void changeBlending(const sFactor, const dFactor, const int blendMode = BLENDMODE_ADD) = 0;
                virtual void changeMask(const int mask) = 0;

                // Vertex / fragment
                ShaderID addFragmentShader(unsigned int type, char *filename = NULL);
                ShaderID addFragmentShader(unsigned int type, unsigned int shaderID);
                ShaderID addVertexShader(char *filename);
                void deleteFragmentShader(const int index);
                void deleteVertexShader(const int index);

                virtual void changeFragmentShader(const ShaderID shader) = 0;
                virtual void changeVertexShader(const ShaderID shader) = 0;

        protected:
                // Texture
                TextureID insertTexture(Texture &texture);
                virtual bool createTexture(Texture &texture) = 0;
                virtual void removeTexture(Texture &texture) = 0;
                virtual void changeTextureUnit(const int tex) = 0;
                virtual void changeTexture(const TextureID textureID) = 0;
                //virtual void resetTextureUnits() = 0;
                virtual void assignNamedTextures() = 0;

                // Shader
                ShaderID insertShader(Shader &shader);
                virtual bool createShader(Shader &shader, const char *vertexShaderText, const char *fragmentShaderText) = 0;
                virtual void removeShader(Shader &shader) = 0;
                virtual void changeShader(const ShaderID shader) = 0;


                // Vertex / fragment
                ShaderID insertFragmentShader(FragmentShader &fragmentShader);

                virtual void createFragmentShader(FragmentShader &fragmentShader) = 0;
                virtual void removeFragmentShader(FragmentShader &fragmentShader) = 0;
                virtual void uploadFragmentShader(FragmentShader &fragmentShader) = 0;

                ShaderID insertVertexShader(VertexShader &vertexShader);
                virtual void createVertexShader(VertexShader &vertexShader) = 0;
                virtual void removeVertexShader(VertexShader &vertexShader) = 0;
                virtual void uploadVertexShader(VertexShader &vertexShader) = 0;

        public:
                unsigned int lockFlags;

        protected:

                // Texture
                Set <Texture> textures;
                int maxTextures;
                int currentTextureUnit;
                TextureID selectedTextures[MAX_TEXTURES];
                TextureID currentTextures[MAX_TEXTURES];
                const char *selectedTextureNames[MAX_TEXTURES];
                int nNamedTextures;

                // Shader
                Set <Shader> shaders;
                ShaderID currentShader, selectedShader;

                // depth, blending, mask
                int selectedDepthFunc, currentDepthFunc;
                int selectedBlendMode, currentBlendMode;
                int selectedBlendSrc, currentBlendSrc;
                int selectedBlendDest, currentBlendDest;
                int selectedMask, currentMask;

                // Vertex / fragment
                Set <VertexShader> vertexShaders;
                Set <FragmentShader> fragmentShaders;
                ShaderID selectedVertexShader, currentVertexShader;
                ShaderID selectedFragmentShader, currentFragmentShader;


        public: // inline (set) functions (increased performance.. a little..)

                // Texture
                inline void setTexture(const char *name, const TextureID texID) {
                        selectedTextureNames[nNamedTextures] = name;
                        selectedTextures[nNamedTextures] = texID;
                        nNamedTextures++;
                }

                inline void setTextures(const TextureID t0) {
                        selectedTextures[0] = t0;
                }

                inline void setTextures(const TextureID t0, const TextureID t1) {
                        selectedTextures[0] = t0;
                        selectedTextures[1] = t1;
                }

                inline void setTextures(const TextureID t0, const TextureID t1, const TextureID t2) {
                        selectedTextures[0] = t0;
                        selectedTextures[1] = t1;
                        selectedTextures[2] = t2;
                }

                inline void setTextures(const TextureID t0, const TextureID t1, const TextureID t2, const TextureID t3) {
                        selectedTextures[0] = t0;
                        selectedTextures[1] = t1;
                        selectedTextures[2] = t2;
                        selectedTextures[3] = t3;
                }

                inline void setTextures(const TextureID t0, const TextureID t1, const TextureID t2, const TextureID t3, const TextureID t4) {
                        selectedTextures[0] = t0;
                        selectedTextures[1] = t1;
                        selectedTextures[2] = t2;
                        selectedTextures[3] = t3;
                        selectedTextures[4] = t4;
                }

                inline void setTextures(const TextureID t0, const TextureID t1, const TextureID t2, const TextureID t3, const TextureID t4, const TextureID t5) {
                        selectedTextures[0] = t0;
                        selectedTextures[1] = t1;
                        selectedTextures[2] = t2;
                        selectedTextures[3] = t3;
                        selectedTextures[4] = t4;
                        selectedTextures[5] = t5;
                }

                // Shader
                inline void setShader(const ShaderID shader) {
                        selectedShader = shader;
                }

                // Set depth func
                inline void setDepthFunc(const int depthFunc) {
                        selectedDepthFunc = depthFunc;
                }

                // Set blending
                inline void setBlending(const int src, const int dest, const int blendMode = BLENDMODE_ADD) {
                        selectedBlendSrc = src;
                        selectedBlendDest = dest;
                        selectedBlendMode = blendMode;
                }

                // Set mask
                inline void setMask(const int mask) {
                        selectedMask = mask;
                }

                inline void setFragmentShader(const ShaderID shader) {
                        selectedFragmentShader = shader;
                }

                inline void setVertexShader(const ShaderID shader) {
                        selectedVertexShader = shader;
                }
};

#endif

---