OpenGLRenderer.h

Go to the documentation of this file.

#ifndef ULT_RENDERER_OPENGL_H_INCLUDED
#define ULT_RENDERER_OPENGL_H_INCLUDED
 
#include <vector>
 
#include <GL/glew.h>
 
#include "RenderInterface.h"
#include "../ResourceManager.h"
#include "../Shader/GLSLParameter.h"
#include "../Shader/GLSLShader.h"
#include "../Texture/GLTexture.h"
#include "VertexDescriptor.h"
 
namespace Ult
{

class OpenGLRenderer : public RenderInterface
{
    //TODO
    //BB_RTTI_EXPOSE_TYPE;
 
public:
    OpenGLRenderer();
    virtual ~OpenGLRenderer();
 
    virtual bool Initialize(const RenderParams* params);
    virtual void Shutdown();
 
    virtual void SetViewport(int x, int y, int width, int height);
    virtual void ResizeWindow(
        float fov,
        float nearDist, float farDist,
        int width, int height
    );
    virtual void ResizeWindowOrtho(
        int left, int right,
        int bottom, int top,
        float nearDist, float farDist
    );
 
    virtual void SetClearColor(int r, int g, int b, int a);
    virtual void StartRendering(bool color, bool depth, bool stencil);
    virtual void EndRendering();
 
    virtual bool Enable(RenderState state);
    virtual bool Disable(RenderState state);
    virtual void SetAlphaFunc(AlphaState state, float val);
 
    virtual void SetView(
        float posX, float posY, float posZ,
        float lookX, float lookY, float lookZ,
        float upX, float upY, float upZ
    );
    virtual void SetMatrix(const float* matrix);
    virtual void MultiplyToCurrentMatrix(const float* m);
    virtual bool SwitchMatrixType(MatrixType type);
    virtual void GetMatrix(MatrixType type, float* matrix);
 
    virtual void RotateMatrix(float angle, float x, float y, float z);
    virtual void TranslateMatrix(float x, float y, float z);
 
    virtual void LoadIdentityMatrix();
    virtual void PushMatrix();
    virtual void PopMatrix();
 
 
    virtual void ApplyFilters(Texture& handle, FilterListPtr filters);
    virtual bool AddEmptyTexture(
        const char* name,
        int width, int height, int numComponents,
        TextureType type,
        TextureFormat format,
        Texture* handle
    );
    virtual bool LoadTexFromFile(
        const char* fileName,
        TextureType type,
        Texture* handle
    );
    virtual bool LoadTexFromMemory(
        const char* name,
        char* fileData,
        int length,
        TextureType type,
        Texture* handle
    );
    virtual bool ApplyTexture(int texUnit, Texture& handle);
    virtual void DeleteTexture(Texture& handle);
 
 
    virtual bool CreateShaderFromFile(const char* vs, const char* ps, ShaderHandle* handle);
    virtual bool CreateShaderFromMemory(const char* vsFile, const char* psFile, ShaderHandle* handle);
    virtual void ApplyShader(ShaderHandle shader);
 
    virtual void SetupShaderParameter(const char* pname, ShaderHandle shader, ParameterHandle* param);
    virtual void SetShaderParameter1i(ParameterHandle param, float val);
    virtual void SetShaderParameter1f(ParameterHandle param, float val);
    virtual void SetShaderParameter2f(ParameterHandle param, float x, float y);
    virtual void SetShaderParameter3f(ParameterHandle param, float x, float y, float z);
    virtual void SetShaderParameter4f(ParameterHandle param, float x, float y, float z, float w);
 
 
    virtual void Render(
        PrimitiveType type,
        VertexDescriptor* desc,
        char* vertexData,
        unsigned int* indices,
        int totalVertices, // size in bytes
        int totalIndices,
        int stride
    );
 
protected:
    VertexDescriptor* mCurrentDesc;
    bool mVboSupport, mFboSupport, mGlslSupport;
    GLuint mVbo, mIbo;
    ResourceManager<GLTexture,Texture>* mTexManager;
 
    std::vector<GLSLShader> mShaders;
    std::vector<GLSLParameter> mParameters;
 
 
    bool InitializeOS(const RenderParams* params);
    void ShutdownOS();
    void InitializeExtensions();
};
 
    
} // namespace Ult
 
#endif // ULT_RENDERER_OPENGL_H_INCLUDED