← Back to branch summary

~hikiko/nux/arb-srgba-shader

« back to all changes in this revision

Viewing changes to NuxGraphics/IOpenGLAsmShader.cpp

  • Committer: Neil Jagdish Patel
  • Date: 2010-09-02 03:28:11 UTC
  • Revision ID: neil.patel@canonical.com-20100902032811-i2m18tfb6pkasnvt
Remove Win EOL chars

Show diffs side-by-side

added added

removed removed

Lines of Context:
NuxGraphics/IOpenGLAsmShader.cpp
20
20
 */
21
21
 
22
22
 
23
 
#include "GLDeviceFactory.h"
24
 
#include "GLDeviceObjects.h"
25
 
#include "IOpenGLAsmShader.h"
26
 
 
27
 
NAMESPACE_BEGIN_OGL
28
 
 
29
 
IMPLEMENT_OBJECT_TYPE(IOpenGLAsmShader);
30
 
IMPLEMENT_OBJECT_TYPE(IOpenGLAsmVertexShader);
31
 
IMPLEMENT_OBJECT_TYPE(IOpenGLAsmPixelShader);
32
 
IMPLEMENT_OBJECT_TYPE(IOpenGLAsmShaderProgram);
33
 
 
34
 
bool ExtractShaderString3(const NString &ShaderToken, const NString &ShaderSource, NString &RetSource, NString ShaderPreprocessorDefines);
35
 
 
36
 
IOpenGLAsmShader::IOpenGLAsmShader(NString ShaderName, OpenGLResourceType ResourceType)
37
 
:   IOpenGLResource(ResourceType)
38
 
,   _ShaderName(ShaderName)
39
 
{
40
 
 
41
 
}
42
 
 
43
 
IOpenGLAsmShader::~IOpenGLAsmShader()
44
 
{
45
 
 
46
 
}
47
 
 
48
 
IOpenGLAsmVertexShader::IOpenGLAsmVertexShader(NString ShaderName)
49
 
:   m_CompiledAndReady(false)
50
 
,   IOpenGLAsmShader(ShaderName, RT_GLSL_VERTEXSHADER)
51
 
{
52
 
    CHECKGL( glGenProgramsARB(1, &_OpenGLID) );
53
 
}
54
 
 
55
 
IOpenGLAsmVertexShader::~IOpenGLAsmVertexShader()
56
 
{
57
 
    CHECKGL( glDeleteProgramsARB(1, &_OpenGLID) );
58
 
    _OpenGLID = 0;
59
 
    m_CompiledAndReady = false;
60
 
}
61
 
 
62
 
void IOpenGLAsmVertexShader::SetShaderCode(const TCHAR* ShaderCode)
63
 
{
64
 
    nuxAssertMsg(ShaderCode, TEXT("[IOpenGLAsmVertexShader::SetShaderCode] Invalid shader code."));
65
 
    INL_RETURN_IF_NULL(ShaderCode);
66
 
    m_CompiledAndReady = false;
67
 
    _ShaderCode = ShaderCode;
68
 
}
69
 
 
70
 
bool IOpenGLAsmVertexShader::Compile()
71
 
{
72
 
    m_CompiledAndReady = false;
73
 
    t_size CodeSize = _ShaderCode.Size();
74
 
    if(CodeSize == 0)
75
 
    {
76
 
        nuxDebugMsg(TEXT("[IOpenGLAsmVertexShader::Compile] Vertex shader source code is empty."));
77
 
    }
78
 
 
79
 
    char* ShaderSource = new char[CodeSize+1];
80
 
    Memset(ShaderSource, 0, CodeSize+1);
81
 
    Memcpy(ShaderSource, TCHAR_TO_ANSI(_ShaderCode.GetTCharPtr()), CodeSize);
82
 
 
83
 
    CHECKGL( glBindProgramARB(GL_VERTEX_PROGRAM_ARB, _OpenGLID) );
84
 
    glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, CodeSize, ShaderSource);
85
 
 
86
 
    if( GL_INVALID_OPERATION == glGetError() )
87
 
    {
88
 
        // Find the error position
89
 
        GLint errPos;
90
 
        glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &errPos );
91
 
        // Print implementation-dependent program
92
 
        // errors and warnings string.
93
 
        const unsigned char *ErrorString;
