/
mojoshader_opengl.c
834 lines (686 loc) · 26.2 KB
1
2
3
4
5
6
7
8
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdarg.h>
#include <assert.h>
#include "mojoshader.h"
9
10
11
#define GL_GLEXT_LEGACY 1
#include "gl.h"
#include "glext.h"
12
13
14
// Get basic wankery out of the way here...
15
16
#define STATICARRAYLEN(x) ( (sizeof ((x))) / (sizeof ((x)[0])) )
17
18
19
20
21
22
23
24
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;
25
GLhandleARB handle;
26
27
28
uint32 refcount;
};
29
30
typedef struct
{
31
MOJOSHADER_shaderType shader_type;
32
const MOJOSHADER_uniform *uniform;
33
GLuint location;
34
35
} UniformMap;
36
37
typedef struct
{
38
const MOJOSHADER_attribute *attribute;
39
GLuint location;
40
41
} AttributeMap;
42
43
struct MOJOSHADER_glProgram
{
44
45
MOJOSHADER_glShader *vertex;
MOJOSHADER_glShader *fragment;
46
GLhandleARB handle;
47
uint32 uniform_count;
48
UniformMap *uniforms;
49
uint32 attribute_count;
50
AttributeMap *attributes;
51
52
53
uint32 refcount;
};
54
// A few entry points in base OpenGL that lack function pointer prototypes...
55
56
57
58
59
typedef WINGDIAPI const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC) (GLenum name);
typedef WINGDIAPI void (APIENTRYP PFNGLDISABLECLIENTSTATEPROC) (GLenum array);
typedef WINGDIAPI void (APIENTRYP PFNGLENABLECLIENTSTATEPROC) (GLenum array);
typedef WINGDIAPI void (APIENTRYP PFNGLVERTEXPOINTERPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
60
61
62
63
64
65
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
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;
PFNGLDISABLECLIENTSTATEPROC glDisableClientState;
PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArray;
PFNGLENABLECLIENTSTATEPROC glEnableClientState;
PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArray;
PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocation;
PFNGLGETINFOLOGARBPROC glGetInfoLog;
PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameteriv;
PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocation;
PFNGLLINKPROGRAMARBPROC glLinkProgram;
PFNGLSHADERSOURCEARBPROC glShaderSource;
PFNGLUNIFORM1IARBPROC glUniform1i;
PFNGLUNIFORM4FVARBPROC glUniform4fv;
PFNGLUNIFORM4IVARBPROC glUniform4iv;
PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObject;
PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointer;
PFNGLVERTEXPOINTERPROC glVertexPointer;
};
static MOJOSHADER_glContext *ctx = NULL;
116
117
118
119
120
121
122
123
124
125
// 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
126
127
128
129
130
131
132
133
134
135
136
137
138
// #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)
{
139
void *retval = ctx->malloc_fn(len, ctx->malloc_data);
140
141
142
if (retval == NULL)
set_error("out of memory");
return retval;
143
144
145
146
} // Malloc
static inline void Free(void *ptr)
{
147
if (ptr != NULL)
148
ctx->free_fn(ptr, ctx->malloc_data);
149
150
151
} // Free
152
153
154
155
156
157
const char *MOJOSHADER_glGetError(void)
{
return error_buffer;
} // MOJOSHADER_glGetError
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
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))
{
180
#define DO_LOOKUP(ext, typ, fn) ctx->fn = (typ) loadsym(lookup, #fn, &ctx->have_##ext)
181
182
183
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(base_opengl, PFNGLDISABLECLIENTSTATEPROC, glDisableClientState);
DO_LOOKUP(base_opengl, PFNGLENABLECLIENTSTATEPROC, glEnableClientState);
DO_LOOKUP(base_opengl, PFNGLVERTEXPOINTERPROC, glVertexPointer);
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
if (ctx->bound_program != NULL)
568
{
569
570
571
ctx->glDisableClientState(GL_VERTEX_ARRAY);
const int count = ctx->bound_program->attribute_count;
for (i = 0; i < count; i++)
572
{
573
574
const AttributeMap *map = &ctx->bound_program->attributes[i];
ctx->glDisableVertexAttribArray(map->location);
575
576
577
} // if
} // for
578
579
580
581
582
583
if (program != NULL)
{
handle = program->handle;
program->refcount++;
} // if
584
585
586
ctx->glUseProgramObject(handle);
program_unref(ctx->bound_program);
ctx->bound_program = program;
587
588
589
} // MOJOSHADER_glBindProgram
590
591
592
593
594
595
static inline uint maxuint(const uint a, const uint b)
{
return ((a > b) ? a : b);
} // maxuint
596
void MOJOSHADER_glSetVertexShaderUniformF(unsigned int idx, const float *data,
597
unsigned int vec4n)
598
{
599
const uint maxregs = STATICARRAYLEN(ctx->vs_reg_file_f) / 4;
600
601
if (idx < maxregs)
{
602
const uint cpy = (maxuint(maxregs - idx, vec4n) * sizeof (*data)) * 4;
603
memcpy(ctx->vs_reg_file_f + (idx * 4), data, cpy);
604
} // if
605
606
607
608
} // MOJOSHADER_glSetVertexShaderUniformF
void MOJOSHADER_glSetVertexShaderUniformI(unsigned int idx, const int *data,
609
unsigned int ivec4n)
610
{
611
const uint maxregs = STATICARRAYLEN(ctx->vs_reg_file_i) / 4;
612
613
if (idx < maxregs)
{
614
const uint cpy = (maxuint(maxregs - idx, ivec4n) * sizeof (*data)) * 4;
615
memcpy(ctx->vs_reg_file_i + (idx * 4), data, cpy);
616
} // if
617
618
619
620
621
622
} // MOJOSHADER_glSetVertexShaderUniformI
void MOJOSHADER_glSetVertexShaderUniformB(unsigned int idx, const int *data,
unsigned int bcount)
{
623
const uint maxregs = STATICARRAYLEN(ctx->vs_reg_file_f) / 4;
624
625
if (idx < maxregs)
{
626
uint8 *wptr = ctx->vs_reg_file_b + idx;
627
628
629
630
uint8 *endptr = wptr + maxuint(maxregs - idx, bcount);
while (wptr != endptr)
*(wptr++) = *(data++) ? 1 : 0;
} // if
631
632
633
634
} // MOJOSHADER_glSetVertexShaderUniformB
void MOJOSHADER_glSetPixelShaderUniformF(unsigned int idx, const float *data,
635
unsigned int vec4n)
636
{
637
const uint maxregs = STATICARRAYLEN(ctx->ps_reg_file_f) / 4;
638
639
if (idx < maxregs)
{
640
const uint cpy = (maxuint(maxregs - idx, vec4n) * sizeof (*data)) * 4;
641
memcpy(ctx->ps_reg_file_f + (idx * 4), data, cpy);
642
} // if
643
644
645
646
} // MOJOSHADER_glSetPixelShaderUniformF
void MOJOSHADER_glSetPixelShaderUniformI(unsigned int idx, const int *data,
647
unsigned int ivec4n)
648
{
649
const uint maxregs = STATICARRAYLEN(ctx->ps_reg_file_i) / 4;
650
651
if (idx < maxregs)
{
652
const uint cpy = (maxuint(maxregs - idx, ivec4n) * sizeof (*data)) * 4;
653
memcpy(ctx->ps_reg_file_i + (idx * 4), data, cpy);
654
} // if
655
656
657
658
} // MOJOSHADER_glSetPixelShaderUniformI
void MOJOSHADER_glSetPixelShaderUniformB(unsigned int idx, const int *data,
659
unsigned int bcount)
660
{
661
const uint maxregs = STATICARRAYLEN(ctx->ps_reg_file_f) / 4;
662
663
if (idx < maxregs)
{
664
uint8 *wptr = ctx->ps_reg_file_b + idx;
665
666
667
668
uint8 *endptr = wptr + maxuint(maxregs - idx, bcount);
while (wptr != endptr)
*(wptr++) = *(data++) ? 1 : 0;
} // if
669
670
671
} // MOJOSHADER_glSetPixelShaderUniformB
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
static inline GLenum opengl_posattr_type(const MOJOSHADER_attributeType type)
{
// we don't ever use the glVertexPointer() stream, so we just need to
// make the data types reasonably match, so the GL doesn't overrun
// the buffer when dereferencing it.
switch (type)
{
case MOJOSHADER_ATTRIBUTE_BYTE: return GL_NONE; // oh well.
case MOJOSHADER_ATTRIBUTE_UBYTE: return GL_NONE; // oh well.
case MOJOSHADER_ATTRIBUTE_SHORT: return GL_SHORT;
case MOJOSHADER_ATTRIBUTE_USHORT: return GL_SHORT;
case MOJOSHADER_ATTRIBUTE_INT: return GL_INT;
case MOJOSHADER_ATTRIBUTE_UINT: return GL_INT;
case MOJOSHADER_ATTRIBUTE_FLOAT: return GL_FLOAT;
case MOJOSHADER_ATTRIBUTE_DOUBLE: return GL_DOUBLE;
688
case MOJOSHADER_ATTRIBUTE_HALF_FLOAT: return GL_SHORT;
689
690
691
692
693
694
695
696
697
698
699
700
701
} // switch
return GL_NONE; // oh well. Raises a GL error later.
} // opengl_posattr_type
static inline GLenum opengl_attr_type(const MOJOSHADER_attributeType type)
{
switch (type)
{
case MOJOSHADER_ATTRIBUTE_BYTE: return GL_BYTE;
case MOJOSHADER_ATTRIBUTE_UBYTE: return GL_UNSIGNED_BYTE;
case MOJOSHADER_ATTRIBUTE_SHORT: return GL_SHORT;
702
case MOJOSHADER_ATTRIBUTE_USHORT: return GL_UNSIGNED_SHORT;
703
704
705
706
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;
707
708
case MOJOSHADER_ATTRIBUTE_HALF_FLOAT:
709
if (ctx->have_GL_NV_half_float)
710
711
return GL_HALF_FLOAT_NV;
break;
712
713
714
715
716
717
} // switch
return GL_NONE; // oh well. Raises a GL error later.
} // opengl_attr_type
718
719
720
721
722
723
void MOJOSHADER_glSetVertexAttribute(MOJOSHADER_usage usage,
int index, unsigned int size,
MOJOSHADER_attributeType type,
int normalized, unsigned int stride,
const void *ptr)
{
724
if ((ctx->bound_program == NULL) || (ctx->bound_program->vertex == NULL))
725
726
727
728
729
730
731
732
733
734
735
return;
// Since glVertexPointer() lacks the flexibility that we can get from
// glVertexAttribPointer(), we set POSITION0 to a generic vertex
// attribute, and the shaders we generate know to look there instead of
// GLSL's gl_Position global variable. But to keep the GL handy, we
// also set the best possible equivalent with glVertexPointer(). Messy.
if ((usage == MOJOSHADER_USAGE_POSITION) && (index == 0))
{
// !!! FIXME: fails if size==1.
736
737
ctx->glVertexPointer(size, opengl_posattr_type(type), stride, ptr);
ctx->glEnableClientState(GL_VERTEX_ARRAY);
738
739
740
741
} // if
int i;
GLuint gl_index = 0;
742
743
const int count = ctx->bound_program->attribute_count;
for (i = 0; i < count; i++)
744
{
745
const AttributeMap *map = &ctx->bound_program->attributes[i];
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
const MOJOSHADER_attribute *a = map->attribute;
// !!! FIXME: is this array guaranteed to be sorted by usage?
// !!! FIXME: if so, we can break out of the loop if a->usage > usage.
if ((a->usage == usage) && (a->index == index))
{
gl_index = map->location;
break;
} // if
} // for
if (gl_index != 0)
{
const GLenum gl_type = opengl_attr_type(type);
761
const GLboolean norm = (normalized) ? GL_TRUE : GL_FALSE;
762
763
ctx->glVertexAttribPointer(gl_index, size, gl_type, norm, stride, ptr);
ctx->glEnableVertexAttribArray(gl_index);
764
} // if
765
766
767
768
769
} // MOJOSHADER_glSetVertexAttribute
void MOJOSHADER_glProgramReady(void)
{
770
771
int i;
772
if (ctx->bound_program == NULL)
773
774
775
776
777
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...
778
779
const int count = ctx->bound_program->uniform_count;
for (i = 0; i < count; i++)
780
{
781
const UniformMap *map = &ctx->bound_program->uniforms[i];
782
783
784
785
786
787
788
789
790
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)
791
ctx->glUniform4fv(location, 1, &ctx->vs_reg_file_f[index * 4]);
792
else if (type == MOJOSHADER_UNIFORM_INT)
793
ctx->glUniform4iv(location, 1, &ctx->vs_reg_file_i[index * 4]);
794
else if (type == MOJOSHADER_UNIFORM_BOOL)
795
ctx->glUniform1i(location, ctx->vs_reg_file_b[index]);
796
797
798
799
800
} // if
else if (shader_type == MOJOSHADER_TYPE_PIXEL)
{
if (type == MOJOSHADER_UNIFORM_FLOAT)
801
ctx->glUniform4fv(location, 1, &ctx->ps_reg_file_f[index * 4]);
802
else if (type == MOJOSHADER_UNIFORM_INT)
803
ctx->glUniform4iv(location, 1, &ctx->ps_reg_file_i[index * 4]);
804
else if (type == MOJOSHADER_UNIFORM_BOOL)
805
ctx->glUniform1i(location, ctx->ps_reg_file_b[index]);
806
807
} // else if
} // for
808
809
810
} // MOJOSHADER_glProgramReady
811
void MOJOSHADER_glDeleteProgram(MOJOSHADER_glProgram *program)
812
{
813
program_unref(program);
814
815
816
} // MOJOSHADER_glDeleteProgram
817
void MOJOSHADER_glDeleteShader(MOJOSHADER_glShader *shader)
818
819
820
821
822
{
shader_unref(shader);
} // MOJOSHADER_glDeleteShader
823
void MOJOSHADER_glDestroyContext(MOJOSHADER_glContext *_ctx)
824
{
825
826
MOJOSHADER_glContext *current_ctx = ctx;
ctx = _ctx;
827
MOJOSHADER_glBindProgram(NULL);
828
lookup_entry_points(NULL);
829
830
Free(ctx);
ctx = ((current_ctx == _ctx) ? NULL : current_ctx);
831
} // MOJOSHADER_glDestroyContext
832
833
// end of mojoshader_opengl.c ...