author | Ryan C. Gordon <icculus@icculus.org> |
Thu, 09 Apr 2009 19:35:31 -0400 | |
changeset 754 | d405cfa22392 |
parent 610 | 166cdcc4414a |
child 758 | f25ef1cca5e2 |
permissions | -rw-r--r-- |
7 | 1 |
/** |
35 | 2 |
* MojoShader; generate shader programs from bytecode of compiled |
3 |
* Direct3D shaders. |
|
7 | 4 |
* |
5 |
* Please see the file LICENSE.txt in the source's root directory. |
|
6 |
* |
|
7 |
* This file written by Ryan C. Gordon. |
|
8 |
*/ |
|
9 |
||
322 | 10 |
// !!! FIXME: this file really needs to be split up. |
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
11 |
// !!! FIXME: I keep changing coding styles for symbols and typedefs. |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
12 |
|
464
eba4cf79437f
Moved some common stuff to mojoshader_internal.h ...
Ryan C. Gordon <icculus@icculus.org>
parents:
463
diff
changeset
|
13 |
#define __MOJOSHADER_INTERNAL__ 1 |
eba4cf79437f
Moved some common stuff to mojoshader_internal.h ...
Ryan C. Gordon <icculus@icculus.org>
parents:
463
diff
changeset
|
14 |
#include "mojoshader_internal.h" |
45 | 15 |
|
148
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
16 |
|
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
17 |
// predeclare. |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
18 |
typedef struct Context Context; |
405
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
19 |
struct ConstantsList; |
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
20 |
|
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
21 |
// one emit function for each opcode in each profile. |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
22 |
typedef void (*emit_function)(Context *ctx); |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
23 |
|
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
24 |
// one emit function for starting output in each profile. |
361
9fa6652cacbd
First (untested) work on nv2 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
360
diff
changeset
|
25 |
typedef void (*emit_start)(Context *ctx, const char *profilestr); |
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
26 |
|
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
27 |
// one emit function for ending output in each profile. |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
28 |
typedef void (*emit_end)(Context *ctx); |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
29 |
|
400
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
30 |
// one emit function for phase opcode output in each profile. |
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
31 |
typedef void (*emit_phase)(Context *ctx); |
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
32 |
|
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
33 |
// one emit function for finalizing output in each profile. |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
34 |
typedef void (*emit_finalize)(Context *ctx); |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
35 |
|
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
36 |
// one emit function for global definitions in each profile. |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
37 |
typedef void (*emit_global)(Context *ctx, RegisterType regtype, int regnum); |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
38 |
|
280
61b2abd9c927
Relative addressing fixes.
Ryan C. Gordon <icculus@icculus.org>
parents:
279
diff
changeset
|
39 |
// one emit function for relative uniform arrays in each profile. |
402
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
40 |
typedef void (*emit_array)(Context *ctx, int base, int size); |
280
61b2abd9c927
Relative addressing fixes.
Ryan C. Gordon <icculus@icculus.org>
parents:
279
diff
changeset
|
41 |
|
405
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
42 |
// one emit function for relative constants arrays in each profile. |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
43 |
typedef void (*emit_const_array)(Context *ctx, |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
44 |
const struct ConstantsList *constslist, |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
45 |
int base, int size); |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
46 |
|
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
47 |
// one emit function for uniforms in each profile. |
402
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
48 |
typedef void (*emit_uniform)(Context *ctx, RegisterType regtype, int regnum, |
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
49 |
int arraybase, int arraysize); |
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
50 |
|
148
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
51 |
// one emit function for samplers in each profile. |
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
52 |
typedef void (*emit_sampler)(Context *ctx, int stage, TextureType ttype); |
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
53 |
|
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
54 |
// one emit function for attributes in each profile. |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
55 |
typedef void (*emit_attribute)(Context *ctx, RegisterType regtype, int regnum, |
431
0d0cbe10db02
First shot at nv4 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
430
diff
changeset
|
56 |
MOJOSHADER_usage usage, int index, int wmask, |
0d0cbe10db02
First shot at nv4 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
430
diff
changeset
|
57 |
int flags); |
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
58 |
|
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
59 |
// one args function for each possible sequence of opcode arguments. |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
60 |
typedef int (*args_function)(Context *ctx); |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
61 |
|
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
62 |
// one state function for each opcode where we have state machine updates. |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
63 |
typedef void (*state_function)(Context *ctx); |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
64 |
|
347
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
65 |
// one function for varnames in each profile. |
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
66 |
typedef const char *(*varname_function)(Context *c, RegisterType t, int num); |
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
67 |
|
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
68 |
// one function for const var array in each profile. |
402
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
69 |
typedef const char *(*const_array_varname_function)(Context *c, int base, int size); |
347
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
70 |
|
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
71 |
typedef struct |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
72 |
{ |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
73 |
const char *name; |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
74 |
emit_start start_emitter; |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
75 |
emit_end end_emitter; |
400
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
76 |
emit_phase phase_emitter; |
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
77 |
emit_global global_emitter; |
402
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
78 |
emit_array array_emitter; |
405
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
79 |
emit_const_array const_array_emitter; |
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
80 |
emit_uniform uniform_emitter; |
148
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
81 |
emit_sampler sampler_emitter; |
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
82 |
emit_attribute attribute_emitter; |
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
83 |
emit_finalize finalize_emitter; |
347
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
84 |
varname_function get_varname; |
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
85 |
const_array_varname_function get_const_array_varname; |
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
86 |
} Profile; |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
87 |
|
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
88 |
|
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
89 |
// A simple linked list of strings, so we can build the final output without |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
90 |
// realloc()ing for each new line, and easily insert lines into the middle |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
91 |
// of the output without much trouble. |
54
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
92 |
typedef struct OutputListNode |
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
93 |
{ |
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
94 |
char *str; |
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
95 |
struct OutputListNode *next; |
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
96 |
} OutputListNode; |
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
97 |
|
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
98 |
typedef struct OutputList |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
99 |
{ |
54
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
100 |
OutputListNode head; |
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
101 |
OutputListNode *tail; |
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
102 |
} OutputList; |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
103 |
|
405
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
104 |
typedef struct ConstantsList |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
105 |
{ |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
106 |
MOJOSHADER_constant constant; |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
107 |
struct ConstantsList *next; |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
108 |
} ConstantsList; |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
109 |
|
399
dc2e64bd03ad
Extract useful information from the ctab.
Ryan C. Gordon <icculus@icculus.org>
parents:
398
diff
changeset
|
110 |
typedef struct VariableList |
dc2e64bd03ad
Extract useful information from the ctab.
Ryan C. Gordon <icculus@icculus.org>
parents:
398
diff
changeset
|
111 |
{ |
dc2e64bd03ad
Extract useful information from the ctab.
Ryan C. Gordon <icculus@icculus.org>
parents:
398
diff
changeset
|
112 |
MOJOSHADER_uniformType type; |
dc2e64bd03ad
Extract useful information from the ctab.
Ryan C. Gordon <icculus@icculus.org>
parents:
398
diff
changeset
|
113 |
int index; |
dc2e64bd03ad
Extract useful information from the ctab.
Ryan C. Gordon <icculus@icculus.org>
parents:
398
diff
changeset
|
114 |
int count; |
405
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
115 |
ConstantsList *constant; |
402
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
116 |
int used; |
399
dc2e64bd03ad
Extract useful information from the ctab.
Ryan C. Gordon <icculus@icculus.org>
parents:
398
diff
changeset
|
117 |
struct VariableList *next; |
dc2e64bd03ad
Extract useful information from the ctab.
Ryan C. Gordon <icculus@icculus.org>
parents:
398
diff
changeset
|
118 |
} VariableList; |
20
bb2e8f285acc
[svn] Bunch More Work...higher level parses dest/src tokens before it goes to the
icculus
parents:
19
diff
changeset
|
119 |
|
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
120 |
typedef struct RegisterList |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
121 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
122 |
RegisterType regtype; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
123 |
int regnum; |
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
124 |
MOJOSHADER_usage usage; |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
125 |
int index; |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
126 |
int writemask; |
248
568c8f9d7cb9
Don't overload meaning of RegisterList::usage for loop tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
235
diff
changeset
|
127 |
int misc; |
402
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
128 |
const VariableList *array; |
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
129 |
struct RegisterList *next; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
130 |
} RegisterList; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
131 |
|
468
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
132 |
typedef struct |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
133 |
{ |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
134 |
const uint32 *token; // this is the unmolested token in the stream. |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
135 |
int regnum; |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
136 |
int swizzle; // xyzw (all four, not split out). |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
137 |
int swizzle_x; |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
138 |
int swizzle_y; |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
139 |
int swizzle_z; |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
140 |
int swizzle_w; |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
141 |
SourceMod src_mod; |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
142 |
RegisterType regtype; |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
143 |
int relative; |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
144 |
RegisterType relative_regtype; |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
145 |
int relative_regnum; |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
146 |
int relative_component; |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
147 |
const VariableList *relative_array; |
28f28973ee80
Moved SourceArgInfo back to mojoshader.c for now.
Ryan C. Gordon <icculus@icculus.org>
parents:
466
diff
changeset
|
148 |
} SourceArgInfo; |
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
149 |
|
141
997857107c39
Attempt to optimize CMP and CND in GLSL profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
140
diff
changeset
|
150 |
#define SCRATCH_BUFFER_SIZE 128 |
343
5d7861fb677d
Increase number of scratch buffers.
Ryan C. Gordon <icculus@icculus.org>
parents:
342
diff
changeset
|
151 |
#define SCRATCH_BUFFERS 32 |
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
152 |
|
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
153 |
// !!! FIXME: the scratch buffers make Context pretty big. |
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
154 |
// !!! FIXME: might be worth having one set of static scratch buffers that |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
155 |
// !!! FIXME: are mutex protected? |
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
156 |
|
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
157 |
// Context...this is state that changes as we parse through a shader... |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
158 |
struct Context |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
159 |
{ |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
160 |
int isfail; |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
161 |
int out_of_memory; |
35 | 162 |
MOJOSHADER_malloc malloc; |
163 |
MOJOSHADER_free free; |
|
97
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
164 |
void *malloc_data; |
475
ea119c8ce5cd
Added error position information to MOJOSHADER_parseData.
Ryan C. Gordon <icculus@icculus.org>
parents:
470
diff
changeset
|
165 |
const uint32 *orig_tokens; |
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
166 |
const uint32 *tokens; |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
167 |
uint32 tokencount; |
523
699696afd731
Allow errors to specify post-processing problems.
Ryan C. Gordon <icculus@icculus.org>
parents:
519
diff
changeset
|
168 |
MOJOSHADER_parsePhase parse_phase; |
450
6a9faf398c1d
Allow overriding of swizzle on vertex attributes during bytecode parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
446
diff
changeset
|
169 |
const MOJOSHADER_swizzle *swizzles; |
6a9faf398c1d
Allow overriding of swizzle on vertex attributes during bytecode parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
446
diff
changeset
|
170 |
unsigned int swizzles_count; |
54
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
171 |
OutputList *output; |
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
172 |
OutputList globals; |
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
173 |
OutputList helpers; |
54
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
174 |
OutputList subroutines; |
189
d31efd640c13
Attribute fixes for GLSL profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
187
diff
changeset
|
175 |
OutputList mainline_intro; |
54
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
176 |
OutputList mainline; |
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
177 |
OutputList ignore; |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
178 |
OutputList *output_stack[2]; |
109
48e95cf41505
Added "passthrough" profile, which just sends the bytecode through unchanged;
Ryan C. Gordon <icculus@icculus.org>
parents:
108
diff
changeset
|
179 |
uint8 *output_bytes; // can be used instead of the OutputLists. |
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
180 |
int indent_stack[2]; |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
181 |
int output_stack_len; |
54
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
182 |
int output_len; // total strlen; prevents walking the lists just to malloc. |
40
f54f1635ac8a
[svn] Filling in some initial GLSL output. Not even close to done!
icculus
parents:
39
diff
changeset
|
183 |
int indent; |
334
5aebcea77f47
Cleaned up the shader type string code.
Ryan C. Gordon <icculus@icculus.org>
parents:
333
diff
changeset
|
184 |
const char *shader_type_str; |
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
185 |
const char *endline; |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
186 |
int endline_len; |
34 | 187 |
char scratch[SCRATCH_BUFFERS][SCRATCH_BUFFER_SIZE]; |
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
188 |
int scratchidx; // current scratch buffer. |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
189 |
int profileid; |
34 | 190 |
const Profile *profile; |
96
bc416e2b9de1
Removed convenience typedef.
Ryan C. Gordon <icculus@icculus.org>
parents:
95
diff
changeset
|
191 |
MOJOSHADER_shaderType shader_type; |
46 | 192 |
uint8 major_ver; |
193 |
uint8 minor_ver; |
|
161
a0e1920ce909
Removed "dest_args" array...it's only ever one structure.
Ryan C. Gordon <icculus@icculus.org>
parents:
160
diff
changeset
|
194 |
DestArgInfo dest_arg; |
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
195 |
SourceArgInfo source_args[5]; |
139
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
196 |
SourceArgInfo predicate_arg; // for predicated instructions. |
31 | 197 |
uint32 dwords[4]; |
398
a5faebe97da4
Initial work on parsing the CTAB comment block.
Ryan C. Gordon <icculus@icculus.org>
parents:
397
diff
changeset
|
198 |
uint32 version_token; |
46 | 199 |
int instruction_count; |
28 | 200 |
uint32 instruction_controls; |
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
201 |
uint32 previous_opcode; |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
202 |
int loops; |
114
3b8cf84b46b8
Implemented REP and ENDREP in the GLSL profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
112
diff
changeset
|
203 |
int reps; |
382
ab4167f50aad
Initial shot at REP/ENDREP in nv2 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
381
diff
changeset
|
204 |
int max_reps; |
118
6aa56b497f4e
Sorta implemented CMP for GLSL profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
117
diff
changeset
|
205 |
int cmps; |
329
e2688732204e
Generalized allocation of scratch registers in arb1 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
328
diff
changeset
|
206 |
int scratch_registers; |
e2688732204e
Generalized allocation of scratch registers in arb1 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
328
diff
changeset
|
207 |
int max_scratch_registers; |
382
ab4167f50aad
Initial shot at REP/ENDREP in nv2 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
381
diff
changeset
|
208 |
int branch_labels_stack_index; |
ab4167f50aad
Initial shot at REP/ENDREP in nv2 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
381
diff
changeset
|
209 |
int branch_labels_stack[32]; |
ab4167f50aad
Initial shot at REP/ENDREP in nv2 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
381
diff
changeset
|
210 |
int assigned_branch_labels; |
332
8c7544035bd0
More work on arb1 profile. Attributes and outputs, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
331
diff
changeset
|
211 |
int assigned_vertex_attributes; |
336
169b595c95fd
Fixed relative addressing in arb1 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
335
diff
changeset
|
212 |
int last_address_reg_component; |
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
213 |
RegisterList used_registers; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
214 |
RegisterList defined_registers; |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
215 |
int error_count; |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
216 |
ErrorList *errors; |
278
5c432d216078
Report hardcoded constants in MOJOSHADER_parseData.
Ryan C. Gordon <icculus@icculus.org>
parents:
268
diff
changeset
|
217 |
int constant_count; |
5c432d216078
Report hardcoded constants in MOJOSHADER_parseData.
Ryan C. Gordon <icculus@icculus.org>
parents:
268
diff
changeset
|
218 |
ConstantsList *constants; |
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
219 |
int uniform_count; |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
220 |
RegisterList uniforms; |
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
221 |
int attribute_count; |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
222 |
RegisterList attributes; |
148
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
223 |
int sampler_count; |
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
224 |
RegisterList samplers; |
399
dc2e64bd03ad
Extract useful information from the ctab.
Ryan C. Gordon <icculus@icculus.org>
parents:
398
diff
changeset
|
225 |
VariableList *variables; // variables to register mapping. |
463
6f3a82d7e3d2
Removed bitfields for full ints.
Ryan C. Gordon <icculus@icculus.org>
parents:
458
diff
changeset
|
226 |
int centroid_allowed; |
6f3a82d7e3d2
Removed bitfields for full ints.
Ryan C. Gordon <icculus@icculus.org>
parents:
458
diff
changeset
|
227 |
int have_ctab; |
531
a059fa2d137a
Initial work on input registers with relative addressing.
Ryan C. Gordon <icculus@icculus.org>
parents:
525
diff
changeset
|
228 |
int have_relative_input_registers; |
463
6f3a82d7e3d2
Removed bitfields for full ints.
Ryan C. Gordon <icculus@icculus.org>
parents:
458
diff
changeset
|
229 |
int determined_constants_arrays; |
6f3a82d7e3d2
Removed bitfields for full ints.
Ryan C. Gordon <icculus@icculus.org>
parents:
458
diff
changeset
|
230 |
int predicated; |
6f3a82d7e3d2
Removed bitfields for full ints.
Ryan C. Gordon <icculus@icculus.org>
parents:
458
diff
changeset
|
231 |
int support_nv2; |
6f3a82d7e3d2
Removed bitfields for full ints.
Ryan C. Gordon <icculus@icculus.org>
parents:
458
diff
changeset
|
232 |
int support_nv3; |
6f3a82d7e3d2
Removed bitfields for full ints.
Ryan C. Gordon <icculus@icculus.org>
parents:
458
diff
changeset
|
233 |
int support_nv4; |
6f3a82d7e3d2
Removed bitfields for full ints.
Ryan C. Gordon <icculus@icculus.org>
parents:
458
diff
changeset
|
234 |
int support_glsl120; |
6f3a82d7e3d2
Removed bitfields for full ints.
Ryan C. Gordon <icculus@icculus.org>
parents:
458
diff
changeset
|
235 |
int glsl_generated_lit_opcode; |
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
236 |
}; |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
237 |
|
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
238 |
|
97
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
239 |
// Convenience functions for allocators... |
610
166cdcc4414a
Don't include malloc()/free() references if using MOJOSHADER_FORCE_ALLOCATOR.
Ryan C. Gordon <icculus@icculus.org>
parents:
558
diff
changeset
|
240 |
#if !MOJOSHADER_FORCE_ALLOCATOR |
553
288ed486e5c3
Renamed internal_malloc() and internal_free().
Ryan C. Gordon <icculus@icculus.org>
parents:
551
diff
changeset
|
241 |
void *MOJOSHADER_internal_malloc(int bytes, void *d) { return malloc(bytes); } |
288ed486e5c3
Renamed internal_malloc() and internal_free().
Ryan C. Gordon <icculus@icculus.org>
parents:
551
diff
changeset
|
242 |
void MOJOSHADER_internal_free(void *ptr, void *d) { free(ptr); } |
610
166cdcc4414a
Don't include malloc()/free() references if using MOJOSHADER_FORCE_ALLOCATOR.
Ryan C. Gordon <icculus@icculus.org>
parents:
558
diff
changeset
|
243 |
#endif |
97
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
244 |
|
551
217200672d64
Make sure internal symbols aren't polluting namespace.
Ryan C. Gordon <icculus@icculus.org>
parents:
547
diff
changeset
|
245 |
MOJOSHADER_error MOJOSHADER_out_of_mem_error = { "Out of memory", NULL, -1 }; |
217200672d64
Make sure internal symbols aren't polluting namespace.
Ryan C. Gordon <icculus@icculus.org>
parents:
547
diff
changeset
|
246 |
MOJOSHADER_parseData MOJOSHADER_out_of_mem_data = { |
217200672d64
Make sure internal symbols aren't polluting namespace.
Ryan C. Gordon <icculus@icculus.org>
parents:
547
diff
changeset
|
247 |
1, &MOJOSHADER_out_of_mem_error, 0, 0, 0, 0, |
217200672d64
Make sure internal symbols aren't polluting namespace.
Ryan C. Gordon <icculus@icculus.org>
parents:
547
diff
changeset
|
248 |
MOJOSHADER_TYPE_UNKNOWN, 0, 0, 0, 0 |
194
8de489efc811
Malloc() now handles calling out_of_memory() if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
193
diff
changeset
|
249 |
}; |
8de489efc811
Malloc() now handles calling out_of_memory() if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
193
diff
changeset
|
250 |
|
542
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
251 |
static inline void out_of_memory(Context *ctx) |
194
8de489efc811
Malloc() now handles calling out_of_memory() if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
193
diff
changeset
|
252 |
{ |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
253 |
ctx->isfail = ctx->out_of_memory = 1; |
194
8de489efc811
Malloc() now handles calling out_of_memory() if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
193
diff
changeset
|
254 |
} // out_of_memory |
8de489efc811
Malloc() now handles calling out_of_memory() if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
193
diff
changeset
|
255 |
|
307
42f6a7ba69e2
Fixes for Visual Studio level 4 compiler warnings.
Ryan C. Gordon <icculus@icculus.org>
parents:
306
diff
changeset
|
256 |
static inline void *Malloc(Context *ctx, const size_t len) |
42f6a7ba69e2
Fixes for Visual Studio level 4 compiler warnings.
Ryan C. Gordon <icculus@icculus.org>
parents:
306
diff
changeset
|
257 |
{ |
42f6a7ba69e2
Fixes for Visual Studio level 4 compiler warnings.
Ryan C. Gordon <icculus@icculus.org>
parents:
306
diff
changeset
|
258 |
void *retval = ctx->malloc((int) len, ctx->malloc_data); |
194
8de489efc811
Malloc() now handles calling out_of_memory() if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
193
diff
changeset
|
259 |
if (retval == NULL) |
8de489efc811
Malloc() now handles calling out_of_memory() if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
193
diff
changeset
|
260 |
out_of_memory(ctx); |
8de489efc811
Malloc() now handles calling out_of_memory() if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
193
diff
changeset
|
261 |
return retval; |
97
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
262 |
} // Malloc |
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
263 |
|
541 | 264 |
static inline char *StrDup(Context *ctx, const char *str) |
265 |
{ |
|
266 |
char *retval = (char *) Malloc(ctx, strlen(str) + 1); |
|
554 | 267 |
if (retval != NULL) |
541 | 268 |
strcpy(retval, str); |
269 |
return retval; |
|
270 |
} // StrDup |
|
97
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
271 |
|
194
8de489efc811
Malloc() now handles calling out_of_memory() if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
193
diff
changeset
|
272 |
static inline void Free(Context *ctx, void *ptr) |
126
556779e8a6d7
Minor tweaks to Malloc() and Free() convenience functions.
Ryan C. Gordon <icculus@icculus.org>
parents:
124
diff
changeset
|
273 |
{ |
556779e8a6d7
Minor tweaks to Malloc() and Free() convenience functions.
Ryan C. Gordon <icculus@icculus.org>
parents:
124
diff
changeset
|
274 |
if (ptr != NULL) // check for NULL in case of dumb free() impl. |
99
20d0bb294e9e
Check for NULL in Free().
Ryan C. Gordon <icculus@icculus.org>
parents:
98
diff
changeset
|
275 |
ctx->free(ptr, ctx->malloc_data); |
97
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
276 |
} // Free |
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
277 |
|
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
278 |
|
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
279 |
// jump between output sections in the context... |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
280 |
|
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
281 |
static inline void push_output(Context *ctx, OutputList *section) |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
282 |
{ |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
283 |
assert(ctx->output_stack_len < STATICARRAYLEN(ctx->output_stack)); |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
284 |
ctx->output_stack[ctx->output_stack_len] = ctx->output; |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
285 |
ctx->indent_stack[ctx->output_stack_len] = ctx->indent; |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
286 |
ctx->output_stack_len++; |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
287 |
ctx->output = section; |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
288 |
ctx->indent = 0; |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
289 |
} // push_output |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
290 |
|
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
291 |
static inline void pop_output(Context *ctx) |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
292 |
{ |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
293 |
assert(ctx->output_stack_len > 0); |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
294 |
ctx->output_stack_len--; |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
295 |
ctx->output = ctx->output_stack[ctx->output_stack_len]; |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
296 |
ctx->indent = ctx->indent_stack[ctx->output_stack_len]; |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
297 |
} // pop_output |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
298 |
|
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
299 |
|
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
300 |
|
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
301 |
// Shader model version magic... |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
302 |
|
43
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
303 |
static inline uint32 ver_ui32(const uint8 major, const uint8 minor) |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
304 |
{ |
493
e2c930ab84b5
Allow SM3 shaders that are vs_3_x or vs_3_sw.
Ryan C. Gordon <icculus@icculus.org>
parents:
491
diff
changeset
|
305 |
return ( (((uint32) major) << 16) | (((minor) == 0xFF) ? 1 : (minor)) ); |
43
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
306 |
} // version_ui32 |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
307 |
|
151
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
308 |
static inline int shader_version_supported(const uint8 maj, const uint8 min) |
43
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
309 |
{ |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
310 |
return (ver_ui32(maj,min) <= ver_ui32(MAX_SHADER_MAJOR, MAX_SHADER_MINOR)); |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
311 |
} // shader_version_supported |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
312 |
|
151
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
313 |
static inline int shader_version_atleast(const Context *ctx, const uint8 maj, |
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
314 |
const uint8 min) |
43
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
315 |
{ |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
316 |
return (ver_ui32(ctx->major_ver, ctx->minor_ver) >= ver_ui32(maj, min)); |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
317 |
} // shader_version_atleast |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
318 |
|
400
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
319 |
static inline int shader_version_exactly(const Context *ctx, const uint8 maj, |
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
320 |
const uint8 min) |
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
321 |
{ |
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
322 |
return ((ctx->major_ver == maj) && (ctx->minor_ver == min)); |
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
323 |
} // shader_version_exactly |
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
324 |
|
151
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
325 |
static inline int shader_is_pixel(const Context *ctx) |
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
326 |
{ |
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
327 |
return (ctx->shader_type == MOJOSHADER_TYPE_PIXEL); |
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
328 |
} // shader_is_pixel |
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
329 |
|
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
330 |
static inline int shader_is_vertex(const Context *ctx) |
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
331 |
{ |
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
332 |
return (ctx->shader_type == MOJOSHADER_TYPE_VERTEX); |
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
333 |
} // shader_is_vertex |
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
334 |
|
43
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
335 |
|
48 | 336 |
static inline int isfail(const Context *ctx) |
44
5d56cf8b4571
[svn] Cleaned up fail check, parse_args and state machine semantics, and added check
icculus
parents:
43
diff
changeset
|
337 |
{ |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
338 |
return ctx->isfail; |
44
5d56cf8b4571
[svn] Cleaned up fail check, parse_args and state machine semantics, and added check
icculus
parents:
43
diff
changeset
|
339 |
} // isfail |
5d56cf8b4571
[svn] Cleaned up fail check, parse_args and state machine semantics, and added check
icculus
parents:
43
diff
changeset
|
340 |
|
5d56cf8b4571
[svn] Cleaned up fail check, parse_args and state machine semantics, and added check
icculus
parents:
43
diff
changeset
|
341 |
|
344
94cf695babc6
Better sanity checking on scratch buffer array.
Ryan C. Gordon <icculus@icculus.org>
parents:
343
diff
changeset
|
342 |
static inline char *get_scratch_buffer(Context *ctx) |
94cf695babc6
Better sanity checking on scratch buffer array.
Ryan C. Gordon <icculus@icculus.org>
parents:
343
diff
changeset
|
343 |
{ |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
344 |
assert(ctx->scratchidx < SCRATCH_BUFFERS); |
344
94cf695babc6
Better sanity checking on scratch buffer array.
Ryan C. Gordon <icculus@icculus.org>
parents:
343
diff
changeset
|
345 |
ctx->scratchidx = (ctx->scratchidx + 1) % SCRATCH_BUFFERS; |
94cf695babc6
Better sanity checking on scratch buffer array.
Ryan C. Gordon <icculus@icculus.org>
parents:
343
diff
changeset
|
346 |
return ctx->scratch[ctx->scratchidx]; |
94cf695babc6
Better sanity checking on scratch buffer array.
Ryan C. Gordon <icculus@icculus.org>
parents:
343
diff
changeset
|
347 |
} // get_scratch_buffer |
94cf695babc6
Better sanity checking on scratch buffer array.
Ryan C. Gordon <icculus@icculus.org>
parents:
343
diff
changeset
|
348 |
|
94cf695babc6
Better sanity checking on scratch buffer array.
Ryan C. Gordon <icculus@icculus.org>
parents:
343
diff
changeset
|
349 |
|
542
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
350 |
static void failf(Context *ctx, const char *fmt, ...) ISPRINTF(2,3); |
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
351 |
static void failf(Context *ctx, const char *fmt, ...) |
12
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
352 |
{ |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
353 |
ctx->isfail = 1; |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
354 |
if (ctx->out_of_memory) |
542
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
355 |
return; |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
356 |
|
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
357 |
int error_position = 0; |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
358 |
switch (ctx->parse_phase) |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
359 |
{ |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
360 |
case MOJOSHADER_PARSEPHASE_NOTSTARTED: |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
361 |
error_position = -2; |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
362 |
break; |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
363 |
case MOJOSHADER_PARSEPHASE_WORKING: |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
364 |
error_position = (ctx->tokens - ctx->orig_tokens) * sizeof (uint32); |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
365 |
break; |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
366 |
case MOJOSHADER_PARSEPHASE_DONE: |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
367 |
error_position = -1; |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
368 |
break; |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
369 |
default: |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
370 |
assert(0 && "Unexpected value"); |
542
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
371 |
return; |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
372 |
} // switch |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
373 |
|
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
374 |
ErrorList *error = (ErrorList *) Malloc(ctx, sizeof (ErrorList)); |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
375 |
if (error == NULL) |
542
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
376 |
return; |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
377 |
|
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
378 |
char *scratch = get_scratch_buffer(ctx); |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
379 |
va_list ap; |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
380 |
va_start(ap, fmt); |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
381 |
const int len = vsnprintf(scratch, SCRATCH_BUFFER_SIZE, fmt, ap); |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
382 |
va_end(ap); |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
383 |
|
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
384 |
char *failstr = (char *) Malloc(ctx, len + 1); |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
385 |
if (failstr == NULL) |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
386 |
Free(ctx, error); |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
387 |
else |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
388 |
{ |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
389 |
// see comments about scratch buffer overflow in output_line(). |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
390 |
if (len < SCRATCH_BUFFER_SIZE) |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
391 |
strcpy(failstr, scratch); // copy it over. |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
392 |
else |
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
393 |
{ |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
394 |
va_start(ap, fmt); |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
395 |
vsnprintf(failstr, len + 1, fmt, ap); // rebuild it. |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
396 |
va_end(ap); |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
397 |
} // else |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
398 |
|
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
399 |
error->error.error = failstr; |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
400 |
error->error.filename = NULL; // no filename at this level. |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
401 |
error->error.error_position = error_position; |
544
f829f48e5214
Fixed stupid linked list bug.
Ryan C. Gordon <icculus@icculus.org>
parents:
542
diff
changeset
|
402 |
error->next = NULL; |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
403 |
|
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
404 |
ErrorList *prev = NULL; |
544
f829f48e5214
Fixed stupid linked list bug.
Ryan C. Gordon <icculus@icculus.org>
parents:
542
diff
changeset
|
405 |
ErrorList *item = ctx->errors; |
f829f48e5214
Fixed stupid linked list bug.
Ryan C. Gordon <icculus@icculus.org>
parents:
542
diff
changeset
|
406 |
while (item != NULL) |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
407 |
{ |
544
f829f48e5214
Fixed stupid linked list bug.
Ryan C. Gordon <icculus@icculus.org>
parents:
542
diff
changeset
|
408 |
prev = item; |
558
314c86ff14dd
Fixed stupid linked list bug.
Ryan C. Gordon <icculus@icculus.org>
parents:
554
diff
changeset
|
409 |
item = item->next; |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
410 |
} // while |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
411 |
|
544
f829f48e5214
Fixed stupid linked list bug.
Ryan C. Gordon <icculus@icculus.org>
parents:
542
diff
changeset
|
412 |
if (prev == NULL) |
f829f48e5214
Fixed stupid linked list bug.
Ryan C. Gordon <icculus@icculus.org>
parents:
542
diff
changeset
|
413 |
ctx->errors = error; |
f829f48e5214
Fixed stupid linked list bug.
Ryan C. Gordon <icculus@icculus.org>
parents:
542
diff
changeset
|
414 |
else |
536
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
415 |
prev->next = error; |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
416 |
|
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
417 |
ctx->error_count++; |
5af65fe6e917
Allow multiple errors from parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
535
diff
changeset
|
418 |
} // else |
12
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
419 |
} // failf |
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
420 |
|
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
421 |
|
542
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
422 |
static inline void fail(Context *ctx, const char *reason) |
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
423 |
{ |
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
424 |
failf(ctx, "%s", reason); |
12
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
425 |
} // fail |
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
426 |
|
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
427 |
|
542
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
428 |
static void output_line(Context *ctx, const char *fmt, ...) ISPRINTF(2,3); |
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
429 |
static void output_line(Context *ctx, const char *fmt, ...) |
7 | 430 |
{ |
54
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
431 |
OutputListNode *item = NULL; |
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
432 |
|
541 | 433 |
if (isfail(ctx) || ctx->out_of_memory) |
434 |
return; // we failed previously, don't go on... |
|
12
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
435 |
|
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
436 |
char *scratch = get_scratch_buffer(ctx); |
40
f54f1635ac8a
[svn] Filling in some initial GLSL output. Not even close to done!
icculus
parents:
39
diff
changeset
|
437 |
|
f54f1635ac8a
[svn] Filling in some initial GLSL output. Not even close to done!
icculus
parents:
39
diff
changeset
|
438 |
const int indent = ctx->indent; |
41 | 439 |
if (indent > 0) |
440 |
memset(scratch, '\t', indent); |
|
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
441 |
|
12
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
442 |
va_list ap; |
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
443 |
va_start(ap, fmt); |
40
f54f1635ac8a
[svn] Filling in some initial GLSL output. Not even close to done!
icculus
parents:
39
diff
changeset
|
444 |
const int len = vsnprintf(scratch+indent, SCRATCH_BUFFER_SIZE-indent, fmt, ap) + indent; |
12
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
445 |
va_end(ap); |
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
446 |
|
97
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
447 |
item = (OutputListNode *) Malloc(ctx, sizeof (OutputListNode)); |
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
448 |
if (item == NULL) |
542
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
449 |
return; |
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
450 |
|
97
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
451 |
item->str = (char *) Malloc(ctx, len + 1); |
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
452 |
if (item->str == NULL) |
12
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
453 |
{ |
98
08b137beb1e3
Whoops, wrong free() call.
Ryan C. Gordon <icculus@icculus.org>
parents:
97
diff
changeset
|
454 |
Free(ctx, item); |
542
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
455 |
return; |
12
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
456 |
} // if |
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
457 |
|
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
458 |
// If we overflowed our scratch buffer, that's okay. We were going to |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
459 |
// allocate anyhow...the scratch buffer just lets us avoid a second |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
460 |
// run of vsnprintf(). |
34 | 461 |
if (len < SCRATCH_BUFFER_SIZE) |
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
462 |
strcpy(item->str, scratch); // copy it over. |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
463 |
else |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
464 |
{ |
41 | 465 |
if (indent > 0) |
466 |
memset(item->str, '\t', indent); |
|
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
467 |
va_start(ap, fmt); |
40
f54f1635ac8a
[svn] Filling in some initial GLSL output. Not even close to done!
icculus
parents:
39
diff
changeset
|
468 |
vsnprintf(item->str+indent, len + 1, fmt, ap); // rebuild it. |
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
469 |
va_end(ap); |
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
470 |
} // else |
12
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
471 |
|
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
472 |
item->next = NULL; |
54
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
473 |
|
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
474 |
ctx->output->tail->next = item; |
b2b64d39df0f
[svn] Split up output into several lists, so GLSL profile can insert lines of text
icculus
parents:
51
diff
changeset
|
475 |
ctx->output->tail = item; |
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
476 |
ctx->output_len += len + ctx->endline_len; |
12
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
477 |
} // output_line |
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
478 |
|
d81712dd1a46
[svn] Cleaned up and improved output and fail state.
icculus
parents:
11
diff
changeset
|
479 |
|
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
480 |
// this is just to stop gcc whining. |
542
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
481 |
static inline void output_blank_line(Context *ctx) |
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
482 |
{ |
a56d3bfd2e36
More work on multiple error messages.
Ryan C. Gordon <icculus@icculus.org>
parents:
541
diff
changeset
|
483 |
output_line(ctx, "%s", ""); |
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
484 |
} // output_blank_line |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
485 |
|
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
486 |
|
43
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
487 |
// !!! FIXME: this is sort of nasty. |
72
b193a3182dcd
Tweak floatstr() to produce strings the GLSL profile can use.
Ryan C. Gordon <icculus@icculus.org>
parents:
71
diff
changeset
|
488 |
static void floatstr(Context *ctx, char *buf, size_t bufsize, float f, |
b193a3182dcd
Tweak floatstr() to produce strings the GLSL profile can use.
Ryan C. Gordon <icculus@icculus.org>
parents:
71
diff
changeset
|
489 |
int leavedecimal) |
43
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
490 |
{ |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
491 |
const size_t len = snprintf(buf, bufsize, "%f", f); |
72
b193a3182dcd
Tweak floatstr() to produce strings the GLSL profile can use.
Ryan C. Gordon <icculus@icculus.org>
parents:
71
diff
changeset
|
492 |
if ((len+2) >= bufsize) |
43
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
493 |
fail(ctx, "BUG: internal buffer is too small"); |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
494 |
else |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
495 |
{ |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
496 |
char *end = buf + len; |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
497 |
char *ptr = strchr(buf, '.'); |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
498 |
if (ptr == NULL) |
72
b193a3182dcd
Tweak floatstr() to produce strings the GLSL profile can use.
Ryan C. Gordon <icculus@icculus.org>
parents:
71
diff
changeset
|
499 |
{ |
b193a3182dcd
Tweak floatstr() to produce strings the GLSL profile can use.
Ryan C. Gordon <icculus@icculus.org>
parents:
71
diff
changeset
|
500 |
if (leavedecimal) |
b193a3182dcd
Tweak floatstr() to produce strings the GLSL profile can use.
Ryan C. Gordon <icculus@icculus.org>
parents:
71
diff
changeset
|
501 |
strcat(buf, ".0"); |
43
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
502 |
return; // done. |
72
b193a3182dcd
Tweak floatstr() to produce strings the GLSL profile can use.
Ryan C. Gordon <icculus@icculus.org>
parents:
71
diff
changeset
|
503 |
} // if |
43
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
504 |
|
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
505 |
while (--end != ptr) |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
506 |
{ |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
507 |
if (*end != '0') |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
508 |
{ |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
509 |
end++; |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
510 |
break; |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
511 |
} // if |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
512 |
} // while |
72
b193a3182dcd
Tweak floatstr() to produce strings the GLSL profile can use.
Ryan C. Gordon <icculus@icculus.org>
parents:
71
diff
changeset
|
513 |
if ((leavedecimal) && (end == ptr)) |
b193a3182dcd
Tweak floatstr() to produce strings the GLSL profile can use.
Ryan C. Gordon <icculus@icculus.org>
parents:
71
diff
changeset
|
514 |
end += 2; |
43
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
515 |
*end = '\0'; // chop extra '0' or all decimal places off. |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
516 |
} // else |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
517 |
} // floatstr |
2f5d9a656dff
[svn] Bunch More Work. Cleaned up some lingering opcode drama, and state machine
icculus
parents:
42
diff
changeset
|
518 |
|
17 | 519 |
|
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
520 |
// Deal with register lists... !!! FIXME: I sort of hate this. |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
521 |
|
97
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
522 |
static void free_reglist(MOJOSHADER_free f, void *d, RegisterList *item) |
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
523 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
524 |
while (item != NULL) |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
525 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
526 |
RegisterList *next = item->next; |
97
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
527 |
f(item, d); |
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
528 |
item = next; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
529 |
} // while |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
530 |
} // free_reglist |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
531 |
|
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
532 |
static inline uint32 reg_to_ui32(const RegisterType regtype, const int regnum) |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
533 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
534 |
return ( ((uint32) regtype) | (((uint32) regnum) << 16) ); |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
535 |
} // reg_to_uint32 |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
536 |
|
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
537 |
static RegisterList *reglist_insert(Context *ctx, RegisterList *prev, |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
538 |
const RegisterType regtype, |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
539 |
const int regnum) |
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
540 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
541 |
const uint32 newval = reg_to_ui32(regtype, regnum); |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
542 |
RegisterList *item = prev->next; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
543 |
while (item != NULL) |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
544 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
545 |
const uint32 val = reg_to_ui32(item->regtype, item->regnum); |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
546 |
if (newval == val) |
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
547 |
return item; // already set, so we're done. |
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
548 |
else if (newval < val) // insert it here. |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
549 |
break; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
550 |
else // if (newval > val) |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
551 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
552 |
// keep going, we're not to the insertion point yet. |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
553 |
prev = item; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
554 |
item = item->next; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
555 |
} // else |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
556 |
} // while |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
557 |
|
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
558 |
// we need to insert an entry after (prev). |
97
4a41e3d17297
Allow instance data to be passed to the allocator.
Ryan C. Gordon <icculus@icculus.org>
parents:
96
diff
changeset
|
559 |
item = (RegisterList *) Malloc(ctx, sizeof (RegisterList)); |
194
8de489efc811
Malloc() now handles calling out_of_memory() if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
193
diff
changeset
|
560 |
if (item != NULL) |
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
561 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
562 |
item->regtype = regtype; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
563 |
item->regnum = regnum; |
248
568c8f9d7cb9
Don't overload meaning of RegisterList::usage for loop tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
235
diff
changeset
|
564 |
item->usage = MOJOSHADER_USAGE_UNKNOWN; |
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
565 |
item->index = 0; |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
566 |
item->writemask = 0; |
248
568c8f9d7cb9
Don't overload meaning of RegisterList::usage for loop tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
235
diff
changeset
|
567 |
item->misc = 0; |
402
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
568 |
item->array = NULL; |
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
569 |
item->next = prev->next; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
570 |
prev->next = item; |
194
8de489efc811
Malloc() now handles calling out_of_memory() if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
193
diff
changeset
|
571 |
} // if |
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
572 |
|
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
573 |
return item; |
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
574 |
} // reglist_insert |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
575 |
|
450
6a9faf398c1d
Allow overriding of swizzle on vertex attributes during bytecode parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
446
diff
changeset
|
576 |
static RegisterList *reglist_find(const RegisterList *prev, |
6a9faf398c1d
Allow overriding of swizzle on vertex attributes during bytecode parsing.
Ryan C. Gordon <icculus@icculus.org>
parents:
446
diff
changeset
|
577 |
const RegisterType rtype, const int regnum) |
122
e9da4ede0a27
Hopefully fixed loop register inheriting to subroutines.
Ryan C. Gordon <icculus@icculus.org>
parents:
121
diff
changeset
|
578 |
{ |
e9da4ede0a27
Hopefully fixed loop register inheriting to subroutines.
Ryan C. Gordon <icculus@icculus.org>
parents:
121
diff
changeset
|
579 |
const uint32 newval = reg_to_ui32(rtype, regnum); |
e9da4ede0a27
Hopefully fixed loop register inheriting to subroutines.
Ryan C. Gordon <icculus@icculus.org>
parents:
121
diff
changeset
|
580 |
RegisterList *item = prev->next; |
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
581 |
while (item != NULL) |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
582 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
583 |
const uint32 val = reg_to_ui32(item->regtype, item->regnum); |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
584 |
if (newval == val) |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
585 |
return item; // here it is. |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
586 |
else if (newval < val) // should have been here if it existed. |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
587 |
return NULL; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
588 |
else // if (newval > val) |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
589 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
590 |
// keep going, we're not to the insertion point yet. |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
591 |
prev = item; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
592 |
item = item->next; |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
593 |
} // else |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
594 |
} // while |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
595 |
|
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
596 |
return NULL; // wasn't in the list. |
122
e9da4ede0a27
Hopefully fixed loop register inheriting to subroutines.
Ryan C. Gordon <icculus@icculus.org>
parents:
121
diff
changeset
|
597 |
} // reglist_find |
e9da4ede0a27
Hopefully fixed loop register inheriting to subroutines.
Ryan C. Gordon <icculus@icculus.org>
parents:
121
diff
changeset
|
598 |
|
e9da4ede0a27
Hopefully fixed loop register inheriting to subroutines.
Ryan C. Gordon <icculus@icculus.org>
parents:
121
diff
changeset
|
599 |
static inline const RegisterList *reglist_exists(RegisterList *prev, |
e9da4ede0a27
Hopefully fixed loop register inheriting to subroutines.
Ryan C. Gordon <icculus@icculus.org>
parents:
121
diff
changeset
|
600 |
const RegisterType regtype, |
e9da4ede0a27
Hopefully fixed loop register inheriting to subroutines.
Ryan C. Gordon <icculus@icculus.org>
parents:
121
diff
changeset
|
601 |
const int regnum) |
e9da4ede0a27
Hopefully fixed loop register inheriting to subroutines.
Ryan C. Gordon <icculus@icculus.org>
parents:
121
diff
changeset
|
602 |
{ |
e9da4ede0a27
Hopefully fixed loop register inheriting to subroutines.
Ryan C. Gordon <icculus@icculus.org>
parents:
121
diff
changeset
|
603 |
return (reglist_find(prev, regtype, regnum)); |
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
604 |
} // reglist_exists |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
605 |
|
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
606 |
static inline void set_used_register(Context *ctx, const RegisterType regtype, |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
607 |
const int regnum) |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
608 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
609 |
reglist_insert(ctx, &ctx->used_registers, regtype, regnum); |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
610 |
} // set_used_register |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
611 |
|
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
612 |
static inline int get_used_register(Context *ctx, const RegisterType regtype, |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
613 |
const int regnum) |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
614 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
615 |
return (reglist_exists(&ctx->used_registers, regtype, regnum) != NULL); |
83
ce46250e553d
Add defined/declared registers to the appropriate register list.
Ryan C. Gordon <icculus@icculus.org>
parents:
82
diff
changeset
|
616 |
} // get_used_register |
82
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
617 |
|
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
618 |
static inline void set_defined_register(Context *ctx, const RegisterType rtype, |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
619 |
const int regnum) |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
620 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
621 |
reglist_insert(ctx, &ctx->defined_registers, rtype, regnum); |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
622 |
} // set_defined_register |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
623 |
|
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
624 |
static inline int get_defined_register(Context *ctx, const RegisterType rtype, |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
625 |
const int regnum) |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
626 |
{ |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
627 |
return (reglist_exists(&ctx->defined_registers, rtype, regnum) != NULL); |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
628 |
} // get_defined_register |
dc7ad4cea75b
Keep a list of used/defined registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
81
diff
changeset
|
629 |
|
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
630 |
static void add_attribute_register(Context *ctx, const RegisterType rtype, |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
631 |
const int regnum, const MOJOSHADER_usage usage, |
431
0d0cbe10db02
First shot at nv4 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
430
diff
changeset
|
632 |
const int index, const int writemask, int flags) |
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
633 |
{ |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
634 |
RegisterList *item = reglist_insert(ctx, &ctx->attributes, rtype, regnum); |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
635 |
item->usage = usage; |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
636 |
item->index = index; |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
637 |
item->writemask = writemask; |
431
0d0cbe10db02
First shot at nv4 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
430
diff
changeset
|
638 |
item->misc = flags; |
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
639 |
} // add_attribute_register |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
640 |
|
148
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
641 |
static inline void add_sampler(Context *ctx, const RegisterType rtype, |
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
642 |
const int regnum, const TextureType ttype) |
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
643 |
{ |
297 | 644 |
// !!! FIXME: make sure it doesn't exist? |
148
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
645 |
RegisterList *item = reglist_insert(ctx, &ctx->samplers, rtype, regnum); |
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
646 |
item->index = (int) ttype; |
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
647 |
} // add_sampler |
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
648 |
|
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
649 |
|
295
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
650 |
static inline int writemask_xyzw(const int writemask) |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
651 |
{ |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
652 |
return (writemask == 0xF); // 0xF == 1111. No explicit mask (full!). |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
653 |
} // writemask_xyzw |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
654 |
|
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
655 |
|
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
656 |
static inline int writemask_xyz(const int writemask) |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
657 |
{ |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
658 |
return (writemask == 0x7); // 0x7 == 0111. (that is: xyz) |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
659 |
} // writemask_xyz |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
660 |
|
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
661 |
|
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
662 |
static inline int writemask_xy(const int writemask) |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
663 |
{ |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
664 |
return (writemask == 0x3); // 0x3 == 0011. (that is: xy) |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
665 |
} // writemask_xy |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
666 |
|
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
667 |
|
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
668 |
static inline int writemask_x(const int writemask) |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
669 |
{ |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
670 |
return (writemask == 0x1); // 0x1 == 0001. (that is: x) |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
671 |
} // writemask_x |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
672 |
|
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
673 |
|
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
674 |
static inline int writemask_y(const int writemask) |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
675 |
{ |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
676 |
return (writemask == 0x2); // 0x1 == 0010. (that is: y) |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
677 |
} // writemask_y |
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
678 |
|
54ef3ccdfa58
Cleaned up explicit writemask tests.
Ryan C. Gordon <icculus@icculus.org>
parents:
294
diff
changeset
|
679 |
|
121
37de8c6bb262
Fixed comparisons in GLSL profile and improved validation.
Ryan C. Gordon <icculus@icculus.org>
parents:
120
diff
changeset
|
680 |
static inline int replicate_swizzle(const int swizzle) |
37de8c6bb262
Fixed comparisons in GLSL profile and improved validation.
Ryan C. Gordon <icculus@icculus.org>
parents:
120
diff
changeset
|
681 |
{ |
37de8c6bb262
Fixed comparisons in GLSL profile and improved validation.
Ryan C. Gordon <icculus@icculus.org>
parents:
120
diff
changeset
|
682 |
return ( (((swizzle >> 0) & 0x3) == ((swizzle >> 2) & 0x3)) && |
37de8c6bb262
Fixed comparisons in GLSL profile and improved validation.
Ryan C. Gordon <icculus@icculus.org>
parents:
120
diff
changeset
|
683 |
(((swizzle >> 2) & 0x3) == ((swizzle >> 4) & 0x3)) && |
37de8c6bb262
Fixed comparisons in GLSL profile and improved validation.
Ryan C. Gordon <icculus@icculus.org>
parents:
120
diff
changeset
|
684 |
(((swizzle >> 4) & 0x3) == ((swizzle >> 6) & 0x3)) ); |
37de8c6bb262
Fixed comparisons in GLSL profile and improved validation.
Ryan C. Gordon <icculus@icculus.org>
parents:
120
diff
changeset
|
685 |
} // replicate_swizzle |
37de8c6bb262
Fixed comparisons in GLSL profile and improved validation.
Ryan C. Gordon <icculus@icculus.org>
parents:
120
diff
changeset
|
686 |
|
37de8c6bb262
Fixed comparisons in GLSL profile and improved validation.
Ryan C. Gordon <icculus@icculus.org>
parents:
120
diff
changeset
|
687 |
|
292
f6c1a2ec6030
Added >= ps_2_0 state for TEXLD opcode, cleaned up swizzle checks.
Ryan C. Gordon <icculus@icculus.org>
parents:
291
diff
changeset
|
688 |
static inline int no_swizzle(const int swizzle) |
f6c1a2ec6030
Added >= ps_2_0 state for TEXLD opcode, cleaned up swizzle checks.
Ryan C. Gordon <icculus@icculus.org>
parents:
291
diff
changeset
|
689 |
{ |
296 | 690 |
return (swizzle == 0xE4); // 0xE4 == 11100100 ... 0 1 2 3. No swizzle. |
292
f6c1a2ec6030
Added >= ps_2_0 state for TEXLD opcode, cleaned up swizzle checks.
Ryan C. Gordon <icculus@icculus.org>
parents:
291
diff
changeset
|
691 |
} // no_swizzle |
f6c1a2ec6030
Added >= ps_2_0 state for TEXLD opcode, cleaned up swizzle checks.
Ryan C. Gordon <icculus@icculus.org>
parents:
291
diff
changeset
|
692 |
|
f6c1a2ec6030
Added >= ps_2_0 state for TEXLD opcode, cleaned up swizzle checks.
Ryan C. Gordon <icculus@icculus.org>
parents:
291
diff
changeset
|
693 |
|
165
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
694 |
static inline int vecsize_from_writemask(const int m) |
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
695 |
{ |
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
696 |
return (m & 1) + ((m >> 1) & 1) + ((m >> 2) & 1) + ((m >> 3) & 1); |
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
697 |
} // vecsize_from_writemask |
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
698 |
|
329
e2688732204e
Generalized allocation of scratch registers in arb1 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
328
diff
changeset
|
699 |
static int allocate_scratch_register(Context *ctx) |
e2688732204e
Generalized allocation of scratch registers in arb1 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
328
diff
changeset
|
700 |
{ |
e2688732204e
Generalized allocation of scratch registers in arb1 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
328
diff
changeset
|
701 |
const int retval = ctx->scratch_registers++; |
e2688732204e
Generalized allocation of scratch registers in arb1 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
328
diff
changeset
|
702 |
if (retval >= ctx->max_scratch_registers) |
e2688732204e
Generalized allocation of scratch registers in arb1 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
328
diff
changeset
|
703 |
ctx->max_scratch_registers = retval + 1; |
e2688732204e
Generalized allocation of scratch registers in arb1 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
328
diff
changeset
|
704 |
return retval; |
e2688732204e
Generalized allocation of scratch registers in arb1 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
328
diff
changeset
|
705 |
} // allocate_scratch_register |
e2688732204e
Generalized allocation of scratch registers in arb1 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
328
diff
changeset
|
706 |
|
382
ab4167f50aad
Initial shot at REP/ENDREP in nv2 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
381
diff
changeset
|
707 |
static int allocate_branch_label(Context *ctx) |
ab4167f50aad
Initial shot at REP/ENDREP in nv2 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
381
diff
changeset
|
708 |
{ |
ab4167f50aad
Initial shot at REP/ENDREP in nv2 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
381
diff
changeset
|
709 |
return ctx->assigned_branch_labels++; |
ab4167f50aad
Initial shot at REP/ENDREP in nv2 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
381
diff
changeset
|
710 |
} // allocate_branch_label |
368
a34d36ff9228
Implemented IF, ELSE, and ENDIF in nv2 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
367
diff
changeset
|
711 |
|
121
37de8c6bb262
Fixed comparisons in GLSL profile and improved validation.
Ryan C. Gordon <icculus@icculus.org>
parents:
120
diff
changeset
|
712 |
|
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
713 |
// D3D stuff that's used in more than just the d3d profile... |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
714 |
|
141
997857107c39
Attempt to optimize CMP and CND in GLSL profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
140
diff
changeset
|
715 |
static const char swizzle_channels[] = { 'x', 'y', 'z', 'w' }; |
997857107c39
Attempt to optimize CMP and CND in GLSL profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
140
diff
changeset
|
716 |
|
997857107c39
Attempt to optimize CMP and CND in GLSL profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
140
diff
changeset
|
717 |
|
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
718 |
static const char *usagestrs[] = { |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
719 |
"_position", "_blendweight", "_blendindices", "_normal", "_psize", |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
720 |
"_texcoord", "_tangent", "_binormal", "_tessfactor", "_positiont", |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
721 |
"_color", "_fog", "_depth", "_sample" |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
722 |
}; |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
723 |
|
24 | 724 |
static const char *get_D3D_register_string(Context *ctx, |
34 | 725 |
RegisterType regtype, |
24 | 726 |
int regnum, char *regnum_str, |
727 |
size_t regnum_size) |
|
728 |
{ |
|
729 |
const char *retval = NULL; |
|
31 | 730 |
int has_number = 1; |
24 | 731 |
|
732 |
switch (regtype) |
|
733 |
{ |
|
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
734 |
case REG_TYPE_TEMP: |
24 | 735 |
retval = "r"; |
736 |
break; |
|
737 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
738 |
case REG_TYPE_INPUT: |
24 | 739 |
retval = "v"; |
740 |
break; |
|
741 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
742 |
case REG_TYPE_CONST: |
31 | 743 |
retval = "c"; |
744 |
break; |
|
745 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
746 |
case REG_TYPE_ADDRESS: // (or REG_TYPE_TEXTURE, same value.) |
151
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
747 |
retval = shader_is_vertex(ctx) ? "a" : "t"; |
24 | 748 |
break; |
749 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
750 |
case REG_TYPE_RASTOUT: |
34 | 751 |
switch ((RastOutType) regnum) |
24 | 752 |
{ |
753 |
case RASTOUT_TYPE_POSITION: retval = "oPos"; break; |
|
754 |
case RASTOUT_TYPE_FOG: retval = "oFog"; break; |
|
755 |
case RASTOUT_TYPE_POINT_SIZE: retval = "oPts"; break; |
|
756 |
} // switch |
|
31 | 757 |
has_number = 0; |
24 | 758 |
break; |
759 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
760 |
case REG_TYPE_ATTROUT: |
24 | 761 |
retval = "oD"; |
762 |
break; |
|
763 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
764 |
case REG_TYPE_OUTPUT: // (or REG_TYPE_TEXCRDOUT, same value.) |
151
1667680fe402
Cleaned up tests for shader type and version.
Ryan C. Gordon <icculus@icculus.org>
parents:
150
diff
changeset
|
765 |
if (shader_is_vertex(ctx) && shader_version_atleast(ctx, 3, 0)) |
24 | 766 |
retval = "o"; |
767 |
else |
|
768 |
retval = "oT"; |
|
769 |
break; |
|
770 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
771 |
case REG_TYPE_CONSTINT: |
24 | 772 |
retval = "i"; |
773 |
break; |
|
774 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
775 |
case REG_TYPE_COLOROUT: |
24 | 776 |
retval = "oC"; |
777 |
break; |
|
778 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
779 |
case REG_TYPE_DEPTHOUT: |
24 | 780 |
retval = "oDepth"; |
31 | 781 |
has_number = 0; |
24 | 782 |
break; |
783 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
784 |
case REG_TYPE_SAMPLER: |
24 | 785 |
retval = "s"; |
786 |
break; |
|
787 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
788 |
case REG_TYPE_CONSTBOOL: |
24 | 789 |
retval = "b"; |
790 |
break; |
|
791 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
792 |
case REG_TYPE_LOOP: |
24 | 793 |
retval = "aL"; |
31 | 794 |
has_number = 0; |
24 | 795 |
break; |
796 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
797 |
case REG_TYPE_MISCTYPE: |
317
74a9f3ae4534
Support for vFace and vPos registers.
Ryan C. Gordon <icculus@icculus.org>
parents:
316
diff
changeset
|
798 |
switch ((const MiscTypeType) regnum) |
24 | 799 |
{ |
800 |
case MISCTYPE_TYPE_POSITION: retval = "vPos"; break; |
|
801 |
case MISCTYPE_TYPE_FACE: retval = "vFace"; break; |
|
802 |
} // switch |
|
31 | 803 |
has_number = 0; |
24 | 804 |
break; |
805 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
806 |
case REG_TYPE_LABEL: |
24 | 807 |
retval = "l"; |
808 |
break; |
|
809 |
||
73
c368f50d89d2
Shrank chatty enum name.
Ryan C. Gordon <icculus@icculus.org>
parents:
72
diff
changeset
|
810 |
case REG_TYPE_PREDICATE: |
24 | 811 |
retval = "p"; |
812 |
break; |
|
234
c05582e582ad
Cleaned up the CONST/CONST2/CONST3/CONST4 tapdance.
Ryan C. Gordon <icculus@icculus.org>
parents:
233
diff
changeset
|
813 |
|
c05582e582ad
Cleaned up the CONST/CONST2/CONST3/CONST4 tapdance.
Ryan C. Gordon <icculus@icculus.org>
parents:
233
diff
changeset
|
814 |
//case REG_TYPE_TEMPFLOAT16: // !!! FIXME: don't know this asm string |
c05582e582ad
Cleaned up the CONST/CONST2/CONST3/CONST4 tapdance.
Ryan C. Gordon <icculus@icculus.org>
parents:
233
diff
changeset
|
815 |
default: |
c05582e582ad
Cleaned up the CONST/CONST2/CONST3/CONST4 tapdance.
Ryan C. Gordon <icculus@icculus.org>
parents:
233
diff
changeset
|
816 |
fail(ctx, "unknown register type"); |
c05582e582ad
Cleaned up the CONST/CONST2/CONST3/CONST4 tapdance.
Ryan C. Gordon <icculus@icculus.org>
parents:
233
diff
changeset
|
817 |
retval = "???"; |
c05582e582ad
Cleaned up the CONST/CONST2/CONST3/CONST4 tapdance.
Ryan C. Gordon <icculus@icculus.org>
parents:
233
diff
changeset
|
818 |
has_number = 0; |
c05582e582ad
Cleaned up the CONST/CONST2/CONST3/CONST4 tapdance.
Ryan C. Gordon <icculus@icculus.org>
parents:
233
diff
changeset
|
819 |
break; |
24 | 820 |
} // switch |
821 |
||
31 | 822 |
if (has_number) |
823 |
snprintf(regnum_str, regnum_size, "%u", (uint) regnum); |
|
824 |
else |
|
825 |
regnum_str[0] = '\0'; |
|
826 |
||
24 | 827 |
return retval; |
828 |
} // get_D3D_register_string |
|
829 |
||
830 |
||
67 | 831 |
#define AT_LEAST_ONE_PROFILE 0 |
832 |
||
833 |
#if !SUPPORT_PROFILE_D3D |
|
834 |
#define PROFILE_EMITTER_D3D(op) |
|
835 |
#else |
|
836 |
#undef AT_LEAST_ONE_PROFILE |
|
837 |
#define AT_LEAST_ONE_PROFILE 1 |
|
838 |
#define PROFILE_EMITTER_D3D(op) emit_D3D_##op, |
|
839 |
||
165
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
840 |
static const char *make_D3D_srcarg_string_in_buf(Context *ctx, |
139
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
841 |
const SourceArgInfo *arg, |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
842 |
char *buf, size_t buflen) |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
843 |
{ |
24 | 844 |
const char *premod_str = ""; |
845 |
const char *postmod_str = ""; |
|
139
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
846 |
switch (arg->src_mod) |
24 | 847 |
{ |
848 |
case SRCMOD_NEGATE: |
|
849 |
premod_str = "-"; |
|
850 |
break; |
|
851 |
||
852 |
case SRCMOD_BIASNEGATE: |
|
853 |
premod_str = "-"; |
|
854 |
// fall through. |
|
855 |
case SRCMOD_BIAS: |
|
856 |
postmod_str = "_bias"; |
|
857 |
break; |
|
858 |
||
859 |
case SRCMOD_SIGNNEGATE: |
|
860 |
premod_str = "-"; |
|
861 |
// fall through. |
|
862 |
case SRCMOD_SIGN: |
|
863 |
postmod_str = "_bx2"; |
|
864 |
break; |
|
865 |
||
866 |
case SRCMOD_COMPLEMENT: |
|
867 |
premod_str = "1-"; |
|
868 |
break; |
|
869 |
||
870 |
case SRCMOD_X2NEGATE: |
|
871 |
premod_str = "-"; |
|
872 |
// fall through. |
|
873 |
case SRCMOD_X2: |
|
874 |
postmod_str = "_x2"; |
|
875 |
break; |
|
876 |
||
877 |
case SRCMOD_DZ: |
|
878 |
postmod_str = "_dz"; |
|
879 |
break; |
|
880 |
||
881 |
case SRCMOD_DW: |
|
882 |
postmod_str = "_dw"; |
|
883 |
break; |
|
884 |
||
885 |
case SRCMOD_ABSNEGATE: |
|
886 |
premod_str = "-"; |
|
887 |
// fall through. |
|
888 |
case SRCMOD_ABS: |
|
889 |
postmod_str = "_abs"; |
|
890 |
break; |
|
891 |
||
892 |
case SRCMOD_NOT: |
|
893 |
premod_str = "!"; |
|
894 |
break; |
|
48 | 895 |
|
896 |
case SRCMOD_NONE: |
|
897 |
case SRCMOD_TOTAL: |
|
898 |
break; // stop compiler whining. |
|
24 | 899 |
} // switch |
900 |
||
901 |
||
902 |
char regnum_str[16]; |
|
56
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
903 |
const char *regtype_str = get_D3D_register_string(ctx, arg->regtype, |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
904 |
arg->regnum, regnum_str, |
1e8b180d3eb1
[svn] Bunch of work from the transatlantic airplane flight...since this is a ton of
icculus
parents:
55
diff
changeset
|
905 |
sizeof (regnum_str)); |
24 | 906 |
|
907 |
if (regtype_str == NULL) |
|
908 |
{ |
|
909 |
fail(ctx, "Unknown source register type."); |
|
68
f00ba7fcd0f8
Better const char * correction.
Ryan C. Gordon <icculus@icculus.org>
parents:
67
diff
changeset
|
910 |
return ""; |
24 | 911 |
} // if |
912 |
||
152
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
913 |
const char *rel_lbracket = ""; |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
914 |
const char *rel_rbracket = ""; |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
915 |
char rel_swizzle[4] = { '\0' }; |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
916 |
char rel_regnum_str[16] = { '\0' }; |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
917 |
const char *rel_regtype_str = ""; |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
918 |
if (arg->relative) |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
919 |
{ |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
920 |
rel_swizzle[0] = '.'; |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
921 |
rel_swizzle[1] = swizzle_channels[arg->relative_component]; |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
922 |
rel_swizzle[2] = '\0'; |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
923 |
rel_lbracket = "["; |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
924 |
rel_rbracket = "]"; |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
925 |
rel_regtype_str = get_D3D_register_string(ctx, arg->relative_regtype, |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
926 |
arg->relative_regnum, |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
927 |
rel_regnum_str, |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
928 |
sizeof (rel_regnum_str)); |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
929 |
|
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
930 |
if (regtype_str == NULL) |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
931 |
{ |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
932 |
fail(ctx, "Unknown relative source register type."); |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
933 |
return ""; |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
934 |
} // if |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
935 |
} // if |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
936 |
|
24 | 937 |
char swizzle_str[6]; |
938 |
int i = 0; |
|
491
bcc3c215807a
Fixed wrong data from scalar_register().
Ryan C. Gordon <icculus@icculus.org>
parents:
476
diff
changeset
|
939 |
const int scalar = scalar_register(ctx->shader_type, arg->regtype, arg->regnum); |
316
93e70dbdba48
Deal with scalar D3D registers more properly.
Ryan C. Gordon <icculus@icculus.org>
parents:
315
diff
changeset
|
940 |
if (!scalar && !no_swizzle(arg->swizzle)) |
24 | 941 |
{ |
942 |
swizzle_str[i++] = '.'; |
|
141
997857107c39
Attempt to optimize CMP and CND in GLSL profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
140
diff
changeset
|
943 |
swizzle_str[i++] = swizzle_channels[arg->swizzle_x]; |
997857107c39
Attempt to optimize CMP and CND in GLSL profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
140
diff
changeset
|
944 |
swizzle_str[i++] = swizzle_channels[arg->swizzle_y]; |
997857107c39
Attempt to optimize CMP and CND in GLSL profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
140
diff
changeset
|
945 |
swizzle_str[i++] = swizzle_channels[arg->swizzle_z]; |
997857107c39
Attempt to optimize CMP and CND in GLSL profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
140
diff
changeset
|
946 |
swizzle_str[i++] = swizzle_channels[arg->swizzle_w]; |
24 | 947 |
|
25 | 948 |
// .xyzz is the same as .xyz, .z is the same as .zzzz, etc. |
949 |
while (swizzle_str[i-1] == swizzle_str[i-2]) |
|
950 |
i--; |
|
24 | 951 |
} // if |
952 |
swizzle_str[i] = '\0'; |
|
953 |
assert(i < sizeof (swizzle_str)); |
|
954 |
||
476 | 955 |
// !!! FIXME: c12[a0.x] actually needs to be c[a0.x + 12] |
152
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
956 |
snprintf(buf, buflen, "%s%s%s%s%s%s%s%s%s%s", |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
957 |
premod_str, regtype_str, regnum_str, postmod_str, |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
958 |
rel_lbracket, rel_regtype_str, rel_regnum_str, rel_swizzle, |
cc7c38dfe145
Relative addressing work.
Ryan C. Gordon <icculus@icculus.org>
parents:
151
diff
changeset
|
959 |
rel_rbracket, swizzle_str); |
67 | 960 |
// !!! FIXME: make sure the scratch buffer was large enough. |
139
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
961 |
return buf; |
165
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
962 |
} // make_D3D_srcarg_string_in_buf |
139
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
963 |
|
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
964 |
|
161
a0e1920ce909
Removed "dest_args" array...it's only ever one structure.
Ryan C. Gordon <icculus@icculus.org>
parents:
160
diff
changeset
|
965 |
static const char *make_D3D_destarg_string(Context *ctx) |
a0e1920ce909
Removed "dest_args" array...it's only ever one structure.
Ryan C. Gordon <icculus@icculus.org>
parents:
160
diff
changeset
|
966 |
{ |
a0e1920ce909
Removed "dest_args" array...it's only ever one structure.
Ryan C. Gordon <icculus@icculus.org>
parents:
160
diff
changeset
|
967 |
const DestArgInfo *arg = &ctx->dest_arg; |
139
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
968 |
|
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
969 |
const char *result_shift_str = ""; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
970 |
switch (arg->result_shift) |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
971 |
{ |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
972 |
case 0x1: result_shift_str = "_x2"; break; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
973 |
case 0x2: result_shift_str = "_x4"; break; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
974 |
case 0x3: result_shift_str = "_x8"; break; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
975 |
case 0xD: result_shift_str = "_d8"; break; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
976 |
case 0xE: result_shift_str = "_d4"; break; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
977 |
case 0xF: result_shift_str = "_d2"; break; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
978 |
} // switch |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
979 |
|
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
980 |
const char *sat_str = (arg->result_mod & MOD_SATURATE) ? "_sat" : ""; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
981 |
const char *pp_str = (arg->result_mod & MOD_PP) ? "_pp" : ""; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
982 |
const char *cent_str = (arg->result_mod & MOD_CENTROID) ? "_centroid" : ""; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
983 |
|
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
984 |
char regnum_str[16]; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
985 |
const char *regtype_str = get_D3D_register_string(ctx, arg->regtype, |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
986 |
arg->regnum, regnum_str, |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
987 |
sizeof (regnum_str)); |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
988 |
if (regtype_str == NULL) |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
989 |
{ |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
990 |
fail(ctx, "Unknown destination register type."); |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
991 |
return ""; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
992 |
} // if |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
993 |
|
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
994 |
char writemask_str[6]; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
995 |
int i = 0; |
491
bcc3c215807a
Fixed wrong data from scalar_register().
Ryan C. Gordon <icculus@icculus.org>
parents:
476
diff
changeset
|
996 |
const int scalar = scalar_register(ctx->shader_type, arg->regtype, arg->regnum); |
316
93e70dbdba48
Deal with scalar D3D registers more properly.
Ryan C. Gordon <icculus@icculus.org>
parents:
315
diff
changeset
|
997 |
if (!scalar && !writemask_xyzw(arg->writemask)) |
139
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
998 |
{ |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
999 |
writemask_str[i++] = '.'; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1000 |
if (arg->writemask0) writemask_str[i++] = 'x'; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1001 |
if (arg->writemask1) writemask_str[i++] = 'y'; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1002 |
if (arg->writemask2) writemask_str[i++] = 'z'; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1003 |
if (arg->writemask3) writemask_str[i++] = 'w'; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1004 |
} // if |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1005 |
writemask_str[i] = '\0'; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1006 |
assert(i < sizeof (writemask_str)); |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1007 |
|
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1008 |
const char *pred_left = ""; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1009 |
const char *pred_right = ""; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1010 |
char pred[32] = { '\0' }; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1011 |
if (ctx->predicated) |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1012 |
{ |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1013 |
pred_left = "("; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1014 |
pred_right = ") "; |
165
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
1015 |
make_D3D_srcarg_string_in_buf(ctx, &ctx->predicate_arg, |
139
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1016 |
pred, sizeof (pred)); |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1017 |
} // if |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1018 |
|
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1019 |
// may turn out something like "_x2_sat_pp_centroid (!p0.x) r0.xyzw" ... |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1020 |
char *retval = get_scratch_buffer(ctx); |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1021 |
snprintf(retval, SCRATCH_BUFFER_SIZE, "%s%s%s%s %s%s%s%s%s%s", |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1022 |
result_shift_str, sat_str, pp_str, cent_str, |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1023 |
pred_left, pred, pred_right, |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1024 |
regtype_str, regnum_str, writemask_str); |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1025 |
// !!! FIXME: make sure the scratch buffer was large enough. |
17 | 1026 |
return retval; |
139
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1027 |
} // make_D3D_destarg_string |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1028 |
|
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1029 |
|
165
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
1030 |
static const char *make_D3D_srcarg_string(Context *ctx, const int idx) |
139
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1031 |
{ |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1032 |
if (idx >= STATICARRAYLEN(ctx->source_args)) |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1033 |
{ |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1034 |
fail(ctx, "Too many source args"); |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1035 |
return ""; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1036 |
} // if |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1037 |
|
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1038 |
const SourceArgInfo *arg = &ctx->source_args[idx]; |
a7695f68cbff
First shot at predicated instruction support.
Ryan C. Gordon <icculus@icculus.org>
parents:
138
diff
changeset
|
1039 |
char *buf = get_scratch_buffer(ctx); |
165
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
1040 |
return make_D3D_srcarg_string_in_buf(ctx, arg, buf, SCRATCH_BUFFER_SIZE); |
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
1041 |
} // make_D3D_srcarg_string |
16 | 1042 |
|
1043 |
||
347
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1044 |
static const char *get_D3D_varname(Context *ctx, RegisterType rt, int regnum) |
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1045 |
{ |
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1046 |
char regnum_str[16]; |
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1047 |
const char *regtype_str = get_D3D_register_string(ctx, rt, regnum, |
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1048 |
regnum_str, sizeof (regnum_str)); |
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1049 |
|
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1050 |
char *retval = get_scratch_buffer(ctx); |
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1051 |
snprintf(retval, SCRATCH_BUFFER_SIZE, "%s%s", regtype_str, regnum_str); |
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1052 |
return retval; |
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1053 |
} // get_D3D_varname |
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1054 |
|
402
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
1055 |
static const char *get_D3D_const_array_varname(Context *ctx, int base, int size) |
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
1056 |
{ |
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
1057 |
char *retval = get_scratch_buffer(ctx); |
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
1058 |
snprintf(retval, SCRATCH_BUFFER_SIZE, "c_array_%d_%d", base, size); |
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
1059 |
return retval; |
347
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1060 |
} // get_D3D_const_array_varname |
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1061 |
|
f8d9d0ae6ba8
Bunch more work (ARB1 profile, OpenGL glue, and general fixes).
Ryan C. Gordon <icculus@icculus.org>
parents:
346
diff
changeset
|
1062 |
|
361
9fa6652cacbd
First (untested) work on nv2 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
360
diff
changeset
|
1063 |
static void emit_D3D_start(Context *ctx, const char *profilestr) |
16 | 1064 |
{ |
1065 |
const uint major = (uint) ctx->major_ver; |
|
1066 |
const uint minor = (uint) ctx->minor_ver; |
|
24 | 1067 |
char minor_str[16]; |
1068 |
||
1069 |
if (minor == 0xFF) |
|
1070 |
strcpy(minor_str, "sw"); |
|
1071 |
else if (minor == 0x1) // apparently this is "vs_2_x". Weird. |
|
1072 |
strcpy(minor_str, "x"); |
|
1073 |
else |
|
1074 |
snprintf(minor_str, sizeof (minor_str), "%u", (uint) minor); |
|
19
8bca9cb2252f
[svn] Fixed output for software vertex shader versions.
icculus
parents:
18
diff
changeset
|
1075 |
|
334
5aebcea77f47
Cleaned up the shader type string code.
Ryan C. Gordon <icculus@icculus.org>
parents:
333
diff
changeset
|
1076 |
output_line(ctx, "%s_%u_%s", ctx->shader_type_str, major, minor_str); |
15 | 1077 |
} // emit_D3D_start |
1078 |
||
17 | 1079 |
|
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
1080 |
static void emit_D3D_end(Context *ctx) |
15 | 1081 |
{ |
30 | 1082 |
output_line(ctx, "end"); |
15 | 1083 |
} // emit_D3D_end |
14 | 1084 |
|
17 | 1085 |
|
400
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
1086 |
static void emit_D3D_phase(Context *ctx) |
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
1087 |
{ |
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
1088 |
output_line(ctx, "phase"); |
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
1089 |
} // emit_D3D_phase |
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
1090 |
|
05e384a14cd6
Implemented support for phase token.
Ryan C. Gordon <icculus@icculus.org>
parents:
399
diff
changeset
|
1091 |
|
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1092 |
static void emit_D3D_finalize(Context *ctx) |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1093 |
{ |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1094 |
// no-op. |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1095 |
} // emit_D3D_finalize |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1096 |
|
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1097 |
|
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1098 |
static void emit_D3D_global(Context *ctx, RegisterType regtype, int regnum) |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1099 |
{ |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1100 |
// no-op. |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1101 |
} // emit_D3D_global |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1102 |
|
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1103 |
|
402
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
1104 |
static void emit_D3D_array(Context *ctx, int base, int size) |
280
61b2abd9c927
Relative addressing fixes.
Ryan C. Gordon <icculus@icculus.org>
parents:
279
diff
changeset
|
1105 |
{ |
61b2abd9c927
Relative addressing fixes.
Ryan C. Gordon <icculus@icculus.org>
parents:
279
diff
changeset
|
1106 |
// no-op. |
402
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
1107 |
} // emit_D3D_array |
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
1108 |
|
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
1109 |
|
405
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
1110 |
static void emit_D3D_const_array(Context *ctx, const ConstantsList *clist, |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
1111 |
int base, int size) |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
1112 |
{ |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
1113 |
// no-op. |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
1114 |
} // emit_D3D_const_array |
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
1115 |
|
e2cffb40e8b8
Build arrays of constants if necessary.
Ryan C. Gordon <icculus@icculus.org>
parents:
404
diff
changeset
|
1116 |
|
402
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
1117 |
static void emit_D3D_uniform(Context *ctx, RegisterType regtype, int regnum, |
933d71481f5b
Better relative addressing support.
Ryan C. Gordon <icculus@icculus.org>
parents:
401
diff
changeset
|
1118 |
int arraybase, int arraysize) |
95
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1119 |
{ |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1120 |
// no-op. |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1121 |
} // emit_D3D_uniform |
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1122 |
|
56af2093eefe
Implemented uniform reporting.
Ryan C. Gordon <icculus@icculus.org>
parents:
93
diff
changeset
|
1123 |
|
148
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
1124 |
static void emit_D3D_sampler(Context *ctx, int stage, TextureType ttype) |
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
1125 |
{ |
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
1126 |
// no-op. |
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
1127 |
} // emit_D3D_sampler |
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
1128 |
|
645003ec6623
Hopefully sorted out the reported uniform/attribute mess.
Ryan C. Gordon <icculus@icculus.org>
parents:
145
diff
changeset
|
1129 |
|
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
1130 |
static void emit_D3D_attribute(Context *ctx, RegisterType regtype, int regnum, |
431
0d0cbe10db02
First shot at nv4 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
430
diff
changeset
|
1131 |
MOJOSHADER_usage usage, int index, int wmask, |
0d0cbe10db02
First shot at nv4 profile.
Ryan C. Gordon <icculus@icculus.org>
parents:
430
diff
changeset
|
1132 |
int flags) |
104
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
1133 |
{ |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
1134 |
// no-op. |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
1135 |
} // emit_D3D_attribute |
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
1136 |
|
7019f99f17d0
Attribute parsing is closer to correct now.
Ryan C. Gordon <icculus@icculus.org>
parents:
103
diff
changeset
|
1137 |
|
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
1138 |
static void emit_D3D_RESERVED(Context *ctx) |
2
c37210f5e87b
[svn] Bunch More Work. Parse out instruction tokens, fail in a bunch of new stubs.
icculus
parents:
1
diff
changeset
|
1139 |
{ |
14 | 1140 |
// do nothing; fails in the state machine. |
1141 |
} // emit_D3D_RESERVED |
|
1142 |
||
17 | 1143 |
|
1144 |
// Generic D3D opcode emitters. A list of macros generate all the entry points |
|
1145 |
// that call into these... |
|
1146 |
||
30 | 1147 |
static char *lowercase(char *dst, const char *src) |
1148 |
{ |
|
1149 |
int i = 0; |
|
1150 |
do |
|
1151 |
{ |
|
1152 |
const char ch = src[i]; |
|
1153 |
dst[i] = (((ch >= 'A') && (ch <= 'Z')) ? (ch - ('A' - 'a')) : ch); |
|
1154 |
} while (src[i++]); |
|
1155 |
return dst; |
|
1156 |
} // lowercase |
|
1157 |
||
1158 |
||
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
1159 |
static void emit_D3D_opcode_d(Context *ctx, const char *opcode) |
17 | 1160 |
{ |
161
a0e1920ce909
Removed "dest_args" array...it's only ever one structure.
Ryan C. Gordon <icculus@icculus.org>
parents:
160
diff
changeset
|
1161 |
const char *dst0 = make_D3D_destarg_string(ctx); |
30 | 1162 |
opcode = lowercase(get_scratch_buffer(ctx), opcode); |
21
d43449cf3cb2
[svn] Implemented destination argument output in D3D profile. Untested.
icculus
parents:
20
diff
changeset
|
1163 |
output_line(ctx, "%s%s", opcode, dst0); |
17 | 1164 |
} // emit_D3D_opcode_d |
1165 |
||
1166 |
||
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
1167 |
static void emit_D3D_opcode_s(Context *ctx, const char *opcode) |
17 | 1168 |
{ |
165
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
1169 |
const char *src0 = make_D3D_srcarg_string(ctx, 0); |
30 | 1170 |
opcode = lowercase(get_scratch_buffer(ctx), opcode); |
20
bb2e8f285acc
[svn] Bunch More Work...higher level parses dest/src tokens before it goes to the
icculus
parents:
19
diff
changeset
|
1171 |
output_line(ctx, "%s %s", opcode, src0); |
17 | 1172 |
} // emit_D3D_opcode_s |
1173 |
||
1174 |
||
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
1175 |
static void emit_D3D_opcode_ss(Context *ctx, const char *opcode) |
17 | 1176 |
{ |
165
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
1177 |
const char *src0 = make_D3D_srcarg_string(ctx, 0); |
708de76f4c36
More swizzle/writemask work.
Ryan C. Gordon <icculus@icculus.org>
parents:
164
diff
changeset
|
1178 |
const char *src1 = make_D3D_srcarg_string(ctx, 1); |
30 | 1179 |
opcode = lowercase(get_scratch_buffer(ctx), opcode); |
20
bb2e8f285acc
[svn] Bunch More Work...higher level parses dest/src tokens before it goes to the
icculus
parents:
19
diff
changeset
|
1180 |
output_line(ctx, "%s %s, %s", opcode, src0, src1); |
39 | 1181 |
} // emit_D3D_opcode_ss |
17 | 1182 |
|
1183 |
||
18
0dbdb2be8bf8
[svn] Bunch More Work. Cleanups, added app-supplied allocators, flexible output, etc.
icculus
parents:
17
diff
changeset
|
1184 |
static void emit_D3D_opcode_ds(Context *ctx, const char *opcode) |