← Back to branch summary

~ubuntu-branches/debian/sid/astromenace/sid

« back to all changes in this revision

Viewing changes to AstroMenaceSource/Core/RendererInterface/OGL_GLSL.cpp

  • Committer: Package Import Robot
  • Author(s): Boris Pek
  • Date: 2013-04-09 02:04:25 UTC
  • Revision ID: package-import@ubuntu.com-20130409020425-a7fl9xk4diamw6di
Tags: upstream-1.3.1+repack
Import upstream version 1.3.1+repack

Show diffs side-by-side

added added

removed removed

Lines of Context:
AstroMenaceSource/Core/RendererInterface/OGL_GLSL.cpp
 
1
/************************************************************************************
 
2
 
 
3
        AstroMenace (Hardcore 3D space shooter with spaceship upgrade possibilities)
 
4
        Copyright © 2006-2012 Michael Kurinnoy, Viewizard
 
5
 
 
6
 
 
7
        AstroMenace is free software: you can redistribute it and/or modify
 
8
        it under the terms of the GNU General Public License as published by
 
9
        the Free Software Foundation, either version 3 of the License, or
 
10
        (at your option) any later version.
 
11
 
 
12
        AstroMenace is distributed in the hope that it will be useful,
 
13
        but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
15
        GNU General Public License for more details.
 
16
 
 
17
        You should have received a copy of the GNU General Public License
 
18
        along with AstroMenace. If not, see <http://www.gnu.org/licenses/>.
 
19
 
 
20
 
 
21
        Web Site: http://www.viewizard.com/
 
22
        Project: http://sourceforge.net/projects/openastromenace/
 
23
        E-mail: viewizard@viewizard.com
 
24
 
 
25
*************************************************************************************/
 
26
 
 
27
 
 
28
#include "RendererInterface.h"
 
29
extern eDevCaps OpenGL_DevCaps;
 
30
 
 
31
 
 
32
 
 
33
// GL_ARB_shader_objects
 
34
PFNGLDELETEOBJECTARBPROC glDeleteObjectARB = NULL;
 
35
PFNGLGETHANDLEARBPROC glGetHandleARB = NULL;
 
36
PFNGLDETACHOBJECTARBPROC glDetachObjectARB = NULL;
 
37
PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB = NULL;
 
38
PFNGLSHADERSOURCEARBPROC glShaderSourceARB = NULL;
 
39
PFNGLCOMPILESHADERARBPROC glCompileShaderARB = NULL;
 
40
PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB = NULL;
 
41
PFNGLATTACHOBJECTARBPROC glAttachObjectARB = NULL;
 
42
PFNGLLINKPROGRAMARBPROC glLinkProgramARB = NULL;
 
43
PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB = NULL;
 
44
PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB = NULL;
 
45
PFNGLUNIFORM1FARBPROC glUniform1fARB = NULL;
 
46
PFNGLUNIFORM2FARBPROC glUniform2fARB = NULL;
 
47
PFNGLUNIFORM3FARBPROC glUniform3fARB = NULL;
 
48
PFNGLUNIFORM4FARBPROC glUniform4fARB = NULL;
 
49
PFNGLUNIFORM1IARBPROC glUniform1iARB = NULL;
 
50
PFNGLUNIFORM2IARBPROC glUniform2iARB = NULL;
 
51
PFNGLUNIFORM3IARBPROC glUniform3iARB = NULL;
 
52
PFNGLUNIFORM4IARBPROC glUniform4iARB = NULL;
 
53
PFNGLUNIFORM1FVARBPROC glUniform1fvARB = NULL;
 
54
PFNGLUNIFORM2FVARBPROC glUniform2fvARB = NULL;
 
55
PFNGLUNIFORM3FVARBPROC glUniform3fvARB = NULL;
 
56
PFNGLUNIFORM4FVARBPROC glUniform4fvARB = NULL;
 
57
PFNGLUNIFORM1IVARBPROC glUniform1ivARB = NULL;
 
58
PFNGLUNIFORM2IVARBPROC glUniform2ivARB = NULL;
 
59
PFNGLUNIFORM3IVARBPROC glUniform3ivARB = NULL;
 
60
PFNGLUNIFORM4IVARBPROC glUniform4ivARB = NULL;
 
61
PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB = NULL;
 
62
PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB = NULL;
 
63
PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB = NULL;
 
64
PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB = NULL;
 
65
PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB = NULL;
 
66
PFNGLGETINFOLOGARBPROC glGetInfoLogARB = NULL;
 
67
PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB = NULL;
 
68
PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB = NULL;
 
69
PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB = NULL;
 
70
PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB = NULL;
 
71
PFNGLGETUNIFORMIVARBPROC glGetUniformivARB = NULL;
 
72
PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB = NULL;
 
73
 
 
74
 
 
75
// GL_ARB_vertex_shader
 
