2011-02-22 10:33:14 +00:00
|
|
|
|
|
|
|
/** \file BL_Shader.h
|
|
|
|
* \ingroup ketsji
|
|
|
|
*/
|
|
|
|
|
2006-01-06 03:46:54 +00:00
|
|
|
#ifndef __BL_SHADER_H__
|
|
|
|
#define __BL_SHADER_H__
|
|
|
|
|
2015-07-12 14:55:33 +00:00
|
|
|
#include "EXP_PyObjectPlus.h"
|
2006-01-06 03:46:54 +00:00
|
|
|
#include "BL_Material.h"
|
2006-02-13 05:45:32 +00:00
|
|
|
#include "BL_Texture.h"
|
|
|
|
#include "MT_Matrix4x4.h"
|
|
|
|
#include "MT_Matrix3x3.h"
|
|
|
|
#include "MT_Tuple2.h"
|
|
|
|
#include "MT_Tuple3.h"
|
|
|
|
#include "MT_Tuple4.h"
|
2006-01-06 03:46:54 +00:00
|
|
|
|
2006-04-02 21:04:20 +00:00
|
|
|
/**
|
|
|
|
* BL_Sampler
|
2015-10-25 18:43:46 +00:00
|
|
|
* Sampler access
|
2006-04-02 21:04:20 +00:00
|
|
|
*/
|
|
|
|
class BL_Sampler
|
|
|
|
{
|
|
|
|
public:
|
2015-10-25 18:43:46 +00:00
|
|
|
BL_Sampler()
|
|
|
|
:
|
2006-04-11 05:57:30 +00:00
|
|
|
mLoc(-1)
|
2006-04-02 21:04:20 +00:00
|
|
|
{
|
|
|
|
}
|
2015-10-25 18:43:46 +00:00
|
|
|
|
|
|
|
int mLoc; // Sampler location
|
|
|
|
|
2009-08-18 15:37:31 +00:00
|
|
|
#ifdef WITH_CXX_GUARDEDALLOC
|
2012-06-25 09:14:37 +00:00
|
|
|
MEM_CXX_CLASS_ALLOC_FUNCS("GE:BL_Sampler")
|
2009-08-18 15:37:31 +00:00
|
|
|
#endif
|
2006-04-02 21:04:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* BL_Uniform
|
2015-10-25 18:43:46 +00:00
|
|
|
* uniform storage
|
2006-04-02 21:04:20 +00:00
|
|
|
*/
|
2015-10-25 18:43:46 +00:00
|
|
|
class BL_Uniform
|
2006-01-06 03:46:54 +00:00
|
|
|
{
|
2006-04-02 21:04:20 +00:00
|
|
|
private:
|
2015-10-25 18:43:46 +00:00
|
|
|
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
|
2006-04-02 21:04:20 +00:00
|
|
|
public:
|
|
|
|
BL_Uniform(int data_size);
|
|
|
|
~BL_Uniform();
|
|
|
|
|
|
|
|
enum UniformTypes {
|
2015-10-25 18:43:46 +00:00
|
|
|
UNI_NONE = 0,
|
2006-04-02 21:04:20 +00:00
|
|
|
UNI_INT,
|
|
|
|
UNI_FLOAT,
|
|
|
|
UNI_INT2,
|
|
|
|
UNI_FLOAT2,
|
|
|
|
UNI_INT3,
|
|
|
|
UNI_FLOAT3,
|
|
|
|
UNI_INT4,
|
|
|
|
UNI_FLOAT4,
|
|
|
|
UNI_MAT3,
|
|
|
|
UNI_MAT4,
|
2016-06-09 22:28:19 +00:00
|
|
|
UNI_FLOAT_EYE,
|
2006-04-02 21:04:20 +00:00
|
|
|
UNI_MAX
|
|
|
|
};
|
|
|
|
|
2016-06-09 22:28:19 +00:00
|
|
|
bool Apply(class BL_Shader *shader);
|
2015-10-25 18:43:46 +00:00
|
|
|
void SetData(int location, int type, bool transpose = false);
|
|
|
|
int GetLocation() { return mLoc; }
|
|
|
|
void *getData() { return mData; }
|
|
|
|
|
2009-08-18 15:37:31 +00:00
|
|
|
#ifdef WITH_CXX_GUARDEDALLOC
|
2012-06-25 09:14:37 +00:00
|
|
|
MEM_CXX_CLASS_ALLOC_FUNCS("GE:BL_Uniform")
|
2009-08-18 15:37:31 +00:00
|
|
|
#endif
|
2006-04-02 21:04:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* BL_DefUniform
|
2015-10-25 18:43:46 +00:00
|
|
|
* pre defined uniform storage
|
2006-04-02 21:04:20 +00:00
|
|
|
*/
|
|
|
|
class BL_DefUniform
|
2006-02-13 05:45:32 +00:00
|
|
|
{
|
2006-04-02 21:04:20 +00:00
|
|
|
public:
|
2015-10-25 18:43:46 +00:00
|
|
|
BL_DefUniform()
|
|
|
|
:
|
2006-04-02 21:04:20 +00:00
|
|
|
mType(0),
|
|
|
|
mLoc(0),
|
|
|
|
mFlag(0)
|
|
|
|
{
|
|
|
|
}
|
2015-10-25 18:43:46 +00:00
|
|
|
|
|
|
|
int mType;
|
|
|
|
int mLoc;
|
|
|
|
unsigned int mFlag;
|
|
|
|
|
2009-08-18 15:37:31 +00:00
|
|
|
#ifdef WITH_CXX_GUARDEDALLOC
|
2012-06-25 09:14:37 +00:00
|
|
|
MEM_CXX_CLASS_ALLOC_FUNCS("GE:BL_DefUniform")
|
2009-08-18 15:37:31 +00:00
|
|
|
#endif
|
2006-02-13 05:45:32 +00:00
|
|
|
};
|
2006-01-06 03:46:54 +00:00
|
|
|
|
2006-04-02 21:04:20 +00:00
|
|
|
/**
|
|
|
|
* BL_Shader
|
2015-10-25 18:43:46 +00:00
|
|
|
* shader access
|
2006-04-02 21:04:20 +00:00
|
|
|
*/
|
2006-01-06 03:46:54 +00:00
|
|
|
class BL_Shader : public PyObjectPlus
|
|
|
|
{
|
2011-11-06 01:39:36 +00:00
|
|
|
Py_Header
|
2006-01-06 03:46:54 +00:00
|
|
|
private:
|
2015-10-25 18:43:46 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
// Stored uniform variables
|
|
|
|
BL_UniformVec mUniforms;
|
|
|
|
BL_UniformVecDef mPreDef;
|
2006-04-02 21:04:20 +00:00
|
|
|
|
|
|
|
// Compiles and links the shader
|
|
|
|
bool LinkProgram();
|
|
|
|
|
|
|
|
// search by location
|
2015-10-25 18:43:46 +00:00
|
|
|
BL_Uniform *FindUniform(const int location);
|
|
|
|
|
2006-04-02 21:04:20 +00:00
|
|
|
// clears uniform data
|
2015-10-25 18:43:46 +00:00
|
|
|
void ClearUniforms();
|
2006-01-06 03:46:54 +00:00
|
|
|
|
|
|
|
public:
|
2009-06-28 11:22:26 +00:00
|
|
|
BL_Shader();
|
2006-01-06 03:46:54 +00:00
|
|
|
virtual ~BL_Shader();
|
|
|
|
|
2015-10-25 18:43:46 +00:00
|
|
|
// Unused for now tangent is set as tex coords
|
2006-04-02 21:04:20 +00:00
|
|
|
enum AttribTypes {
|
2015-10-25 18:43:46 +00:00
|
|
|
SHD_TANGENT = 1
|
2006-02-13 05:45:32 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum GenType {
|
|
|
|
MODELVIEWMATRIX,
|
|
|
|
MODELVIEWMATRIX_TRANSPOSE,
|
|
|
|
MODELVIEWMATRIX_INVERSE,
|
|
|
|
MODELVIEWMATRIX_INVERSETRANSPOSE,
|
|
|
|
MODELMATRIX,
|
|
|
|
MODELMATRIX_TRANSPOSE,
|
|
|
|
MODELMATRIX_INVERSE,
|
|
|
|
MODELMATRIX_INVERSETRANSPOSE,
|
|
|
|
VIEWMATRIX,
|
|
|
|
VIEWMATRIX_TRANSPOSE,
|
|
|
|
VIEWMATRIX_INVERSE,
|
|
|
|
VIEWMATRIX_INVERSETRANSPOSE,
|
2006-04-02 21:04:20 +00:00
|
|
|
CAM_POS,
|
|
|
|
CONSTANT_TIMER
|
2006-02-13 05:45:32 +00:00
|
|
|
};
|
|
|
|
|
2015-10-25 18:43:46 +00:00
|
|
|
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; }
|
|
|
|
|
2006-04-02 21:04:20 +00:00
|
|
|
// Apply methods : sets colected uniforms
|
|
|
|
void ApplyShader();
|
|
|
|
void UnloadShader();
|
2006-02-13 05:45:32 +00:00
|
|
|
|
2006-04-02 21:04:20 +00:00
|
|
|
// Update predefined uniforms each render call
|
2015-10-25 18:43:46 +00:00
|
|
|
void Update(const class RAS_MeshSlot &ms, class RAS_IRasterizer *rasty);
|
2006-04-02 21:04:20 +00:00
|
|
|
|
2015-10-25 18:43:46 +00:00
|
|
|
// Set sampler units (copied)
|
|
|
|
//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);
|
2012-11-10 22:32:15 +00:00
|
|
|
int GetAttribLocation(const char *name);
|
|
|
|
void BindAttribute(const char *attr, int loc);
|
|
|
|
int GetUniformLocation(const char *name);
|
2015-10-25 18:43:46 +00:00
|
|
|
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);
|
2006-04-02 21:04:20 +00:00
|
|
|
void SetUniform(int uniform, const int val);
|
|
|
|
|
|
|
|
// Python interface
|
2010-10-31 04:11:39 +00:00
|
|
|
#ifdef WITH_PYTHON
|
2015-10-25 18:43:46 +00:00
|
|
|
virtual PyObject *py_repr()
|
|
|
|
{
|
|
|
|
return PyUnicode_FromFormat("BL_Shader\n\tvertex shader:%s\n\n\tfragment shader%s\n\n", vertProg, fragProg);
|
|
|
|
}
|
2006-01-06 03:46:54 +00:00
|
|
|
|
2006-04-11 05:57:30 +00:00
|
|
|
// -----------------------------------
|
2012-04-29 17:11:40 +00:00
|
|
|
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);
|
2006-04-11 05:57:30 +00:00
|
|
|
|
|
|
|
// -----------------------------------
|
2012-04-29 17:11:40 +00:00
|
|
|
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);
|
2016-06-09 22:28:19 +00:00
|
|
|
KX_PYMETHOD_DOC(BL_Shader, setUniformEyef);
|
2012-04-29 17:11:40 +00:00
|
|
|
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);
|
2009-09-29 21:42:40 +00:00
|
|
|
#endif
|
2006-01-06 03:46:54 +00:00
|
|
|
};
|
|
|
|
|
2012-10-09 13:36:42 +00:00
|
|
|
#endif /* __BL_SHADER_H__ */
|