94
 
        ErrorString = INL_STATIC_CAST(const unsigned char*, glGetString(GL_PROGRAM_ERROR_STRING_ARB) );
95
 
        nuxError(TEXT("[IOpenGLAsmVertexShader::Compile] Error in vertex shader at position: %d\n%s\n"), errPos, ErrorString );
96
 
        return m_CompiledAndReady;
97
 
    }
98
 
    delete ShaderSource;
99
 
 
100
 
    m_CompiledAndReady = true;
101
 
    return m_CompiledAndReady;
102
 
}
103
 
 
104
 
bool IOpenGLAsmVertexShader::IsValid()
105
 
{
106
 
    return m_CompiledAndReady;
107
 
}
108
 
 
109
 
IOpenGLAsmPixelShader::IOpenGLAsmPixelShader(NString ShaderName)
110
 
:   m_CompiledAndReady(false)
111
 
,   IOpenGLAsmShader(ShaderName, RT_GLSL_PIXELSHADER)
112
 
{
113
 
    CHECKGL( glGenProgramsARB(1, &_OpenGLID) );
114
 
}
115
 
 
116
 
IOpenGLAsmPixelShader::~IOpenGLAsmPixelShader()
117
 
{
118
 
    CHECKGL( glDeleteProgramsARB(1, &_OpenGLID) );
119
 
    _OpenGLID = 0;
120
 
    m_CompiledAndReady = false;
121
 
}
122
 
 
123
 
void IOpenGLAsmPixelShader::SetShaderCode(const TCHAR* ShaderCode)
124
 
{
125
 
    nuxAssertMsg(ShaderCode, TEXT("[IOpenGLAsmPixelShader::SetShaderCode] Invalid shader code."));
126
 
    INL_RETURN_IF_NULL(ShaderCode);
127
 
    m_CompiledAndReady = false;
128
 
    _ShaderCode = ShaderCode;
129
 
}
130
 
 
131
 
bool IOpenGLAsmPixelShader::Compile()
132
 
{
133
 
    m_CompiledAndReady = false;
134
 
    t_size CodeSize = _ShaderCode.Size();
135
 
    if(CodeSize == 0)
136
 
    {
137
 
        nuxDebugMsg(TEXT("[IOpenGLAsmPixelShader::Compile] Vertex shader source code is empty."));
138
 
    }
139
 
 
140
 
    char* ShaderSource = new char[CodeSize+1];
141
 
    Memset(ShaderSource, 0, CodeSize+1);
142
 
    Memcpy(ShaderSource, TCHAR_TO_ANSI(_ShaderCode.GetTCharPtr()), CodeSize);
143
 
 
144
 
    CHECKGL( glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, _OpenGLID) );
145
 
    glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, CodeSize, ShaderSource);
146
 
 
147
 
    if( GL_INVALID_OPERATION == glGetError() )
148
 
    {
149
 
        // Find the error position
150
 
        GLint errPos;
151
 
        glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &errPos );
152
 
        // Print implementation-dependent program
153
 
        // errors and warnings string.
154
 
        const unsigned char *ErrorString;
155
 
        ErrorString = INL_STATIC_CAST(const unsigned char*, glGetString(GL_PROGRAM_ERROR_STRING_ARB) );
156
 
        nuxError(TEXT("[IOpenGLAsmPixelShader::Compile] Error in fragment shader at position: %d\n%s\n"), errPos, ErrorString );
157
 
    }
158
 
    delete ShaderSource;
159
 
 
160
 
    m_CompiledAndReady = true;
161
 
    return m_CompiledAndReady;
162
 
}
163
 
 
164
 
bool IOpenGLAsmPixelShader::IsValid()
165
 
{
166
 
    return m_CompiledAndReady;
167
 
}
168
 
 
169
 
IOpenGLAsmShaderProgram::IOpenGLAsmShaderProgram(NString ShaderProgramName)
170
 
:   IOpenGLResource(RT_GLSL_SHADERPROGRAM)
171
 
,   _ShaderProgramName(ShaderProgramName)
172
 
{
173
 
    _OpenGLID = 0;
174
 
    m_AsmVertexProgram = GetThreadGLDeviceFactory()->CreateAsmVertexShader();
175
 
    m_AsmFragmentProgram = GetThreadGLDeviceFactory()->CreateAsmPixelShader();
176
 
}
177
 
 
178
 
