/
mojoshader.c
2721 lines (2239 loc) · 79.4 KB
1
/**
2
3
* MojoShader; generate shader programs from bytecode of compiled
* Direct3D shaders.
4
5
6
7
8
9
*
* Please see the file LICENSE.txt in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
10
11
// !!! FIXME: I keep changing coding styles for symbols and typedefs.
12
13
14
// !!! FIXME: do DEF* and DCL_* opcodes have to come before instructions?
// !!! FIXME: my reading of the msdn spec suggests no.
15
16
17
// Shader bytecode format is described at MSDN:
// http://msdn2.microsoft.com/en-us/library/ms800307.aspx
18
#include <stdio.h>
19
#include <string.h>
20
#include <stdlib.h>
21
#include <stdint.h>
22
#include <stdarg.h>
23
#include <assert.h>
24
25
#include "mojoshader.h"
26
27
28
29
30
31
// This is the highest shader version we currently support.
#define MAX_SHADER_MAJOR 3
#define MAX_SHADER_MINOR 0
32
33
34
// You get all the profiles unless you go out of your way to disable them.
35
36
37
38
39
40
41
42
#ifndef SUPPORT_PROFILE_D3D
#define SUPPORT_PROFILE_D3D 1
#endif
#ifndef SUPPORT_PROFILE_GLSL
#define SUPPORT_PROFILE_GLSL 1
#endif
43
44
45
46
47
48
// Get basic wankery out of the way here...
typedef unsigned int uint; // this is a printf() helper. don't use for code.
typedef uint8_t uint8;
typedef uint32_t uint32;
49
typedef int32_t int32;
50
51
52
53
54
55
56
#ifdef __GNUC__
#define ISPRINTF(x,y) __attribute__((format (printf, x, y)))
#else
#define ISPRINTF(x,y)
#endif
57
58
#define STATICARRAYLEN(x) ( (sizeof ((x))) / (sizeof ((x)[0])) )
59
60
61
62
63
64
65
#ifdef _WINDOWS // !!! FIXME: bleh
const char *endline_str = "\r\n";
#else
const char *endline_str = "\n";
#endif
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
// Byteswap magic...
#if ((defined __GNUC__) && (defined __POWERPC__))
static inline uint32 SWAP32(uint32 x)
{
__asm__ __volatile__("lwbrx %0,0,%1" : "=r" (x) : "r" (&x));
return x;
} // SWAP32
#elif defined(__POWERPC__)
static inline uint32 SWAP32(uint32 x)
{
return ( (((x) >> 24) & 0x000000FF) | (((x) >> 8) & 0x0000FF00) |
(((x) << 8) & 0x00FF0000) | (((x) << 24) & 0xFF000000) );
} // SWAP32
#else
# define SWAP32(x) (x)
#endif
85
86
// predeclare.
87
typedef struct Context Context;
88
89
// one emit function for each opcode in each profile.
90
typedef void (*emit_function)(Context *ctx);
91
92
// one emit function for comments in each profile.
93
typedef void (*emit_comment)(Context *ctx, const char *str);
94
95
// one emit function for starting output in each profile.
96
typedef void (*emit_start)(Context *ctx);
97
98
// one emit function for ending output in each profile.
99
typedef void (*emit_end)(Context *ctx);
100
101
102
103
// one args function for each possible sequence of opcode arguments.
typedef int (*args_function)(Context *ctx);
104
// one state function for each opcode where we have state machine updates.
105
typedef void (*state_function)(Context *ctx);
106
107
108
109
110
111
112
typedef struct
{
const char *name;
emit_start start_emitter;
emit_end end_emitter;
emit_comment comment_emitter;
113
} Profile;
114
115
typedef MOJOSHADER_shaderType ShaderType;
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
typedef enum
{
REGISTER_TYPE_TEMP = 0,
REGISTER_TYPE_INPUT = 1,
REGISTER_TYPE_CONST = 2,
REGISTER_TYPE_ADDR = 3,
REGISTER_TYPE_TEXTURE = 3, // ALSO 3!
REGISTER_TYPE_RASTOUT = 4,
REGISTER_TYPE_ATTROUT = 5,
REGISTER_TYPE_TEXCRDOUT = 6,
REGISTER_TYPE_OUTPUT = 6, // ALSO 6!
REGISTER_TYPE_CONSTINT = 7,
REGISTER_TYPE_COLOROUT = 8,
REGISTER_TYPE_DEPTHOUT = 9,
REGISTER_TYPE_SAMPLER = 10,
REGISTER_TYPE_CONST2 = 11,
REGISTER_TYPE_CONST3 = 12,
REGISTER_TYPE_CONST4 = 13,
REGISTER_TYPE_CONSTBOOL = 14,
REGISTER_TYPE_LOOP = 15,
REGISTER_TYPE_TEMPFLOAT16 = 16,
REGISTER_TYPE_MISCTYPE = 17,
REGISTER_TYPE_LABEL = 18,
REGISTER_TYPE_PREDICATE = 19,
REGISTER_TYPE_MAX = 19
142
} RegisterType;
143
144
145
146
147
148
149
typedef enum
{
RASTOUT_TYPE_POSITION = 0,
RASTOUT_TYPE_FOG = 1,
RASTOUT_TYPE_POINT_SIZE = 2,
RASTOUT_TYPE_MAX = 2
150
} RastOutType;
151
152
153
154
155
156
typedef enum
{
MISCTYPE_TYPE_POSITION = 0,
MISCTYPE_TYPE_FACE = 1,
MISCTYPE_TYPE_MAX = 1
157
} MiscTypeType;
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
typedef enum
{
DECLUSAGE_POSITION = 0,
DECLUSAGE_BLENDWEIGHT = 1,
DECLUSAGE_BLENDINDICES = 2,
DECLUSAGE_NORMAL = 3,
DECLUSAGE_PSIZE = 4,
DECLUSAGE_TEXCOORD = 5,
DECLUSAGE_TANGENT = 6,
DECLUSAGE_BINORMAL = 7,
DECLUSAGE_TESSFACTOR = 8,
DECLUSAGE_POSITIONT = 9,
DECLUSAGE_COLOR = 10,
DECLUSAGE_FOG = 11,
DECLUSAGE_DEPTH = 12,
DECLUSAGE_SAMPLE = 13
175
} DeclUsageType;
176
177
178
179
180
181
typedef enum
{
TEXTURE_TYPE_2D = 2,
TEXTURE_TYPE_CUBE = 3,
TEXTURE_TYPE_VOLUME = 4,
182
} TextureType;
183
184
185
186
187
// A simple linked list of strings, so we can build the final output without
// realloc()ing for each new line, and easily insert lines into the middle
// of the output without much trouble.
188
typedef struct OutputListNode
189
190
{
char *str;
191
192
193
194
195
196
197
struct OutputListNode *next;
} OutputListNode;
typedef struct OutputList
{
OutputListNode head;
OutputListNode *tail;
198
199
} OutputList;
200
201
202
203
204
205
// result modifiers.
#define MOD_SATURATE 0x01
#define MOD_PP 0x02
#define MOD_CENTROID 0x04
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
// source modifiers.
typedef enum
{
SRCMOD_NONE,
SRCMOD_NEGATE,
SRCMOD_BIAS,
SRCMOD_BIASNEGATE,
SRCMOD_SIGN,
SRCMOD_SIGNNEGATE,
SRCMOD_COMPLEMENT,
SRCMOD_X2,
SRCMOD_X2NEGATE,
SRCMOD_DZ,
SRCMOD_DW,
SRCMOD_ABS,
SRCMOD_ABSNEGATE,
SRCMOD_NOT,
SRCMOD_TOTAL
224
} SourceMod;
225
226
227
228
typedef struct
{
229
const uint32 *token; // this is the unmolested token in the stream.
230
231
int regnum;
int relative;
232
233
234
235
236
int writemask; // xyzw or rgba (all four, not split out).
int writemask0; // x or red
int writemask1; // y or green
int writemask2; // z or blue
int writemask3; // w or alpha
237
238
239
240
241
242
243
int result_mod;
int result_shift;
int regtype;
} DestArgInfo;
typedef struct
{
244
const uint32 *token; // this is the unmolested token in the stream.
245
246
int regnum;
int relative;
247
int swizzle; // xyzw (all four, not split out).
248
249
250
251
252
253
254
255
256
int swizzle_x;
int swizzle_y;
int swizzle_z;
int swizzle_w;
int src_mod;
int regtype;
} SourceArgInfo;
257
258
#define SCRATCH_BUFFER_SIZE 256
#define SCRATCH_BUFFERS 10
259
260
// Context...this is state that changes as we parse through a shader...
261
struct Context
262
{
263
264
MOJOSHADER_malloc malloc;
MOJOSHADER_free free;
265
266
const uint32 *tokens;
uint32 tokencount;
267
268
269
270
271
OutputList *output;
OutputList globals;
OutputList subroutines;
OutputList mainline;
int output_len; // total strlen; prevents walking the lists just to malloc.
272
int indent;
273
274
275
const char *endline;
int endline_len;
const char *failstr;
276
char scratch[SCRATCH_BUFFERS][SCRATCH_BUFFER_SIZE];
277
278
int scratchidx; // current scratch buffer.
int profileid;
279
280
const Profile *profile;
ShaderType shader_type;
281
282
uint8 major_ver;
uint8 minor_ver;
283
284
DestArgInfo dest_args[1];
SourceArgInfo source_args[4];
285
uint32 dwords[4];
286
int instruction_count;
287
uint32 instruction_controls;
288
289
290
};
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
// Shader model version magic.
static inline uint32 ver_ui32(const uint8 major, const uint8 minor)
{
return ( (((uint32) major) << 16) | (((minor) == 0xFF) ? 0 : (minor)) );
} // version_ui32
static int shader_version_supported(uint8 maj, uint8 min)
{
return (ver_ui32(maj,min) <= ver_ui32(MAX_SHADER_MAJOR, MAX_SHADER_MINOR));
} // shader_version_supported
static int shader_version_atleast(const Context *ctx, uint8 maj, uint8 min)
{
return (ver_ui32(ctx->major_ver, ctx->minor_ver) >= ver_ui32(maj, min));
} // shader_version_atleast
309
static inline char *get_scratch_buffer(Context *ctx)
310
{
311
ctx->scratchidx = (ctx->scratchidx + 1) % SCRATCH_BUFFERS;
312
return ctx->scratch[ctx->scratchidx];
313
314
} // get_scratch_buffer
315
316
317
// Special-case return values from the parsing pipeline...
#define FAIL (-1)
318
319
#define NOFAIL (-2)
#define END_OF_STREAM (-3)
320
321
static inline int isfail(const Context *ctx)
322
323
324
325
326
{
return (ctx->failstr != NULL);
} // isfail
327
328
329
330
331
static MOJOSHADER_parseData out_of_mem_data = {
"Out of memory", 0, 0, 0, MOJOSHADER_TYPE_UNKNOWN, 0, 0, 0, 0
};
static const char *out_of_mem_str = "Out of memory";
332
333
334
static inline int out_of_memory(Context *ctx)
{
if (ctx->failstr == NULL)
335
ctx->failstr = out_of_mem_str; // fail() would call malloc().
336
337
338
339
340
341
return FAIL;
} // out_of_memory
static int failf(Context *ctx, const char *fmt, ...) ISPRINTF(2,3);
static int failf(Context *ctx, const char *fmt, ...)
342
{
343
344
if (ctx->failstr == NULL) // don't change existing error.
{
345
char *scratch = get_scratch_buffer(ctx);
346
347
va_list ap;
va_start(ap, fmt);
348
const int len = vsnprintf(scratch,SCRATCH_BUFFER_SIZE,fmt,ap);
349
350
va_end(ap);
351
352
353
354
355
356
char *failstr = (char *) ctx->malloc(len + 1);
if (failstr == NULL)
out_of_memory(ctx);
else
{
// see comments about scratch buffer overflow in output_line().
357
if (len < SCRATCH_BUFFER_SIZE)
358
359
360
361
362
363
364
365
366
strcpy(failstr, scratch); // copy it over.
else
{
va_start(ap, fmt);
vsnprintf(failstr, len + 1, fmt, ap); // rebuild it.
va_end(ap);
} // else
ctx->failstr = failstr;
} // else
367
368
369
370
371
372
} // if
return FAIL;
} // failf
373
static inline int fail(Context *ctx, const char *reason)
374
375
376
377
378
{
return failf(ctx, "%s", reason);
} // fail
379
380
static int output_line(Context *ctx, const char *fmt, ...) ISPRINTF(2,3);
static int output_line(Context *ctx, const char *fmt, ...)
381
{
382
383
OutputListNode *item = NULL;
384
if (isfail(ctx))
385
386
return FAIL; // we failed previously, don't go on...
387
item = (OutputListNode *) ctx->malloc(sizeof (OutputListNode));
388
389
390
391
if (item == NULL)
return out_of_memory(ctx);
char *scratch = get_scratch_buffer(ctx);
392
393
const int indent = ctx->indent;
394
395
if (indent > 0)
memset(scratch, '\t', indent);
396
397
va_list ap;
va_start(ap, fmt);
398
const int len = vsnprintf(scratch+indent, SCRATCH_BUFFER_SIZE-indent, fmt, ap) + indent;
399
400
va_end(ap);
401
402
item->str = (char *) ctx->malloc(len + 1);
if (item->str == NULL)
403
{
404
405
free(item);
return out_of_memory(ctx);
406
407
} // if
408
409
410
// If we overflowed our scratch buffer, that's okay. We were going to
// allocate anyhow...the scratch buffer just lets us avoid a second
// run of vsnprintf().
411
if (len < SCRATCH_BUFFER_SIZE)
412
413
414
strcpy(item->str, scratch); // copy it over.
else
{
415
416
if (indent > 0)
memset(item->str, '\t', indent);
417
va_start(ap, fmt);
418
vsnprintf(item->str+indent, len + 1, fmt, ap); // rebuild it.
419
420
va_end(ap);
} // else
421
422
item->next = NULL;
423
424
425
ctx->output->tail->next = item;
ctx->output->tail = item;
426
ctx->output_len += len + ctx->endline_len;
427
428
429
430
431
return 0;
} // output_line
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
// !!! FIXME: this is sort of nasty.
static void floatstr(Context *ctx, char *buf, size_t bufsize, float f)
{
const size_t len = snprintf(buf, bufsize, "%f", f);
if (len >= bufsize)
fail(ctx, "BUG: internal buffer is too small");
else
{
char *end = buf + len;
char *ptr = strchr(buf, '.');
if (ptr == NULL)
return; // done.
while (--end != ptr)
{
if (*end != '0')
{
end++;
break;
} // if
} // while
*end = '\0'; // chop extra '0' or all decimal places off.
} // else
} // floatstr
457
458
// if SUPPORT_PROFILE_* isn't defined, we assume an implicit desire to support.
459
460
461
462
463
464
465
466
467
#define AT_LEAST_ONE_PROFILE 0
#if !SUPPORT_PROFILE_D3D
#define PROFILE_EMITTER_D3D(op)
#else
#undef AT_LEAST_ONE_PROFILE
#define AT_LEAST_ONE_PROFILE 1
#define PROFILE_EMITTER_D3D(op) emit_D3D_##op,
468
static const char *get_D3D_register_string(Context *ctx,
469
RegisterType regtype,
470
471
int regnum, char *regnum_str,
size_t regnum_size)
472
{
473
const char *retval = NULL;
474
int has_number = 1;
475
476
switch (regtype)
477
478
{
case REGISTER_TYPE_TEMP:
479
retval = "r";
480
481
482
break;
case REGISTER_TYPE_INPUT:
483
retval = "v";
484
485
486
break;
case REGISTER_TYPE_CONST:
487
488
489
retval = "c";
break;
490
case REGISTER_TYPE_CONST2:
491
492
493
494
retval = "c";
regnum += 2048;
break;
495
case REGISTER_TYPE_CONST3:
496
497
498
499
retval = "c";
regnum += 4096;
break;
500
case REGISTER_TYPE_CONST4:
501
retval = "c";
502
regnum += 6144;
503
504
505
break;
case REGISTER_TYPE_ADDR: // (or REGISTER_TYPE_TEXTURE, same value.)
506
retval = (ctx->shader_type == MOJOSHADER_TYPE_VERTEX) ? "a" : "t";
507
508
509
break;
case REGISTER_TYPE_RASTOUT:
510
switch ((RastOutType) regnum)
511
{
512
513
514
case RASTOUT_TYPE_POSITION: retval = "oPos"; break;
case RASTOUT_TYPE_FOG: retval = "oFog"; break;
case RASTOUT_TYPE_POINT_SIZE: retval = "oPts"; break;
515
} // switch
516
has_number = 0;
517
518
519
break;
case REGISTER_TYPE_ATTROUT:
520
retval = "oD";
521
522
523
break;
case REGISTER_TYPE_TEXCRDOUT: // (or REGISTER_TYPE_OUTPUT, same value.)
524
if ((ctx->shader_type==MOJOSHADER_TYPE_VERTEX) && (ctx->major_ver>=3))
525
retval = "o";
526
else
527
retval = "oT";
528
529
530
break;
case REGISTER_TYPE_CONSTINT:
531
retval = "i";
532
533
534
break;
case REGISTER_TYPE_COLOROUT:
535
retval = "oC";
536
537
538
break;
case REGISTER_TYPE_DEPTHOUT:
539
retval = "oDepth";
540
has_number = 0;
541
542
543
break;
case REGISTER_TYPE_SAMPLER:
544
retval = "s";
545
546
547
break;
case REGISTER_TYPE_CONSTBOOL:
548
retval = "b";
549
550
551
break;
case REGISTER_TYPE_LOOP:
552
retval = "aL";
553
has_number = 0;
554
555
556
break;
// !!! FIXME: don't know what the asm string is for this..
557
558
559
560
case REGISTER_TYPE_TEMPFLOAT16:
retval = "???";
has_number = 0;
break;
561
562
case REGISTER_TYPE_MISCTYPE:
563
switch ((MiscTypeType) regnum)
564
{
565
566
case MISCTYPE_TYPE_POSITION: retval = "vPos"; break;
case MISCTYPE_TYPE_FACE: retval = "vFace"; break;
567
} // switch
568
has_number = 0;
569
570
571
break;
case REGISTER_TYPE_LABEL:
572
retval = "l";
573
574
575
break;
case REGISTER_TYPE_PREDICATE:
576
retval = "p";
577
578
579
break;
} // switch
580
581
582
583
584
if (has_number)
snprintf(regnum_str, regnum_size, "%u", (uint) regnum);
else
regnum_str[0] = '\0';
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
return retval;
} // get_D3D_register_string
static char *make_D3D_destarg_string(Context *ctx, const int idx)
{
if (idx >= STATICARRAYLEN(ctx->dest_args))
{
fail(ctx, "Too many destination args");
return "";
} // if
const DestArgInfo *arg = &ctx->dest_args[idx];
const char *result_shift_str = "";
switch (arg->result_shift)
{
case 0x1: result_shift_str = "_x2"; break;
case 0x2: result_shift_str = "_x4"; break;
case 0x3: result_shift_str = "_x8"; break;
case 0xD: result_shift_str = "_d8"; break;
case 0xE: result_shift_str = "_d4"; break;
case 0xF: result_shift_str = "_d2"; break;
} // switch
const char *sat_str = (arg->result_mod & MOD_SATURATE) ? "_sat" : "";
const char *pp_str = (arg->result_mod & MOD_PP) ? "_pp" : "";
const char *cent_str = (arg->result_mod & MOD_CENTROID) ? "_centroid" : "";
char regnum_str[16];
const char *regtype_str = get_D3D_register_string(ctx,
616
(RegisterType) arg->regtype,
617
618
arg->regnum, regnum_str,
sizeof (regnum_str));
619
620
621
622
623
624
if (regtype_str == NULL)
{
fail(ctx, "Unknown destination register type.");
return "";
} // if
625
626
627
628
629
630
631
632
633
634
635
636
char writemask_str[6];
int i = 0;
if (arg->writemask != 0xF) // 0xF == 1111. No explicit mask.
{
writemask_str[i++] = '.';
if (arg->writemask0) writemask_str[i++] = 'x';
if (arg->writemask1) writemask_str[i++] = 'y';
if (arg->writemask2) writemask_str[i++] = 'z';
if (arg->writemask3) writemask_str[i++] = 'w';
} // if
writemask_str[i] = '\0';
assert(i < sizeof (writemask_str));
637
638
639
// may turn out something like "_x2_sat_pp_centroid r0.xyzw" ...
char *retval = get_scratch_buffer(ctx);
640
snprintf(retval, SCRATCH_BUFFER_SIZE, "%s%s%s%s %s%s%s",
641
result_shift_str, sat_str, pp_str, cent_str,
642
regtype_str, regnum_str, writemask_str);
643
return retval;
644
} // make_D3D_destarg_string
645
646
647
static char *make_D3D_sourcearg_string(Context *ctx, const int idx)
648
{
649
650
651
if (idx >= STATICARRAYLEN(ctx->source_args))
{
fail(ctx, "Too many source args");
652
return "";
653
} // if
654
655
656
657
658
const SourceArgInfo *arg = &ctx->source_args[idx];
const char *premod_str = "";
const char *postmod_str = "";
659
switch ((SourceMod) arg->src_mod)
660
661
662
663
664
665
666
667
668
669
670
{
case SRCMOD_NEGATE:
premod_str = "-";
break;
case SRCMOD_BIASNEGATE:
premod_str = "-";
// fall through.
case SRCMOD_BIAS:
postmod_str = "_bias";
break;
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
case SRCMOD_SIGNNEGATE:
premod_str = "-";
// fall through.
case SRCMOD_SIGN:
postmod_str = "_bx2";
break;
case SRCMOD_COMPLEMENT:
premod_str = "1-";
break;
case SRCMOD_X2NEGATE:
premod_str = "-";
// fall through.
case SRCMOD_X2:
postmod_str = "_x2";
break;
case SRCMOD_DZ:
postmod_str = "_dz";
break;
case SRCMOD_DW:
postmod_str = "_dw";
break;
case SRCMOD_ABSNEGATE:
premod_str = "-";
// fall through.
case SRCMOD_ABS:
postmod_str = "_abs";
break;
case SRCMOD_NOT:
premod_str = "!";
break;
708
709
710
711
case SRCMOD_NONE:
case SRCMOD_TOTAL:
break; // stop compiler whining.
712
713
714
715
716
} // switch
char regnum_str[16];
const char *regtype_str = get_D3D_register_string(ctx,
717
(RegisterType) arg->regtype,
718
719
720
721
722
723
724
725
726
727
728
arg->regnum, regnum_str,
sizeof (regnum_str));
if (regtype_str == NULL)
{
fail(ctx, "Unknown source register type.");
return "";
} // if
char swizzle_str[6];
int i = 0;
729
if (arg->swizzle != 0xE4) // 0xE4 == 11100100 ... 3 2 1 0. No swizzle.
730
731
732
{
static const char channel[] = { 'x', 'y', 'z', 'w' };
swizzle_str[i++] = '.';
733
734
735
736
737
738
739
740
swizzle_str[i++] = channel[arg->swizzle_x];
swizzle_str[i++] = channel[arg->swizzle_y];
swizzle_str[i++] = channel[arg->swizzle_z];
swizzle_str[i++] = channel[arg->swizzle_w];
// .xyzz is the same as .xyz, .z is the same as .zzzz, etc.
while (swizzle_str[i-1] == swizzle_str[i-2])
i--;
741
742
743
744
745
} // if
swizzle_str[i] = '\0';
assert(i < sizeof (swizzle_str));
char *retval = get_scratch_buffer(ctx);
746
747
snprintf(retval, SCRATCH_BUFFER_SIZE, "%s%s%s%s%s",
premod_str, regtype_str, regnum_str, postmod_str, swizzle_str);
748
return retval;
749
} // make_D3D_sourcearg_string
750
751
752
static void emit_D3D_start(Context *ctx)
753
754
755
{
const uint major = (uint) ctx->major_ver;
const uint minor = (uint) ctx->minor_ver;
756
757
758
759
760
761
762
763
764
const char *shadertype_str = NULL;
char minor_str[16];
if (minor == 0xFF)
strcpy(minor_str, "sw");
else if (minor == 0x1) // apparently this is "vs_2_x". Weird.
strcpy(minor_str, "x");
else
snprintf(minor_str, sizeof (minor_str), "%u", (uint) minor);
765
766
if (ctx->shader_type == MOJOSHADER_TYPE_PIXEL)
767
shadertype_str = "ps";
768
else if (ctx->shader_type == MOJOSHADER_TYPE_VERTEX)
769
shadertype_str = "vs";
770
else
771
772
773
{
failf(ctx, "Shader type %u unsupported in this profile.",
(uint) ctx->shader_type);
774
return;
775
} // else
776
777
output_line(ctx, "%s_%u_%s", shadertype_str, major, minor_str);
778
779
} // emit_D3D_start
780
781
static void emit_D3D_end(Context *ctx)
782
{
783
output_line(ctx, "end");
784
} // emit_D3D_end
785
786
787
static void emit_D3D_comment(Context *ctx, const char *str)
788
{
789
790
output_line(ctx, "; %s", str);
} // emit_D3D_comment
791
792
793
static void emit_D3D_RESERVED(Context *ctx)
794
{
795
796
797
// do nothing; fails in the state machine.
} // emit_D3D_RESERVED
798
799
800
801
// Generic D3D opcode emitters. A list of macros generate all the entry points
// that call into these...
802
803
804
805
806
807
808
809
810
811
812
813
static char *lowercase(char *dst, const char *src)
{
int i = 0;
do
{
const char ch = src[i];
dst[i] = (((ch >= 'A') && (ch <= 'Z')) ? (ch - ('A' - 'a')) : ch);
} while (src[i++]);
return dst;
} // lowercase
814
static void emit_D3D_opcode_d(Context *ctx, const char *opcode)
815
{
816
const char *dst0 = make_D3D_destarg_string(ctx, 0);
817
opcode = lowercase(get_scratch_buffer(ctx), opcode);
818
output_line(ctx, "%s%s", opcode, dst0);
819
820
821
} // emit_D3D_opcode_d
822
static void emit_D3D_opcode_s(Context *ctx, const char *opcode)
823
{
824
const char *src0 = make_D3D_destarg_string(ctx, 0);
825
opcode = lowercase(get_scratch_buffer(ctx), opcode);
826
output_line(ctx, "%s %s", opcode, src0);
827
828
829
} // emit_D3D_opcode_s
830
static void emit_D3D_opcode_ss(Context *ctx, const char *opcode)
831
{
832
833
const char *src0 = make_D3D_sourcearg_string(ctx, 0);
const char *src1 = make_D3D_sourcearg_string(ctx, 1);
834
opcode = lowercase(get_scratch_buffer(ctx), opcode);
835
output_line(ctx, "%s %s, %s", opcode, src0, src1);
836
} // emit_D3D_opcode_ss
837
838
839
static void emit_D3D_opcode_ds(Context *ctx, const char *opcode)
840
{
841
842
const char *dst0 = make_D3D_destarg_string(ctx, 0);
const char *src0 = make_D3D_sourcearg_string(ctx, 0);
843
opcode = lowercase(get_scratch_buffer(ctx), opcode);
844
output_line(ctx, "%s%s, %s", opcode, dst0, src0);
845
846
847
} // emit_D3D_opcode_ds
848
static void emit_D3D_opcode_dss(Context *ctx, const char *opcode)
849
{
850
851
852
const char *dst0 = make_D3D_destarg_string(ctx, 0);
const char *src0 = make_D3D_sourcearg_string(ctx, 0);
const char *src1 = make_D3D_sourcearg_string(ctx, 1);
853
opcode = lowercase(get_scratch_buffer(ctx), opcode);
854
output_line(ctx, "%s%s, %s, %s", opcode, dst0, src0, src1);
855
856
857
} // emit_D3D_opcode_dss
858
static void emit_D3D_opcode_dsss(Context *ctx, const char *opcode)
859
{
860
861
862
863
const char *dst0 = make_D3D_destarg_string(ctx, 0);
const char *src0 = make_D3D_sourcearg_string(ctx, 0);
const char *src1 = make_D3D_sourcearg_string(ctx, 1);
const char *src2 = make_D3D_sourcearg_string(ctx, 2);
864
opcode = lowercase(get_scratch_buffer(ctx), opcode);
865
output_line(ctx, "%s%s, %s, %s, %s", opcode, dst0, src0, src1, src2);
866
867
868
} // emit_D3D_opcode_dsss
869
static void emit_D3D_opcode_dssss(Context *ctx, const char *opcode)
870
{
871
872
873
874
875
const char *dst0 = make_D3D_destarg_string(ctx, 0);
const char *src0 = make_D3D_sourcearg_string(ctx, 0);
const char *src1 = make_D3D_sourcearg_string(ctx, 1);
const char *src2 = make_D3D_sourcearg_string(ctx, 2);
const char *src3 = make_D3D_sourcearg_string(ctx, 3);
876
opcode = lowercase(get_scratch_buffer(ctx), opcode);
877
output_line(ctx,"%s%s, %s, %s, %s, %s",opcode,dst0,src0,src1,src2,src3);
878
879
880
} // emit_D3D_opcode_dssss
881
882
883
884
885
886
887
static void emit_D3D_opcode(Context *ctx, const char *opcode)
{
opcode = lowercase(get_scratch_buffer(ctx), opcode);
output_line(ctx, "%s", opcode);
} // emit_D3D_opcode_dssss
888
#define EMIT_D3D_OPCODE_FUNC(op) \
889
static void emit_D3D_##op(Context *ctx) { \
890
emit_D3D_opcode(ctx, #op); \
891
892
}
#define EMIT_D3D_OPCODE_D_FUNC(op) \
893
static void emit_D3D_##op(Context *ctx) { \
894
895
896
emit_D3D_opcode_d(ctx, #op); \
}
#define EMIT_D3D_OPCODE_S_FUNC(op) \
897
static void emit_D3D_##op(Context *ctx) { \
898
899
900
emit_D3D_opcode_s(ctx, #op); \
}
#define EMIT_D3D_OPCODE_SS_FUNC(op) \
901
static void emit_D3D_##op(Context *ctx) { \
902
903
904
emit_D3D_opcode_ss(ctx, #op); \
}
#define EMIT_D3D_OPCODE_DS_FUNC(op) \
905
static void emit_D3D_##op(Context *ctx) { \
906
907
908
emit_D3D_opcode_ds(ctx, #op); \
}
#define EMIT_D3D_OPCODE_DSS_FUNC(op) \
909
static void emit_D3D_##op(Context *ctx) { \
910
911
912
emit_D3D_opcode_dss(ctx, #op); \
}
#define EMIT_D3D_OPCODE_DSSS_FUNC(op) \
913
static void emit_D3D_##op(Context *ctx) { \
914
915
916
emit_D3D_opcode_dsss(ctx, #op); \
}
#define EMIT_D3D_OPCODE_DSSSS_FUNC(op) \
917
static void emit_D3D_##op(Context *ctx) { \
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
emit_D3D_opcode_dssss(ctx, #op); \
}
EMIT_D3D_OPCODE_FUNC(NOP)
EMIT_D3D_OPCODE_DS_FUNC(MOV)
EMIT_D3D_OPCODE_DSS_FUNC(ADD)
EMIT_D3D_OPCODE_DSS_FUNC(SUB)
EMIT_D3D_OPCODE_DSSS_FUNC(MAD)
EMIT_D3D_OPCODE_DSS_FUNC(MUL)
EMIT_D3D_OPCODE_DS_FUNC(RCP)
EMIT_D3D_OPCODE_DS_FUNC(RSQ)
EMIT_D3D_OPCODE_DSS_FUNC(DP3)
EMIT_D3D_OPCODE_DSS_FUNC(DP4)
EMIT_D3D_OPCODE_DSS_FUNC(MIN)
EMIT_D3D_OPCODE_DSS_FUNC(MAX)
EMIT_D3D_OPCODE_DSS_FUNC(SLT)
EMIT_D3D_OPCODE_DSS_FUNC(SGE)
EMIT_D3D_OPCODE_DS_FUNC(EXP)
EMIT_D3D_OPCODE_DS_FUNC(LOG)
EMIT_D3D_OPCODE_DS_FUNC(LIT)
EMIT_D3D_OPCODE_DSS_FUNC(DST)
EMIT_D3D_OPCODE_DSSS_FUNC(LRP)
EMIT_D3D_OPCODE_DS_FUNC(FRC)
EMIT_D3D_OPCODE_DSS_FUNC(M4X4)
EMIT_D3D_OPCODE_DSS_FUNC(M4X3)
EMIT_D3D_OPCODE_DSS_FUNC(M3X4)
EMIT_D3D_OPCODE_DSS_FUNC(M3X3)
EMIT_D3D_OPCODE_DSS_FUNC(M3X2)
EMIT_D3D_OPCODE_S_FUNC(CALL)
EMIT_D3D_OPCODE_SS_FUNC(CALLNZ)
948
EMIT_D3D_OPCODE_SS_FUNC(LOOP)
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
EMIT_D3D_OPCODE_FUNC(RET)
EMIT_D3D_OPCODE_FUNC(ENDLOOP)
EMIT_D3D_OPCODE_S_FUNC(LABEL)
EMIT_D3D_OPCODE_DSS_FUNC(POW)
EMIT_D3D_OPCODE_DSS_FUNC(CRS)
EMIT_D3D_OPCODE_DSSS_FUNC(SGN)
EMIT_D3D_OPCODE_DS_FUNC(ABS)
EMIT_D3D_OPCODE_DS_FUNC(NRM)
EMIT_D3D_OPCODE_DS_FUNC(SINCOS)
EMIT_D3D_OPCODE_S_FUNC(REP)
EMIT_D3D_OPCODE_FUNC(ENDREP)
EMIT_D3D_OPCODE_S_FUNC(IF)
EMIT_D3D_OPCODE_FUNC(ELSE)
EMIT_D3D_OPCODE_FUNC(ENDIF)
EMIT_D3D_OPCODE_FUNC(BREAK)
EMIT_D3D_OPCODE_DS_FUNC(MOVA)
EMIT_D3D_OPCODE_D_FUNC(TEXKILL)
EMIT_D3D_OPCODE_DS_FUNC(TEXBEM)
EMIT_D3D_OPCODE_DS_FUNC(TEXBEML)
EMIT_D3D_OPCODE_DS_FUNC(TEXREG2AR)
EMIT_D3D_OPCODE_DS_FUNC(TEXREG2GB)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X2PAD)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X2TEX)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X3PAD)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X3TEX)
EMIT_D3D_OPCODE_DSS_FUNC(TEXM3X3SPEC)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X3VSPEC)
EMIT_D3D_OPCODE_DS_FUNC(EXPP)
EMIT_D3D_OPCODE_DS_FUNC(LOGP)
EMIT_D3D_OPCODE_DSSS_FUNC(CND)
EMIT_D3D_OPCODE_DS_FUNC(TEXREG2RGB)
EMIT_D3D_OPCODE_DS_FUNC(TEXDP3TEX)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X2DEPTH)
EMIT_D3D_OPCODE_DS_FUNC(TEXDP3)
EMIT_D3D_OPCODE_DS_FUNC(TEXM3X3)
EMIT_D3D_OPCODE_D_FUNC(TEXDEPTH)
EMIT_D3D_OPCODE_DSSS_FUNC(CMP)
EMIT_D3D_OPCODE_DSS_FUNC(BEM)
EMIT_D3D_OPCODE_DSSS_FUNC(DP2ADD)
EMIT_D3D_OPCODE_DS_FUNC(DSX)
EMIT_D3D_OPCODE_DS_FUNC(DSY)
EMIT_D3D_OPCODE_DSSSS_FUNC(TEXLDD)
EMIT_D3D_OPCODE_DSS_FUNC(TEXLDL)
992
EMIT_D3D_OPCODE_S_FUNC(BREAKP)
993
994
995
996
997
998
999
1000
// special cases for comparison opcodes...
static const char *get_D3D_comparison_string(Context *ctx)
{
static const char *comps[] = {
"", "_gt", "_eq", "_ge", "_lt", "_ne", "_le"
};