76
PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB = NULL;
 
77
PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB = NULL;
 
78
PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB = NULL;
 
79
 
 
80
 
 
81
// для менеджера
 
82
eGLSL *StartGLSLMan = 0;
 
83
eGLSL *EndGLSLMan = 0;
 
84
int NumGLSLMan = 0;
 
85
 
 
86
 
 
87
 
 
88
 
 
89
 
 
90
 
 
91
 
 
92
 
 
93
 
 
94
 
 
95
 
 
96
 
 
97
 
 
98
 
 
99
 
 
100
//------------------------------------------------------------------------------------
 
101
// иним и подключаем все указатели
 
102
//------------------------------------------------------------------------------------
 
103
bool vw_Internal_InitializationGLSL()
 
104
{
 
105
        // GL_ARB_shader_objects
 
106
        glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) SDL_GL_GetProcAddress("glDeleteObjectARB");
 
107
        glGetHandleARB = (PFNGLGETHANDLEARBPROC) SDL_GL_GetProcAddress("glGetHandleARB");
 
108
        glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC) SDL_GL_GetProcAddress("glDetachObjectARB");
 
109
        glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC) SDL_GL_GetProcAddress("glCreateShaderObjectARB");
 
110
        glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) SDL_GL_GetProcAddress("glShaderSourceARB");
 
111
        glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC) SDL_GL_GetProcAddress("glCompileShaderARB");
 
112
        glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC) SDL_GL_GetProcAddress("glCreateProgramObjectARB");
 
113
        glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC) SDL_GL_GetProcAddress("glAttachObjectARB");
 
114
        glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC) SDL_GL_GetProcAddress("glLinkProgramARB");
 
115
        glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) SDL_GL_GetProcAddress("glUseProgramObjectARB");
 
116
        glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC) SDL_GL_GetProcAddress("glValidateProgramARB");
 
117
        glUniform1fARB = (PFNGLUNIFORM1FARBPROC) SDL_GL_GetProcAddress("glUniform1fARB");
 
118
        glUniform2fARB = (PFNGLUNIFORM2FARBPROC) SDL_GL_GetProcAddress("glUniform2fARB");
 
119
        glUniform3fARB = (PFNGLUNIFORM3FARBPROC) SDL_GL_GetProcAddress("glUniform3fARB");
 
120
        glUniform4fARB = (PFNGLUNIFORM4FARBPROC) SDL_GL_GetProcAddress("glUniform4fARB");
 
121
        glUniform1iARB = (PFNGLUNIFORM1IARBPROC) SDL_GL_GetProcAddress("glUniform1iARB");
 
122
        glUniform2iARB = (PFNGLUNIFORM2IARBPROC) SDL_GL_GetProcAddress("glUniform2iARB");
 
123
        glUniform3iARB = (PFNGLUNIFORM3IARBPROC) SDL_GL_GetProcAddress("glUniform3iARB");
 
124
        glUniform4iARB = (PFNGLUNIFORM4IARBPROC) SDL_GL_GetProcAddress("glUniform4iARB");
 
125
        glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC) SDL_GL_GetProcAddress("glUniform1fvARB");
 
126
        glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC) SDL_GL_GetProcAddress("glUniform2fvARB");
 
127
        glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC) SDL_GL_GetProcAddress("glUniform3fvARB");
 
128
        glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC) SDL_GL_GetProcAddress("glUniform4fvARB");
 
129
        glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC) SDL_GL_GetProcAddress("glUniform1ivARB");
 
130
        glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC) SDL_GL_GetProcAddress("glUniform2ivARB");
 
131
        glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC) SDL_GL_GetProcAddress("glUniform3ivARB");
 
132
        glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC) SDL_GL_GetProcAddress("glUniform4ivARB");
 
133
        glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC) SDL_GL_GetProcAddress("glUniformMatrix2fvARB");
 
134
        glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC) SDL_GL_GetProcAddress("glUniformMatrix3fvARB");
 
135
        glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC) SDL_GL_GetProcAddress("glUniformMatrix4fvARB");
 
136
        glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC) SDL_GL_GetProcAddress("glGetObjectParameterfvARB");
 
137
        glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC) SDL_GL_GetProcAddress("glGetObjectParameterivARB");
 
138
        glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC) SDL_GL_GetProcAddress("glGetInfoLogARB");
 
139
        glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC) SDL_GL_GetProcAddress("glGetAttachedObjectsARB");
 
140
        glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC) SDL_GL_GetProcAddress("glGetUniformLocationARB");
 
141
        glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC) SDL_GL_GetProcAddress("glGetActiveUniformARB");
 
142
        glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC) SDL_GL_GetProcAddress("glGetUniformfvARB");
 
143
        glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC) SDL_GL_GetProcAddress("glGetUniformivARB");
 
