BL_Shader.h

Go to the documentation of this file.

#ifndef __BL_SHADER_H__
#define __BL_SHADER_H__

#include "PyObjectPlus.h"
#include "BL_Material.h"
#include "BL_Texture.h"
// --
#include "MT_Matrix4x4.h"
#include "MT_Matrix3x3.h"
#include "MT_Tuple2.h"
#include "MT_Tuple3.h"
#include "MT_Tuple4.h"

#define SHADER_ATTRIBMAX 1

class BL_Sampler
{
public:
    BL_Sampler():
        mLoc(-1)
    {
    }
    int             mLoc;       // Sampler location
    
#ifdef WITH_CXX_GUARDEDALLOC
public:
    void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:BL_Sampler"); }
    void operator delete( void *mem ) { MEM_freeN(mem); }
#endif
};

class BL_Uniform 
{
private:
    int         mLoc;       // Uniform location
    void*       mData;      // Memory allocated for variable
    bool        mDirty;     // Caching variable  
    int         mType;      // Enum UniformTypes
    bool        mTranspose; // Transpose matrices
    const int   mDataLen;   // Length of our data
public:
    BL_Uniform(int data_size);
    ~BL_Uniform();
    

    void Apply(class BL_Shader *shader);
    void SetData(int location, int type, bool transpose=false);

    enum UniformTypes {
        UNI_NONE    =0,
        UNI_INT,
        UNI_FLOAT,
        UNI_INT2,
        UNI_FLOAT2,
        UNI_INT3,
        UNI_FLOAT3,
        UNI_INT4,
        UNI_FLOAT4,
        UNI_MAT3,
        UNI_MAT4,
        UNI_MAX
    };

    int GetLocation()   { return mLoc; }
    void* getData()     { return mData; }
    
    
#ifdef WITH_CXX_GUARDEDALLOC
public:
    void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:BL_Uniform"); }
    void operator delete( void *mem ) { MEM_freeN(mem); }
#endif
};

class BL_DefUniform
{
public:
    BL_DefUniform() :
        mType(0),
        mLoc(0),
        mFlag(0)
    {
    }
    int             mType;
    int             mLoc;
    unsigned int    mFlag;
    
    
#ifdef WITH_CXX_GUARDEDALLOC
public:
    void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:BL_DefUniform"); }
    void operator delete( void *mem ) { MEM_freeN(mem); }
#endif
};

class BL_Shader : public PyObjectPlus
{
    Py_Header
private:
    typedef std::vector<BL_Uniform*>    BL_UniformVec;
    typedef std::vector<BL_DefUniform*> BL_UniformVecDef;

    unsigned int    mShader;            // Shader object 
    int             mPass;              // 1.. unused
    bool            mOk;                // Valid and ok
    bool            mUse;               // ...
//BL_Sampler        mSampler[MAXTEX];   // Number of samplers
    int             mAttr;              // Tangent attribute
    const char*     vertProg;           // Vertex program string
    const char*     fragProg;           // Fragment program string
    bool            mError;             // ...
    bool            mDirty;             // 

    // Compiles and links the shader
    bool LinkProgram();

    // Stored uniform variables
    BL_UniformVec       mUniforms;
    BL_UniformVecDef    mPreDef;

    // search by location
    BL_Uniform*     FindUniform(const int location);
    // clears uniform data
    void            ClearUniforms();

public:
    BL_Shader();
    virtual ~BL_Shader();

    // Unused for now tangent is set as 
    // tex coords
    enum AttribTypes {
        SHD_TANGENT =1
    };

    enum GenType {
        MODELVIEWMATRIX,
        MODELVIEWMATRIX_TRANSPOSE,
        MODELVIEWMATRIX_INVERSE,
        MODELVIEWMATRIX_INVERSETRANSPOSE,
    
        // Model matrix
        MODELMATRIX,
        MODELMATRIX_TRANSPOSE,
        MODELMATRIX_INVERSE,
        MODELMATRIX_INVERSETRANSPOSE,
    