IOpenGLAsmShaderProgram::~IOpenGLAsmShaderProgram()
179
 
{
180
 
    _OpenGLID = 0;
181
 
}
182
 
 
183
 
void IOpenGLAsmShaderProgram::LoadIShaderFile(const TCHAR* ShaderFileName)
184
 
{
185
 
    nuxAssertMsg(ShaderFileName, TEXT("[IOpenGLAsmShaderProgram::LoadIShaderFile] Invalid shader file name."));
186
 
    INL_RETURN_IF_NULL(ShaderFileName);
187
 
    NString SourceCode;
188
 
    LoadFileToString(SourceCode, ShaderFileName);
189
 
    LoadIShader(&SourceCode[0]);
190
 
}
191
 
 
192
 
void IOpenGLAsmShaderProgram::LoadIShader(const TCHAR* ShaderCode)
193
 
{
194
 
    nuxAssertMsg(ShaderCode, TEXT("[IOpenGLAsmShaderProgram::LoadIShader] Invalid shader code."));
195
 
    INL_RETURN_IF_NULL(ShaderCode);
196
 
    NString VertexShaderSource;
197
 
    ExtractShaderString3(TEXT("[Vertex Shader]"), ShaderCode, VertexShaderSource, NString(""));
198
 
    NString PixelShaderSource;
199
 
    ExtractShaderString3(TEXT("[Fragment Shader]"), ShaderCode, PixelShaderSource, NString(""));
200
 
 
201
 
    m_AsmVertexProgram->SetShaderCode(&VertexShaderSource[0]);
202
 
    m_AsmFragmentProgram->SetShaderCode(&PixelShaderSource[0]);
203
 
 
204
 
    m_AsmVertexProgram->Compile();
205
 
    m_AsmFragmentProgram->Compile();
206
 
}
207
 
 
208
 
void IOpenGLAsmShaderProgram::LoadVertexShader(const TCHAR* glslshader)
209
 
{
210
 
    nuxAssertMsg(glslshader, TEXT("[IOpenGLAsmShaderProgram::LoadVertexShader] Invalid shader code."));
211
 
    INL_RETURN_IF_NULL(glslshader);
212
 
    m_AsmVertexProgram->SetShaderCode(glslshader);
213
 
    m_AsmVertexProgram->Compile();
214
 
}
215
 
 
216
 
void IOpenGLAsmShaderProgram::LoadPixelShader(const TCHAR* glslshader)
217
 
{
218
 
    nuxAssertMsg(glslshader, TEXT("[IOpenGLAsmShaderProgram::LoadPixelShader] Invalid shader code."));
219
 
    INL_RETURN_IF_NULL(glslshader);
220
 
    m_AsmFragmentProgram->SetShaderCode(glslshader);
221
 
    m_AsmFragmentProgram->Compile();
222
 
}
223
 
 
224
 
void IOpenGLAsmShaderProgram::Link()
225
 
{
226
 
    m_AsmVertexProgram->Compile();
227
 
    m_AsmFragmentProgram->Compile();
228
 
}
229
 
 
230
 
bool IOpenGLAsmShaderProgram::IsValid()
231
 
{
232
 
    if(m_AsmVertexProgram->IsValid() && m_AsmFragmentProgram->IsValid())
233
 
        return true;
234
 
    return false;
235
 
}
236
 
 
237
 
void IOpenGLAsmShaderProgram::Begin(void)
238
 
{
239
 
    CHECKGL( glEnable(GL_VERTEX_PROGRAM_ARB) );
240
 
    CHECKGL( glBindProgramARB(GL_VERTEX_PROGRAM_ARB, m_AsmVertexProgram->GetOpenGLID()) );
241
 
    CHECKGL( glEnable(GL_FRAGMENT_PROGRAM_ARB) );
242
 
    CHECKGL( glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, m_AsmFragmentProgram->GetOpenGLID()) );
243
 
}
244
 
 
245
 
void IOpenGLAsmShaderProgram::End(void)
246
 
{
247
 
    CHECKGL( glDisable(GL_VERTEX_PROGRAM_ARB) );
248
 
    CHECKGL( glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0) );
249
 
    CHECKGL( glDisable(GL_FRAGMENT_PROGRAM_ARB) );
250
 
    CHECKGL( glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0) );
251
 
}
252
 
 
253
 