144
        glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC) SDL_GL_GetProcAddress("glGetShaderSourceARB");
 
145
 
 
146
        // GL_ARB_vertex_shader
 
147
        glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC) SDL_GL_GetProcAddress("glBindAttribLocationARB");
 
148
        glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC) SDL_GL_GetProcAddress("glGetActiveAttribARB");
 
149
        glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC) SDL_GL_GetProcAddress("glGetAttribLocationARB");
 
150
 
 
151
        // инициализация менеджера
 
152
        StartGLSLMan = 0;
 
153
        EndGLSLMan = 0;
 
154
        NumGLSLMan = 0;
 
155
 
 
156
 
 
157
        if (glDeleteObjectARB == NULL || glGetHandleARB == NULL || glDetachObjectARB == NULL || glCreateShaderObjectARB == NULL ||
 
158
                glShaderSourceARB == NULL || glCompileShaderARB == NULL || glCreateProgramObjectARB == NULL || glAttachObjectARB == NULL ||
 
159
                glLinkProgramARB == NULL || glUseProgramObjectARB == NULL || glValidateProgramARB == NULL || glUniform1fARB == NULL ||
 
160
                glUniform2fARB == NULL || glUniform3fARB == NULL || glUniform4fARB == NULL || glUniform1iARB == NULL ||
 
161
                glUniform2iARB == NULL || glUniform3iARB == NULL || glUniform4iARB == NULL || glUniform1fvARB == NULL ||
 
162
                glUniform2fvARB == NULL || glUniform3fvARB == NULL || glUniform4fvARB == NULL || glUniform1ivARB == NULL ||
 
163
                glUniform2ivARB == NULL || glUniform3ivARB == NULL || glUniform4ivARB == NULL || glUniformMatrix2fvARB == NULL ||
 
164
                glUniformMatrix3fvARB == NULL || glUniformMatrix4fvARB == NULL || glGetObjectParameterfvARB == NULL ||
 
165
                glGetObjectParameterivARB == NULL || glGetInfoLogARB == NULL || glGetAttachedObjectsARB == NULL ||
 
166
                glGetUniformLocationARB == NULL || glGetActiveUniformARB == NULL || glGetUniformfvARB == NULL || glGetUniformivARB == NULL ||
 
167
                glGetShaderSourceARB == NULL || glBindAttribLocationARB == NULL || glGetActiveAttribARB == NULL || glGetAttribLocationARB == NULL)
 
168
        {
 
169
                glDeleteObjectARB = NULL;
 
170
                glGetHandleARB = NULL;
 
171
                glDetachObjectARB = NULL;
 
172
                glCreateShaderObjectARB = NULL;
 
173
                glShaderSourceARB = NULL;
 
174
                glCompileShaderARB = NULL;
 
175
                glCreateProgramObjectARB = NULL;
 
176
                glAttachObjectARB = NULL;
 
177
                glLinkProgramARB = NULL;
 
178
                glUseProgramObjectARB = NULL;
 
179
                glValidateProgramARB = NULL;
 
180
                glUniform1fARB = NULL;
 
181
                glUniform2fARB = NULL;
 
182
                glUniform3fARB = NULL;
 
183
                glUniform4fARB = NULL;
 
184
                glUniform1iARB = NULL;
 
185
                glUniform2iARB = NULL;
 
186
                glUniform3iARB = NULL;
 
187
                glUniform4iARB = NULL;
 
188
                glUniform1fvARB = NULL;
 
189
                glUniform2fvARB = NULL;
 
190
                glUniform3fvARB = NULL;
 
191
                glUniform4fvARB = NULL;
 
192
                glUniform1ivARB = NULL;
 
193
                glUniform2ivARB = NULL;
 
194
                glUniform3ivARB = NULL;
 
195
                glUniform4ivARB = NULL;
 
196
                glUniformMatrix2fvARB = NULL;
 
197
                glUniformMatrix3fvARB = NULL;
 
198
                glUniformMatrix4fvARB = NULL;
 
199
                glGetObjectParameterfvARB = NULL;
 
200
                glGetObjectParameterivARB = NULL;
 
201
                glGetInfoLogARB = NULL;
 
202
                glGetAttachedObjectsARB = NULL;
 
203
                glGetUniformLocationARB = NULL;
 
204
                glGetActiveUniformARB = NULL;
 
205
                glGetUniformfvARB = NULL;
 
206
                glGetUniformivARB = NULL;
 
207
                glGetShaderSourceARB = NULL;
 
208
                glBindAttribLocationARB = NULL;
 
209
                glGetActiveAttribARB = NULL;
 
210
                glGetAttribLocationARB = NULL;
 
211
 
 
212
                return false;
 
213
        }
 
214
 
 
215
        return true;
 
216
}
 
217
 
 
218
 
 
219
 
 
220
 
 
221
 
 
222
//------------------------------------------------------------------------------------
 
