← Back to branch summary

~ubuntu-branches/ubuntu/warty/aqsis/warty

« back to all changes in this revision

Viewing changes to libslparse/funcdef.cpp

  • Committer: Bazaar Package Importer
  • Author(s): LaMont Jones
  • Date: 2004-08-24 07:25:04 UTC
  • Revision ID: james.westby@ubuntu.com-20040824072504-zf993vnevvisdsvb
Tags: upstream-0.9.1
Import upstream version 0.9.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
libslparse/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, "operator-", "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, "operator-", "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, "operator-", "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, "operator-", "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, "operator-", "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_Float, "xcomp", "xcomp", "p" ),
 
176
                                 CqFuncDef( Type_Float, "ycomp", "ycomp", "p" ),
 
177
                                 CqFuncDef( Type_Float, "zcomp", "zcomp", "p" ),
 
178
                                 CqFuncDef( Type_Float, "xcomp", "xcomp", "h" ),
 
179
                                 CqFuncDef( Type_Float, "ycomp", "ycomp", "h" ),
 
180
                                 CqFuncDef( Type_Float, "zcomp", "zcomp", "h" ),
 
181
                                 CqFuncDef( Type_Float, "xcomp", "xcomp", "n" ),
 
182
                                 CqFuncDef( Type_Float, "ycomp", "ycomp", "n" ),
 
183
                                 CqFuncDef( Type_Float, "zcomp", "zcomp", "n" ),
 
184
                                 CqFuncDef( Type_Float, "xcomp", "xcomp", "v" ),
 
185
                                 CqFuncDef( Type_Float, "ycomp", "ycomp", "v" ),
 
186
                                 CqFuncDef( Type_Float, "zcomp", "zcomp", "v" ),
 
187
                                 CqFuncDef( Type_Float, "length", "length", "p" ),
 
188
                                 CqFuncDef( Type_Float, "distance", "distance", "pp" ),
 