void IOpenGLAsmShaderProgram::SetVertexEnvParameter4dARB (t_uint32 index, double x, double y, double z, double w)
254
 
{
255
 
    CHECKGL( glProgramEnvParameter4dARB(GL_VERTEX_PROGRAM_ARB, index, x, y, z, w) );
256
 
}
257
 
 
258
 
void IOpenGLAsmShaderProgram::SetVertexEnvParameter4dvARB(t_uint32 index, const double *params)
259
 
{
260
 
    CHECKGL( glProgramEnvParameter4dvARB(GL_VERTEX_PROGRAM_ARB, index, params) );
261
 
}
262
 
 
263
 
void IOpenGLAsmShaderProgram::SetVertexEnvParameter4fARB (t_uint32 index, float x, float y, float z, float w)
264
 
{
265
 
    CHECKGL( glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, index, x, y, z, w) );
266
 
}
267
 
 
268
 
void IOpenGLAsmShaderProgram::SetVertexEnvParameter4fvARB(t_uint32 index, const float *params)
269
 
{
270
 
    CHECKGL( glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index, params) );
271
 
}
272
 
 
273
 
void IOpenGLAsmShaderProgram::SetVertexLocalParameter4dARB(t_uint32 index, double x, double y, double z, double w)
274
 
{
275
 
    CHECKGL( glProgramEnvParameter4dARB(GL_VERTEX_PROGRAM_ARB, index, x, y, z, w) );
276
 
}
277
 
 
278
 
void IOpenGLAsmShaderProgram::SetVertexLocalParameter4dvARB(t_uint32 index, const double *params)
279
 
{
280
 
    CHECKGL( glProgramEnvParameter4dvARB(GL_VERTEX_PROGRAM_ARB, index, params) );
281
 
}
282
 
 
283
 
void IOpenGLAsmShaderProgram::SetVertexLocalParameter4fARB(t_uint32 index, float x, float y, float z, float w)
284
 
{
285
 
    CHECKGL( glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, index, x, y, z, w) );
286
 
}
287
 
 
288
 
void IOpenGLAsmShaderProgram::SetVertexLocalParameter4fvARB(t_uint32 index, const float *params)
289
 
{
290
 
    CHECKGL( glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index, params) );
291
 
}
292
 
 
293
 
void IOpenGLAsmShaderProgram::SetFragmentEnvParameter4dARB (t_uint32 index, double x, double y, double z, double w)
294
 
{
295
 
    CHECKGL( glProgramEnvParameter4dARB(GL_FRAGMENT_PROGRAM_ARB, index, x, y, z, w) );
296
 
}
297
 
 
298
 
void IOpenGLAsmShaderProgram::SetFragmentEnvParameter4dvARB(t_uint32 index, const double *params)
299
 
{
300
 
    CHECKGL( glProgramEnvParameter4dvARB(GL_FRAGMENT_PROGRAM_ARB, index, params) );
301
 
}
302
 
 
303
 
void IOpenGLAsmShaderProgram::SetFragmentEnvParameter4fARB (t_uint32 index, float x, float y, float z, float w)
304
 
{
305
 
    CHECKGL( glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, index, x, y, z, w) );
306
 
}
307
 
 
308
 
void IOpenGLAsmShaderProgram::SetFragmentEnvParameter4fvARB(t_uint32 index, const float *params)
309
 
{
310
 
    CHECKGL( glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, index, params) );
311
 
}
312
 
 
313
 
void IOpenGLAsmShaderProgram::SetFragmentLocalParameter4dARB(t_uint32 index, double x, double y, double z, double w)
314
 
{
315
 
    CHECKGL( glProgramEnvParameter4dARB(GL_FRAGMENT_PROGRAM_ARB, index, x, y, z, w) );
316
 
}
317
 
 
318
 
void IOpenGLAsmShaderProgram::SetFragmentLocalParameter4dvARB(t_uint32 index, const double *params)
319
 
{
320
 
    CHECKGL( glProgramEnvParameter4dvARB(GL_FRAGMENT_PROGRAM_ARB, index, params) );
321
 
}
322
 
 
323
 
void IOpenGLAsmShaderProgram::SetFragmentLocalParameter4fARB(t_uint32 index, float x, float y, float z, float w)
324
 
{
325
 
    CHECKGL( glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, index, x, y, z, w) );