223
// ошибка
 
224
//------------------------------------------------------------------------------------
 
225
int CheckOGLError()
 
226
{
 
227
    // Returns 1 if an OpenGL error occurred, 0 otherwise.
 
228
    GLenum glErr;
 
229
    int    retCode = 0;
 
230
 
 
231
    glErr = glGetError();
 
232
    while (glErr != GL_NO_ERROR)
 
233
    {
 
234
        fprintf(stderr, "glError 0x%x %s\n", glErr, gluErrorString(glErr));
 
235
        retCode = 1;
 
236
        glErr = glGetError();
 
237
    }
 
238
    return retCode;
 
239
}
 
240
 
 
241
 
 
242
//------------------------------------------------------------------------------------
 
243
// Print out the information log for a shader object
 
244
//------------------------------------------------------------------------------------
 
245
void vw_PrintShaderInfoLog(GLuint shader, const char *ShaderName)
 
246
{
 
247
        if (glGetObjectParameterivARB == NULL) return;
 
248
        if (glGetInfoLogARB == NULL) return;
 
249
 
 
250
    int infologLength = 0;
 
251
    int charsWritten  = 0;
 
252
    GLchar *infoLog;
 
253
 
 
254
    CheckOGLError();  // Check for OpenGL errors
 
255
 
 
256
    glGetObjectParameterivARB(shader, GL_INFO_LOG_LENGTH, &infologLength);
 
257
 
 
258
    CheckOGLError();  // Check for OpenGL errors
 
259
 
 
260
    if (infologLength > 0)
 
261
    {
 
262
        infoLog = (GLchar *)malloc(infologLength);
 
263
        if (infoLog == NULL)
 
264
        {
 
265
            fprintf(stderr, "ERROR: Could not allocate InfoLog buffer\n");
 
266
            return;
 
267
        }
 
268
        glGetInfoLogARB(shader, infologLength, &charsWritten, infoLog);
 
269
        if (strlen(infoLog) >1)
 
270
                        printf("Shader InfoLog %s:\n%s\n\n", ShaderName, infoLog);
 
271
        free(infoLog);
 
272
    }
 
273
    CheckOGLError();  // Check for OpenGL errors
 
274
}
 
275
 
 
276
 
 
277
void vw_PrintProgramInfoLog(GLuint program)
 
278
{
 
279
        if (glGetObjectParameterivARB == NULL) return;
 
280
        if (glGetInfoLogARB == NULL) return;
 
281
 
 
282
    int infologLength = 0;
 
283
    int charsWritten  = 0;
 
284
    GLchar *infoLog;
 
285
 
 
286
    CheckOGLError();  // Check for OpenGL errors
 
287
 
 
288
    glGetObjectParameterivARB(program, GL_INFO_LOG_LENGTH, &infologLength);
 
289
 
 
290
    CheckOGLError();  // Check for OpenGL errors
 
291
 
 
292
    if (infologLength > 0)
 
293
    {
 
294
        infoLog = (GLchar *)malloc(infologLength);
 
295
        if (infoLog == NULL)
 
296
        {
 
297
            printf("ERROR: Could not allocate InfoLog buffer\n");
 
298
            exit(1);
 
299
        }
 
300
        glGetInfoLogARB(program, infologLength, &charsWritten, infoLog);
 
301
        if (strlen(infoLog) >1)
 
302
                        printf("Program InfoLog:\n%s\n\n", infoLog);
 
303
        free(infoLog);
 
304
    }
 
305
    CheckOGLError();  // Check for OpenGL errors
 
306
}
 
307
 
 
308
 
 
309
 
 
310
 
 
311
 
 
312
//------------------------------------------------------------------------------------
 
313
// освобождаем память
 
314
//------------------------------------------------------------------------------------
 
315
void vw_ReleaseShader(eGLSL *GLSL)
 
316
{
 
317
        if (GLSL == 0) return;
 
318
        if (glDetachObjectARB == NULL) return;
 
319
        if (glDeleteObjectARB == NULL) return;
 
320
 
 
321
        vw_DetachShader(GLSL);
 
322
 
 
323
        // открепляем хидеры шейдеров
 
324
        if (GLSL->VertexShaderUse) glDetachObjectARB(GLSL->Program, GLSL->VertexShader);
 
325
        if (GLSL->FragmentShaderUse) glDetachObjectARB(GLSL->Program, GLSL->FragmentShader);
 
326
        // удаляем
 
327
        glDeleteObjectARB(GLSL->VertexShader);
 
328
        glDeleteObjectARB(GLSL->FragmentShader);
 
329
        glDeleteObjectARB(GLSL->Program);
 
330
 
 
331
        if (GLSL->Name != 0){delete [] GLSL->Name; GLSL->Name = 0;}
 
332
 
 
333
        // удаляем указатель
 
334
        delete GLSL; GLSL = 0;
 
335
}
 