        // View Matrix
        VIEWMATRIX,
        VIEWMATRIX_TRANSPOSE,
        VIEWMATRIX_INVERSE,
        VIEWMATRIX_INVERSETRANSPOSE,

        // Current camera position 
        CAM_POS,

        // RAS timer
        CONSTANT_TIMER
    };

    const char* GetVertPtr();
    const char* GetFragPtr();
    void SetVertPtr( char *vert );
    void SetFragPtr( char *frag );
    
    // ---
    int getNumPass()    {return mPass;}
    bool GetError()     {return mError;}
    // ---
    //const BL_Sampler* GetSampler(int i);
    void                SetSampler(int loc, int unit);

    bool                Ok()const;
    unsigned int        GetProg();
    void                SetProg(bool enable);
    int                 GetAttribute(){return mAttr;};

    // -- 
    // Apply methods : sets colected uniforms
    void ApplyShader();
    void UnloadShader();

    // Update predefined uniforms each render call
    void Update(const class RAS_MeshSlot & ms, class RAS_IRasterizer* rasty);

    //void InitializeSampler(int unit, BL_Texture* texture );


    void SetUniformfv(int location,int type, float *param, int size,bool transpose=false);
    void SetUniformiv(int location,int type, int *param, int size,bool transpose=false);

    int GetAttribLocation(const STR_String& name);
    void BindAttribute(const STR_String& attr, int loc);
    int GetUniformLocation(const STR_String& name);

    void SetUniform(int uniform, const MT_Tuple2& vec);
    void SetUniform(int uniform, const MT_Tuple3& vec);
    void SetUniform(int uniform, const MT_Tuple4& vec);
    void SetUniform(int uniform, const MT_Matrix4x4& vec, bool transpose=false);
    void SetUniform(int uniform, const MT_Matrix3x3& vec, bool transpose=false);
    void SetUniform(int uniform, const float& val);
    void SetUniform(int uniform, const float* val, int len);
    void SetUniform(int uniform, const int* val, int len);
    void SetUniform(int uniform, const unsigned int& val);
    void SetUniform(int uniform, const int val);

    // Python interface
#ifdef WITH_PYTHON
    virtual PyObject* py_repr(void) { return PyUnicode_FromFormat("BL_Shader\n\tvertex shader:%s\n\n\tfragment shader%s\n\n", vertProg, fragProg); }

    // -----------------------------------
    KX_PYMETHOD_DOC( BL_Shader, setSource );
    KX_PYMETHOD_DOC( BL_Shader, delSource );
    KX_PYMETHOD_DOC( BL_Shader, getVertexProg );
    KX_PYMETHOD_DOC( BL_Shader, getFragmentProg );
    KX_PYMETHOD_DOC( BL_Shader, setNumberOfPasses );
    KX_PYMETHOD_DOC( BL_Shader, isValid);
    KX_PYMETHOD_DOC( BL_Shader, validate);

    // -----------------------------------
    KX_PYMETHOD_DOC( BL_Shader, setUniform4f );
    KX_PYMETHOD_DOC( BL_Shader, setUniform3f );
    KX_PYMETHOD_DOC( BL_Shader, setUniform2f );
    KX_PYMETHOD_DOC( BL_Shader, setUniform1f );
    KX_PYMETHOD_DOC( BL_Shader, setUniform4i );
    KX_PYMETHOD_DOC( BL_Shader, setUniform3i );
    KX_PYMETHOD_DOC( BL_Shader, setUniform2i );
    KX_PYMETHOD_DOC( BL_Shader, setUniform1i );
    KX_PYMETHOD_DOC( BL_Shader, setUniformfv );
    KX_PYMETHOD_DOC( BL_Shader, setUniformiv );
    KX_PYMETHOD_DOC( BL_Shader, setUniformMatrix4 );
    KX_PYMETHOD_DOC( BL_Shader, setUniformMatrix3 );
    KX_PYMETHOD_DOC( BL_Shader, setUniformDef );
    KX_PYMETHOD_DOC( BL_Shader, setAttrib );
    KX_PYMETHOD_DOC( BL_Shader, setSampler);
#endif
};

#endif//__BL_SHADER_H__