326
 
}
327
 
 
328
 
void IOpenGLAsmShaderProgram::SetFragmentLocalParameter4fvARB(t_uint32 index, const float *params)
329
 
{
330
 
    CHECKGL( glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, index, params) );
331
 
}
332
 
 
333
 
NAMESPACE_END_OGL
 
23
#include "GLDeviceFactory.h"
 
24
#include "GLDeviceObjects.h"
 
25
#include "IOpenGLAsmShader.h"
 
26
 
 
27
NAMESPACE_BEGIN_OGL
 
28
 
 
29
IMPLEMENT_OBJECT_TYPE(IOpenGLAsmShader);
 
30
IMPLEMENT_OBJECT_TYPE(IOpenGLAsmVertexShader);
 
31
IMPLEMENT_OBJECT_TYPE(IOpenGLAsmPixelShader);
 
32
IMPLEMENT_OBJECT_TYPE(IOpenGLAsmShaderProgram);
 
33
 
 
34
bool ExtractShaderString3(const NString &ShaderToken, const NString &ShaderSource, NString &RetSource, NString ShaderPreprocessorDefines);
 
35
 
 
36
IOpenGLAsmShader::IOpenGLAsmShader(NString ShaderName, OpenGLResourceType ResourceType)
 
37
:   IOpenGLResource(ResourceType)
 
38
,   _ShaderName(ShaderName)
 
39
{
 
40
 
 
41
}
 
42
 
 
43
IOpenGLAsmShader::~IOpenGLAsmShader()
 
44
{
 
45
 
 
46
}
 
47
 
 
48
IOpenGLAsmVertexShader::IOpenGLAsmVertexShader(NString ShaderName)
 
49
:   m_CompiledAndReady(false)
 
50
,   IOpenGLAsmShader(ShaderName, RT_GLSL_VERTEXSHADER)
 
51
{
 
52
    CHECKGL( glGenProgramsARB(1, &_OpenGLID) );
 
53
}
 
54
 
 
55
IOpenGLAsmVertexShader::~IOpenGLAsmVertexShader()
 
56
{
 
57
    CHECKGL( glDeleteProgramsARB(1, &_OpenGLID) );
 
58
    _OpenGLID = 0;
 
59
    m_CompiledAndReady = false;
 
60
}
 
61
 
 
62
void IOpenGLAsmVertexShader::SetShaderCode(const TCHAR* ShaderCode)
 
63
{
 
64
    nuxAssertMsg(ShaderCode, TEXT("[IOpenGLAsmVertexShader::SetShaderCode] Invalid shader code."));
 
65
    INL_RETURN_IF_NULL(ShaderCode);
 
66
    m_CompiledAndReady = false;
 
67
    _ShaderCode = ShaderCode;
 
68
}
 
69
 
 
70
bool IOpenGLAsmVertexShader::Compile()
 
71
{
 
72
    m_CompiledAndReady = false;
 
73
    t_size CodeSize = _ShaderCode.Size();
 
74
    if(CodeSize == 0)
 
75
    {
 
76
        nuxDebugMsg(TEXT("[IOpenGLAsmVertexShader::Compile] Vertex shader source code is empty."));
 
77
    }
 
78
 
 
79
    char* ShaderSource = new char[CodeSize+1];
 
80
    Memset(ShaderSource, 0, CodeSize+1);
 
81
    Memcpy(ShaderSource, TCHAR_TO_ANSI(_ShaderCode.GetTCharPtr()), CodeSize);
 
82
 
 
83
    CHECKGL( glBindProgramARB(GL_VERTEX_PROGRAM_ARB, _OpenGLID) );
 
84
    glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, CodeSize, ShaderSource);
 
85
 
 
86
    if( GL_INVALID_OPERATION == glGetError() )
 
87
    {
 
88
        // Find the error position
 
89
        GLint errPos;
 
90
        glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &errPos );
 
91
        // Print implementation-dependent program
 
92
        // errors and warnings string.
 
93
        const unsigned char *ErrorString;
 
94
        ErrorString = INL_STATIC_CAST(const unsigned char*, glGetString(GL_PROGRAM_ERROR_STRING_ARB) );
 
95
        nuxError(TEXT("[IOpenGLAsmVertexShader::Compile] Error in vertex shader at position: %d\n%s\n"), errPos, ErrorString );
 