336
 
 
337
 
 
338
 
 
339
 
 
340
 
 
341
 
 
342
 
 
343
 
 
344
//------------------------------------------------------------------------------------
 
345
// освобождаем все шейдеры подключенные к менеджеру
 
346
//------------------------------------------------------------------------------------
 
347
void vw_ReleaseAllShaders()
 
348
{
 
349
        // Чистка памяти...
 
350
        eGLSL *Tmp = StartGLSLMan;
 
351
        while (Tmp != 0)
 
352
        {
 
353
                eGLSL *Tmp1 = Tmp->Next;
 
354
                vw_ReleaseShader(Tmp);
 
355
                Tmp = Tmp1;
 
356
        }
 
357
 
 
358
        StartGLSLMan = 0;
 
359
        EndGLSLMan = 0;
 
360
        NumGLSLMan = 0;
 
361
}
 
362
 
 
363
 
 
364
 
 
365
 
 
366
 
 
367
 
 
368
 
 
369
//------------------------------------------------------------------------------------
 
370
// подключение к менеджеру
 
371
//------------------------------------------------------------------------------------
 
372
void vw_AttachShader(eGLSL* GLSL)
 
373
{
 
374
        if (GLSL == 0) return;
 
375
 
 
376
        // первый в списке...
 
377
        if (EndGLSLMan == 0)
 
378
        {
 
379
                GLSL->Prev = 0;
 
380
                GLSL->Next = 0;
 
381
                NumGLSLMan += 1;
 
382
                GLSL->Num = NumGLSLMan;
 
383
                StartGLSLMan = GLSL;
 
384
                EndGLSLMan = GLSL;
 
385
        }
 
386
        else // продолжаем заполнение...
 
387
        {
 
388
                GLSL->Prev = EndGLSLMan;
 
389
                GLSL->Next = 0;
 
390
                EndGLSLMan->Next = GLSL;
 
391
                NumGLSLMan += 1;
 
392
                GLSL->Num = NumGLSLMan;
 
393
                EndGLSLMan = GLSL;
 
394
        }
 
395
}
 
396
 
 
397
 
 
398
 
 
399
 
 
400
 
 
401
//------------------------------------------------------------------------------------
 
402
// отключение от менеджера
 
403
//------------------------------------------------------------------------------------
 
404
void vw_DetachShader(eGLSL* GLSL)
 
405
{
 
406
        if (GLSL == 0) return;
 
407
 
 
408
        // переустанавливаем указатели...
 
409
        if (StartGLSLMan == GLSL) StartGLSLMan = GLSL->Next;
 
410
        if (EndGLSLMan == GLSL) EndGLSLMan = GLSL->Prev;
 
411
 
 
412
 
 
413
        if (GLSL->Next != 0) GLSL->Next->Prev = GLSL->Prev;
 
414
                else if (GLSL->Prev != 0) GLSL->Prev->Next = 0;
 
415
        if (GLSL->Prev != 0) GLSL->Prev->Next = GLSL->Next;
 
416
                else if (GLSL->Next != 0) GLSL->Next->Prev = 0;
 
417
}
 
418
 
 
419
 
 
420
 
 
421
 
 
422
 
 
423
//------------------------------------------------------------------------------------
 
424
// Нахождение по уникальному номеру...
 
425
//------------------------------------------------------------------------------------
 
426
eGLSL* vw_FindShaderByNum(int Num)
 
427
{
 
428
        eGLSL *Tmp = StartGLSLMan;
 
429
 
 
430
        while (Tmp != 0)
 
431
        {
 
432
                eGLSL *Tmp1 = Tmp->Next;
 
433
                if (Tmp->Num == Num) return Tmp;
 
434
                Tmp = Tmp1;
 
435
        }
 
436
 
 
437
        return 0;
 
438
}
 
439
 
 
440
 
 
441
 
 
442
 
 
443
 
 
444
 
 
445
//------------------------------------------------------------------------------------
 
446
// Нахождение по имени...
 
447
//------------------------------------------------------------------------------------
 
448
eGLSL* vw_FindShaderByName(const char *Name)
 
449
{
 
450
        eGLSL *Tmp = StartGLSLMan;
 
451
 
 
452
        while (Tmp != 0)
 
453
        {
 
454
                eGLSL *Tmp1 = Tmp->Next;
 
455
                if( vw_strcmp(Tmp->Name, Name) == 0 ) return Tmp;
 
456
                Tmp = Tmp1;
 
457
        }
 
458
 
 
459
        return 0;
 
460
}
 
461
 
 
462
 
 
463
 
 
464
 
 
465
 
 
466
 
 
467
 
 
468
 
 
469
 
 
470
 
 
471
 
 
472
 
 
473
 
 
474
 
 
475
 
 
476
 
 
477
 
 
478
 
 
479
 
 
480
 
 
481
 
 
482
 
 
483
 
 
484
 
 
485
 
 
486
 
 
487
//------------------------------------------------------------------------------------
 
