/
mojoshader_opengl.c
900 lines (736 loc) · 27.2 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
35
36
#ifdef _MSC_VER
#define snprintf _snprintf
typedef unsigned __int8 uint8;
typedef unsigned __int32 uint32;
typedef unsigned __int32 int32;
#else
#include <stdint.h>
37
38
39
typedef uint8_t uint8;
typedef uint32_t uint32;
typedef int32_t int32;
40
41
42
#endif
#define STATICARRAYLEN(x) ( (sizeof ((x))) / (sizeof ((x)[0])) )
43
44
45
46
47
#ifndef SUPPORT_PROFILE_GLSL
#define SUPPORT_PROFILE_GLSL 1
#endif
48
49
50
struct MOJOSHADER_glShader
{
const MOJOSHADER_parseData *parseData;
51
GLhandleARB handle;
52
53
54
uint32 refcount;
};
55
56
typedef struct
{
57
MOJOSHADER_shaderType shader_type;
58
const MOJOSHADER_uniform *uniform;
59
GLuint location;
60
61
} UniformMap;
62
63
typedef struct
{
64
const MOJOSHADER_attribute *attribute;
65
GLuint location;
66
67
} AttributeMap;
68
69
struct MOJOSHADER_glProgram
{
70
71
MOJOSHADER_glShader *vertex;
MOJOSHADER_glShader *fragment;
72
GLhandleARB handle;
73
uint32 uniform_count;
74
UniformMap *uniforms;
75
uint32 attribute_count;
76
AttributeMap *attributes;
77
78
79
uint32 refcount;
};
80
// Entry points in base OpenGL that lack function pointer prototypes...
81
82
typedef WINGDIAPI void (APIENTRYP PFNGLGETINTEGERVPROC) (GLenum pname, GLint *params);
typedef WINGDIAPI const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC) (GLenum name);
83
84
85
86
87
88
89
90
91
92
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...
93
94
95
96
97
98
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];
99
100
101
102
103
// GL stuff...
int opengl_major;
int opengl_minor;
MOJOSHADER_glProgram *bound_program;
104
char profile[16];
105
106
107
108
109
110
111
112
113
114
115
// Extensions...
int have_base_opengl;
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;
116
PFNGLGETINTEGERVPROC glGetIntegerv;
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
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;
};
static MOJOSHADER_glContext *ctx = NULL;
138
139
140
141
142
143
144
145
146
147
// 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
148
149
150
151
152
153
154
155
156
157
158
159
160
// #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)
{
161
void *retval = ctx->malloc_fn(len, ctx->malloc_data);
162
163
164
if (retval == NULL)
set_error("out of memory");
return retval;
165
166
167
168
} // Malloc
static inline void Free(void *ptr)
{
169
if (ptr != NULL)
170
ctx->free_fn(ptr, ctx->malloc_data);
171
172
173
} // Free
174
175
176
177
178
179
const char *MOJOSHADER_glGetError(void)
{
return error_buffer;
} // MOJOSHADER_glGetError
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
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))
{
202
#define DO_LOOKUP(ext, typ, fn) ctx->fn = (typ) loadsym(lookup, #fn, &ctx->have_##ext)
203
DO_LOOKUP(base_opengl, PFNGLGETSTRINGPROC, glGetString);
204
DO_LOOKUP(base_opengl, PFNGLGETINTEGERVPROC, glGetIntegerv);
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
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);
#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.
233
234
235
else if (!ctx->have_base_opengl)
return 0; // don't bother checking, we're missing basic functionality.
236
// See if it's in the spec for this GL implementation's version.
237
238
if (major >= 0)
{
239
if ( ((ctx->opengl_major << 16) | (ctx->opengl_minor & 0xFFFF)) >=
240
241
242
((major << 16) | (minor & 0xFFFF)) )
return 1;
} // if
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
// 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)
260
ctx->opengl_major = ctx->opengl_minor = 0;
261
else
262
sscanf(verstr, "%d.%d", &ctx->opengl_major, &ctx->opengl_minor);
263
264
265
} // parse_opengl_version
266
static void load_extensions(void *(*lookup)(const char *fnname))
267
{
268
269
const char *extlist = NULL;
270
271
272
273
274
275
ctx->have_base_opengl = 1;
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;
276
277
278
lookup_entry_points(lookup);
279
if (!ctx->have_base_opengl)
280
set_error("missing basic OpenGL entry points");
281
282
283
284
285
else
{
parse_opengl_version((const char *) ctx->glGetString(GL_VERSION));
extlist = (const char *) ctx->glGetString(GL_EXTENSIONS);
} // else
286
287
288
289
290
if (extlist == NULL)
extlist = ""; // just in case.
#define VERIFY_EXT(ext, major, minor) \
291
ctx->have_##ext = verify_extension(#ext, ctx->have_##ext, extlist, major, minor)
292
293
294
295
296
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);
297
VERIFY_EXT(GL_NV_half_float, -1, -1);
298
299
#undef VERIFY_EXT
300
301
302
303
304
305
306
} // load_extensions
static int valid_profile(const char *profile)
{
if (!ctx->have_base_opengl)
return 0;
307
308
309
#define MUST_HAVE(p, x) \
if (!ctx->have_##x) { set_error(#p " profile needs " #x); return 0; }
310
311
312
313
314
if (0) {}
#if SUPPORT_PROFILE_GLSL
else if (strcmp(profile, MOJOSHADER_PROFILE_GLSL) == 0)
315
{
316
317
318
319
320
321
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
322
323
324
else
{
325
set_error("unknown or unsupported profile");
326
327
328
return 0;
} // else
329
#undef MUST_HAVE
330
331
return 1;
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
} // 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,
};
int i;
for (i = 0; i < STATICARRAYLEN(priority); i++)
{
if (valid_profile(priority[i]))
{
retval = priority[i];
break;
} // if
} // for
360
361
362
363
if (retval == NULL)
set_error("no profiles available");
} // if
364
365
366
367
368
369
370
ctx = current_ctx;
return retval;
} // MOJOSHADER_glBestProfile
MOJOSHADER_glContext *MOJOSHADER_glCreateContext(const char *profile,
371
372
373
void *(*lookup)(const char *fnname),
MOJOSHADER_malloc m, MOJOSHADER_free f,
void *d)
374
{
375
MOJOSHADER_glContext *retval = NULL;
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
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;
393
snprintf(ctx->profile, sizeof (ctx->profile), "%s", profile);
394
395
396
load_extensions(lookup);
if (!valid_profile(profile))
397
goto init_fail;
398
399
400
MOJOSHADER_glBindProgram(NULL);
401
retval = ctx;
402
403
ctx = current_ctx;
return retval;
404
405
init_fail:
406
407
408
409
if (ctx != NULL)
f(ctx, d);
ctx = current_ctx;
return NULL;
410
} // MOJOSHADER_glCreateContext
411
412
413
414
415
416
417
418
void MOJOSHADER_glMakeContextCurrent(MOJOSHADER_glContext *_ctx)
{
ctx = _ctx;
} // MOJOSHADER_glMakeContextCurrent
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
int MOJOSHADER_glMaxUniforms(MOJOSHADER_shaderType shader_type)
{
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;
} // MOJOSHADER_glMaxUniforms
435
436
437
438
MOJOSHADER_glShader *MOJOSHADER_glCompileShader(const unsigned char *tokenbuf,
const unsigned int bufsize)
{
MOJOSHADER_glShader *retval = NULL;
439
GLhandleARB shader = 0;
440
441
442
443
const MOJOSHADER_parseData *pd = MOJOSHADER_parse(ctx->profile, tokenbuf,
bufsize, ctx->malloc_fn,
ctx->free_fn,
ctx->malloc_data);
444
445
446
447
GLint ok = 0;
const GLenum shader_type = (pd->shader_type == MOJOSHADER_TYPE_PIXEL) ? GL_FRAGMENT_SHADER : GL_VERTEX_SHADER;
GLint shaderlen = (GLint) pd->output_len;
448
if (pd->error != NULL)
449
450
{
set_error(pd->error);
451
goto compile_shader_fail;
452
} // if
453
454
455
retval = (MOJOSHADER_glShader *) Malloc(sizeof (MOJOSHADER_glShader));
if (retval == NULL)
456
457
goto compile_shader_fail;
458
shader = ctx->glCreateShaderObject(shader_type);
459
460
461
462
ctx->glShaderSource(shader, 1, (const GLchar **) &pd->output, &shaderlen);
ctx->glCompileShader(shader);
ctx->glGetObjectParameteriv(shader, GL_OBJECT_COMPILE_STATUS_ARB, &ok);
463
464
465
466
if (!ok)
{
GLsizei len = 0;
467
ctx->glGetInfoLog(shader, sizeof (error_buffer), &len, (GLchar *) error_buffer);
468
goto compile_shader_fail;
469
470
471
472
473
474
} // if
retval->parseData = pd;
retval->handle = shader;
retval->refcount = 1;
return retval;
475
476
477
478
479
compile_shader_fail:
MOJOSHADER_freeParseData(pd);
Free(retval);
if (shader != 0)
480
ctx->glDeleteObject(shader);
481
return NULL;
482
483
484
} // MOJOSHADER_glCompileShader
485
486
487
488
489
490
491
const MOJOSHADER_parseData *MOJOSHADER_glGetShaderParseData(
MOJOSHADER_glShader *shader)
{
return (shader != NULL) ? shader->parseData : NULL;
} // MOJOSHADER_glGetShaderParseData
492
493
494
495
static void shader_unref(MOJOSHADER_glShader *shader)
{
if (shader != NULL)
{
496
const uint32 refcount = shader->refcount;
497
if (refcount > 1)
498
shader->refcount--;
499
500
else
{
501
ctx->glDeleteObject(shader->handle);
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
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
{
518
ctx->glDeleteObject(program->handle);
519
520
shader_unref(program->vertex);
shader_unref(program->fragment);
521
Free(program->attributes);
522
Free(program->uniforms);
523
524
525
526
527
528
Free(program);
} // else
} // if
} // program_unref
529
530
531
532
533
static void lookup_uniforms(MOJOSHADER_glProgram *program,
MOJOSHADER_glShader *shader)
{
int i;
const MOJOSHADER_parseData *pd = shader->parseData;
534
const MOJOSHADER_uniform *u = pd->uniforms;
535
const MOJOSHADER_shaderType shader_type = pd->shader_type;
536
537
538
for (i = 0; i < pd->uniform_count; i++)
{
539
const GLint loc = ctx->glGetUniformLocation(program->handle, u[i].name);
540
541
542
if (loc != -1) // maybe the Uniform was optimized out?
{
UniformMap *map = &program->uniforms[program->uniform_count];
543
map->shader_type = shader_type;
544
map->uniform = &u[i];
545
map->location = (GLuint) loc;
546
547
548
549
550
551
program->uniform_count++;
} // if
} // for
} // lookup_uniforms
552
553
554
555
static void lookup_attributes(MOJOSHADER_glProgram *program)
{
int i;
const MOJOSHADER_parseData *pd = program->vertex->parseData;
556
const MOJOSHADER_attribute *a = pd->attributes;
557
558
559
for (i = 0; i < pd->attribute_count; i++)
{
560
const GLint loc = ctx->glGetAttribLocation(program->handle, a->name);
561
562
563
564
if (loc != -1) // maybe the Attribute was optimized out?
{
AttributeMap *map = &program->attributes[program->attribute_count];
map->attribute = &a[i];
565
map->location = (GLuint) loc;
566
567
568
569
570
571
program->attribute_count++;
} // if
} // for
} // lookup_attributes
572
573
574
MOJOSHADER_glProgram *MOJOSHADER_glLinkProgram(MOJOSHADER_glShader *vshader,
MOJOSHADER_glShader *pshader)
{
575
576
577
if ((vshader == NULL) && (pshader == NULL))
return NULL;
578
MOJOSHADER_glProgram *retval = NULL;
579
const GLhandleARB program = ctx->glCreateProgramObject();
580
int numregs = 0;
581
582
583
if (vshader != NULL) ctx->glAttachObject(program, vshader->handle);
if (pshader != NULL) ctx->glAttachObject(program, pshader->handle);
584
585
ctx->glLinkProgram(program);
586
587
GLint ok = 0;
588
ctx->glGetObjectParameteriv(program, GL_OBJECT_LINK_STATUS_ARB, &ok);
589
590
591
if (!ok)
{
GLsizei len = 0;
592
ctx->glGetInfoLog(program, sizeof (error_buffer), &len, (GLchar *) error_buffer);
593
594
goto link_program_fail;
} // if
595
596
597
retval = (MOJOSHADER_glProgram *) Malloc(sizeof (MOJOSHADER_glProgram));
if (retval == NULL)
598
599
goto link_program_fail;
memset(retval, '\0', sizeof (MOJOSHADER_glProgram));
600
601
602
if (vshader != NULL) numregs += vshader->parseData->uniform_count;
if (pshader != NULL) numregs += pshader->parseData->uniform_count;
603
604
605
retval->uniforms = (UniformMap *) Malloc(sizeof (UniformMap) * numregs);
if (retval->uniforms == NULL)
goto link_program_fail;
606
memset(retval->uniforms, '\0', sizeof (UniformMap) * numregs);
607
608
609
610
611
retval->handle = program;
retval->vertex = vshader;
retval->fragment = pshader;
retval->refcount = 1;
612
613
if (vshader != NULL)
614
{
615
616
617
618
619
620
retval->attributes = (AttributeMap *) Malloc(sizeof (AttributeMap) *
vshader->parseData->attribute_count);
if (retval->attributes == NULL)
goto link_program_fail;
lookup_attributes(retval);
621
lookup_uniforms(retval, vshader);
622
vshader->refcount++;
623
624
} // if
625
if (pshader != NULL)
626
627
{
lookup_uniforms(retval, pshader);
628
pshader->refcount++;
629
} // if
630
631
return retval;
632
633
634
635
link_program_fail:
if (retval != NULL)
{
636
637
Free(retval->uniforms);
Free(retval->attributes);
638
639
640
Free(retval);
} // if
641
ctx->glDeleteObject(program);
642
return NULL;
643
644
645
646
647
} // MOJOSHADER_glLinkProgram
void MOJOSHADER_glBindProgram(MOJOSHADER_glProgram *program)
{
648
GLhandleARB handle = 0;
649
int i;
650
651
if (program == ctx->bound_program)
652
653
654
return; // nothing to do.
// Disable any client-side arrays the current program could have used.
655
656
// !!! FIXME: don't disable yet...see which ones get reused, and disable
// !!! FIXME: only what we don't need in MOJOSHADER_glProgramReady().
657
if (ctx->bound_program != NULL)
658
{
659
660
const int count = ctx->bound_program->attribute_count;
for (i = 0; i < count; i++)
661
{
662
663
const AttributeMap *map = &ctx->bound_program->attributes[i];
ctx->glDisableVertexAttribArray(map->location);
664
665
666
} // if
} // for
667
668
669
670
671
672
if (program != NULL)
{
handle = program->handle;
program->refcount++;
} // if
673
674
675
ctx->glUseProgramObject(handle);
program_unref(ctx->bound_program);
ctx->bound_program = program;
676
677
678
} // MOJOSHADER_glBindProgram
679
static inline uint minuint(const uint a, const uint b)
680
{
681
682
return ((a < b) ? a : b);
} // minuint
683
684
685
void MOJOSHADER_glSetVertexShaderUniformF(unsigned int idx, const float *data,
686
unsigned int vec4n)
687
{
688
const uint maxregs = STATICARRAYLEN(ctx->vs_reg_file_f) / 4;
689
690
if (idx < maxregs)
{
691
assert(sizeof (GLfloat) == sizeof (float));
692
const uint cpy = (minuint(maxregs - idx, vec4n) * sizeof (*data)) * 4;
693
memcpy(ctx->vs_reg_file_f + (idx * 4), data, cpy);
694
} // if
695
696
697
698
} // MOJOSHADER_glSetVertexShaderUniformF
void MOJOSHADER_glSetVertexShaderUniformI(unsigned int idx, const int *data,
699
unsigned int ivec4n)
700
{
701
const uint maxregs = STATICARRAYLEN(ctx->vs_reg_file_i) / 4;
702
703
if (idx < maxregs)
{
704
assert(sizeof (GLint) == sizeof (int));
705
const uint cpy = (minuint(maxregs - idx, ivec4n) * sizeof (*data)) * 4;
706
memcpy(ctx->vs_reg_file_i + (idx * 4), data, cpy);
707
} // if
708
709
710
711
712
713
} // MOJOSHADER_glSetVertexShaderUniformI
void MOJOSHADER_glSetVertexShaderUniformB(unsigned int idx, const int *data,
unsigned int bcount)
{
714
const uint maxregs = STATICARRAYLEN(ctx->vs_reg_file_f) / 4;
715
716
if (idx < maxregs)
{
717
GLint *wptr = ctx->vs_reg_file_b + idx;
718
GLint *endptr = wptr + minuint(maxregs - idx, bcount);
719
720
721
while (wptr != endptr)
*(wptr++) = *(data++) ? 1 : 0;
} // if
722
723
724
725
} // MOJOSHADER_glSetVertexShaderUniformB
void MOJOSHADER_glSetPixelShaderUniformF(unsigned int idx, const float *data,
726
unsigned int vec4n)
727
{
728
const uint maxregs = STATICARRAYLEN(ctx->ps_reg_file_f) / 4;
729
730
if (idx < maxregs)
{
731
assert(sizeof (GLfloat) == sizeof (float));
732
const uint cpy = (minuint(maxregs - idx, vec4n) * sizeof (*data)) * 4;
733
memcpy(ctx->ps_reg_file_f + (idx * 4), data, cpy);
734
} // if
735
736
737
738
} // MOJOSHADER_glSetPixelShaderUniformF
void MOJOSHADER_glSetPixelShaderUniformI(unsigned int idx, const int *data,
739
unsigned int ivec4n)
740
{
741
const uint maxregs = STATICARRAYLEN(ctx->ps_reg_file_i) / 4;
742
743
if (idx < maxregs)
{
744
assert(sizeof (GLint) == sizeof (int));
745
const uint cpy = (minuint(maxregs - idx, ivec4n) * sizeof (*data)) * 4;
746
memcpy(ctx->ps_reg_file_i + (idx * 4), data, cpy);
747
} // if
748
749
750
751
} // MOJOSHADER_glSetPixelShaderUniformI
void MOJOSHADER_glSetPixelShaderUniformB(unsigned int idx, const int *data,
752
unsigned int bcount)
753
{
754
const uint maxregs = STATICARRAYLEN(ctx->ps_reg_file_f) / 4;
755
756
if (idx < maxregs)
{
757
GLint *wptr = ctx->ps_reg_file_b + idx;
758
GLint *endptr = wptr + minuint(maxregs - idx, bcount);
759
760
761
while (wptr != endptr)
*(wptr++) = *(data++) ? 1 : 0;
} // if
762
763
764
} // MOJOSHADER_glSetPixelShaderUniformB
765
766
767
768
static inline GLenum opengl_attr_type(const MOJOSHADER_attributeType type)
{
switch (type)
{
769
case MOJOSHADER_ATTRIBUTE_UNKNOWN: return GL_NONE; // oh well.
770
771
772
case MOJOSHADER_ATTRIBUTE_BYTE: return GL_BYTE;
case MOJOSHADER_ATTRIBUTE_UBYTE: return GL_UNSIGNED_BYTE;
case MOJOSHADER_ATTRIBUTE_SHORT: return GL_SHORT;
773
case MOJOSHADER_ATTRIBUTE_USHORT: return GL_UNSIGNED_SHORT;
774
775
776
777
case MOJOSHADER_ATTRIBUTE_INT: return GL_INT;
case MOJOSHADER_ATTRIBUTE_UINT: return GL_UNSIGNED_INT;
case MOJOSHADER_ATTRIBUTE_FLOAT: return GL_FLOAT;
case MOJOSHADER_ATTRIBUTE_DOUBLE: return GL_DOUBLE;
778
779
case MOJOSHADER_ATTRIBUTE_HALF_FLOAT:
780
if (ctx->have_GL_NV_half_float)
781
782
return GL_HALF_FLOAT_NV;
break;
783
784
785
786
787
788
} // switch
return GL_NONE; // oh well. Raises a GL error later.
} // opengl_attr_type
789
790
791
792
793
794
void MOJOSHADER_glSetVertexAttribute(MOJOSHADER_usage usage,
int index, unsigned int size,
MOJOSHADER_attributeType type,
int normalized, unsigned int stride,
const void *ptr)
{
795
if ((ctx->bound_program == NULL) || (ctx->bound_program->vertex == NULL))
796
797
return;
798
799
800
const GLenum gl_type = opengl_attr_type(type);
const GLboolean norm = (normalized) ? GL_TRUE : GL_FALSE;
GLuint gl_index = 0;
801
802
803
804
// We have to map POSITION0 to generic vertex attribute 0; the
// GL_ARB_vertex_shader spec says this is equivalent to using
// glVertexPointer(), but without the limitations of that entry point.
805
806
if ((usage != MOJOSHADER_USAGE_POSITION) || (index != 0))
807
{
808
809
810
811
812
813
int i;
const int count = ctx->bound_program->attribute_count;
for (i = 0; i < count; i++)
{
const AttributeMap *map = &ctx->bound_program->attributes[i];
const MOJOSHADER_attribute *a = map->attribute;
814
815
816
// !!! FIXME: is this array guaranteed to be sorted by usage?
// !!! FIXME: if so, we can break if a->usage > usage.
817
818
819
820
821
822
823
if ((a->usage == usage) && (a->index == index))
{
gl_index = map->location;
break;
} // if
} // for
824
825
826
if (gl_index == 0)
return; // nothing to do, this shader doesn't use this stream.
827
} // if
828
829
830
ctx->glVertexAttribPointer(gl_index, size, gl_type, norm, stride, ptr);
ctx->glEnableVertexAttribArray(gl_index);
831
832
833
834
835
} // MOJOSHADER_glSetVertexAttribute
void MOJOSHADER_glProgramReady(void)
{
836
837
int i;
838
if (ctx->bound_program == NULL)
839
840
841
842
843
return; // nothing to do.
// !!! FIXME: don't push Uniforms if we know they haven't changed.
// push Uniforms to the program from our register files...
844
845
const int count = ctx->bound_program->uniform_count;
for (i = 0; i < count; i++)
846
{
847
const UniformMap *map = &ctx->bound_program->uniforms[i];
848
849
850
851
852
853
854
855
856
const MOJOSHADER_uniform *u = map->uniform;
const MOJOSHADER_uniformType type = u->type;
const MOJOSHADER_shaderType shader_type = map->shader_type;
const int index = u->index;
const GLint location = map->location;
if (shader_type == MOJOSHADER_TYPE_VERTEX)
{
if (type == MOJOSHADER_UNIFORM_FLOAT)
857
ctx->glUniform4fv(location, 1, &ctx->vs_reg_file_f[index * 4]);
858
else if (type == MOJOSHADER_UNIFORM_INT)
859
ctx->glUniform4iv(location, 1, &ctx->vs_reg_file_i[index * 4]);
860
else if (type == MOJOSHADER_UNIFORM_BOOL)
861
ctx->glUniform1i(location, ctx->vs_reg_file_b[index]);
862
863
864
865
866
} // if
else if (shader_type == MOJOSHADER_TYPE_PIXEL)
{
if (type == MOJOSHADER_UNIFORM_FLOAT)
867
ctx->glUniform4fv(location, 1, &ctx->ps_reg_file_f[index * 4]);
868
else if (type == MOJOSHADER_UNIFORM_INT)
869
ctx->glUniform4iv(location, 1, &ctx->ps_reg_file_i[index * 4]);
870
else if (type == MOJOSHADER_UNIFORM_BOOL)
871
ctx->glUniform1i(location, ctx->ps_reg_file_b[index]);
872
873
} // else if
} // for
874
875
876
} // MOJOSHADER_glProgramReady
877
void MOJOSHADER_glDeleteProgram(MOJOSHADER_glProgram *program)
878
{
879
program_unref(program);
880
881
882
} // MOJOSHADER_glDeleteProgram
883
void MOJOSHADER_glDeleteShader(MOJOSHADER_glShader *shader)
884
885
886
887
888
{
shader_unref(shader);
} // MOJOSHADER_glDeleteShader
889
void MOJOSHADER_glDestroyContext(MOJOSHADER_glContext *_ctx)
890
{
891
892
MOJOSHADER_glContext *current_ctx = ctx;
ctx = _ctx;
893
MOJOSHADER_glBindProgram(NULL);
894
lookup_entry_points(NULL);
895
896
Free(ctx);
ctx = ((current_ctx == _ctx) ? NULL : current_ctx);
897
} // MOJOSHADER_glDestroyContext
898
899
// end of mojoshader_opengl.c ...