96
        return m_CompiledAndReady;
 
97
    }
 
98
    delete ShaderSource;
 
99
 
 
100
    m_CompiledAndReady = true;
 
101
    return m_CompiledAndReady;
 
102
}
 
103
 
 
104
bool IOpenGLAsmVertexShader::IsValid()
 
105
{
 
106
    return m_CompiledAndReady;
 
107
}
 
108
 
 
109
IOpenGLAsmPixelShader::IOpenGLAsmPixelShader(NString ShaderName)
 
110
:   m_CompiledAndReady(false)
 
111
,   IOpenGLAsmShader(ShaderName, RT_GLSL_PIXELSHADER)
 
112
{
 
113
    CHECKGL( glGenProgramsARB(1, &_OpenGLID) );
 
114
}
 
115
 
 
116
IOpenGLAsmPixelShader::~IOpenGLAsmPixelShader()
 
117
{
 
118
    CHECKGL( glDeleteProgramsARB(1, &_OpenGLID) );
 
119
    _OpenGLID = 0;
 
120
    m_CompiledAndReady = false;
 
121
}
 
122
 
 
123
void IOpenGLAsmPixelShader::SetShaderCode(const TCHAR* ShaderCode)
 
124
{
 
125
    nuxAssertMsg(ShaderCode, TEXT("[IOpenGLAsmPixelShader::SetShaderCode] Invalid shader code."));
 
126
    INL_RETURN_IF_NULL(ShaderCode);
 
127
    m_CompiledAndReady = false;
 
128
    _ShaderCode = ShaderCode;
 
129
}
 
130
 
 
131
bool IOpenGLAsmPixelShader::Compile()
 
132
{
 
133
    m_CompiledAndReady = false;
 
134
    t_size CodeSize = _ShaderCode.Size();
 
135
    if(CodeSize == 0)
 
136
    {
 
137
        nuxDebugMsg(TEXT("[IOpenGLAsmPixelShader::Compile] Vertex shader source code is empty."));
 
138
    }
 
139
 
 
140
    char* ShaderSource = new char[CodeSize+1];
 
141
    Memset(ShaderSource, 0, CodeSize+1);
 
142
    Memcpy(ShaderSource, TCHAR_TO_ANSI(_ShaderCode.GetTCharPtr()), CodeSize);
 
143
 
 
144
    CHECKGL( glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, _OpenGLID) );
 
145
    glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, CodeSize, ShaderSource);
 
146
 
 
147
    if( GL_INVALID_OPERATION == glGetError() )
 
148
    {
 
149
        // Find the error position
 
150
        GLint errPos;
 
151
        glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &errPos );
 
152
        // Print implementation-dependent program
 
153
        // errors and warnings string.
 
154
        const unsigned char *ErrorString;
 
155
        ErrorString = INL_STATIC_CAST(const unsigned char*, glGetString(GL_PROGRAM_ERROR_STRING_ARB) );
 
156
        nuxError(TEXT("[IOpenGLAsmPixelShader::Compile] Error in fragment shader at position: %d\n%s\n"), errPos, ErrorString );
 
157
    }
 
158
    delete ShaderSource;
 
159
 
 
160
    m_CompiledAndReady = true;
 
161
    return m_CompiledAndReady;
 
162
}
 
163
 
 
164
bool IOpenGLAsmPixelShader::IsValid()
 
165
{
 
166
    return m_CompiledAndReady;
 
167
}
 
168
 
 
169
IOpenGLAsmShaderProgram::IOpenGLAsmShaderProgram(NString ShaderProgramName)
 
170
:   IOpenGLResource(RT_GLSL_SHADERPROGRAM)
 
171
,   _ShaderProgramName(ShaderProgramName)
 
172
{
 
173
    _OpenGLID = 0;
 
174
    m_AsmVertexProgram = GetThreadGLDeviceFactory()->CreateAsmVertexShader();
 
175
    m_AsmFragmentProgram = GetThreadGLDeviceFactory()->CreateAsmPixelShader();
 
176
}
 
177
 
 
178
IOpenGLAsmShaderProgram::~IOpenGLAsmShaderProgram()
 
179
{
 
180
    _OpenGLID = 0;
 
181
}
 
182
 
 
183
void IOpenGLAsmShaderProgram::LoadIShaderFile(const TCHAR* ShaderFileName)
 
