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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
#ifndef GLW_VERTEXSHADER_H
#define GLW_VERTEXSHADER_H
#include "./shader.h"
namespace glw
{
class VertexShaderArguments : public ShaderArguments
{
public:
typedef ShaderArguments BaseType;
typedef VertexShaderArguments ThisType;
VertexShaderArguments(void)
: BaseType()
{
;
}
void clear(void)
{
BaseType::clear();
}
};
class VertexShader : public Shader
{
friend class Context;
public:
typedef Shader BaseType;
typedef VertexShader ThisType;
virtual Type type(void) const
{
return VertexShaderType;
}
protected:
VertexShader(Context * ctx)
: BaseType(ctx)
{
;
}
virtual GLenum shaderType(void) const
{
return GL_VERTEX_SHADER;
}
bool create(const VertexShaderArguments & args)
{
return BaseType::create(args);
}
};
namespace detail { template <> struct BaseOf <VertexShader> { typedef Shader Type; }; };
typedef detail::ObjectSharedPointerTraits <VertexShader> ::Type VertexShaderPtr;
class SafeVertexShader : public SafeShader
{
friend class Context;
friend class BoundVertexShader;
public:
typedef SafeShader BaseType;
typedef SafeVertexShader ThisType;
protected:
SafeVertexShader(const VertexShaderPtr & vertexShader)
: BaseType(vertexShader)
{
;
}
const VertexShaderPtr & object(void) const
{
return static_cast<const VertexShaderPtr &>(BaseType::object());
}
VertexShaderPtr & object(void)
{
return static_cast<VertexShaderPtr &>(BaseType::object());
}
};
namespace detail { template <> struct BaseOf <SafeVertexShader> { typedef SafeShader Type; }; };
namespace detail { template <> struct ObjectBase <SafeVertexShader> { typedef VertexShader Type; }; };
namespace detail { template <> struct ObjectSafe <VertexShader > { typedef SafeVertexShader Type; }; };
typedef detail::ObjectSharedPointerTraits <SafeVertexShader> ::Type VertexShaderHandle;
class VertexShaderBindingParams : public ShaderBindingParams
{
public:
typedef ShaderBindingParams BaseType;
typedef VertexShaderBindingParams ThisType;
VertexShaderBindingParams(void)
: BaseType(GL_VERTEX_SHADER, 0)
{
;
}
};
class BoundVertexShader : public BoundShader
{
friend class Context;
public:
typedef BoundShader BaseType;
typedef BoundVertexShader ThisType;
const VertexShaderHandle & handle(void) const
{
return static_cast<const VertexShaderHandle &>(BaseType::handle());
}
VertexShaderHandle & handle(void)
{
return static_cast<VertexShaderHandle &>(BaseType::handle());
}
protected:
BoundVertexShader(const VertexShaderHandle & handle, const ShaderBindingParams & params)
: BaseType(handle, params)
{
;
}
const VertexShaderPtr & object(void) const
{
return this->handle()->object();
}
VertexShaderPtr & object(void)
{
return this->handle()->object();
}
};
namespace detail { template <> struct ParamsOf <BoundVertexShader> { typedef VertexShaderBindingParams Type; }; };
namespace detail { template <> struct BaseOf <BoundVertexShader> { typedef BoundShader Type; }; };
namespace detail { template <> struct ObjectBase <BoundVertexShader> { typedef VertexShader Type; }; };
namespace detail { template <> struct ObjectBound <VertexShader > { typedef BoundVertexShader Type; }; };
typedef detail::ObjectSharedPointerTraits <BoundVertexShader> ::Type BoundVertexShaderHandle;
};
#endif // GLW_VERTEXSHADER_H
|