488
// создаем шейдерную программу
 
489
//------------------------------------------------------------------------------------
 
490
eGLSL *vw_CreateShader(const char *ShaderName, const char *VertexShaderFileName, const char *FragmentShaderFileName)
 
491
{
 
492
        if (glCreateShaderObjectARB == NULL) return 0;
 
493
        if (glShaderSourceARB == NULL) return 0;
 
494
        if (glCompileShaderARB == NULL) return 0;
 
495
        if (glCreateProgramObjectARB == NULL) return 0;
 
496
        if (glAttachObjectARB == NULL) return 0;
 
497
        if (glGetObjectParameterivARB == NULL) return 0;
 
498
        if (VertexShaderFileName == 0 && FragmentShaderFileName == 0) return 0;
 
499
 
 
500
 
 
501
        GLint   vertCompiled, fragCompiled;    // status values
 
502
 
 
503
        // создаем структуру в памяти
 
504
        eGLSL *GLSLtmp = 0;
 
505
        GLSLtmp = new eGLSL;
 
506
        if (GLSLtmp == 0) return 0;
 
507
 
 
508
        // создаем пустые объекты и получаем хидеры на них
 
509
    GLSLtmp->VertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
 
510
    GLSLtmp->FragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
 
511
 
 
512
 
 
513
        // загружаем данные в пустые шейдеры
 
514
 
 
515
        // вертекстный шейдер
 
516
        GLSLtmp->VertexShaderUse = false;
 
517
        if (VertexShaderFileName != 0)
 
518
        {
 
519
                eFILE *VertexFile = 0;
 
520
                VertexFile = vw_fopen(VertexShaderFileName);
 
521
 
 
522
                if (VertexFile != 0)
 
523
                {
 
524
                        const GLcharARB *TmpGLcharARB =  (const GLcharARB *)VertexFile->Data;
 
525
                        glShaderSourceARB(GLSLtmp->VertexShader, 1, &TmpGLcharARB, &VertexFile->RealLength);
 
526
                        vw_fclose(VertexFile);
 
527
                        GLSLtmp->VertexShaderUse = true;
 
528
                }
 
529
        }
 
530
        // фрагментный шейдер
 
531
        GLSLtmp->FragmentShaderUse = false;
 
532
        if (FragmentShaderFileName != 0)
 
533
        {
 
534
                eFILE *FragmentFile = 0;
 
535
                FragmentFile = vw_fopen(FragmentShaderFileName);
 
536
 
 
537
                if (FragmentFile != 0)
 
538
                {
 
539
                        const GLcharARB *TmpGLcharARB =  (const GLcharARB *)FragmentFile->Data;
 
540
                        glShaderSourceARB(GLSLtmp->FragmentShader, 1, &TmpGLcharARB, &FragmentFile->RealLength);
 
541
                        vw_fclose(FragmentFile);
 
542
                        GLSLtmp->FragmentShaderUse = true;
 
543
                }
 
544
        }
 
545
 
 
546
 
 
547
        // компилируем шейдеры
 
548
 
 
549
        if (GLSLtmp->VertexShaderUse)
 
550
        {
 
551
                glCompileShaderARB(GLSLtmp->VertexShader);
 
552
                CheckOGLError();  // Check for OpenGL errors
 
553
                glGetObjectParameterivARB(GLSLtmp->VertexShader, GL_COMPILE_STATUS, &vertCompiled);
 
554
                vw_PrintShaderInfoLog(GLSLtmp->VertexShader, VertexShaderFileName);
 
555
 
 
556
                if (!vertCompiled)      return 0;
 
557
        }
 
558
        if (GLSLtmp->FragmentShaderUse)
 
559
        {
 
560
                glCompileShaderARB(GLSLtmp->FragmentShader);
 
561
                CheckOGLError();  // Check for OpenGL errors
 
562
                glGetObjectParameterivARB(GLSLtmp->FragmentShader, GL_COMPILE_STATUS, &fragCompiled);
 
563
                vw_PrintShaderInfoLog(GLSLtmp->FragmentShader, FragmentShaderFileName);
 
564
 
 
565
                if (!fragCompiled)      return 0;
 
566
        }
 
567
 
 
568
 
 
569
    // создаем программу, чтобы подключить эти шейдеры
 
570
    GLSLtmp->Program = glCreateProgramObjectARB();
 
571
    if (GLSLtmp->VertexShaderUse) glAttachObjectARB(GLSLtmp->Program, GLSLtmp->VertexShader);
 
572
    if (GLSLtmp->FragmentShaderUse) glAttachObjectARB(GLSLtmp->Program, GLSLtmp->FragmentShader);
 
573
 
 
574
 
 
575
        if (VertexShaderFileName == 0)
 
576
                printf("Shader ... %s\n", FragmentShaderFileName);
 
577
        else
 
578
                if (FragmentShaderFileName == 0)
 
579
                        printf("Shader ... %s\n", VertexShaderFileName);
 
580
                else
 
581
                        printf("Shader ... %s %s\n", VertexShaderFileName, FragmentShaderFileName);
 
582
 
 
583
 
 
584
        if (ShaderName != 0)
 
585
        {
 
586
                GLSLtmp->Name = new char[strlen(ShaderName)+1];
 
587
                strcpy(GLSLtmp->Name, ShaderName);
 
588
        }
 
589
        else
 
590
        {
 
591
                GLSLtmp->Name = new char[strlen(VertexShaderFileName)+1];
 
592
                strcpy(GLSLtmp->Name, VertexShaderFileName);
 
593
        }
 
594
 
 
595
        vw_AttachShader(GLSLtmp);
 
596
 
 
597
        return GLSLtmp;
 
598
}
 