184
{
 
185
    nuxAssertMsg(ShaderFileName, TEXT("[IOpenGLAsmShaderProgram::LoadIShaderFile] Invalid shader file name."));
 
186
    INL_RETURN_IF_NULL(ShaderFileName);
 
187
    NString SourceCode;
 
188
    LoadFileToString(SourceCode, ShaderFileName);
 
189
    LoadIShader(&SourceCode[0]);
 
190
}
 
191
 
 
192
void IOpenGLAsmShaderProgram::LoadIShader(const TCHAR* ShaderCode)
 
193
{
 
194
    nuxAssertMsg(ShaderCode, TEXT("[IOpenGLAsmShaderProgram::LoadIShader] Invalid shader code."));
 
195
    INL_RETURN_IF_NULL(ShaderCode);
 
196
    NString VertexShaderSource;
 
197
    ExtractShaderString3(TEXT("[Vertex Shader]"), ShaderCode, VertexShaderSource, NString(""));
 
198
    NString PixelShaderSource;
 
199
    ExtractShaderString3(TEXT("[Fragment Shader]"), ShaderCode, PixelShaderSource, NString(""));
 
200
 
 
201
    m_AsmVertexProgram->SetShaderCode(&VertexShaderSource[0]);
 
202
    m_AsmFragmentProgram->SetShaderCode(&PixelShaderSource[0]);
 
203
 
 
204
    m_AsmVertexProgram->Compile();
 
205
    m_AsmFragmentProgram->Compile();
 
206
}
 
207
 
 
208
void IOpenGLAsmShaderProgram::LoadVertexShader(const TCHAR* glslshader)
 
209
{
 
210
    nuxAssertMsg(glslshader, TEXT("[IOpenGLAsmShaderProgram::LoadVertexShader] Invalid shader code."));
 
211
    INL_RETURN_IF_NULL(glslshader);
 
212
    m_AsmVertexProgram->SetShaderCode(glslshader);
 
213
    m_AsmVertexProgram->Compile();
 
214
}
 
215
 
 
216
void IOpenGLAsmShaderProgram::LoadPixelShader(const TCHAR* glslshader)
 
217
{
 
218
    nuxAssertMsg(glslshader, TEXT("[IOpenGLAsmShaderProgram::LoadPixelShader] Invalid shader code."));
 
219
    INL_RETURN_IF_NULL(glslshader);
 
220
    m_AsmFragmentProgram->SetShaderCode(glslshader);
 
221
    m_AsmFragmentProgram->Compile();
 
222
}
 
223
 
 
224
void IOpenGLAsmShaderProgram::Link()
 
225
{
 
226
    m_AsmVertexProgram->Compile();
 
227
    m_AsmFragmentProgram->Compile();
 
228
}
 
229
 
 
230
bool IOpenGLAsmShaderProgram::IsValid()
 
231
{
 
232
    if(m_AsmVertexProgram->IsValid() && m_AsmFragmentProgram->IsValid())
 
233
        return true;
 
234
    return false;
 
235
}
 
236
 
 
237
void IOpenGLAsmShaderProgram::Begin(void)
 
238
{
 
239
    CHECKGL( glEnable(GL_VERTEX_PROGRAM_ARB) );
 
240
    CHECKGL( glBindProgramARB(GL_VERTEX_PROGRAM_ARB, m_AsmVertexProgram->GetOpenGLID()) );
 
241
    CHECKGL( glEnable(GL_FRAGMENT_PROGRAM_ARB) );
 
242
    CHECKGL( glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, m_AsmFragmentProgram->GetOpenGLID()) );
 
243
}
 
244
 
 
245
void IOpenGLAsmShaderProgram::End(void)
 
246
{
 
247
    CHECKGL( glDisable(GL_VERTEX_PROGRAM_ARB) );
 
248
    CHECKGL( glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0) );
 
249
    CHECKGL( glDisable(GL_FRAGMENT_PROGRAM_ARB) );
 
250
    CHECKGL( glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0) );
 
251
}
 
252
 
 
253
void IOpenGLAsmShaderProgram::SetVertexEnvParameter4dARB (t_uint32 index, double x, double y, double z, double w)
 
254
{
 
255
    CHECKGL( glProgramEnvParameter4dARB(GL_VERTEX_PROGRAM_ARB, index, x, y, z, w) );
 
256
}
 
