/
mojoshader_opengl.c
1476 lines (1226 loc) · 48.3 KB
1
2
3
4
5
6
7
8
9
/**
* MojoShader; generate shader programs from bytecode of compiled
* Direct3D shaders.
*
* Please see the file LICENSE.txt in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
10
11
12
13
14
15
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <assert.h>
16
17
18
19
20
#ifdef _MSC_VER
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h> // GL headers need this for WINGDIAPI definition.
#endif
21
#include "mojoshader.h"
22
#define GL_GLEXT_LEGACY 1
23
24
#include "GL/gl.h"
#include "GL/glext.h"
25
26
27
28
// Get basic wankery out of the way here...
typedef unsigned int uint; // this is a printf() helper. don't use for code.
29
30
31
32
33
34
#ifdef _MSC_VER
#define snprintf _snprintf
typedef unsigned __int8 uint8;
typedef unsigned __int32 uint32;
typedef unsigned __int32 int32;
35
36
37
// Warning Level 4 considered harmful. :)
#pragma warning(disable: 4100) // "unreferenced formal parameter"
#pragma warning(disable: 4389) // "signed/unsigned mismatch"
38
39
#else
#include <stdint.h>
40
41
42
typedef uint8_t uint8;
typedef uint32_t uint32;
typedef int32_t int32;
43
44
45
#endif
#define STATICARRAYLEN(x) ( (sizeof ((x))) / (sizeof ((x)[0])) )
46
47
48
49
50
#ifndef SUPPORT_PROFILE_GLSL
#define SUPPORT_PROFILE_GLSL 1
#endif
51
52
53
54
#ifndef SUPPORT_PROFILE_ARB1
#define SUPPORT_PROFILE_ARB1 1
#endif
55
56
57
struct MOJOSHADER_glShader
{
const MOJOSHADER_parseData *parseData;
58
GLuint handle;
59
60
61
uint32 refcount;
};
62
63
typedef struct
{
64
MOJOSHADER_shaderType shader_type;
65
const MOJOSHADER_uniform *uniform;
66
GLuint location;
67
68
} UniformMap;
69
70
71
72
73
74
75
typedef struct
{
MOJOSHADER_shaderType shader_type;
const MOJOSHADER_sampler *sampler;
GLuint location;
} SamplerMap;
76
77
typedef struct
{
78
const MOJOSHADER_attribute *attribute;
79
GLuint location;
80
81
} AttributeMap;
82
83
struct MOJOSHADER_glProgram
{
84
85
MOJOSHADER_glShader *vertex;
MOJOSHADER_glShader *fragment;
86
GLuint handle;
87
88
uint32 constant_count; // !!! FIXME: misnamed.
GLfloat *constants; // !!! FIXME: misnamed.
89
uint32 uniform_count;
90
UniformMap *uniforms;
91
92
uint32 sampler_count;
SamplerMap *samplers;
93
uint32 attribute_count;
94
AttributeMap *attributes;
95
96
97
uint32 refcount;
};
98
99
100
101
#ifndef WINGDIAPI
#define WINGDIAPI
#endif
102
// Entry points in base OpenGL that lack function pointer prototypes...
103
104
typedef WINGDIAPI void (APIENTRYP PFNGLGETINTEGERVPROC) (GLenum pname, GLint *params);
typedef WINGDIAPI const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC) (GLenum name);
105
typedef WINGDIAPI GLenum (APIENTRYP PFNGLGETERRORPROC) (void);
106
107
typedef WINGDIAPI void (APIENTRYP PFNGLENABLEPROC) (GLenum cap);
typedef WINGDIAPI void (APIENTRYP PFNGLDISABLEPROC) (GLenum cap);
108
109
110
111
112
113
114
115
116
117
struct MOJOSHADER_glContext
{
// Allocators...
MOJOSHADER_malloc malloc_fn;
MOJOSHADER_free free_fn;
void *malloc_data;
// The constant register files...
// Man, it kills me how much memory this takes...
118
119
120
121
122
123
GLfloat vs_reg_file_f[8192 * 4];
GLint vs_reg_file_i[2047 * 4];
GLint vs_reg_file_b[2047];
GLfloat ps_reg_file_f[8192 * 4];
GLint ps_reg_file_i[2047 * 4];
GLint ps_reg_file_b[2047];
124
GLuint sampler_reg_file[16];
125
126
127
128
129
// GL stuff...
int opengl_major;
int opengl_minor;
MOJOSHADER_glProgram *bound_program;
130
char profile[16];
131
132
133
// Extensions...
int have_base_opengl;
134
135
int have_GL_ARB_vertex_program;
int have_GL_ARB_fragment_program;
136
137
138
139
140
141
142
143
int have_GL_ARB_shader_objects;
int have_GL_ARB_vertex_shader;
int have_GL_ARB_fragment_shader;
int have_GL_ARB_shading_language_100;
int have_GL_NV_half_float;
// Entry points...
PFNGLGETSTRINGPROC glGetString;
144
PFNGLGETERRORPROC glGetError;
145
PFNGLGETINTEGERVPROC glGetIntegerv;
146
147
PFNGLENABLEPROC glEnable;
PFNGLDISABLEPROC glDisable;
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
PFNGLDELETEOBJECTARBPROC glDeleteObject;
PFNGLATTACHOBJECTARBPROC glAttachObject;
PFNGLCOMPILESHADERARBPROC glCompileShader;
PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObject;
PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObject;
PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArray;
PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArray;
PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocation;
PFNGLGETINFOLOGARBPROC glGetInfoLog;
PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameteriv;
PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocation;
PFNGLLINKPROGRAMARBPROC glLinkProgram;
PFNGLSHADERSOURCEARBPROC glShaderSource;
PFNGLUNIFORM1IARBPROC glUniform1i;
PFNGLUNIFORM4FVARBPROC glUniform4fv;
PFNGLUNIFORM4IVARBPROC glUniform4iv;
PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObject;
PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointer;
166
167
168
169
170
171
172
PFNGLGETPROGRAMIVARBPROC glGetProgramivARB;
PFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB;
PFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB;
PFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB;
PFNGLGENPROGRAMSARBPROC glGenProgramsARB;
PFNGLBINDPROGRAMARBPROC glBindProgramARB;
PFNGLPROGRAMSTRINGARBPROC glProgramStringARB;
173
174
175
// interface for profile-specific things.
int (*profileMaxUniforms)(MOJOSHADER_shaderType shader_type);
176
int (*profileCompileShader)(const MOJOSHADER_parseData *pd, GLuint *s);
177
178
void (*profileDeleteShader)(const GLuint shader);
void (*profileDeleteProgram)(const GLuint program);
179
180
181
GLint (*profileGetAttribLocation)(MOJOSHADER_glProgram *program, int idx);
GLint (*profileGetUniformLocation)(MOJOSHADER_glProgram *, MOJOSHADER_glShader *, int);
GLint (*profileGetSamplerLocation)(MOJOSHADER_glProgram *, MOJOSHADER_glShader *, int);
182
183
GLuint (*profileLinkProgram)(MOJOSHADER_glShader *, MOJOSHADER_glShader *);
void (*profileUseProgramObject)(MOJOSHADER_glProgram *program);
184
185
186
void (*profileUniform4fv)(const MOJOSHADER_parseData *, GLint, GLsizei, GLfloat *);
void (*profileUniform4iv)(const MOJOSHADER_parseData *, GLint, GLsizei, GLint *);
void (*profileUniform1i)(const MOJOSHADER_parseData *, GLint, GLint);
187
void (*profileSetSampler)(GLint loc, GLuint sampler);
188
189
};
190
191
// predeclare some profile implementation stuff...
static int impl_GLSL_MaxUniforms(MOJOSHADER_shaderType shader_type);
192
193
194
static int impl_GLSL_CompileShader(const MOJOSHADER_parseData *pd, GLuint *s);
static void impl_GLSL_DeleteShader(const GLuint shader);
static void impl_GLSL_DeleteProgram(const GLuint program);
195
196
197
static GLint impl_GLSL_GetAttribLocation(MOJOSHADER_glProgram *, int);
static GLint impl_GLSL_GetUniformLocation(MOJOSHADER_glProgram *, MOJOSHADER_glShader *, int);
static GLint impl_GLSL_GetSamplerLocation(MOJOSHADER_glProgram *, MOJOSHADER_glShader *, int);
198
199
static GLuint impl_GLSL_LinkProgram(MOJOSHADER_glShader *, MOJOSHADER_glShader *);
static void impl_GLSL_UseProgramObject(MOJOSHADER_glProgram *program);
200
201
202
static void impl_GLSL_Uniform4fv(const MOJOSHADER_parseData *pd, GLint loc, GLsizei siz, GLfloat *v);
static void impl_GLSL_Uniform4iv(const MOJOSHADER_parseData *pd, GLint loc, GLsizei siz, GLint *v);
static void impl_GLSL_Uniform1i(const MOJOSHADER_parseData *pd, GLint loc, GLint v);
203
204
static void impl_GLSL_SetSampler(GLint loc, GLuint sampler);
205
static int impl_ARB1_MaxUniforms(MOJOSHADER_shaderType shader_type);
206
207
208
static int impl_ARB1_CompileShader(const MOJOSHADER_parseData *pd, GLuint *s);
static void impl_ARB1_DeleteShader(const GLuint shader);
static void impl_ARB1_DeleteProgram(const GLuint program);
209
210
211
static GLint impl_ARB1_GetAttribLocation(MOJOSHADER_glProgram *, int);
static GLint impl_ARB1_GetUniformLocation(MOJOSHADER_glProgram *, MOJOSHADER_glShader *, int);
static GLint impl_ARB1_GetSamplerLocation(MOJOSHADER_glProgram *, MOJOSHADER_glShader *, int);
212
213
static GLuint impl_ARB1_LinkProgram(MOJOSHADER_glShader *, MOJOSHADER_glShader *);
static void impl_ARB1_UseProgramObject(MOJOSHADER_glProgram *program);
214
215
216
static void impl_ARB1_Uniform4fv(const MOJOSHADER_parseData *pd, GLint loc, GLsizei siz, GLfloat *v);
static void impl_ARB1_Uniform4iv(const MOJOSHADER_parseData *pd, GLint loc, GLsizei siz, GLint *v);
static void impl_ARB1_Uniform1i(const MOJOSHADER_parseData *pd, GLint loc, GLint v);
217
static void impl_ARB1_SetSampler(GLint loc, GLuint sampler);
218
219
220
static MOJOSHADER_glContext *ctx = NULL;
221
222
223
224
225
226
227
228
229
// Error state...
static char error_buffer[1024] = { '\0' };
static void set_error(const char *str)
{
snprintf(error_buffer, sizeof (error_buffer), "%s", str);
} // set_error
230
231
232
233
234
235
236
237
238
239
240
241
242
// #define this to force app to supply an allocator, so there's no reference
// to the C runtime's malloc() and free()...
#if MOJOSHADER_FORCE_ALLOCATOR
#define internal_malloc NULL
#define internal_free NULL
#else
static void *internal_malloc(int bytes, void *d) { return malloc(bytes); }
static void internal_free(void *ptr, void *d) { free(ptr); }
#endif
static inline void *Malloc(const size_t len)
{
243
void *retval = ctx->malloc_fn((int) len, ctx->malloc_data);
244
245
246
if (retval == NULL)
set_error("out of memory");
return retval;
247
248
249
250
} // Malloc
static inline void Free(void *ptr)
{
251
if (ptr != NULL)
252
ctx->free_fn(ptr, ctx->malloc_data);
253
254
255
} // Free
256
257
258
259
260
261
const char *MOJOSHADER_glGetError(void)
{
return error_buffer;
} // MOJOSHADER_glGetError
262
263
264
265
266
267
268
269
270
static inline void toggle_gl_state(GLenum state, int val)
{
if (val)
ctx->glEnable(state);
else
ctx->glDisable(state);
} // toggle_gl_state
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
static void *loadsym(void *(*lookup)(const char *fn), const char *fn, int *ext)
{
void *retval = NULL;
if (lookup != NULL)
{
retval = lookup(fn);
if (retval == NULL)
{
char arbfn[64];
snprintf(arbfn, sizeof (arbfn), "%sARB", fn);
retval = lookup(arbfn);
} // if
} // if
if (retval == NULL)
*ext = 0;
return retval;
} // loadsym
static void lookup_entry_points(void *(*lookup)(const char *fnname))
{
293
#define DO_LOOKUP(ext, typ, fn) ctx->fn = (typ) loadsym(lookup, #fn, &ctx->have_##ext)
294
DO_LOOKUP(base_opengl, PFNGLGETSTRINGPROC, glGetString);
295
DO_LOOKUP(base_opengl, PFNGLGETERRORPROC, glGetError);
296
DO_LOOKUP(base_opengl, PFNGLGETINTEGERVPROC, glGetIntegerv);
297
298
DO_LOOKUP(base_opengl, PFNGLENABLEPROC, glEnable);
DO_LOOKUP(base_opengl, PFNGLDISABLEPROC, glDisable);
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
DO_LOOKUP(GL_ARB_shader_objects, PFNGLDELETEOBJECTARBPROC, glDeleteObject);
DO_LOOKUP(GL_ARB_shader_objects, PFNGLATTACHOBJECTARBPROC, glAttachObject);
DO_LOOKUP(GL_ARB_shader_objects, PFNGLCOMPILESHADERARBPROC, glCompileShader);
DO_LOOKUP(GL_ARB_shader_objects, PFNGLCREATEPROGRAMOBJECTARBPROC, glCreateProgramObject);
DO_LOOKUP(GL_ARB_shader_objects, PFNGLCREATESHADEROBJECTARBPROC, glCreateShaderObject);
DO_LOOKUP(GL_ARB_shader_objects, PFNGLGETINFOLOGARBPROC, glGetInfoLog);
DO_LOOKUP(GL_ARB_shader_objects, PFNGLGETOBJECTPARAMETERIVARBPROC, glGetObjectParameteriv);
DO_LOOKUP(GL_ARB_shader_objects, PFNGLGETUNIFORMLOCATIONARBPROC, glGetUniformLocation);
DO_LOOKUP(GL_ARB_shader_objects, PFNGLLINKPROGRAMARBPROC, glLinkProgram);
DO_LOOKUP(GL_ARB_shader_objects, PFNGLSHADERSOURCEARBPROC, glShaderSource);
DO_LOOKUP(GL_ARB_shader_objects, PFNGLUNIFORM1IARBPROC, glUniform1i);
DO_LOOKUP(GL_ARB_shader_objects, PFNGLUNIFORM4FVARBPROC, glUniform4fv);
DO_LOOKUP(GL_ARB_shader_objects, PFNGLUNIFORM4IVARBPROC, glUniform4iv);
DO_LOOKUP(GL_ARB_shader_objects, PFNGLUSEPROGRAMOBJECTARBPROC, glUseProgramObject);
DO_LOOKUP(GL_ARB_vertex_shader, PFNGLDISABLEVERTEXATTRIBARRAYARBPROC, glDisableVertexAttribArray);
DO_LOOKUP(GL_ARB_vertex_shader, PFNGLENABLEVERTEXATTRIBARRAYARBPROC, glEnableVertexAttribArray);
DO_LOOKUP(GL_ARB_vertex_shader, PFNGLGETATTRIBLOCATIONARBPROC, glGetAttribLocation);
DO_LOOKUP(GL_ARB_vertex_shader, PFNGLVERTEXATTRIBPOINTERARBPROC, glVertexAttribPointer);
317
318
319
320
321
322
323
324
325
326
DO_LOOKUP(GL_ARB_vertex_program, PFNGLUSEPROGRAMOBJECTARBPROC, glUseProgramObject);
DO_LOOKUP(GL_ARB_vertex_program, PFNGLVERTEXATTRIBPOINTERARBPROC, glVertexAttribPointer);
DO_LOOKUP(GL_ARB_vertex_program, PFNGLGETPROGRAMIVARBPROC, glGetProgramivARB);
DO_LOOKUP(GL_ARB_vertex_program, PFNGLGETPROGRAMSTRINGARBPROC, glGetProgramStringARB);
DO_LOOKUP(GL_ARB_vertex_program, PFNGLPROGRAMENVPARAMETER4FVARBPROC, glProgramEnvParameter4fvARB);
DO_LOOKUP(GL_ARB_vertex_program, PFNGLDELETEPROGRAMSARBPROC, glDeleteProgramsARB);
DO_LOOKUP(GL_ARB_vertex_program, PFNGLGENPROGRAMSARBPROC, glGenProgramsARB);
DO_LOOKUP(GL_ARB_vertex_program, PFNGLBINDPROGRAMARBPROC, glBindProgramARB);
DO_LOOKUP(GL_ARB_vertex_program, PFNGLPROGRAMSTRINGARBPROC, glProgramStringARB);
327
328
329
330
331
332
333
334
335
336
#undef DO_LOOKUP
} // lookup_entry_points
static int verify_extension(const char *ext, int have, const char *extlist,
int major, int minor)
{
if (have == 0)
return 0; // don't bother checking, we're missing an entry point.
337
338
339
else if (!ctx->have_base_opengl)
return 0; // don't bother checking, we're missing basic functionality.
340
// See if it's in the spec for this GL implementation's version.
341
342
if (major >= 0)
{
343
if ( ((ctx->opengl_major << 16) | (ctx->opengl_minor & 0xFFFF)) >=
344
345
346
((major << 16) | (minor & 0xFFFF)) )
return 1;
} // if
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
// Not available in the GL version, check the extension list.
const char *ptr = strstr(extlist, ext);
if (ptr == NULL)
return 0;
const char endchar = ptr[strlen(ext)];
if ((endchar == '\0') || (endchar == ' '))
return 1; // extension is in the list.
return 0; // just not supported, fail.
} // verify_extension
static void parse_opengl_version(const char *verstr)
{
if (verstr == NULL)
364
ctx->opengl_major = ctx->opengl_minor = 0;
365
else
366
sscanf(verstr, "%d.%d", &ctx->opengl_major, &ctx->opengl_minor);
367
368
369
} // parse_opengl_version
370
static void load_extensions(void *(*lookup)(const char *fnname))
371
{
372
373
const char *extlist = NULL;
374
ctx->have_base_opengl = 1;
375
376
ctx->have_GL_ARB_vertex_program = 1;
ctx->have_GL_ARB_fragment_program = 1;
377
378
379
380
381
ctx->have_GL_ARB_shader_objects = 1;
ctx->have_GL_ARB_vertex_shader = 1;
ctx->have_GL_ARB_fragment_shader = 1;
ctx->have_GL_ARB_shading_language_100 = 1;
ctx->have_GL_NV_half_float = 1;
382
383
384
lookup_entry_points(lookup);
385
if (!ctx->have_base_opengl)
386
set_error("missing basic OpenGL entry points");
387
388
389
390
391
else
{
parse_opengl_version((const char *) ctx->glGetString(GL_VERSION));
extlist = (const char *) ctx->glGetString(GL_EXTENSIONS);
} // else
392
393
394
395
396
if (extlist == NULL)
extlist = ""; // just in case.
#define VERIFY_EXT(ext, major, minor) \
397
ctx->have_##ext = verify_extension(#ext, ctx->have_##ext, extlist, major, minor)
398
399
400
VERIFY_EXT(GL_ARB_vertex_program, -1, -1);
VERIFY_EXT(GL_ARB_fragment_program, -1, -1);
401
402
403
404
VERIFY_EXT(GL_ARB_shader_objects, 2, 0);
VERIFY_EXT(GL_ARB_vertex_shader, 2, 0);
VERIFY_EXT(GL_ARB_fragment_shader, 2, 0);
VERIFY_EXT(GL_ARB_shading_language_100, 2, 0);
405
VERIFY_EXT(GL_NV_half_float, -1, -1);
406
407
#undef VERIFY_EXT
408
409
410
411
412
413
414
} // load_extensions
static int valid_profile(const char *profile)
{
if (!ctx->have_base_opengl)
return 0;
415
416
417
#define MUST_HAVE(p, x) \
if (!ctx->have_##x) { set_error(#p " profile needs " #x); return 0; }
418
419
420
421
422
423
if (profile == NULL)
{
set_error("NULL profile");
return 0;
} // if
424
425
426
427
428
429
430
431
432
#if SUPPORT_PROFILE_ARB1
else if (strcmp(profile, MOJOSHADER_PROFILE_ARB1) == 0)
{
MUST_HAVE(MOJOSHADER_PROFILE_ARB1, GL_ARB_vertex_program);
MUST_HAVE(MOJOSHADER_PROFILE_ARB1, GL_ARB_fragment_program);
} // else if
#endif
433
434
#if SUPPORT_PROFILE_GLSL
else if (strcmp(profile, MOJOSHADER_PROFILE_GLSL) == 0)
435
{
436
437
438
439
440
441
MUST_HAVE(MOJOSHADER_PROFILE_GLSL, GL_ARB_shader_objects);
MUST_HAVE(MOJOSHADER_PROFILE_GLSL, GL_ARB_vertex_shader);
MUST_HAVE(MOJOSHADER_PROFILE_GLSL, GL_ARB_fragment_shader);
MUST_HAVE(MOJOSHADER_PROFILE_GLSL, GL_ARB_shading_language_100);
} // else if
#endif
442
443
444
else
{
445
set_error("unknown or unsupported profile");
446
447
448
return 0;
} // else
449
#undef MUST_HAVE
450
451
return 1;
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
} // valid_profile
const char *MOJOSHADER_glBestProfile(void *(*lookup)(const char *fnname))
{
const char *retval = NULL;
MOJOSHADER_glContext _ctx;
MOJOSHADER_glContext *current_ctx = ctx;
ctx = &_ctx;
memset(ctx, '\0', sizeof (MOJOSHADER_glContext));
load_extensions(lookup);
if (ctx->have_base_opengl)
{
static const char *priority[] = {
MOJOSHADER_PROFILE_GLSL,
469
MOJOSHADER_PROFILE_ARB1,
470
471
472
473
474
};
int i;
for (i = 0; i < STATICARRAYLEN(priority); i++)
{
475
476
// !!! FIXME: if Mac OS X <= 10.4, don't ever pick GLSL, even if
// !!! FIXME: the system claims it is available.
477
478
479
480
481
482
if (valid_profile(priority[i]))
{
retval = priority[i];
break;
} // if
} // for
483
484
485
486
if (retval == NULL)
set_error("no profiles available");
} // if
487
488
489
490
491
492
493
ctx = current_ctx;
return retval;
} // MOJOSHADER_glBestProfile
MOJOSHADER_glContext *MOJOSHADER_glCreateContext(const char *profile,
494
495
496
void *(*lookup)(const char *fnname),
MOJOSHADER_malloc m, MOJOSHADER_free f,
void *d)
497
{
498
MOJOSHADER_glContext *retval = NULL;
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
MOJOSHADER_glContext *current_ctx = ctx;
ctx = NULL;
if (m == NULL) m = internal_malloc;
if (f == NULL) f = internal_free;
ctx = (MOJOSHADER_glContext *) m(sizeof (MOJOSHADER_glContext), d);
if (ctx == NULL)
{
set_error("out of memory");
goto init_fail;
} // if
memset(ctx, '\0', sizeof (MOJOSHADER_glContext));
ctx->malloc_fn = m;
ctx->free_fn = f;
ctx->malloc_data = d;
516
snprintf(ctx->profile, sizeof (ctx->profile), "%s", profile);
517
518
519
load_extensions(lookup);
if (!valid_profile(profile))
520
goto init_fail;
521
522
523
MOJOSHADER_glBindProgram(NULL);
524
525
526
527
528
529
530
531
532
533
// !!! FIXME: generalize this part.
if (profile == NULL) {}
#if SUPPORT_PROFILE_GLSL
else if (strcmp(profile, MOJOSHADER_PROFILE_GLSL) == 0)
{
ctx->profileMaxUniforms = impl_GLSL_MaxUniforms;
ctx->profileCompileShader = impl_GLSL_CompileShader;
ctx->profileDeleteShader = impl_GLSL_DeleteShader;
ctx->profileDeleteProgram = impl_GLSL_DeleteProgram;
534
ctx->profileGetAttribLocation = impl_GLSL_GetAttribLocation;
535
ctx->profileGetUniformLocation = impl_GLSL_GetUniformLocation;
536
ctx->profileGetSamplerLocation = impl_GLSL_GetSamplerLocation;
537
538
539
540
541
542
ctx->profileLinkProgram = impl_GLSL_LinkProgram;
ctx->profileUseProgramObject = impl_GLSL_UseProgramObject;
ctx->profileUniform4fv = impl_GLSL_Uniform4fv;
ctx->profileUniform4iv = impl_GLSL_Uniform4iv;
ctx->profileUniform1i = impl_GLSL_Uniform1i;
ctx->profileSetSampler = impl_GLSL_SetSampler;
543
544
545
546
547
548
549
550
551
552
} // if
#endif
#if SUPPORT_PROFILE_ARB1
else if (strcmp(profile, MOJOSHADER_PROFILE_ARB1) == 0)
{
ctx->profileMaxUniforms = impl_ARB1_MaxUniforms;
ctx->profileCompileShader = impl_ARB1_CompileShader;
ctx->profileDeleteShader = impl_ARB1_DeleteShader;
ctx->profileDeleteProgram = impl_ARB1_DeleteProgram;
553
ctx->profileGetAttribLocation = impl_ARB1_GetAttribLocation;
554
ctx->profileGetUniformLocation = impl_ARB1_GetUniformLocation;
555
ctx->profileGetSamplerLocation = impl_ARB1_GetSamplerLocation;
556
557
558
559
560
561
ctx->profileLinkProgram = impl_ARB1_LinkProgram;
ctx->profileUseProgramObject = impl_ARB1_UseProgramObject;
ctx->profileUniform4fv = impl_ARB1_Uniform4fv;
ctx->profileUniform4iv = impl_ARB1_Uniform4iv;
ctx->profileUniform1i = impl_ARB1_Uniform1i;
ctx->profileSetSampler = impl_ARB1_SetSampler;
562
563
564
565
566
567
568
} // if
#endif
assert(ctx->profileMaxUniforms != NULL);
assert(ctx->profileCompileShader != NULL);
assert(ctx->profileDeleteShader != NULL);
assert(ctx->profileDeleteProgram != NULL);
569
assert(ctx->profileMaxUniforms != NULL);
570
assert(ctx->profileGetAttribLocation != NULL);
571
assert(ctx->profileGetUniformLocation != NULL);
572
assert(ctx->profileGetSamplerLocation != NULL);
573
574
575
576
577
578
assert(ctx->profileLinkProgram != NULL);
assert(ctx->profileUseProgramObject != NULL);
assert(ctx->profileUniform4fv != NULL);
assert(ctx->profileUniform4iv != NULL);
assert(ctx->profileUniform1i != NULL);
assert(ctx->profileSetSampler != NULL);
579
580
retval = ctx;
581
582
ctx = current_ctx;
return retval;
583
584
init_fail:
585
586
587
588
if (ctx != NULL)
f(ctx, d);
ctx = current_ctx;
return NULL;
589
} // MOJOSHADER_glCreateContext
590
591
592
593
594
595
596
597
void MOJOSHADER_glMakeContextCurrent(MOJOSHADER_glContext *_ctx)
{
ctx = _ctx;
} // MOJOSHADER_glMakeContextCurrent
598
static int impl_GLSL_MaxUniforms(MOJOSHADER_shaderType shader_type)
599
600
601
602
603
604
605
606
607
608
609
610
{
GLenum pname = GL_NONE;
GLint val = 0;
if (shader_type == MOJOSHADER_TYPE_VERTEX)
pname = GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB;
else if (shader_type == MOJOSHADER_TYPE_PIXEL)
pname = GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB;
else
return -1;
ctx->glGetIntegerv(pname, &val);
return (int) val;
611
612
613
} // impl_GLSL_MaxUniforms
614
615
616
617
618
619
620
621
622
623
624
625
static int impl_ARB1_MaxUniforms(MOJOSHADER_shaderType shader_type)
{
GLint retval = 0;
GLenum program_type = GL_NONE;
if (shader_type == MOJOSHADER_TYPE_VERTEX)
program_type = GL_VERTEX_PROGRAM_ARB;
else if (shader_type == MOJOSHADER_TYPE_PIXEL)
program_type = GL_FRAGMENT_PROGRAM_ARB;
else
return -1;
ctx->glGetProgramivARB(program_type, GL_MAX_PROGRAM_PARAMETERS_ARB, &retval);
626
return (int) retval; // !!! FIXME: times four?
627
628
629
} // impl_ARB1_MaxUniforms
630
631
632
int MOJOSHADER_glMaxUniforms(MOJOSHADER_shaderType shader_type)
{
return ctx->profileMaxUniforms(shader_type);
633
634
635
} // MOJOSHADER_glMaxUniforms
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
static int impl_GLSL_CompileShader(const MOJOSHADER_parseData *pd, GLuint *s)
{
GLint ok = 0;
GLint shaderlen = (GLint) pd->output_len;
const GLenum shader_type = (pd->shader_type == MOJOSHADER_TYPE_PIXEL) ? GL_FRAGMENT_SHADER : GL_VERTEX_SHADER;
GLuint shader = ctx->glCreateShaderObject(shader_type);
ctx->glShaderSource(shader, 1, (const GLchar **) &pd->output, &shaderlen);
ctx->glCompileShader(shader);
ctx->glGetObjectParameteriv(shader, GL_OBJECT_COMPILE_STATUS_ARB, &ok);
if (!ok)
{
GLsizei len = 0;
ctx->glGetInfoLog(shader, sizeof (error_buffer), &len,
(GLchar *) error_buffer);
*s = 0;
return 0;
} // if
*s = shader;
return 1;
} // impl_GLSL_CompileShader
661
662
663
664
665
666
667
668
669
static int impl_ARB1_CompileShader(const MOJOSHADER_parseData *pd, GLuint *s)
{
GLint shaderlen = (GLint) pd->output_len;
const GLenum shader_type = (pd->shader_type == MOJOSHADER_TYPE_PIXEL) ? GL_FRAGMENT_PROGRAM_ARB : GL_VERTEX_PROGRAM_ARB;
GLuint shader = 0;
ctx->glGenProgramsARB(1, &shader);
ctx->glGetError(); // flush any existing error state.
ctx->glBindProgramARB(shader_type, shader);
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
#if 0
if (shader_type == GL_FRAGMENT_PROGRAM_ARB) {
const char *prog =
"!!ARBfp1.0\n"
"OUTPUT oC0 = result.color;\n"
"MOV oC0, { 1.0, 0.0, 0.0, 1.0 };\n"
"END\n";
ctx->glProgramStringARB(shader_type, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(prog), prog);
} else
#endif
{
ctx->glProgramStringARB(shader_type, GL_PROGRAM_FORMAT_ASCII_ARB,
shaderlen, pd->output);
}
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
if (ctx->glGetError() == GL_INVALID_OPERATION)
{
GLint pos = 0;
ctx->glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
const GLubyte *errstr = ctx->glGetString(GL_PROGRAM_ERROR_STRING_ARB);
snprintf(error_buffer, sizeof (error_buffer),
"ARB1 compile error at position %d: %s",
(int) pos, (const char *) errstr);
ctx->glBindProgramARB(shader_type, 0);
ctx->glDeleteProgramsARB(1, &shader);
*s = 0;
return 0;
} // if
*s = shader;
return 1;
} // impl_ARB1_CompileShader
707
708
709
710
711
712
static void impl_GLSL_DeleteShader(const GLuint shader)
{
ctx->glDeleteObject(shader);
} // impl_GLSL_DeleteShader
713
714
715
716
717
718
719
static void impl_ARB1_DeleteShader(const GLuint _shader)
{
GLuint shader = _shader; // const removal.
ctx->glDeleteProgramsARB(1, &shader);
} // impl_ARB1_DeleteShader
720
721
722
723
724
725
static void impl_GLSL_DeleteProgram(const GLuint program)
{
ctx->glDeleteObject(program);
} // impl_GLSL_DeleteProgram
726
727
728
729
730
731
static void impl_ARB1_DeleteProgram(const GLuint program)
{
// no-op. ARB1 doesn't have real linked programs.
} // impl_GLSL_DeleteProgram
732
733
734
735
MOJOSHADER_glShader *MOJOSHADER_glCompileShader(const unsigned char *tokenbuf,
const unsigned int bufsize)
{
MOJOSHADER_glShader *retval = NULL;
736
GLuint shader = 0;
737
738
739
740
const MOJOSHADER_parseData *pd = MOJOSHADER_parse(ctx->profile, tokenbuf,
bufsize, ctx->malloc_fn,
ctx->free_fn,
ctx->malloc_data);
741
if (pd->error != NULL)
742
743
{
set_error(pd->error);
744
goto compile_shader_fail;
745
} // if
746
747
748
retval = (MOJOSHADER_glShader *) Malloc(sizeof (MOJOSHADER_glShader));
if (retval == NULL)
749
750
goto compile_shader_fail;
751
if (!ctx->profileCompileShader(pd, &shader))
752
goto compile_shader_fail;
753
754
755
756
757
retval->parseData = pd;
retval->handle = shader;
retval->refcount = 1;
return retval;
758
759
760
761
762
compile_shader_fail:
MOJOSHADER_freeParseData(pd);
Free(retval);
if (shader != 0)
763
ctx->profileDeleteShader(shader);
764
return NULL;
765
766
767
} // MOJOSHADER_glCompileShader
768
769
770
771
772
773
774
const MOJOSHADER_parseData *MOJOSHADER_glGetShaderParseData(
MOJOSHADER_glShader *shader)
{
return (shader != NULL) ? shader->parseData : NULL;
} // MOJOSHADER_glGetShaderParseData
775
776
777
778
static void shader_unref(MOJOSHADER_glShader *shader)
{
if (shader != NULL)
{
779
const uint32 refcount = shader->refcount;
780
if (refcount > 1)
781
shader->refcount--;
782
783
else
{
784
ctx->profileDeleteShader(shader->handle);
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
MOJOSHADER_freeParseData(shader->parseData);
Free(shader);
} // else
} // if
} // shader_unref
static void program_unref(MOJOSHADER_glProgram *program)
{
if (program != NULL)
{
const uint32 refcount = program->refcount;
if (refcount > 1)
program->refcount--;
else
{
801
ctx->profileDeleteProgram(program->handle);
802
803
shader_unref(program->vertex);
shader_unref(program->fragment);
804
Free(program->constants);
805
806
807
Free(program->samplers);
Free(program->uniforms);
Free(program->attributes);
808
809
810
811
812
813
Free(program);
} // else
} // if
} // program_unref
814
815
static GLint impl_GLSL_GetUniformLocation(MOJOSHADER_glProgram *program,
MOJOSHADER_glShader *shader, int idx)
816
{
817
818
return ctx->glGetUniformLocation(program->handle,
shader->parseData->uniforms[idx].name);
819
820
} // impl_GLSL_GetUniformLocation
821
822
823
static GLint impl_ARB1_GetUniformLocation(MOJOSHADER_glProgram *program,
MOJOSHADER_glShader *shader, int idx)
824
{
825
826
assert(shader->parseData->uniforms[idx].type == MOJOSHADER_UNIFORM_FLOAT);
return shader->parseData->uniforms[idx].index; // !!! FIXME: doesn't work if there are int or bool uniforms!
827
828
829
} // impl_ARB1_GetUniformLocation
830
831
832
833
static void lookup_uniforms(MOJOSHADER_glProgram *program,
MOJOSHADER_glShader *shader)
{
const MOJOSHADER_parseData *pd = shader->parseData;
834
const MOJOSHADER_uniform *u = pd->uniforms;
835
const MOJOSHADER_shaderType shader_type = pd->shader_type;
836
int i;
837
838
839
for (i = 0; i < pd->uniform_count; i++)
{
840
const GLint loc = ctx->profileGetUniformLocation(program, shader, i);
841
842
843
if (loc != -1) // maybe the Uniform was optimized out?
{
UniformMap *map = &program->uniforms[program->uniform_count];
844
map->shader_type = shader_type;
845
map->uniform = &u[i];
846
map->location = (GLuint) loc;
847
848
849
850
851
852
program->uniform_count++;
} // if
} // for
} // lookup_uniforms
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
static GLint impl_GLSL_GetSamplerLocation(MOJOSHADER_glProgram *program,
MOJOSHADER_glShader *shader, int idx)
{
return ctx->glGetUniformLocation(program->handle,
shader->parseData->samplers[idx].name);
} // impl_GLSL_GetSamplerLocation
static GLint impl_ARB1_GetSamplerLocation(MOJOSHADER_glProgram *program,
MOJOSHADER_glShader *shader, int idx)
{
return shader->parseData->samplers[idx].index;
} // impl_ARB1_GetSamplerLocation
868
869
870
871
872
873
874
875
876
877
static void lookup_samplers(MOJOSHADER_glProgram *program,
MOJOSHADER_glShader *shader)
{
int i;
const MOJOSHADER_parseData *pd = shader->parseData;
const MOJOSHADER_sampler *s = pd->samplers;
const MOJOSHADER_shaderType shader_type = pd->shader_type;
for (i = 0; i < pd->sampler_count; i++)
{
878
const GLint loc = ctx->profileGetSamplerLocation(program, shader, i);
879
880
881
882
883
884
885
886
887
888
889
890
if (loc != -1) // maybe the Sampler was optimized out?
{
SamplerMap *map = &program->samplers[program->sampler_count];
map->shader_type = shader_type;
map->sampler = &s[i];
map->location = (GLuint) loc;
program->sampler_count++;
} // if
} // for
} // lookup_samplers
891
892
893
894
895
896
897
898
899
900
901
902
903
static GLint impl_GLSL_GetAttribLocation(MOJOSHADER_glProgram *program, int idx)
{
const MOJOSHADER_parseData *pd = program->vertex->parseData;
const MOJOSHADER_attribute *a = pd->attributes;
return ctx->glGetAttribLocation(program->handle, a[idx].name);
} // impl_GLSL_GetAttribLocation
static GLint impl_ARB1_GetAttribLocation(MOJOSHADER_glProgram *program, int idx)
{
return idx; // map to vertex arrays in the same order as the parseData.
} // impl_ARB1_GetAttribLocation
904
905
906
907
static void lookup_attributes(MOJOSHADER_glProgram *program)
{
int i;
const MOJOSHADER_parseData *pd = program->vertex->parseData;
908
const MOJOSHADER_attribute *a = pd->attributes;
909
910
911
for (i = 0; i < pd->attribute_count; i++)
{
912
const GLint loc = ctx->profileGetAttribLocation(program, i);
913
914
915
916
if (loc != -1) // maybe the Attribute was optimized out?
{
AttributeMap *map = &program->attributes[program->attribute_count];
map->attribute = &a[i];
917
map->location = (GLuint) loc;
918
919
920
921
922
923
program->attribute_count++;
} // if
} // for
} // lookup_attributes
924
925
static GLuint impl_GLSL_LinkProgram(MOJOSHADER_glShader *vshader,
MOJOSHADER_glShader *pshader)
926
{
927
const GLuint program = ctx->glCreateProgramObject();
928
929
930
if (vshader != NULL) ctx->glAttachObject(program, vshader->handle);
if (pshader != NULL) ctx->glAttachObject(program, pshader->handle);
931
932
ctx->glLinkProgram(program);
933
934
GLint ok = 0;
935
ctx->glGetObjectParameteriv(program, GL_OBJECT_LINK_STATUS_ARB, &ok);
936
937
938
if (!ok)
{
GLsizei len = 0;
939
ctx->glGetInfoLog(program, sizeof (error_buffer), &len, (GLchar *) error_buffer);
940
941
ctx->glDeleteObject(program);
return 0;
942
} // if
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
return program;
} // impl_GLSL_LinkProgram
static GLuint impl_ARB1_LinkProgram(MOJOSHADER_glShader *vshader,
MOJOSHADER_glShader *pshader)
{
// there is no formal linking in ARB1...just return a unique value.
static GLuint retval = 1;
return retval++;
} // impl_ARB1_LinkProgram
MOJOSHADER_glProgram *MOJOSHADER_glLinkProgram(MOJOSHADER_glShader *vshader,
MOJOSHADER_glShader *pshader)
{
if ((vshader == NULL) && (pshader == NULL))
return NULL;
int numregs = 0;
int consts = 0;
MOJOSHADER_glProgram *retval = NULL;
const GLuint program = ctx->profileLinkProgram(vshader, pshader);
if (program == 0)
goto link_program_fail;
970
971
retval = (MOJOSHADER_glProgram *) Malloc(sizeof (MOJOSHADER_glProgram));
if (retval == NULL)
972
973
goto link_program_fail;
memset(retval, '\0', sizeof (MOJOSHADER_glProgram));
974
975
numregs = 0;
976
977
if (vshader != NULL) numregs += vshader->parseData->uniform_count;
if (pshader != NULL) numregs += pshader->parseData->uniform_count;
978
979
980
981
982
983
984
985
if (numregs > 0)
{
const size_t len = sizeof (UniformMap) * numregs;
retval->uniforms = (UniformMap *) Malloc(len);
if (retval->uniforms == NULL)
goto link_program_fail;
memset(retval->uniforms, '\0', len);
} // if
986
987
988
989
numregs = 0;
if (vshader != NULL) numregs += vshader->parseData->sampler_count;
if (pshader != NULL) numregs += pshader->parseData->sampler_count;
990
991
992
993
994
995
996
997
if (numregs > 0)
{
const size_t len = sizeof (SamplerMap) * numregs;
retval->samplers = (SamplerMap *) Malloc(len);
if (retval->samplers == NULL)
goto link_program_fail;
memset(retval->samplers, '\0', len);
} // if
998
999
1000
retval->handle = program;
retval->vertex = vshader;