599
 
 
600
 
 
601
 
 
602
 
 
603
 
 
604
 
 
605
//------------------------------------------------------------------------------------
 
606
// линкуем программу, с учетом отбинденных данных
 
607
//------------------------------------------------------------------------------------
 
608
bool vw_LinkShaderProgram(eGLSL *GLSL)
 
609
{
 
610
        if (GLSL == 0) return false;
 
611
        if (glLinkProgramARB == NULL) return false;
 
612
        if (glGetObjectParameterivARB == NULL) return false;
 
613
 
 
614
    GLint linked;
 
615
 
 
616
    glLinkProgramARB(GLSL->Program);
 
617
    CheckOGLError();  // Check for OpenGL errors
 
618
    glGetObjectParameterivARB(GLSL->Program, GL_LINK_STATUS, &linked);
 
619
    vw_PrintProgramInfoLog(GLSL->Program);
 
620
 
 
621
    if (!linked)
 
622
        return false;
 
623
 
 
624
        return true;
 
625
}
 
626
 
 
627
 
 
628
 
 
629
 
 
630
 
 
631
//------------------------------------------------------------------------------------
 
632
// запускаем шейдер на исполнение
 
633
//------------------------------------------------------------------------------------
 
634
bool vw_UseShaderProgram(eGLSL *GLSL)
 
635
{
 
636
        if (GLSL == 0) return false;
 
637
        if (glUseProgramObjectARB == NULL) return false;
 
638
 
 
639
    glUseProgramObjectARB(GLSL->Program);
 
640
    CheckOGLError();
 
641
 
 
642
        return true;
 
643
}
 
644
 
 
645
 
 
646
 
 
647
 
 
648
 
 
649
//------------------------------------------------------------------------------------
 
650
// останавливаем работу шейдера
 
651
//------------------------------------------------------------------------------------
 
652
bool vw_StopShaderProgram()
 
653
{
 
654
        if (glUseProgramObjectARB == NULL) return false;
 
655
 
 
656
    glUseProgramObjectARB(0);
 
657
    CheckOGLError();
 
658
 
 
659
        return true;
 
660
}
 
661
 
 
662
 
 
663
 
 
664
 
 
665
 
 
666
//------------------------------------------------------------------------------------
 
667
// Get the location of a uniform variable
 
668
//------------------------------------------------------------------------------------
 
669
int vw_GetUniformLocation(eGLSL *GLSL, const char *name)
 
670
{
 
671
        if (glGetUniformLocationARB == NULL) return -1;
 
672
 
 
673
    int loc;
 
674
 
 
675
    loc = glGetUniformLocationARB(GLSL->Program, name);
 
676
 
 
677
    if (loc == -1)
 
678
        fprintf(stderr, "No such uniform named \"%s\"\n", name);
 
679
 
 
680
    CheckOGLError();  // Check for OpenGL errors
 
681
    return loc;
 
682
}
 
683
 
 
684
 
 
685
 
 
686
 
 
687
//------------------------------------------------------------------------------------
 
688
// установка значения параметра
 
689
//------------------------------------------------------------------------------------
 
690
bool vw_Uniform1i(eGLSL *GLSL, int UniformLocation, int data)
 
691
{
 
692
        if (GLSL == 0) return false;
 
693
        if (glUniform1iARB == NULL) return false;
 
694
 
 
695
        glUniform1iARB(UniformLocation, data);
 
696
 
 
697
        CheckOGLError();  // Check for OpenGL errors
 
698
 
 
699
        return true;
 
700
}
 
701
bool vw_Uniform1i(eGLSL *GLSL, const char *name, int data)
 
702
{
 
703
        if (GLSL == 0) return false;
 
704
        if (name == 0) return false;
 
705
 
 
706
        int Loc = vw_GetUniformLocation(GLSL, name);
 
707
        if (Loc == -1) return false;
 
708
 
 
709
        return vw_Uniform1i(GLSL, Loc, data);
 
710
}
 