257
 
 
258
void IOpenGLAsmShaderProgram::SetVertexEnvParameter4dvARB(t_uint32 index, const double *params)
 
259
{
 
260
    CHECKGL( glProgramEnvParameter4dvARB(GL_VERTEX_PROGRAM_ARB, index, params) );
 
261
}
 
262
 
 
263
void IOpenGLAsmShaderProgram::SetVertexEnvParameter4fARB (t_uint32 index, float x, float y, float z, float w)
 
264
{
 
265
    CHECKGL( glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, index, x, y, z, w) );
 
266
}
 
267
 
 
268
void IOpenGLAsmShaderProgram::SetVertexEnvParameter4fvARB(t_uint32 index, const float *params)
 
269
{
 
270
    CHECKGL( glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index, params) );
 
271
}
 
272
 
 
273
void IOpenGLAsmShaderProgram::SetVertexLocalParameter4dARB(t_uint32 index, double x, double y, double z, double w)
 
274
{
 
275
    CHECKGL( glProgramEnvParameter4dARB(GL_VERTEX_PROGRAM_ARB, index, x, y, z, w) );
 
276
}
 
277
 
 
278
void IOpenGLAsmShaderProgram::SetVertexLocalParameter4dvARB(t_uint32 index, const double *params)
 
279
{
 
280
    CHECKGL( glProgramEnvParameter4dvARB(GL_VERTEX_PROGRAM_ARB, index, params) );
 
281
}
 
282
 
 
283
void IOpenGLAsmShaderProgram::SetVertexLocalParameter4fARB(t_uint32 index, float x, float y, float z, float w)
 
284
{
 
285
    CHECKGL( glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, index, x, y, z, w) );
 
286
}
 
287
 
 
288
void IOpenGLAsmShaderProgram::SetVertexLocalParameter4fvARB(t_uint32 index, const float *params)
 
289
{
 
290
    CHECKGL( glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index, params) );
 
291
}
 
292
 
 
293
void IOpenGLAsmShaderProgram::SetFragmentEnvParameter4dARB (t_uint32 index, double x, double y, double z, double w)
 
294
{
 
295
    CHECKGL( glProgramEnvParameter4dARB(GL_FRAGMENT_PROGRAM_ARB, index, x, y, z, w) );
 
296
}
 
297
 
 
298
void IOpenGLAsmShaderProgram::SetFragmentEnvParameter4dvARB(t_uint32 index, const double *params)
 
299
{
 
300
    CHECKGL( glProgramEnvParameter4dvARB(GL_FRAGMENT_PROGRAM_ARB, index, params) );
 
301
}
 
302
 
 
303
void IOpenGLAsmShaderProgram::SetFragmentEnvParameter4fARB (t_uint32 index, float x, float y, float z, float w)
 
304
{
 
305
    CHECKGL( glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, index, x, y, z, w) );
 
306
}
 
307
 
 
308
void IOpenGLAsmShaderProgram::SetFragmentEnvParameter4fvARB(t_uint32 index, const float *params)
 
309
{
 
310
    CHECKGL( glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, index, params) );
 
311
}
 
312
 
 
313
void IOpenGLAsmShaderProgram::SetFragmentLocalParameter4dARB(t_uint32 index, double x, double y, double z, double w)
 
314
{
 
315
    CHECKGL( glProgramEnvParameter4dARB(GL_FRAGMENT_PROGRAM_ARB, index, x, y, z, w) );
 
316
}
 
317
 
 
318
void IOpenGLAsmShaderProgram::SetFragmentLocalParameter4dvARB(t_uint32 index, const double *params)
 
319
{
 
320
    CHECKGL( glProgramEnvParameter4dvARB(GL_FRAGMENT_PROGRAM_ARB, index, params) );
 
321
}
 
322
 
 
323
void IOpenGLAsmShaderProgram::SetFragmentLocalParameter4fARB(t_uint32 index, float x, float y, float z, float w)
 
324
{
 
325
    CHECKGL( glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, index, x, y, z, w) );
 
326
}
 
327
 
 
328
void IOpenGLAsmShaderProgram::SetFragmentLocalParameter4fvARB(t_uint32 index, const float *params)
 
329
{
 
330
    CHECKGL( glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, index, params) );
 
331
}
 
332
 
 
333
NAMESPACE_END_OGL