1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __C_OPENGL_SHADER_LANGUAGE_MATERIAL_RENDERER_H_INCLUDED__
#define __C_OPENGL_SHADER_LANGUAGE_MATERIAL_RENDERER_H_INCLUDED__
#ifdef _IRR_COMPILE_WITH_OPENGL_
#include "EMaterialTypes.h"
#include "IMaterialRenderer.h"
#include "IMaterialRendererServices.h"
#include "IGPUProgrammingServices.h"
#include "irrArray.h"
#include "irrString.h"
#include "COpenGLCommon.h"
namespace irr
{
namespace video
{
class COpenGLDriver;
class IShaderConstantSetCallBack;
//! Class for using GLSL shaders with OpenGL
//! Please note: This renderer implements its own IMaterialRendererServices
class COpenGLSLMaterialRenderer : public IMaterialRenderer, public IMaterialRendererServices
{
public:
//! Constructor
COpenGLSLMaterialRenderer(
COpenGLDriver* driver,
s32& outMaterialTypeNr,
const c8* vertexShaderProgram = 0,
const c8* vertexShaderEntryPointName = 0,
E_VERTEX_SHADER_TYPE vsCompileTarget = video::EVST_VS_1_1,
const c8* pixelShaderProgram = 0,
const c8* pixelShaderEntryPointName = 0,
E_PIXEL_SHADER_TYPE psCompileTarget = video::EPST_PS_1_1,
const c8* geometryShaderProgram = 0,
const c8* geometryShaderEntryPointName = "main",
E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
u32 verticesOut = 0,
IShaderConstantSetCallBack* callback = 0,
E_MATERIAL_TYPE baseMaterial = EMT_SOLID,
s32 userData = 0);
//! Destructor
virtual ~COpenGLSLMaterialRenderer();
virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,
bool resetAllRenderstates, IMaterialRendererServices* services) override;
bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype) override;
void OnUnsetMaterial() override;
//! Returns if the material is transparent.
bool isTransparent() const override;
//! Access the callback provided by the users when creating shader materials
IShaderConstantSetCallBack* getShaderConstantSetCallBack() const override
{
return CallBack;
}
// implementations for the render services
void setBasicRenderStates(const SMaterial& material, const SMaterial& lastMaterial, bool resetAllRenderstates) override;
s32 getVertexShaderConstantID(const c8* name) override;
s32 getPixelShaderConstantID(const c8* name) override;
void setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount=1) override;
void setPixelShaderConstant(const f32* data, s32 startRegister, s32 constantAmount=1) override;
bool setVertexShaderConstant(s32 index, const f32* floats, int count) override;
bool setVertexShaderConstant(s32 index, const s32* ints, int count) override;
bool setVertexShaderConstant(s32 index, const u32* ints, int count) override;
bool setPixelShaderConstant(s32 index, const f32* floats, int count) override;
bool setPixelShaderConstant(s32 index, const s32* ints, int count) override;
bool setPixelShaderConstant(s32 index, const u32* ints, int count) override;
IVideoDriver* getVideoDriver() override;
protected:
//! constructor only for use by derived classes who want to
//! create a fall back material for example.
COpenGLSLMaterialRenderer(COpenGLDriver* driver,
IShaderConstantSetCallBack* callback,
E_MATERIAL_TYPE baseMaterial,
s32 userData=0);
void init(s32& outMaterialTypeNr,
const c8* vertexShaderProgram,
const c8* pixelShaderProgram,
const c8* geometryShaderProgram,
scene::E_PRIMITIVE_TYPE inType=scene::EPT_TRIANGLES,
scene::E_PRIMITIVE_TYPE outType=scene::EPT_TRIANGLE_STRIP,
u32 verticesOut=0);
bool createProgram();
bool createShader(GLenum shaderType, const char* shader);
bool linkProgram();
COpenGLDriver* Driver;
IShaderConstantSetCallBack* CallBack;
bool Alpha;
bool Blending;
bool FixedBlending;
bool AlphaTest;
struct SUniformInfo
{
core::stringc name;
GLenum type;
GLint location;
};
GLhandleARB Program;
GLuint Program2;
core::array<SUniformInfo> UniformInfo;
s32 UserData;
};
} // end namespace video
} // end namespace irr
#endif // compile with OpenGL
#endif // if included
|