189
                                 CqFuncDef( Type_Float, "area", "area", "p", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
 
190
                                 CqFuncDef( Type_Float, "area", "area", "h", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
 
191
                                 CqFuncDef( Type_Point, "normalize", "normalize", "p" ),
 
192
                                 CqFuncDef( Type_Point, "faceforward", "faceforward", "pp" ),
 
193
                                 CqFuncDef( Type_Point, "faceforward", "faceforward2", "ppp" ),
 
194
                                 CqFuncDef( Type_Point, "reflect", "reflect", "pp" ),
 
195
                                 CqFuncDef( Type_Point, "refract", "refract", "ppf" ),
 
196
                                 CqFuncDef( Type_Void, "fresnel", "fresnel", "ppfFF" ),
 
197
                                 CqFuncDef( Type_Void, "fresnel", "fresnel2", "ppfFFPP" ),
 
198
                                 CqFuncDef( Type_Point, "transform", "transform2", "ssp" ),
 
199
                                 CqFuncDef( Type_Point, "transform", "transform", "sp" ),
 
200
                                 CqFuncDef( Type_Float, "depth", "depth", "p" ),
 
201
                                 CqFuncDef( Type_Point, "calculatenormal", "calculatenormal", "p", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
 
202
                                 CqFuncDef( Type_Point, "calculatenormal", "calculatenormal", "h", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
 
203
                                 CqFuncDef( Type_Float, "comp", "comp", "cf" ),
 
204
                                 CqFuncDef( Type_Void, "setcomp", "setcomp", "cff" ),
 
205
                                 CqFuncDef( Type_Color, "mix", "cmix", "ccf" ),
 
206
                                 CqFuncDef( Type_Color, "ambient", "ambient", "" ),
 
207
                                 CqFuncDef( Type_Color, "diffuse", "diffuse", "p" ),
 
208
                                 CqFuncDef( Type_Color, "specular", "specular", "ppf" ),
 
209
                                 CqFuncDef( Type_Color, "phong", "phong", "ppf" ),
 
210
                                 CqFuncDef( Type_Color, "trace", "trace", "pp" ),
 
211
                                 CqFuncDef( Type_Float, "shadow", "shadow2", "sfpppp*" ),
 
212
                                 CqFuncDef( Type_Float, "shadow", "shadow", "sfp*" ),
 
213
                                 CqFuncDef( Type_Float, "texture", "ftexture3", "sfffffffff*" ),
 
214
                                 CqFuncDef( Type_Float, "texture", "ftexture2", "sfff*", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
 
215
                                 CqFuncDef( Type_Float, "texture", "ftexture1", "sf*", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) | ( 1 << EnvVars_s ) | ( 1 << EnvVars_t ) ),
 
216
                                 CqFuncDef( Type_Color, "texture", "ctexture3", "sfffffffff*" ),
 
217
                                 CqFuncDef( Type_Color, "texture", "ctexture2", "sfff*", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
 
218
                                 CqFuncDef( Type_Color, "texture", "ctexture1", "sf*", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) | ( 1 << EnvVars_s ) | ( 1 << EnvVars_t ) ),
 
219
                                 CqFuncDef( Type_Float, "environment", "fenvironment3", "sfpppp*" ),
 
220
                                 CqFuncDef( Type_Float, "environment", "fenvironment2", "sfp*", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
 
221
                                 CqFuncDef( Type_Color, "environment", "cenvironment3", "sfpppp*" ),
 
222
                                 CqFuncDef( Type_Color, "environment", "cenvironment2", "sfp*", ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) | ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) ),
 
223
                                 CqFuncDef( Type_Point, "bump", "bump3", "sfpppffffffff*" ),
 
224
                                 CqFuncDef( Type_Point, "bump", "bump2", "sfpppff*" ),
 
225
                                 CqFuncDef( Type_Point, "bump", "bump1", "sfppp*" ),
 
226
                                 CqFuncDef( Type_Void, "printf", "printf", "s*" ),
 
227
 
 
228
                                 CqFuncDef( Type_Point, "transform", "transformm", "mp" ),
 
229
                                 CqFuncDef( Type_Vector, "vtransform", "vtransform2", "ssv" ),
 
230
                                 CqFuncDef( Type_Vector, "vtransform", "vtransform", "sv" ),
 
231
                                 CqFuncDef( Type_Vector, "vtransform", "vtransformm", "mv" ),
 
232
                                 CqFuncDef( Type_Normal, "ntransform", "ntransform2", "ssn" ),
 
233
                                 CqFuncDef( Type_Normal, "ntransform", "ntransform", "sn" ),
 
234
                                 CqFuncDef( Type_Normal, "ntransform", "ntransformm", "mn" ),
 
235
                                 CqFuncDef( Type_Color, "ctransform", "ctransform2", "ssc" ),
 
236
                                 CqFuncDef( Type_Color, "ctransform", "ctransform", "sc" ),
 
237
                                 CqFuncDef( Type_Float, "cellnoise", "fcellnoise1", "f" ),
 
238
                                 CqFuncDef( Type_Float, "cellnoise", "fcellnoise2", "ff" ),
 
239
                                 CqFuncDef( Type_Float, "cellnoise", "fcellnoise3", "p" ),
 
240
                                 CqFuncDef( Type_Float, "cellnoise", "fcellnoise4", "pf" ),
 
241
                                 CqFuncDef( Type_Color, "cellnoise", "ccellnoise1", "f" ),
 
242
                                 CqFuncDef( Type_Color, "cellnoise", "ccellnoise2", "ff" ),
 
243
                                 CqFuncDef( Type_Color, "cellnoise", "ccellnoise3", "p" ),
 
244
                                 CqFuncDef( Type_Color, "cellnoise", "ccellnoise4", "pf" ),
 
245
                                 CqFuncDef( Type_Point, "cellnoise", "pcellnoise1", "f" ),
 
246
                                 CqFuncDef( Type_Point, "cellnoise", "pcellnoise2", "ff" ),
 
247
                                 CqFuncDef( Type_Point, "cellnoise", "pcellnoise3", "p" ),
 
248
                                 CqFuncDef( Type_Point, "cellnoise", "pcellnoise4", "pf" ),
 
249
                                 CqFuncDef( Type_Float, "mix", "fmix", "fff" ),
 
250
                                 CqFuncDef( Type_Point, "mix", "pmix", "ppf" ),
 
251
                                 CqFuncDef( Type_Vector, "mix", "vmix", "vvf" ),
 
252
                                 CqFuncDef( Type_Normal, "mix", "nmix", "nnf" ),
 
253
 
 
254
                                 CqFuncDef( Type_Void, "setcomp", "setcomp", "Cff" ),
 
255
                                 CqFuncDef( Type_Void, "setxcomp", "setxcomp", "Pf" ),
 
256
                                 CqFuncDef( Type_Void, "setycomp", "setycomp", "Pf" ),
 
257
                                 CqFuncDef( Type_Void, "setzcomp", "setzcomp", "Pf" ),
 
258
                                 CqFuncDef( Type_Void, "setxcomp", "setxcomp", "Nf" ),
 
259
                                 CqFuncDef( Type_Void, "setycomp", "setycomp", "Nf" ),
 
260
                                 CqFuncDef( Type_Void, "setzcomp", "setzcomp", "Nf" ),
 
261
                                 CqFuncDef( Type_Void, "setxcomp", "setxcomp", "Vf" ),
 
262
                                 CqFuncDef( Type_Void, "setycomp", "setycomp", "Vf" ),
 
263
                                 CqFuncDef( Type_Void, "setzcomp", "setzcomp", "Vf" ),
 
264
 
 
265
                                 CqFuncDef( Type_Float, "ptlined", "ptlined", "ppp" ),
 
266
                                 CqFuncDef( Type_Float, "inversesqrt", "inversesqrt", "f" ),
 
267
                                 CqFuncDef( Type_String, "concat", "concat", "ss*" ),
 
268
                                 CqFuncDef( Type_String, "format", "format", "s*" ),
 
269
                                 CqFuncDef( Type_Float, "match", "match", "ss" ),
 
270
                                 CqFuncDef( Type_Point, "rotate", "rotate", "pfpp" ),
 
271
                                 CqFuncDef( Type_Float, "filterstep", "filterstep2", "fff*"),
 
272
                                 CqFuncDef( Type_Float, "filterstep", "filterstep", "ff*", ( 1 << EnvVars_du ) | ( 1 << EnvVars_u ) | ( 1 << EnvVars_dv ) | ( 1 << EnvVars_v ) ),
 
273
                                 CqFuncDef( Type_Color, "specularbrdf", "specularbrdf", "vnvf" ),
 
274
 
 
275
                                 CqFuncDef( Type_Float, "pnoise", "fpnoise1", "ff" ),
 
276
                                 CqFuncDef( Type_Float, "pnoise", "fpnoise2", "ffff" ),
 
277
                                 CqFuncDef( Type_Float, "pnoise", "fpnoise3", "pp" ),
 
278
                                 CqFuncDef( Type_Float, "pnoise", "fpnoise4", "pfpf" ),
 
279
                                 CqFuncDef( Type_Color, "pnoise", "cpnoise1", "ff" ),
 
280
                                 CqFuncDef( Type_Color, "pnoise", "cpnoise2", "ffff" ),
 
281
                                 CqFuncDef( Type_Color, "pnoise", "cpnoise3", "pp" ),
 
282
                                 CqFuncDef( Type_Color, "pnoise", "cpnoise4", "pfpf" ),
 
283
                                 CqFuncDef( Type_Point, "pnoise", "ppnoise1", "ff" ),
 
284
                                 CqFuncDef( Type_Point, "pnoise", "ppnoise2", "ffff" ),
 
285
                                 CqFuncDef( Type_Point, "pnoise", "ppnoise3", "pp" ),
 
286
                                 CqFuncDef( Type_Point, "pnoise", "ppnoise4", "pfpf" ),
 
287
 
 
288
                                 CqFuncDef( Type_Matrix, "mtransform", "mtransform2", "ssm" ),
 
289
                                 CqFuncDef( Type_Matrix, "mtransform", "mtransform", "sm" ),
 
290
                                 CqFuncDef( Type_Float, "comp", "mcomp", "mff" ),
 
291
                                 CqFuncDef( Type_Void, "setcomp", "setmcomp", "mfff" ),
 
292
                                 CqFuncDef( Type_Float, "determinant", "determinant", "m" ),
 
293
                                 CqFuncDef( Type_Matrix, "translate", "mtranslate", "mv" ),
 
294
                                 CqFuncDef( Type_Matrix, "rotate", "mrotate", "mfv" ),
 
295
                                 CqFuncDef( Type_Matrix, "scale", "mscale", "mp" ),
 
296
 
 
297
                                 CqFuncDef( Type_Float, "spline", "fsplinea", "f[f]" ),
 
298
                                 CqFuncDef( Type_Color, "spline", "csplinea", "f[c]" ),
 
299
                                 CqFuncDef( Type_Point, "spline", "psplinea", "f[p]" ),
 
300
                                 CqFuncDef( Type_Point, "spline", "vsplinea", "f[v]" ),
 
301
                                 CqFuncDef( Type_Float, "spline", "sfsplinea", "sf[f]" ),
 
302
                                 CqFuncDef( Type_Color, "spline", "scsplinea", "sf[c]" ),
 
303
                                 CqFuncDef( Type_Point, "spline", "spsplinea", "sf[p]" ),
 
304
                                 CqFuncDef( Type_Point, "spline", "svsplinea", "sf[v]" ),
 
305
 
 
306
                                 CqFuncDef( Type_String, "shadername", "shadername2", "s" ),
 
307
                                 CqFuncDef( Type_String, "shadername", "shadername", "" ),
 
308
                                 CqFuncDef( Type_Void, "bake", "bake_f", "sfff" ),
 
309
                                 CqFuncDef( Type_Void, "bake", "bake_3c", "sffc" ),
 
310
                                 CqFuncDef( Type_Void, "bake", "bake_3p", "sffp" ),
 
311
                                 CqFuncDef( Type_Void, "bake", "bake_3v", "sffv" ),
 
312
                                 CqFuncDef( Type_Void, "bake", "bake_3n", "sffn" ),
 
313
 
 
314
                                 CqFuncDef( Type_Float, "occlusion", "occlusion", "sfpnf*" ),
 
315
                             };
 
316
 
 
317
TqUint  gcStandardFuncs = sizeof( gStandardFuncs ) / sizeof( gStandardFuncs[ 0 ] );
 
318
 
 
319
 
 
320
 
 
321
std::vector<CqFuncDef>  gLocalFuncs;
 
322
 
 
323
 
 
324
///---------------------------------------------------------------------
 
325
/** Constructor.
 
326
 */
 
327
 
 
328
CqFuncDef::CqFuncDef( TqInt Type, const char* strName, const char* strVMName, const char* strParams, CqParseNode* pDef, CqParseNode* pArgs ) :
 
329
        m_Type( Type ),
 
330
        m_strName( strName ),
 
331
        m_strVMName( strVMName ),
 
332
        m_strParamTypes( strParams ),
 
333
        m_fLocal( TqTrue ),
 
334
        m_pDef( pDef ),
 
335
        m_pArgs( pArgs ),
 
336
        m_fVarying( TqFalse )
 
337
{
 
338
    // Build the type array.
 
339
    TypeArray();
 
340
 
 
341
    if ( m_pDef )
 
342
        m_pDef->Optimise();
 
343
}
 
344
 
 
345
 
 
346
///---------------------------------------------------------------------
 
347
/** Find a function definition by searchin the standard and user definitions lists.
 
348
 */
 
349
 
 
350
TqBool CqFuncDef::FindFunction( const char* strName, std::vector<SqFuncRef>& Refs )
 
351
{
 
352
    SqFuncRef ref;
 
353
    // Clear any existing indexes.
 
354
    Refs.clear();
 
355
 
 
356
    // Search the standard definitions first.
 
357
    TqUint i;
 
358
    for ( i = 0; i < gcStandardFuncs; i++ )
 
359
    {
 
360
        if ( gStandardFuncs[ i ].m_strName == strName )
 
361
        {
 
362
            ref.m_Type = FuncTypeStandard;
 
363
            ref.m_Index = i;
 
364
            Refs.push_back( ref );
 
365
        }
 
366
    }
 
367
 
 
368
    // Search the local definitions next.
 
369
    for ( i = 0; i < gLocalFuncs.size(); i++ )
 
370
    {
 
371
        if ( gLocalFuncs[ i ].m_strName == strName )
 
372
        {
 
373
            ref.m_Type = FuncTypeLocal;
 
374
            ref.m_Index = i;
 
375
            Refs.push_back( ref );
 
376
        }
 
377
    }
 
378
    if ( !Refs.empty() ) return ( TqTrue );
 
379
    else        return ( TqFalse );
 
380
}
 
381
 
 
382
 
 
383
///---------------------------------------------------------------------
 
384
/** Add a new local function.
 
385
 */
 
386
 
 
387
TqInt CqFuncDef::AddFunction( CqFuncDef& Def )
 
388
{
 
389
    gLocalFuncs.push_back( Def );
 
390
    return ( gLocalFuncs.size() - 1 );
 
391
}
 
392
 
 
393
 
 
394
///---------------------------------------------------------------------
 
395
/** Fill in an array of types from a typespec string.
 
396
 */
 
397
 
 
398
int CqFuncDef::TypeArray()
 
399
{
 
400
    // Go through the type string parsing the types.
 
401
    unsigned int j = 0, cvars = 0;
 
402
 
 
403
    while ( j < m_strParamTypes.size() )
 
404
    {
 
405
        TqInt type = Type_Nil;
 
406
        int ctype = m_strParamTypes[ j++ ];
 
407
        switch ( tolower( ctype ) )
 
408
        {
 
409
        case '@':
 
410
            break;
 
411
        case 'f':
 
412
            type = ( ( type & ( ~Type_Mask ) ) | Type_Float );
 
413
            break;
 
414
        case 'i':
 
415
            type = ( ( type & ( ~Type_Mask ) ) | Type_Integer );
 
416
            break;
 
417
        case 'p':
 
418
            type = ( ( type & ( ~Type_Mask ) ) | Type_Point );
 
419
            break;
 
420
        case 's':
 
421
            type = ( ( type & ( ~Type_Mask ) ) | Type_String );
 
422
            break;
 
423
        case 'c':
 
424
            type = ( ( type & ( ~Type_Mask ) ) | Type_Color );
 
425
            break;
 
426
        case 't':
 
427
            type = ( ( type & ( ~Type_Mask ) ) | Type_Triple );
 
428
            break;
 
429
        case 'h':
 
430
            type = ( ( type & ( ~Type_Mask ) ) | Type_hPoint );
 
431
            break;
 
432
        case 'n':
 
433
            type = ( ( type & ( ~Type_Mask ) ) | Type_Normal );
 
434
            break;
 
435
        case 'v':
 
436
            type = ( ( type & ( ~Type_Mask ) ) | Type_Vector );
 
437
            break;
 
438
        case 'x':
 
439
            type = ( ( type & ( ~Type_Mask ) ) | Type_Void );
 
440
            break;
 
441
        case 'm':
 
442
            type = ( ( type & ( ~Type_Mask ) ) | Type_Matrix );
 
443
            break;
 
444
        case 'w':
 
445
            type = ( ( type & ( ~Type_Mask ) ) | Type_HexTuple );
 
446
            break;
 
447
        case '[':
 
448
            type = ( type | Type_Array );
 
449
            break;
 
450
        case ']':
 
451
            break;
 
452
        case '*':
 
453
            m_fVarying = TqTrue;
 
454
            break;
 
455
        }
 
456
        if ( isupper( ctype ) )
 
457
            type = ( type | Type_Variable );
 
458
 
 
459
        if ( ( type & Type_Mask ) != Type_Nil )
 
460
        {
 
461
            m_aTypeSpec.push_back( type );
 
462
            cvars++;
 
463
        }
 
464
    }
 
465
    return ( cvars );
 
466
}
 
467
 
 
468
 
 
469
const IqParseNode* CqFuncDef::pArgs() const
 
470
{
 
471
    return ( m_pArgs );
 
472
}
 
473
 
 
474
 
 
475
const IqParseNode* CqFuncDef::pDef() const
 
476
{
 
477
    return ( m_pDef );
 
478
}
 
479
 
 
480
IqParseNode* CqFuncDef::pDef()
 
481
{
 
482
    return ( m_pDef );
 
483
}
 
484
 
 
485
 
 
486
///---------------------------------------------------------------------
 
487
/** Return a temporary pointer to a function definition..
 
488
 */
 
489
 
 
490
CqFuncDef* CqFuncDef::GetFunctionPtr( const SqFuncRef& Ref )
 
491
{
 
492
    if ( Ref.m_Type == FuncTypeStandard && Ref.m_Index < gcStandardFuncs )
 
493
        return ( &gStandardFuncs[ Ref.m_Index ] );
 
494
 
 
495
    if ( Ref.m_Type == FuncTypeLocal && Ref.m_Index < gLocalFuncs.size() )
 
496
        return ( &gLocalFuncs[ Ref.m_Index ] );
 
497
 
 
498
    return ( 0 );
 
499
}
 
500
 
 
501
 
 
502
///---------------------------------------------------------------------
 
503
/// IqFuncDef::GetFunctionPtr
 
504
/// Return a temporary pointer to a function definition..
 
505
 
 
506
IqFuncDef* IqFuncDef::GetFunctionPtr( const SqFuncRef& Ref )
 
507
{
 
508
    return ( CqFuncDef::GetFunctionPtr( Ref ) );
 
509
}
 
510
 
 
511
 
 
512
END_NAMESPACE( Aqsis )
 
513
//---------------------------------------------------------------------