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