711
 
 
712
 
 
713
bool vw_Uniform1f(eGLSL *GLSL, int UniformLocation, float data)
 
714
{
 
715
        if (GLSL == 0) return false;
 
716
        if (glUniform3fARB == NULL) return false;
 
717
 
 
718
        glUniform1fARB(UniformLocation, data);
 
719
 
 
720
        CheckOGLError();  // Check for OpenGL errors
 
721
 
 
722
        return true;
 
723
}
 
724
bool vw_Uniform1f(eGLSL *GLSL, const char *name, float data)
 
725
{
 
726
        if (GLSL == 0) return false;
 
727
        if (name == 0) return false;
 
728
 
 
729
        int Loc = vw_GetUniformLocation(GLSL, name);
 
730
        if (Loc == -1) return false;
 
731
 
 
732
        return vw_Uniform1f(GLSL, Loc, data);
 
733
}
 
734
 
 
735
 
 
736
bool vw_Uniform3f(eGLSL *GLSL, int UniformLocation, float data1, float data2, float data3)
 
737
{
 
738
        if (GLSL == 0) return false;
 
739
        if (glUniform3fARB == NULL) return false;
 
740
 
 
741
        glUniform3fARB(UniformLocation, data1, data2, data3);
 
742
 
 
743
        CheckOGLError();  // Check for OpenGL errors
 
744
 
 
745
        return true;
 
746
}
 
747
bool vw_Uniform3f(eGLSL *GLSL, const char *name, float data1, float data2, float data3)
 
748
{
 
749
        if (GLSL == 0) return false;
 
750
        if (name == 0) return false;
 
751
 
 
752
        int Loc = vw_GetUniformLocation(GLSL, name);
 
753
        if (Loc == -1) return false;
 
754
 
 
755
        return vw_Uniform3f(GLSL, Loc, data1, data2, data3);
 
756
}
 
757
 
 
758
 
 
759
bool vw_Uniform1fv(eGLSL *GLSL, int UniformLocation, int count, float *data)
 
760
{
 
761
        if (GLSL == 0) return false;
 
762
        if (glUniform1fvARB == NULL) return false;
 
763
 
 
764
        glUniform1fvARB(UniformLocation, count, data);
 
765
 
 
766
        CheckOGLError();  // Check for OpenGL errors
 
767
 
 
768
        return true;
 
769
}
 
770
bool vw_Uniform1fv(eGLSL *GLSL, const char *name, int count, float *data)
 
771
{
 
772
        if (GLSL == 0) return false;
 
773
        if (name == 0) return false;
 
774
 
 
775
        int Loc = vw_GetUniformLocation(GLSL, name);
 
776
        if (Loc == -1) return false;
 
777
 
 
778
        return vw_Uniform1fv(GLSL, Loc, count, data);
 
779
}
 
780
 
 
781
 
 
782
bool vw_Uniform4fv(eGLSL *GLSL, int UniformLocation, int count, float *data)
 
783
{
 
784
        if (GLSL == 0) return false;
 
785
        if (glUniform4fvARB == NULL) return false;
 
786
 
 
787
        glUniform4fvARB(UniformLocation, count, data);
 
788
 
 
789
        CheckOGLError();  // Check for OpenGL errors
 
790
 
 
791
        return true;
 
792
}
 
793
bool vw_Uniform4fv(eGLSL *GLSL, const char *name, int count, float *data)
 
794
{
 
795
        if (GLSL == 0) return false;
 
796
        if (name == 0) return false;
 
797
 
 
798
        int Loc = vw_GetUniformLocation(GLSL, name);
 
799
        if (Loc == -1) return false;
 
800
 
 
801
        return vw_Uniform4fv(GLSL, Loc, count, data);
 
802
}
 
803
 
 
804
 
 
805
bool vw_UniformMatrix4fv(eGLSL *GLSL, int UniformLocation, bool transpose, int count, float *data)
 
806
{
 
807
        if (GLSL == 0) return false;
 
808
        if (glUniformMatrix4fvARB == NULL) return false;
 
809
 
 
810
        glUniformMatrix4fvARB(UniformLocation, count, transpose, data);
 
811
 
 
812
        CheckOGLError();  // Check for OpenGL errors
 
813
 
 
814
        return true;
 
815
}
 
816
bool vw_UniformMatrix4fv(eGLSL *GLSL, const char *name, bool transpose, int count, float *data)
 
817
{
 
818
        if (GLSL == 0) return false;
 
819
        if (name == 0) return false;
 
820
 
 
821
        int Loc = vw_GetUniformLocation(GLSL, name);
 
822
        if (Loc == -1) return false;
 
823
 
 
824
        return vw_UniformMatrix4fv(GLSL, Loc, transpose, count, data);
 
825
}
 
826