← Back to branch summary

~ubuntu-branches/ubuntu/quantal/aqsis/quantal

« back to all changes in this revision

Viewing changes to shadercompiler/slparse/funcdef.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Fabrice Coutadeur
  • Date: 2009-08-06 04:53:26 UTC
  • mfrom: (1.2.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20090806045326-z6xeaaao62idxcc6
Tags: 1.6.0-0ubuntu1
* New upstream release
* debian/control:
  - changed name of lib package to libaqsis1 instead of aqsis-libsc2a
  - changed name of dev package to libaqsis-dev instead of aqsis-libs-dev
  - Added aqsis-data package
  - Revised summary text according to that specified by the RISpec (Pixar)
* Moved examples installation from aqsis.install to aqsis-data.install
* debian/rules: 
  - added content to binary-indep target
* debian/rules: added explicit name of mime file to force dh_installmime
  to generate postinst and prerm scripts

Show diffs side-by-side

added added

removed removed

Lines of Context:
shadercompiler/slparse/funcdef.cpp
1
 
////---------------------------------------------------------------------
2
 
////    Class definition file:  FUNCDEF.CPP
3
 
////    Associated header file: FUNCDEF.H
4
 
////
5
 
////    Author:                                 Paul C. Gregory
6
 
////    Creation date:                  22/07/99
7
 
////---------------------------------------------------------------------
8
 
 
9
 
#include        "aqsis.h"
10
 
#include        "parsenode.h"
11
 
#include        "funcdef.h"
12
 
 
13
 
START_NAMESPACE( Aqsis )
14
 
 
15
 
///---------------------------------------------------------------------
16
 
/// Global array of standard function definitions
17
 
 
18
 
char* gVariableTypeIdentifiers[] =
19
 
    {
20
 
        "@",
21
 
        "f",
22
 
        "i",
23
 
        "p",
24
 
        "s",
25
 
        "c",
26
 
        "t",
27
 
        "h",
28
 
        "n",
29
 
        "v",
30
 
        "x",
31
 
        "m",
32
 
        "w",
33
 
    };
34
 
TqInt gcVariableTypeIdentifiers = sizeof( gVariableTypeIdentifiers ) / sizeof( gVariableTypeIdentifiers[ 0 ] );
35
 
 
36
 
 
37
 
CqFuncDef       gStandardFuncs[] = {
38
 
                                 CqFuncDef( Type_Float, "operator*", "mulff", "ff" ),
39
 
                                 CqFuncDef( Type_Float, "operator/", "divff", "ff" ),
40
 
                                 CqFuncDef( Type_Float, "operator+", "addff", "ff" ),
41
 
                                 CqFuncDef( Type_Float, "operator-", "subff", "ff" ),
42
 
                                 CqFuncDef( Type_Float, "operatorneg", "negf", "f" ),
43
 
 
44
 
                                 CqFuncDef( Type_Point, "operator*", "mulpp", "pp" ),
45
 
                                 CqFuncDef( Type_Point, "operator/", "divpp", "pp" ),
46
 
                                 CqFuncDef( Type_Point, "operator+", "addpp", "pp" ),
47
 
                                 CqFuncDef( Type_Point, "operator-", "subpp", "pp" ),
48
 
                                 CqFuncDef( Type_Point, "operator^", "crspp", "pp" ),
49
 
                                 CqFuncDef( Type_Float, "operator.", "dotpp", "pp" ),
50
 
                                 CqFuncDef( Type_Point, "operatorneg", "negp", "p" ),
51
 
 
52
 
                                 CqFuncDef( Type_Color, "operator*", "mulcc", "cc" ),
53
 
                                 CqFuncDef( Type_Color, "operator/", "divcc", "cc" ),
54
 
                                 CqFuncDef( Type_Color, "operator+", "addcc", "cc" ),
55
 
                                 CqFuncDef( Type_Color, "operator-", "subcc", "cc" ),
56
 
                                 CqFuncDef( Type_Color, "operatorneg", "negc", "c" ),
57
 
 
58
 
                                 CqFuncDef( Type_Vector, "operator*", "mulpp", "vv" ),
59
 
                                 CqFuncDef( Type_Vector, "operator/", "divpp", "vv" ),
60
 
                                 CqFuncDef( Type_Vector, "operator+", "addpp", "vv" ),
61
 
                                 CqFuncDef( Type_Vector, "operator-", "subpp", "vv" ),
62
 
                                 CqFuncDef( Type_Vector, "operator^", "crspp", "vv" ),
63
 
                                 CqFuncDef( Type_Float, "operator.", "dotpp", "vv" ),
64
 
                                 CqFuncDef( Type_Vector, "operatorneg", "negp", "v" ),
65
 
 
66
 
                                 CqFuncDef( Type_Normal, "operator*", "mulpp", "nn" ),
67
 
                                 CqFuncDef( Type_Normal, "operator/", "divpp", "nn" ),
68
 
                                 CqFuncDef( Type_Normal, "operator+", "addpp", "nn" ),
69
 
                                 CqFuncDef( Type_Normal, "operator-", "subpp", "nn" ),
70
 
                                 CqFuncDef( Type_Normal, "operator^", "crspp", "nn" ),
71
 
                                 CqFuncDef( Type_Float, "operator.", "dotpp", "nn" ),
72
 
                                 CqFuncDef( Type_Normal, "operatorneg", "negp", "n" ),
73
 
 
74
 
                                 CqFuncDef( Type_Point, "operator*", "mulfp", "fp" ),
75
 
                                 CqFuncDef( Type_Point, "operator/", "divfp", "fp" ),
76
 
                                 CqFuncDef( Type_Point, "operator+", "addfp", "fp" ),
77
 
                                 CqFuncDef( Type_Point, "operator-", "subfp", "fp" ),
78
 
 
79
 
                                 CqFuncDef( Type_Color, "operator*", "mulfc", "fc" ),
80
 
                                 CqFuncDef( Type_Color, "operator/", "divfc", "fc" ),
81
 
                                 CqFuncDef( Type_Color, "operator+", "addfc", "fc" ),
82
 
                                 CqFuncDef( Type_Color, "operator-", "subfc", "fc" ),
83
 
 
84
 
                                 CqFuncDef( Type_Vector, "operator*", "mulfp", "fv" ),
85
 
                                 CqFuncDef( Type_Vector, "operator/", "divfp", "fv" ),
86
 
                                 CqFuncDef( Type_Vector, "operator+", "addfp", "fv" ),
87
 
                                 CqFuncDef( Type_Vector, "operator-", "subfp", "fv" ),
88
 
 
89
 
                                 CqFuncDef( Type_Normal, "operator*", "mulfp", "fn" ),
90
 
                                 CqFuncDef( Type_Normal, "operator/", "divfp", "fn" ),
91
 
                                 CqFuncDef( Type_Normal, "operator+", "addfp", "fn" ),
92
 
                                 CqFuncDef( Type_Normal, "operator-", "subfp", "fn" ),
93
 
 
94
 
                                 CqFuncDef( Type_Matrix, "operator*", "mulmm", "mm" ),
95
 
                                 CqFuncDef( Type_Matrix, "operator/", "divmm", "mm" ),
96
 
 
97
 
                                 CqFuncDef( Type_Float, "radians", "radians", "f" ),
98
 
                                 CqFuncDef( Type_Float, "degrees", "degrees", "f" ),
99
 
                                 CqFuncDef( Type_Float, "sin", "sin", "f" ),
100
 
                                 CqFuncDef( Type_Float, "asin", "asin", "f" ),
101
 
                                 CqFuncDef( Type_Float, "cos", "cos", "f" ),
102
 
                                 CqFuncDef( Type_Float, "acos", "acos", "f" ),
103
 
                                 CqFuncDef( Type_Float, "tan", "tan", "f" ),
104
 
                                 CqFuncDef( Type_Float, "atan", "atan", "f" ),
105
 
                                 CqFuncDef( Type_Float, "atan", "atan2", "ff" ),
106
 
                                 CqFuncDef( Type_Float, "pow", "pow", "ff" ),
107
 
                                 CqFuncDef( Type_Float, "exp", "exp", "f" ),
108
 
                                 CqFuncDef( Type_Float, "sqrt", "sqrt", "f" ),
109
 
                                 CqFuncDef( Type_Float, "log", "log", "f" ),
110
 
                                 CqFuncDef( Type_Float, "log", "log2", "ff" ),
111
 
                                 CqFuncDef( Type_Float, "mod", "mod", "ff" ),
112
 
                                 CqFuncDef( Type_Float, "abs", "abs", "f" ),
113
 
                                 CqFuncDef( Type_Float, "sign", "sign", "f" ),
114
 
                                 CqFuncDef( Type_Float, "min", "min", "ff*" ),
115
 
                                 CqFuncDef( Type_Float, "max", "max", "ff*" ),
116
 
                                 CqFuncDef( Type_Point, "min", "pmin", "pp*" ),
117
 
                                 CqFuncDef( Type_Point, "max", "pmax", "pp*" ),
118
 
                                 CqFuncDef( Type_Vector, "min", "vmin", "vv*" ),
119
 
                                 CqFuncDef( Type_Vector, "max", "vmax", "vv*" ),
120
 
                                 CqFuncDef( Type_Normal, "min", "nmin", "nn*" ),
121
 
                                 CqFuncDef( Type_Normal, "max", "nmax", "nn*" ),
122
 
                                 CqFuncDef( Type_Color, "min", "cmin", "cc*" ),
123
 
                                 CqFuncDef( Type_Color, "max", "cmax", "cc*" ),
124
 
                                 CqFuncDef( Type_Float, "clamp", "clamp", "fff" ),
125
 
                                 CqFuncDef( Type_Point, "clamp", "pclamp", "ppp" ),
126
 
                                 CqFuncDef( Type_Vector, "clamp", "vclamp", "vvv" ),
127
 
                                 CqFuncDef( Type_Normal, "clamp", "nclamp", "nnn" ),
128
 
                                 CqFuncDef( Type_Color, "clamp", "cclamp", "ccc" ),
129
 
                                 CqFuncDef( Type_Float, "floor", "floor", "f" ),
130
 
                                 CqFuncDef( Type_Float, "ceil", "ceil", "f" ),
131
 
                                 CqFuncDef( Type_Float, "round", "round", "f" ),
132
 
                                 CqFuncDef( Type_Float, "step", "step", "ff" ),
133
 
                                 CqFuncDef( Type_Float, "smoothstep", "smoothstep", "fff" ),
134
 
                                 CqFuncDef( Type_Float, "spline", "fspline", "fffff*" ),
135
 
                                 CqFuncDef( Type_Color, "spline", "cspline", "fcccc*" ),
136
 
                                 CqFuncDef( Type_Point, "spline", "pspline", "fpppp*" ),
137
 
                                 CqFuncDef( Type_Point, "spline", "vspline", "fvvvv*" ),
138
 
                                 CqFuncDef( Type_Float, "spline", "sfspline", "sfffff*" ),
139
 
                                 CqFuncDef( Type_Color, "spline", "scspline", "sfcccc*" ),
140
 
                                 CqFuncDef( Type_Point, "spline", "spspline", "sfpppp*" ),
141
 
                                 CqFuncDef( Type_Point, "spline", "svspline", "sfvvvv*" ),
142
 
                                 CqFuncDef( Type_Float, "Du", "fDu", "f", ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
143
 
                                 CqFuncDef( Type_Float, "Dv", "fDv", "f", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) ),
144
 
                                 CqFuncDef( Type_Float, "Deriv", "fDeriv", "ff", ( 1 << EnvVars_u ) | ( 1 << EnvVars_v ) ),
145
 
                                 CqFuncDef( Type_Color, "Du", "cDu", "c", ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
146
 
                                 CqFuncDef( Type_Color, "Dv", "cDv", "c", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) ),
147
 
                                 CqFuncDef( Type_Color, "Deriv", "cDeriv", "cf", ( 1 << EnvVars_u ) | ( 1 << EnvVars_v ) ),
148
 
                                 CqFuncDef( Type_Point, "Du", "pDu", "p", ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
149
 
                                 CqFuncDef( Type_Point, "Dv", "pDv", "p", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) ),
150
 
                                 CqFuncDef( Type_Point, "Deriv", "pDeriv", "pf", ( 1 << EnvVars_u ) | ( 1 << EnvVars_v ) ),
151
 
                                 CqFuncDef( Type_hPoint, "Du", "hDu", "h", ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
152
 
                                 CqFuncDef( Type_hPoint, "Dv", "hDv", "h", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) ),
153
 
                                 CqFuncDef( Type_hPoint, "Deriv", "hDeriv", "hf", ( 1 << EnvVars_u ) | ( 1 << EnvVars_v ) ),
154
 
                                 CqFuncDef( Type_Normal, "Du", "nDu", "n", ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
155
 
                                 CqFuncDef( Type_Normal, "Dv", "nDv", "n", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) ),
156
 
                                 CqFuncDef( Type_Normal, "Deriv", "nDeriv", "nf", ( 1 << EnvVars_u ) | ( 1 << EnvVars_v ) ),
157
 
                                 CqFuncDef( Type_Vector, "Du", "vDu", "v", ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
158
 
                                 CqFuncDef( Type_Vector, "Dv", "vDv", "v", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) ),
159
 
                                 CqFuncDef( Type_Vector, "Deriv", "vDeriv", "vf", ( 1 << EnvVars_u ) | ( 1 << EnvVars_v ) ),
160
 
                                 CqFuncDef( Type_Float, "random", "frandom", "" ),
161
 
                                 CqFuncDef( Type_Color, "random", "crandom", "" ),
162
 
                                 CqFuncDef( Type_Point, "random", "prandom", "" ),
163
 
                                 CqFuncDef( Type_Float, "noise", "noise1", "f" ),
164
 
                                 CqFuncDef( Type_Float, "noise", "noise2", "ff" ),
165
 
                                 CqFuncDef( Type_Float, "noise", "noise3", "p" ),
166
 
                                 CqFuncDef( Type_Float, "noise", "noise4", "pf" ),
167
 
                                 CqFuncDef( Type_Color, "noise", "cnoise1", "f" ),
168
 
                                 CqFuncDef( Type_Color, "noise", "cnoise2", "ff" ),
169
 
                                 CqFuncDef( Type_Color, "noise", "cnoise3", "p" ),
170
 
                                 CqFuncDef( Type_Color, "noise", "cnoise4", "pf" ),
171
 
                                 CqFuncDef( Type_Point, "noise", "pnoise1", "f" ),
172
 
                                 CqFuncDef( Type_Point, "noise", "pnoise2", "ff" ),
173
 
                                 CqFuncDef( Type_Point, "noise", "pnoise3", "p" ),
174
 
                                 CqFuncDef( Type_Point, "noise", "pnoise4", "pf" ),
175
 
                                 CqFuncDef( Type_Vector, "noise", "pnoise1", "f" ),
176
 
                                 CqFuncDef( Type_Vector, "noise", "pnoise2", "ff" ),
177
 
                                 CqFuncDef( Type_Vector, "noise", "pnoise3", "p" ),
178
 
                                 CqFuncDef( Type_Vector, "noise", "pnoise4", "pf" ),
179
 
                                 CqFuncDef( Type_Float, "xcomp", "xcomp", "p" ),
180
 
                                 CqFuncDef( Type_Float, "ycomp", "ycomp", "p" ),
181
 
                                 CqFuncDef( Type_Float, "zcomp", "zcomp", "p" ),
182
 
                                 CqFuncDef( Type_Float, "xcomp", "xcomp", "h" ),
183
 
                                 CqFuncDef( Type_Float, "ycomp", "ycomp", "h" ),
184
 
                                 CqFuncDef( Type_Float, "zcomp", "zcomp", "h" ),
185
 
                                 CqFuncDef( Type_Float, "xcomp", "xcomp", "n" ),
186
 
                                 CqFuncDef( Type_Float, "ycomp", "ycomp", "n" ),
187
 
                                 CqFuncDef( Type_Float, "zcomp", "zcomp", "n" ),
188
 
                                 CqFuncDef( Type_Float, "xcomp", "xcomp", "v" ),
189
 
                                 CqFuncDef( Type_Float, "ycomp", "ycomp", "v" ),
190
 
                                 CqFuncDef( Type_Float, "zcomp", "zcomp", "v" ),
191
 
                                 CqFuncDef( Type_Float, "length", "length", "p" ),
192
 
                                 CqFuncDef( Type_Float, "distance", "distance", "pp" ),
193
 
                                 CqFuncDef( Type_Float, "area", "area", "p", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
194
 
                                 CqFuncDef( Type_Float, "area", "area", "h", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
195
 
                                 CqFuncDef( Type_Point, "normalize", "normalize", "p" ),
196
 
                                 CqFuncDef( Type_Point, "faceforward", "faceforward", "pp" ),
197
 
                                 CqFuncDef( Type_Point, "faceforward", "faceforward2", "ppp" ),
198
 
                                 CqFuncDef( Type_Point, "reflect", "reflect", "pp" ),
199
 
                                 CqFuncDef( Type_Point, "refract", "refract", "ppf" ),
200
 
                                 CqFuncDef( Type_Void, "fresnel", "fresnel", "ppfFF" ),
201
 
                                 CqFuncDef( Type_Void, "fresnel", "fresnel2", "ppfFFPP" ),
202
 
                                 CqFuncDef( Type_Point, "transform", "transform2", "ssp" ),
203
 
                                 CqFuncDef( Type_Point, "transform", "transform", "sp" ),
204
 
                                 CqFuncDef( Type_Float, "depth", "depth", "p" ),
205
 
                                 CqFuncDef( Type_Point, "calculatenormal", "calculatenormal", "p", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
206
 
                                 CqFuncDef( Type_Point, "calculatenormal", "calculatenormal", "h", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
207
 
                                 CqFuncDef( Type_Float, "comp", "comp", "cf" ),
208
 
                                 CqFuncDef( Type_Void, "setcomp", "setcomp", "cff" ),
209
 
                                 CqFuncDef( Type_Color, "mix", "cmix", "ccf" ),
210
 
                                 CqFuncDef( Type_Color, "ambient", "ambient", "" ),
211
 
                                 CqFuncDef( Type_Color, "diffuse", "diffuse", "p" ),
212
 
                                 CqFuncDef( Type_Color, "specular", "specular", "ppf" ),
213
 
                                 CqFuncDef( Type_Color, "phong", "phong", "ppf" ),
214
 
                                 CqFuncDef( Type_Color, "trace", "trace", "pp" ),
215
 
                                 CqFuncDef( Type_Float, "shadow", "shadow2", "sfpppp*" ),
216
 
                                 CqFuncDef( Type_Float, "shadow", "shadow", "sfp*" ),
217
 
                                 CqFuncDef( Type_Float, "texture", "ftexture3", "sfffffffff*" ),
218
 
                                 CqFuncDef( Type_Float, "texture", "ftexture2", "sfff*", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
219
 
                                 CqFuncDef( Type_Float, "texture", "ftexture1", "sf*", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) | ( 1 << EnvVars_s ) | ( 1 << EnvVars_t ) ),
220
 
                                 CqFuncDef( Type_Color, "texture", "ctexture3", "sfffffffff*" ),
221
 
                                 CqFuncDef( Type_Color, "texture", "ctexture2", "sfff*", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
222
 
                                 CqFuncDef( Type_Color, "texture", "ctexture1", "sf*", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) | ( 1 << EnvVars_s ) | ( 1 << EnvVars_t ) ),
223
 
                                 CqFuncDef( Type_Float, "environment", "fenvironment3", "sfpppp*" ),
224
 
                                 CqFuncDef( Type_Float, "environment", "fenvironment2", "sfp*", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
225
 
                                 CqFuncDef( Type_Color, "environment", "cenvironment3", "sfpppp*" ),
226
 
                                 CqFuncDef( Type_Color, "environment", "cenvironment2", "sfp*", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
227
 
                                 CqFuncDef( Type_Point, "bump", "bump3", "sfpppffffffff*" ),
228
 
                                 CqFuncDef( Type_Point, "bump", "bump2", "sfpppff*" ),
229
 
                                 CqFuncDef( Type_Point, "bump", "bump1", "sfppp*" ),
230
 
                                 CqFuncDef( Type_Void, "printf", "printf", "s*" ),
231
 
 
232
 
                                 CqFuncDef( Type_Point, "transform", "transformm", "mp" ),
233
 
                                 CqFuncDef( Type_Vector, "vtransform", "vtransform2", "ssv" ),
234
 
                                 CqFuncDef( Type_Vector, "vtransform", "vtransform", "sv" ),
235
 
                                 CqFuncDef( Type_Vector, "vtransform", "vtransformm", "mv" ),
236
 
                                 CqFuncDef( Type_Normal, "ntransform", "ntransform2", "ssn" ),
237
 
                                 CqFuncDef( Type_Normal, "ntransform", "ntransform", "sn" ),
238
 
                                 CqFuncDef( Type_Normal, "ntransform", "ntransformm", "mn" ),
239
 
                                 CqFuncDef( Type_Color, "ctransform", "ctransform2", "ssc" ),
240
 
                                 CqFuncDef( Type_Color, "ctransform", "ctransform", "sc" ),
241
 
                                 CqFuncDef( Type_Float, "cellnoise", "fcellnoise1", "f" ),
242
 
                                 CqFuncDef( Type_Float, "cellnoise", "fcellnoise2", "ff" ),
243
 
                                 CqFuncDef( Type_Float, "cellnoise", "fcellnoise3", "p" ),
244
 
                                 CqFuncDef( Type_Float, "cellnoise", "fcellnoise4", "pf" ),
245
 
                                 CqFuncDef( Type_Color, "cellnoise", "ccellnoise1", "f" ),
246
 
                                 CqFuncDef( Type_Color, "cellnoise", "ccellnoise2", "ff" ),
247
 
                                 CqFuncDef( Type_Color, "cellnoise", "ccellnoise3", "p" ),
248
 
                                 CqFuncDef( Type_Color, "cellnoise", "ccellnoise4", "pf" ),
249
 
                                 CqFuncDef( Type_Point, "cellnoise", "pcellnoise1", "f" ),
250
 
                                 CqFuncDef( Type_Point, "cellnoise", "pcellnoise2", "ff" ),
251
 
                                 CqFuncDef( Type_Point, "cellnoise", "pcellnoise3", "p" ),
252
 
                                 CqFuncDef( Type_Point, "cellnoise", "pcellnoise4", "pf" ),
253
 
                                 CqFuncDef( Type_Vector, "cellnoise", "pcellnoise1", "f" ),
254
 
                                 CqFuncDef( Type_Vector, "cellnoise", "pcellnoise2", "ff" ),
255
 
                                 CqFuncDef( Type_Vector, "cellnoise", "pcellnoise3", "p" ),
256
 
                                 CqFuncDef( Type_Vector, "cellnoise", "pcellnoise4", "pf" ),
257
 
                                 CqFuncDef( Type_Float, "mix", "fmix", "fff" ),
258
 
                                 CqFuncDef( Type_Point, "mix", "pmix", "ppf" ),
259
 
                                 CqFuncDef( Type_Vector, "mix", "vmix", "vvf" ),
260
 
                                 CqFuncDef( Type_Normal, "mix", "nmix", "nnf" ),
261
 
 
262
 
                                 CqFuncDef( Type_Void, "setcomp", "setcomp", "Cff" ),
263
 
                                 CqFuncDef( Type_Void, "setxcomp", "setxcomp", "Pf" ),
264
 
                                 CqFuncDef( Type_Void, "setycomp", "setycomp", "Pf" ),
265
 
                                 CqFuncDef( Type_Void, "setzcomp", "setzcomp", "Pf" ),
266
 
                                 CqFuncDef( Type_Void, "setxcomp", "setxcomp", "Nf" ),
267
 
                                 CqFuncDef( Type_Void, "setycomp", "setycomp", "Nf" ),
268
 
                                 CqFuncDef( Type_Void, "setzcomp", "setzcomp", "Nf" ),
269
 
                                 CqFuncDef( Type_Void, "setxcomp", "setxcomp", "Vf" ),
270
 
                                 CqFuncDef( Type_Void, "setycomp", "setycomp", "Vf" ),
271
 
                                 CqFuncDef( Type_Void, "setzcomp", "setzcomp", "Vf" ),
272
 
 
273
 
                                 CqFuncDef( Type_Float, "ptlined", "ptlined", "ppp" ),
274
 
                                 CqFuncDef( Type_Float, "inversesqrt", "inversesqrt", "f" ),
275
 
                                 CqFuncDef( Type_String, "concat", "concat", "ss*" ),
276
 
                                 CqFuncDef( Type_String, "format", "format", "s*" ),
277
 
                                 CqFuncDef( Type_Float, "match", "match", "ss" ),
278
 
                                 CqFuncDef( Type_Point, "rotate", "rotate", "pfpp" ),
279
 
                                 CqFuncDef( Type_Float, "filterstep", "filterstep2", "fff*"),
280
 
                                 CqFuncDef( Type_Float, "filterstep", "filterstep", "ff*", ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) | ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) ),
281
 
                                 CqFuncDef( Type_Color, "specularbrdf", "specularbrdf", "vnvf" ),
282
 
 
283
 
                                 CqFuncDef( Type_Float, "pnoise", "fpnoise1", "ff" ),
284
 
                                 CqFuncDef( Type_Float, "pnoise", "fpnoise2", "ffff" ),
285
 
                                 CqFuncDef( Type_Float, "pnoise", "fpnoise3", "pp" ),
286
 
                                 CqFuncDef( Type_Float, "pnoise", "fpnoise4", "pfpf" ),
287
 
                                 CqFuncDef( Type_Color, "pnoise", "cpnoise1", "ff" ),
288
 
                                 CqFuncDef( Type_Color, "pnoise", "cpnoise2", "ffff" ),
289
 
                                 CqFuncDef( Type_Color, "pnoise", "cpnoise3", "pp" ),
290
 
                                 CqFuncDef( Type_Color, "pnoise", "cpnoise4", "pfpf" ),
291
 
                                 CqFuncDef( Type_Point, "pnoise", "ppnoise1", "ff" ),
292
 
                                 CqFuncDef( Type_Point, "pnoise", "ppnoise2", "ffff" ),
293
 
                                 CqFuncDef( Type_Point, "pnoise", "ppnoise3", "pp" ),
294
 
                                 CqFuncDef( Type_Point, "pnoise", "ppnoise4", "pfpf" ),
295
 
                                 CqFuncDef( Type_Vector, "pnoise", "ppnoise1", "ff" ),
296
 
                                 CqFuncDef( Type_Vector, "pnoise", "ppnoise2", "ffff" ),
297
 
                                 CqFuncDef( Type_Vector, "pnoise", "ppnoise3", "pp" ),
298
 
                                 CqFuncDef( Type_Vector, "pnoise", "ppnoise4", "pfpf" ),
299
 
 
300
 
                                 CqFuncDef( Type_Matrix, "mtransform", "mtransform2", "ssm" ),
301
 
                                 CqFuncDef( Type_Matrix, "mtransform", "mtransform", "sm" ),
302
 
                                 CqFuncDef( Type_Float, "comp", "mcomp", "mff" ),
303
 
                                 CqFuncDef( Type_Void, "setcomp", "setmcomp", "mfff" ),
304
 
                                 CqFuncDef( Type_Float, "determinant", "determinant", "m" ),
305
 
                                 CqFuncDef( Type_Matrix, "translate", "mtranslate", "mv" ),
306
 
                                 CqFuncDef( Type_Matrix, "rotate", "mrotate", "mfv" ),
307
 
                                 CqFuncDef( Type_Matrix, "scale", "mscale", "mp" ),
308
 
 
309
 
                                 CqFuncDef( Type_Float, "spline", "fsplinea", "f[f]" ),
310
 
                                 CqFuncDef( Type_Color, "spline", "csplinea", "f[c]" ),
311
 
                                 CqFuncDef( Type_Point, "spline", "psplinea", "f[p]" ),
312
 
                                 CqFuncDef( Type_Point, "spline", "vsplinea", "f[v]" ),
313
 
                                 CqFuncDef( Type_Float, "spline", "sfsplinea", "sf[f]" ),
314
 
                                 CqFuncDef( Type_Color, "spline", "scsplinea", "sf[c]" ),
315
 
                                 CqFuncDef( Type_Point, "spline", "spsplinea", "sf[p]" ),
316
 
                                 CqFuncDef( Type_Point, "spline", "svsplinea", "sf[v]" ),
317
 
 
318
 
                                 CqFuncDef( Type_String, "shadername", "shadername2", "s" ),
319
 
                                 CqFuncDef( Type_String, "shadername", "shadername", "" ),
320
 
                                 CqFuncDef( Type_Void, "bake", "bake_f", "sfff" ),
321
 
                                 CqFuncDef( Type_Void, "bake", "bake_3c", "sffc" ),
322
 
                                 CqFuncDef( Type_Void, "bake", "bake_3p", "sffp" ),
323
 
                                 CqFuncDef( Type_Void, "bake", "bake_3v", "sffv" ),
324
 
                                 CqFuncDef( Type_Void, "bake", "bake_3n", "sffn" ),
325
 
 
326
 
                                 CqFuncDef( Type_Float, "occlusion", "occlusion", "sfpnf*" ),
327
 
                             };
328
 
 
329
 
TqUint  gcStandardFuncs = sizeof( gStandardFuncs ) / sizeof( gStandardFuncs[ 0 ] );
330
 
 
331
 
 
332
 
 
333
 
std::vector<CqFuncDef>  gLocalFuncs;
334
 
 
335
 
 
336
 
///---------------------------------------------------------------------
337
 
/** Constructor.
338
 
 */
339
 
 
340
 
CqFuncDef::CqFuncDef( TqInt Type, const char* strName, const char* strVMName, const char* strParams, CqParseNode* pDef, CqParseNode* pArgs ) :
341
 
                m_Type( Type ),
342
 
                m_strName( strName ),
343
 
                m_strVMName( strVMName ),
344
 
                m_strParamTypes( strParams ),
345
 
                m_fLocal( TqTrue ),
346
 
                m_pDef( pDef ),
347
 
                m_pArgs( pArgs ),
348
 
                m_fVarying( TqFalse )
349
 
{
350
 
        // Build the type array.
351
 
        TypeArray();
352
 
 
353
 
        if ( m_pDef )
354
 
                m_pDef->Optimise();
355
 
}
356
 
 
357
 
 
358
 
///---------------------------------------------------------------------
359
 
/** Find a function definition by searchin the standard and user definitions lists.
360
 
 */
361
 
 
362
 
TqBool CqFuncDef::FindFunction( const char* strName, std::vector<SqFuncRef>& Refs )
363
 
{
364
 
        SqFuncRef ref;
365
 
        // Clear any existing indexes.
366
 
        Refs.clear();
367
 
 
368
 
        // Search the standard definitions first.
369
 
        TqUint i;
370
 
        for ( i = 0; i < gcStandardFuncs; i++ )
371
 
        {
372
 
                if ( gStandardFuncs[ i ].m_strName == strName )
373
 
                {
374
 
                        ref.m_Type = FuncTypeStandard;
375
 
                        ref.m_Index = i;
376
 
                        Refs.push_back( ref );
377
 
                }
378
 
        }
379
 
 
380
 
        // Search the local definitions next.
381
 
        for ( i = 0; i < gLocalFuncs.size(); i++ )
382
 
        {
383
 
                if ( gLocalFuncs[ i ].m_strName == strName )
384
 
                {
385
 
                        ref.m_Type = FuncTypeLocal;
386
 
                        ref.m_Index = i;
387
 
                        Refs.push_back( ref );
388
 
                }
389
 
        }
390
 
        if ( !Refs.empty() )
391
 
                return ( TqTrue );
392
 
        else
393
 
                return ( TqFalse );
394
 
}
395
 
 
396
 
 
397
 
///---------------------------------------------------------------------
398
 
/** Add a new local function.
399
 
 */
400
 
 
401
 
TqInt CqFuncDef::AddFunction( CqFuncDef& Def )
402
 
{
403
 
        gLocalFuncs.push_back( Def );
404
 
        return ( gLocalFuncs.size() - 1 );
405
 
}
406
 
 
407
 
 
408
 
///---------------------------------------------------------------------
409
 
/** Fill in an array of types from a typespec string.
410
 
 */
411
 
 
412
 
int CqFuncDef::TypeArray()
413
 
{
414
 
        // Go through the type string parsing the types.
415
 
        unsigned int j = 0, cvars = 0;
416
 
 
417
 
        while ( j < m_strParamTypes.size() )
418
 
        {
419
 
                TqInt type = Type_Nil;
420
 
                int ctype = m_strParamTypes[ j++ ];
421
 
                switch ( tolower( ctype ) )
422
 
                {
423
 
                                case '@':
424
 
                                break;
425
 
                                case 'f':
426
 
                                type = ( ( type & ( ~Type_Mask ) ) | Type_Float );
427
 
                                break;
428
 
                                case 'i':
429
 
                                type = ( ( type & ( ~Type_Mask ) ) | Type_Integer );
430
 
                                break;
431
 
                                case 'p':
432
 
                                type = ( ( type & ( ~Type_Mask ) ) | Type_Point );
433
 
                                break;
434
 
                                case 's':
435
 
                                type = ( ( type & ( ~Type_Mask ) ) | Type_String );
436
 
                                break;
437
 
                                case 'c':
438
 
                                type = ( ( type & ( ~Type_Mask ) ) | Type_Color );
439
 
                                break;
440
 
                                case 't':
441
 
                                type = ( ( type & ( ~Type_Mask ) ) | Type_Triple );
442
 
                                break;
443
 
                                case 'h':
444
 
                                type = ( ( type & ( ~Type_Mask ) ) | Type_hPoint );
445
 
                                break;
446
 
                                case 'n':
447
 
                                type = ( ( type & ( ~Type_Mask ) ) | Type_Normal );
448
 
                                break;
449
 
                                case 'v':
450
 
                                type = ( ( type & ( ~Type_Mask ) ) | Type_Vector );
451
 
                                break;
452
 
                                case 'x':
453
 
                                type = ( ( type & ( ~Type_Mask ) ) | Type_Void );
454
 
                                break;
455
 
                                case 'm':
456
 
                                type = ( ( type & ( ~Type_Mask ) ) | Type_Matrix );
457
 
                                break;
458
 
                                case 'w':
459
 
                                type = ( ( type & ( ~Type_Mask ) ) | Type_HexTuple );
460
 
                                break;
461
 
                                case '[':
462
 
                                type = ( type | Type_Array );
463
 
                                break;
464
 
                                case ']':
465
 
                                break;
466
 
                                case '*':
467
 
                                m_fVarying = TqTrue;
468
 
                                break;
469
 
                }
470
 
                if ( isupper( ctype ) )
471
 
                        type = ( type | Type_Variable );
472
 
 
473
 
                if ( ( type & Type_Mask ) != Type_Nil )
474
 
                {
475
 
                        m_aTypeSpec.push_back( type );
476
 
                        cvars++;
477
 
                }
478
 
        }
479
 
        return ( cvars );
480
 
}
481
 
 
482
 
 
483
 
const IqParseNode* CqFuncDef::pArgs() const
484
 
{
485
 
        return ( m_pArgs );
486
 
}
487
 
 
488
 
 
489
 
const IqParseNode* CqFuncDef::pDef() const
490
 
{
491
 
        return ( m_pDef );
492
 
}
493
 
 
494
 
IqParseNode* CqFuncDef::pDef()
495
 
{
496
 
        return ( m_pDef );
497
 
}
498
 
 
499
 
 
500
 
///---------------------------------------------------------------------
501
 
/** Return a temporary pointer to a function definition..
502
 
 */
503
 
 
504
 
CqFuncDef* CqFuncDef::GetFunctionPtr( const SqFuncRef& Ref )
505
 
{
506
 
        if ( Ref.m_Type == FuncTypeStandard && Ref.m_Index < gcStandardFuncs )
507
 
                return ( &gStandardFuncs[ Ref.m_Index ] );
508
 
 
509
 
        if ( Ref.m_Type == FuncTypeLocal && Ref.m_Index < gLocalFuncs.size() )
510
 
                return ( &gLocalFuncs[ Ref.m_Index ] );
511
 
 
512
 
        return ( 0 );
513
 
}
514
 
 
515
 
 
516
 
///---------------------------------------------------------------------
517
 
/// IqFuncDef::GetFunctionPtr
518
 
/// Return a temporary pointer to a function definition..
519
 
 
520
 
IqFuncDef* IqFuncDef::GetFunctionPtr( const SqFuncRef& Ref )
521
 
{
522
 
        return ( CqFuncDef::GetFunctionPtr( Ref ) );
523
 
}
524
 
 
525
 
 
526
 
END_NAMESPACE( Aqsis )
527
 
//---------------------------------------------------------------------