/
mojoshader.c
3205 lines (2654 loc) · 97.7 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
32
// This is the highest shader version we currently support.
#define MAX_SHADER_MAJOR 3
#define MAX_SHADER_MINOR 0
33
34
35
// You get all the profiles unless you go out of your way to disable them.
36
37
38
39
40
41
42
43
#ifndef SUPPORT_PROFILE_D3D
#define SUPPORT_PROFILE_D3D 1
#endif
#ifndef SUPPORT_PROFILE_GLSL
#define SUPPORT_PROFILE_GLSL 1
#endif
44
45
46
47
48
49
// 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;
50
typedef int32_t int32;
51
52
53
54
55
56
57
#ifdef __GNUC__
#define ISPRINTF(x,y) __attribute__((format (printf, x, y)))
#else
#define ISPRINTF(x,y)
#endif
58
59
#define STATICARRAYLEN(x) ( (sizeof ((x))) / (sizeof ((x)[0])) )
60
61
62
63
64
65
66
#ifdef _WINDOWS // !!! FIXME: bleh
const char *endline_str = "\r\n";
#else
const char *endline_str = "\n";
#endif
67
68
69
// we need to reference this by explicit value occasionally.
#define OPCODE_RET 28
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
// 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
89
90
// predeclare.
91
typedef struct Context Context;
92
93
// one emit function for each opcode in each profile.
94
typedef void (*emit_function)(Context *ctx);
95
96
// one emit function for comments in each profile.
97
typedef void (*emit_comment)(Context *ctx, const char *str);
98
99
// one emit function for starting output in each profile.
100
typedef void (*emit_start)(Context *ctx);
101
102
// one emit function for ending output in each profile.
103
typedef void (*emit_end)(Context *ctx);
104
105
106
107
// one args function for each possible sequence of opcode arguments.
typedef int (*args_function)(Context *ctx);
108
// one state function for each opcode where we have state machine updates.
109
typedef void (*state_function)(Context *ctx);
110
111
112
113
114
115
116
typedef struct
{
const char *name;
emit_start start_emitter;
emit_end end_emitter;
emit_comment comment_emitter;
117
} Profile;
118
119
typedef MOJOSHADER_shaderType ShaderType;
120
121
122
123
124
125
typedef enum
{
REGISTER_TYPE_TEMP = 0,
REGISTER_TYPE_INPUT = 1,
REGISTER_TYPE_CONST = 2,
126
REGISTER_TYPE_ADDRESS = 3,
127
128
129
130
REGISTER_TYPE_TEXTURE = 3, // ALSO 3!
REGISTER_TYPE_RASTOUT = 4,
REGISTER_TYPE_ATTROUT = 5,
REGISTER_TYPE_TEXCRDOUT = 6,
131
132
133
134
REGISTER_TYPE_OUTPUT = 6, // ALSO 6!
REGISTER_TYPE_CONSTINT = 7,
REGISTER_TYPE_COLOROUT = 8,
REGISTER_TYPE_DEPTHOUT = 9,
135
136
137
138
139
140
141
142
143
144
145
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
146
} RegisterType;
147
148
149
150
151
152
153
typedef enum
{
RASTOUT_TYPE_POSITION = 0,
RASTOUT_TYPE_FOG = 1,
RASTOUT_TYPE_POINT_SIZE = 2,
RASTOUT_TYPE_MAX = 2
154
} RastOutType;
155
156
157
158
159
160
typedef enum
{
MISCTYPE_TYPE_POSITION = 0,
MISCTYPE_TYPE_FACE = 1,
MISCTYPE_TYPE_MAX = 1
161
} MiscTypeType;
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
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
179
} DeclUsageType;
180
181
182
183
184
185
typedef enum
{
TEXTURE_TYPE_2D = 2,
TEXTURE_TYPE_CUBE = 3,
TEXTURE_TYPE_VOLUME = 4,
186
} TextureType;
187
188
189
190
191
// 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.
192
typedef struct OutputListNode
193
194
{
char *str;
195
196
197
198
199
200
201
struct OutputListNode *next;
} OutputListNode;
typedef struct OutputList
{
OutputListNode head;
OutputListNode *tail;
202
203
} OutputList;
204
205
206
207
208
209
// result modifiers.
#define MOD_SATURATE 0x01
#define MOD_PP 0x02
#define MOD_CENTROID 0x04
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
// 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
228
} SourceMod;
229
230
231
232
typedef struct
{
233
const uint32 *token; // this is the unmolested token in the stream.
234
235
int regnum;
int relative;
236
237
238
239
240
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
241
242
int result_mod;
int result_shift;
243
RegisterType regtype;
244
245
246
247
} DestArgInfo;
typedef struct
{
248
const uint32 *token; // this is the unmolested token in the stream.
249
250
int regnum;
int relative;
251
int swizzle; // xyzw (all four, not split out).
252
253
254
255
256
int swizzle_x;
int swizzle_y;
int swizzle_z;
int swizzle_w;
int src_mod;
257
RegisterType regtype;
258
259
260
} SourceArgInfo;
261
262
263
264
265
266
267
268
269
typedef enum
{
CTX_FLAGS_GLSL_LIT_OPCODE = (1 << 0),
CTX_FLAGS_GLSL_DST_OPCODE = (1 << 1),
CTX_FLAGS_GLSL_LRP_OPCODE = (1 << 2),
CTX_FLAGS_MASK = 0xFFFFFFFF
} ContextFlags;
270
271
#define SCRATCH_BUFFER_SIZE 256
#define SCRATCH_BUFFERS 10
272
273
274
275
276
277
278
// !!! FIXME: labels_called and the scratch buffers make this pretty big.
// !!! FIXME: might be worth having one set of static scratch buffers that
// !!! FIXME: are mutex protected?
// !!! FIXME: and replace the bit array for labels_called with a linked list?
// !!! FIXME: maybe just malloc() the label list, since it can't be more than
// !!! FIXME: around (bytes_of_shader / 20) elements in the pathological case?
279
// Context...this is state that changes as we parse through a shader...
280
struct Context
281
{
282
283
MOJOSHADER_malloc malloc;
MOJOSHADER_free free;
284
285
const uint32 *tokens;
uint32 tokencount;
286
287
OutputList *output;
OutputList globals;
288
OutputList helpers;
289
290
OutputList subroutines;
OutputList mainline;
291
292
293
294
OutputList ignore;
OutputList *output_stack[2];
int indent_stack[2];
int output_stack_len;
295
int output_len; // total strlen; prevents walking the lists just to malloc.
296
int indent;
297
298
299
const char *endline;
int endline_len;
const char *failstr;
300
char scratch[SCRATCH_BUFFERS][SCRATCH_BUFFER_SIZE];
301
302
int scratchidx; // current scratch buffer.
int profileid;
303
304
const Profile *profile;
ShaderType shader_type;
305
306
uint8 major_ver;
uint8 minor_ver;
307
DestArgInfo dest_args[1];
308
SourceArgInfo source_args[5];
309
uint32 dwords[4];
310
int instruction_count;
311
uint32 instruction_controls;
312
313
314
315
uint32 previous_opcode;
ContextFlags flags;
uint8 labels_called[256];
int loops;
316
317
318
};
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
// jump between output sections in the context...
static inline void push_output(Context *ctx, OutputList *section)
{
assert(ctx->output_stack_len < STATICARRAYLEN(ctx->output_stack));
ctx->output_stack[ctx->output_stack_len] = ctx->output;
ctx->indent_stack[ctx->output_stack_len] = ctx->indent;
ctx->output_stack_len++;
ctx->output = section;
ctx->indent = 0;
} // push_output
static inline void pop_output(Context *ctx)
{
assert(ctx->output_stack_len > 0);
ctx->output_stack_len--;
ctx->output = ctx->output_stack[ctx->output_stack_len];
ctx->indent = ctx->indent_stack[ctx->output_stack_len];
} // pop_output
// Shader model version magic...
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
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
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
// Bit arrays (for storing large arrays of booleans...
static void set_bit_array(uint8 *array, size_t arraylen, int index, int val)
{
const int byteindex = index / 8;
const int bitindex = index % 8;
assert(byteindex < arraylen);
if (val)
array[byteindex] |= (1 << bitindex);
else
array[byteindex] &= ~(1 << bitindex);
} // set_bit_array
static int get_bit_array(const uint8 *array, size_t arraylen, int index)
{
const int byteindex = index / 8;
const int bitindex = index % 8;
assert(byteindex < arraylen);
const uint8 byte = array[byteindex];
return (byte & (1 << bitindex)) ? 1 : 0;
} // get_bit_array
382
383
static inline char *get_scratch_buffer(Context *ctx)
384
{
385
ctx->scratchidx = (ctx->scratchidx + 1) % SCRATCH_BUFFERS;
386
return ctx->scratch[ctx->scratchidx];
387
388
} // get_scratch_buffer
389
390
391
// Special-case return values from the parsing pipeline...
#define FAIL (-1)
392
393
#define NOFAIL (-2)
#define END_OF_STREAM (-3)
394
395
static inline int isfail(const Context *ctx)
396
397
398
399
400
{
return (ctx->failstr != NULL);
} // isfail
401
402
403
404
405
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";
406
407
408
static inline int out_of_memory(Context *ctx)
{
if (ctx->failstr == NULL)
409
ctx->failstr = out_of_mem_str; // fail() would call malloc().
410
411
412
413
414
415
return FAIL;
} // out_of_memory
static int failf(Context *ctx, const char *fmt, ...) ISPRINTF(2,3);
static int failf(Context *ctx, const char *fmt, ...)
416
{
417
418
if (ctx->failstr == NULL) // don't change existing error.
{
419
char *scratch = get_scratch_buffer(ctx);
420
421
va_list ap;
va_start(ap, fmt);
422
const int len = vsnprintf(scratch,SCRATCH_BUFFER_SIZE,fmt,ap);
423
424
va_end(ap);
425
426
427
428
429
430
char *failstr = (char *) ctx->malloc(len + 1);
if (failstr == NULL)
out_of_memory(ctx);
else
{
// see comments about scratch buffer overflow in output_line().
431
if (len < SCRATCH_BUFFER_SIZE)
432
433
434
435
436
437
438
439
440
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
441
442
443
444
445
446
} // if
return FAIL;
} // failf
447
static inline int fail(Context *ctx, const char *reason)
448
449
450
451
452
{
return failf(ctx, "%s", reason);
} // fail
453
454
static int output_line(Context *ctx, const char *fmt, ...) ISPRINTF(2,3);
static int output_line(Context *ctx, const char *fmt, ...)
455
{
456
457
OutputListNode *item = NULL;
458
if (isfail(ctx))
459
460
return FAIL; // we failed previously, don't go on...
461
char *scratch = get_scratch_buffer(ctx);
462
463
const int indent = ctx->indent;
464
465
if (indent > 0)
memset(scratch, '\t', indent);
466
467
468
va_list ap;
va_start(ap, fmt);
469
const int len = vsnprintf(scratch+indent, SCRATCH_BUFFER_SIZE-indent, fmt, ap) + indent;
470
471
va_end(ap);
472
473
474
475
item = (OutputListNode *) ctx->malloc(sizeof (OutputListNode));
if (item == NULL)
return out_of_memory(ctx);
476
477
item->str = (char *) ctx->malloc(len + 1);
if (item->str == NULL)
478
{
479
480
free(item);
return out_of_memory(ctx);
481
482
} // if
483
484
485
// 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().
486
if (len < SCRATCH_BUFFER_SIZE)
487
488
489
strcpy(item->str, scratch); // copy it over.
else
{
490
491
if (indent > 0)
memset(item->str, '\t', indent);
492
va_start(ap, fmt);
493
vsnprintf(item->str+indent, len + 1, fmt, ap); // rebuild it.
494
495
va_end(ap);
} // else
496
497
item->next = NULL;
498
499
500
ctx->output->tail->next = item;
ctx->output->tail = item;
501
ctx->output_len += len + ctx->endline_len;
502
503
504
505
506
return 0;
} // output_line
507
508
509
510
511
512
513
// this is just to stop gcc whining.
static inline int output_blank_line(Context *ctx)
{
return output_line(ctx, "%s", "");
} // output_blank_line
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
// !!! 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
539
540
// if SUPPORT_PROFILE_* isn't defined, we assume an implicit desire to support.
541
542
543
544
545
546
547
548
549
#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,
550
static const char *get_D3D_register_string(Context *ctx,
551
RegisterType regtype,
552
553
int regnum, char *regnum_str,
size_t regnum_size)
554
{
555
const char *retval = NULL;
556
int has_number = 1;
557
558
switch (regtype)
559
560
{
case REGISTER_TYPE_TEMP:
561
retval = "r";
562
563
564
break;
case REGISTER_TYPE_INPUT:
565
retval = "v";
566
567
568
break;
case REGISTER_TYPE_CONST:
569
570
571
retval = "c";
break;
572
case REGISTER_TYPE_CONST2:
573
574
575
576
retval = "c";
regnum += 2048;
break;
577
case REGISTER_TYPE_CONST3:
578
579
580
581
retval = "c";
regnum += 4096;
break;
582
case REGISTER_TYPE_CONST4:
583
retval = "c";
584
regnum += 6144;
585
586
break;
587
case REGISTER_TYPE_ADDRESS: // (or REGISTER_TYPE_TEXTURE, same value.)
588
retval = (ctx->shader_type == MOJOSHADER_TYPE_VERTEX) ? "a" : "t";
589
590
591
break;
case REGISTER_TYPE_RASTOUT:
592
switch ((RastOutType) regnum)
593
{
594
595
596
case RASTOUT_TYPE_POSITION: retval = "oPos"; break;
case RASTOUT_TYPE_FOG: retval = "oFog"; break;
case RASTOUT_TYPE_POINT_SIZE: retval = "oPts"; break;
597
} // switch
598
has_number = 0;
599
600
601
break;
case REGISTER_TYPE_ATTROUT:
602
retval = "oD";
603
604
break;
605
case REGISTER_TYPE_OUTPUT: // (or REGISTER_TYPE_TEXCRDOUT, same value.)
606
if ((ctx->shader_type==MOJOSHADER_TYPE_VERTEX) && (ctx->major_ver>=3))
607
retval = "o";
608
else
609
retval = "oT";
610
611
612
break;
case REGISTER_TYPE_CONSTINT:
613
retval = "i";
614
615
616
break;
case REGISTER_TYPE_COLOROUT:
617
retval = "oC";
618
619
620
break;
case REGISTER_TYPE_DEPTHOUT:
621
retval = "oDepth";
622
has_number = 0;
623
624
625
break;
case REGISTER_TYPE_SAMPLER:
626
retval = "s";
627
628
629
break;
case REGISTER_TYPE_CONSTBOOL:
630
retval = "b";
631
632
633
break;
case REGISTER_TYPE_LOOP:
634
retval = "aL";
635
has_number = 0;
636
637
638
break;
// !!! FIXME: don't know what the asm string is for this..
639
640
641
642
case REGISTER_TYPE_TEMPFLOAT16:
retval = "???";
has_number = 0;
break;
643
644
case REGISTER_TYPE_MISCTYPE:
645
switch ((MiscTypeType) regnum)
646
{
647
648
case MISCTYPE_TYPE_POSITION: retval = "vPos"; break;
case MISCTYPE_TYPE_FACE: retval = "vFace"; break;
649
} // switch
650
has_number = 0;
651
652
653
break;
case REGISTER_TYPE_LABEL:
654
retval = "l";
655
656
657
break;
case REGISTER_TYPE_PREDICATE:
658
retval = "p";
659
660
661
break;
} // switch
662
663
664
665
666
if (has_number)
snprintf(regnum_str, regnum_size, "%u", (uint) regnum);
else
regnum_str[0] = '\0';
667
668
669
670
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
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];
697
698
699
const char *regtype_str = get_D3D_register_string(ctx, arg->regtype,
arg->regnum, regnum_str,
sizeof (regnum_str));
700
701
702
703
704
705
if (regtype_str == NULL)
{
fail(ctx, "Unknown destination register type.");
return "";
} // if
706
707
708
709
710
711
712
713
714
715
716
717
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));
718
719
720
// may turn out something like "_x2_sat_pp_centroid r0.xyzw" ...
char *retval = get_scratch_buffer(ctx);
721
snprintf(retval, SCRATCH_BUFFER_SIZE, "%s%s%s%s %s%s%s",
722
result_shift_str, sat_str, pp_str, cent_str,
723
regtype_str, regnum_str, writemask_str);
724
return retval;
725
} // make_D3D_destarg_string
726
727
728
static char *make_D3D_sourcearg_string(Context *ctx, const int idx)
729
{
730
731
732
if (idx >= STATICARRAYLEN(ctx->source_args))
{
fail(ctx, "Too many source args");
733
return "";
734
} // if
735
736
737
738
739
const SourceArgInfo *arg = &ctx->source_args[idx];
const char *premod_str = "";
const char *postmod_str = "";
740
switch ((SourceMod) arg->src_mod)
741
742
743
744
745
746
747
748
749
750
751
{
case SRCMOD_NEGATE:
premod_str = "-";
break;
case SRCMOD_BIASNEGATE:
premod_str = "-";
// fall through.
case SRCMOD_BIAS:
postmod_str = "_bias";
break;
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
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;
789
790
791
792
case SRCMOD_NONE:
case SRCMOD_TOTAL:
break; // stop compiler whining.
793
794
795
796
} // switch
char regnum_str[16];
797
798
799
const char *regtype_str = get_D3D_register_string(ctx, arg->regtype,
arg->regnum, regnum_str,
sizeof (regnum_str));
800
801
802
803
804
805
806
807
808
if (regtype_str == NULL)
{
fail(ctx, "Unknown source register type.");
return "";
} // if
char swizzle_str[6];
int i = 0;
809
if (arg->swizzle != 0xE4) // 0xE4 == 11100100 ... 3 2 1 0. No swizzle.
810
811
812
{
static const char channel[] = { 'x', 'y', 'z', 'w' };
swizzle_str[i++] = '.';
813
814
815
816
817
818
819
820
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--;
821
822
823
824
825
} // if
swizzle_str[i] = '\0';
assert(i < sizeof (swizzle_str));
char *retval = get_scratch_buffer(ctx);
826
827
snprintf(retval, SCRATCH_BUFFER_SIZE, "%s%s%s%s%s",
premod_str, regtype_str, regnum_str, postmod_str, swizzle_str);
828
return retval;
829
} // make_D3D_sourcearg_string
830
831
832
static void emit_D3D_start(Context *ctx)
833
834
835
{
const uint major = (uint) ctx->major_ver;
const uint minor = (uint) ctx->minor_ver;
836
837
838
839
840
841
842
843
844
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);
845
846
if (ctx->shader_type == MOJOSHADER_TYPE_PIXEL)
847
shadertype_str = "ps";
848
else if (ctx->shader_type == MOJOSHADER_TYPE_VERTEX)
849
shadertype_str = "vs";
850
else
851
852
853
{
failf(ctx, "Shader type %u unsupported in this profile.",
(uint) ctx->shader_type);
854
return;
855
} // else
856
857
output_line(ctx, "%s_%u_%s", shadertype_str, major, minor_str);
858
859
} // emit_D3D_start
860
861
static void emit_D3D_end(Context *ctx)
862
{
863
output_line(ctx, "end");
864
} // emit_D3D_end
865
866
867
static void emit_D3D_comment(Context *ctx, const char *str)
868
{
869
870
output_line(ctx, "; %s", str);
} // emit_D3D_comment
871
872
873
static void emit_D3D_RESERVED(Context *ctx)
874
{
875
876
877
// do nothing; fails in the state machine.
} // emit_D3D_RESERVED
878
879
880
881
// Generic D3D opcode emitters. A list of macros generate all the entry points
// that call into these...
882
883
884
885
886
887
888
889
890
891
892
893
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
894
static void emit_D3D_opcode_d(Context *ctx, const char *opcode)
895
{
896
const char *dst0 = make_D3D_destarg_string(ctx, 0);
897
opcode = lowercase(get_scratch_buffer(ctx), opcode);
898
output_line(ctx, "%s%s", opcode, dst0);
899
900
901
} // emit_D3D_opcode_d
902
static void emit_D3D_opcode_s(Context *ctx, const char *opcode)
903
{
904
const char *src0 = make_D3D_sourcearg_string(ctx, 0);
905
opcode = lowercase(get_scratch_buffer(ctx), opcode);
906
output_line(ctx, "%s %s", opcode, src0);
907
908
909
} // emit_D3D_opcode_s
910
static void emit_D3D_opcode_ss(Context *ctx, const char *opcode)
911
{
912
913
const char *src0 = make_D3D_sourcearg_string(ctx, 0);
const char *src1 = make_D3D_sourcearg_string(ctx, 1);
914
opcode = lowercase(get_scratch_buffer(ctx), opcode);
915
output_line(ctx, "%s %s, %s", opcode, src0, src1);
916
} // emit_D3D_opcode_ss
917
918
919
static void emit_D3D_opcode_ds(Context *ctx, const char *opcode)
920
{
921
922
const char *dst0 = make_D3D_destarg_string(ctx, 0);
const char *src0 = make_D3D_sourcearg_string(ctx, 0);
923
opcode = lowercase(get_scratch_buffer(ctx), opcode);
924
output_line(ctx, "%s%s, %s", opcode, dst0, src0);
925
926
927
} // emit_D3D_opcode_ds
928
static void emit_D3D_opcode_dss(Context *ctx, const char *opcode)
929
{
930
931
932
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);
933
opcode = lowercase(get_scratch_buffer(ctx), opcode);
934
output_line(ctx, "%s%s, %s, %s", opcode, dst0, src0, src1);
935
936
937
} // emit_D3D_opcode_dss
938
static void emit_D3D_opcode_dsss(Context *ctx, const char *opcode)
939
{
940
941
942
943
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);
944
opcode = lowercase(get_scratch_buffer(ctx), opcode);
945
output_line(ctx, "%s%s, %s, %s, %s", opcode, dst0, src0, src1, src2);
946
947
948
} // emit_D3D_opcode_dsss
949
static void emit_D3D_opcode_dssss(Context *ctx, const char *opcode)
950
{
951
952
953
954
955
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);
956
opcode = lowercase(get_scratch_buffer(ctx), opcode);
957
output_line(ctx,"%s%s, %s, %s, %s, %s",opcode,dst0,src0,src1,src2,src3);
958
959
960
} // emit_D3D_opcode_dssss
961
962
963
964
965
966
967
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
968
#define EMIT_D3D_OPCODE_FUNC(op) \
969
static void emit_D3D_##op(Context *ctx) { \
970
emit_D3D_opcode(ctx, #op); \
971
972
}
#define EMIT_D3D_OPCODE_D_FUNC(op) \
973
static void emit_D3D_##op(Context *ctx) { \
974
975
976
emit_D3D_opcode_d(ctx, #op); \
}
#define EMIT_D3D_OPCODE_S_FUNC(op) \
977
static void emit_D3D_##op(Context *ctx) { \
978
979
980
emit_D3D_opcode_s(ctx, #op); \
}
#define EMIT_D3D_OPCODE_SS_FUNC(op) \
981
static void emit_D3D_##op(Context *ctx) { \
982
983
984
emit_D3D_opcode_ss(ctx, #op); \
}
#define EMIT_D3D_OPCODE_DS_FUNC(op) \
985
static void emit_D3D_##op(Context *ctx) { \
986
987
988
emit_D3D_opcode_ds(ctx, #op); \
}
#define EMIT_D3D_OPCODE_DSS_FUNC(op) \
989
static void emit_D3D_##op(Context *ctx) { \
990
991
992
emit_D3D_opcode_dss(ctx, #op); \
}
#define EMIT_D3D_OPCODE_DSSS_FUNC(op) \
993
static void emit_D3D_##op(Context *ctx) { \
994
995
996
emit_D3D_opcode_dsss(ctx, #op); \
}
#define EMIT_D3D_OPCODE_DSSSS_FUNC(op) \
997
static void emit_D3D_##op(Context *ctx) { \
998
999
1000
emit_D3D_opcode_dssss(ctx, #op); \
}