← Back to branch summary

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

« back to all changes in this revision

Viewing changes to render/ishaderexecenv.h

  • 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:
render/ishaderexecenv.h
 
1
// Aqsis
 
2
// Copyright � 1997 - 2001, Paul C. Gregory
 
3
//
 
4
// Contact: pgregory@aqsis.com
 
5
//
 
6
// This library is free software; you can redistribute it and/or
 
7
// modify it under the terms of the GNU General Public
 
8
// License as published by the Free Software Foundation; either
 
9
// version 2 of the License, or (at your option) any later version.
 
10
//
 
11
// This library is distributed in the hope that it will be useful,
 
12
// but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
// General Public License for more details.
 
15
//
 
16
// You should have received a copy of the GNU General Public
 
17
// License along with this library; if not, write to the Free Software
 
18
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 
 
20
 
 
21
/** \file
 
22
                \brief Declares interface used to access the shader execution environment.
 
23
                \author Paul C. Gregory (pgregory@aqsis.com)
 
24
*/
 
25
 
 
26
#ifndef ___ishaderexecenv_Loaded___
 
27
#define ___ishaderexecenv_Loaded___
 
28
 
 
29
#include        "aqsis.h"
 
30
#include        <boost/shared_ptr.hpp>
 
31
 
 
32
#include        "vector3d.h"
 
33
#include        "matrix.h"
 
34
#include        "sstring.h"
 
35
#include        "bitvector.h"
 
36
#include        "shadeop.h"
 
37
 
 
38
START_NAMESPACE( Aqsis )
 
39
 
 
40
struct IqSurface;
 
41
struct IqAttributes;
 
42
struct IqTransform;
 
43
struct IqShader;
 
44
struct IqShaderData;
 
45
 
 
46
/** \enum EqEnvVars
 
47
 * Identifiers for the standard environment variables.
 
48
 */
 
49
 
 
50
enum EqEnvVars
 
51
{
 
52
    EnvVars_Cs,                 ///< Surface color.
 
53
    EnvVars_Os,                 ///< Surface opacity.
 
54
    EnvVars_Ng,                 ///< Geometric normal.
 
55
    EnvVars_du,                 ///< First derivative in u.
 
56
    EnvVars_dv,                 ///< First derivative in v.
 
57
    EnvVars_L,                  ///< Incoming light direction.
 
58
    EnvVars_Cl,                 ///< Light color.
 
59
    EnvVars_Ol,                 ///< Light opacity.
 
60
    EnvVars_P,                  ///< Point being shaded.
 
61
    EnvVars_dPdu,       ///< Change in P with respect to change in u.
 
62
    EnvVars_dPdv,       ///< Change in P with respect to change in v.
 
63
    EnvVars_N,                  ///< Surface normal.
 
64
    EnvVars_u,                  ///< Surface u coordinate.
 
65
    EnvVars_v,                  ///< Surface v coordinate.
 
66
    EnvVars_s,                  ///< Texture s coordinate.
 
67
    EnvVars_t,                  ///< Texture t coordinate.
 
68
    EnvVars_I,                  ///< Incident ray direction.
 
69
    EnvVars_Ci,                 ///< Incident color.
 
70
    EnvVars_Oi,                 ///< Incident opacity.
 
71
    EnvVars_Ps,                 ///< Point being lit.
 
72
    EnvVars_E,                  ///< Viewpoint position.
 
73
    EnvVars_ncomps,     ///< Number of color components.
 
74
    EnvVars_time,       ///< Frame time.
 
75
    EnvVars_alpha,      ///< Fractional pixel coverage.
 
76
 
 
77
    EnvVars_Ns,                 ///< Normal at point being lit.
 
78
 
 
79
    EnvVars_Last
 
80
};
 
81
 
 
82
 
 
83
#define STD_SO          void
 
84
#define STD_SOIMPL      void
 
85
 
 
86
#define FLOATVAL        IqShaderData*
 
87
#define POINTVAL        IqShaderData*
 
88
#define VECTORVAL       IqShaderData*
 
89
#define NORMALVAL       IqShaderData*
 
90
#define COLORVAL        IqShaderData*
 
91
#define STRINGVAL       IqShaderData*
 
92
#define MATRIXVAL       IqShaderData*
 
93
 
 
94
#define FLOATPTR        IqShaderData**
 
95
#define POINTPTR        IqShaderData**
 
96
#define VECTORPTR       IqShaderData**
 
97
#define NORMALPTR       IqShaderData**
 
98
#define COLORPTR        IqShaderData**
 
99
#define STRINGPTR       IqShaderData**
 
100
#define MATRIXPTR       IqShaderData**
 
101
 
 
102
#define FLOATARRAYVAL   IqShaderData*
 
103
#define POINTARRAYVAL   IqShaderData*
 
104
#define VECTORARRAYVAL  IqShaderData*
 
105
#define NORMALARRAYVAL  IqShaderData*
 
106
#define COLORARRAYVAL   IqShaderData*
 
107
#define STRINGARRAYVAL  IqShaderData*
 
108
#define MATRIXARRAYVAL  IqShaderData*
 
109
 
 
110
#define DEFPARAM                IqShaderData* Result, IqShader* pShader=0
 
111
#define DEFVOIDPARAM    IqShader* pShader=0
 
112
#define DEFPARAMVAR             DEFPARAM, int cParams=0, IqShaderData** apParams=0
 
113
#define DEFVOIDPARAMVAR DEFVOIDPARAM, int cParams=0, IqShaderData** apParams=0
 
114
 
 
115
 
 
116
//----------------------------------------------------------------------
 
117
/** \struct IqShaderExecEnv
 
118
 * Interface to shader execution environment.
 
119
 * The shader execution environment is responsible for providing functionality for accessing shader data on a
 
120
 * 'shadable' item, and providing shadeops to process that data.
 
121
 */
 
122
 
 
123
struct IqShaderExecEnv
 
124
{
 
125
    virtual     ~IqShaderExecEnv()
 
126
    {}
 
127
 
 
128
    virtual     void    Initialise( const TqInt uGridRes, const TqInt vGridRes, IqAttributes* pAttr, IqTransform* pTrans, IqShader* pShader, TqInt Uses ) = 0;
 
129
    /** Get grid size in u
 
130
     */
 
131
    virtual     TqInt   uGridRes() const = 0;
 
132
    /** Get grid size in v
 
133
     */
 
134
    virtual     TqInt   vGridRes() const = 0;
 
135
    /** Get total grid size.
 
136
     */
 
137
    virtual     TqInt   GridSize() const = 0;
 
138
    /** Get the matrix which describes the transformation from Object space to World space for the surface related to this execution environment.
 
139
     */
 
140
    virtual     const CqMatrix& matObjectToWorld() const = 0;
 
141
    /** Get a pointer to the associated attributes.
 
142
     */
 
143
    virtual     const IqAttributes*     pAttributes() const = 0;
 
144
    /** Get a pointer to the associated transform.
 
145
     */
 
146
    virtual     const IqTransform*      pTransform() const = 0;
 
147
    /** Update all cached lighting results.
 
148
     */
 
149
    virtual     void    ValidateIlluminanceCache( IqShaderData* pP, IqShaderData* pN, IqShader* pShader ) = 0;
 
150
    /** Reset the illuminance cache.
 
151
     */
 
152
    virtual     void    InvalidateIlluminanceCache() = 0;
 
153
    /** Get the current execution state. Bits in the vector indicate which SIMD indexes have passed the current condition.
 
154
     */
 
155
    virtual     CqBitVector& CurrentState() = 0;
 
156
    /** Get the running execution state. Bits in the vector indicate which SIMD indexes are valid.
 
157
     */
 
158
    virtual     CqBitVector& RunningState() = 0;
 
159
    /** Transfer the current state into the running state.
 
160
     */
 
161
    virtual     void    GetCurrentState() = 0;
 
162
    /** Clear the current state ready for a new condition.
 
163
     */
 
164
    virtual     void    ClearCurrentState() = 0;
 
165
    /** Push the running state onto the stack.
 
166
     */
 
167
    virtual     void    PushState() = 0;
 
168
    /** Pop the running state from the stack.
 
169
     */
 
170
    virtual     void    PopState() = 0;
 
171
    /** Invert the bits in the running state, to perform the opposite to the condition, i.e. else.
 
172
     */
 
173
    virtual     void    InvertRunningState() = 0;
 
174
    /** Find a named standard variable in the list.
 
175
     * \param pname Character pointer to the name.
 
176
     * \return IqShaderData pointer or 0.
 
177
     */
 
178
    virtual     IqShaderData* FindStandardVar( const char* pname ) = 0;
 
179
    /** Find a named standard variable in the list.
 
180
     * \param pname Character pointer to the name.
 
181
     * \return Integer index in the list or -1.
 
182
     */
 
183
    virtual     TqInt   FindStandardVarIndex( const char* pname ) = 0;
 
184
    /** Get a standard variable pointer given an index.
 
185
     * \param Index The integer index returned from FindStandardVarIndex.
 
186
     * \return IqShaderData pointer.
 
187
     */
 
188
    virtual     IqShaderData*   pVar( TqInt Index ) = 0;
 
189
    /** Delete an indexed variable from the list.
 
190
     * \param Index The integer index returned from FindStandardVarIndex.
 
191
     */
 
192
    virtual     void    DeleteVariable( TqInt Index ) = 0;
 
193
    /** Get a reference to the Cs standard variable.
 
194
     */
 
195
    virtual     IqShaderData* Cs() = 0;
 
196
    /** Get a reference to the Os standard variable.
 
197
     */
 
198
    virtual     IqShaderData* Os() = 0;
 
199
    /** Get a reference to the Ng standard variable.
 
200
     */
 
201
    virtual     IqShaderData* Ng() = 0;
 
202
    /** Get a reference to the du standard variable.
 
203
     */
 
204
    virtual     IqShaderData* du() = 0;
 
205
    /** Get a reference to the dv standard variable.
 
206
     */
 
207
    virtual     IqShaderData* dv() = 0;
 
208
    /** Get a reference to the L standard variable.
 
209
     */
 
210
    virtual     IqShaderData* L() = 0;
 
211
    /** Get a reference to the Cl standard variable.
 
212
     */
 
213
    virtual     IqShaderData* Cl() = 0;
 
214
    /** Get a reference to the Ol standard variable.
 
215
     */
 
216
    virtual IqShaderData* Ol() = 0;
 
217
    /** Get a reference to the P standard variable.
 
218
     */
 
219
    virtual IqShaderData* P() = 0;
 
220
    /** Get a reference to the dPdu standard variable.
 
221
     */
 
222
    virtual IqShaderData* dPdu() = 0;
 
223
    /** Get a reference to the dPdv standard variable.
 
224
     */
 
225
    virtual IqShaderData* dPdv() = 0;
 
226
    /** Get a reference to the N standard variable.
 
227
     */
 
228
    virtual IqShaderData* N() = 0;
 
229
    /** Get a reference to the u standard variable.
 
230
     */
 
231
    virtual IqShaderData* u() = 0;
 
232
    /** Get a reference to the v standard variable.
 
233
     */
 
234
    virtual IqShaderData* v() = 0;
 
235
    /** Get a reference to the s standard variable.
 
236
     */
 
237
    virtual IqShaderData* s() = 0;
 
238
    /** Get a reference to the t standard variable.
 
239
     */
 
240
    virtual IqShaderData* t() = 0;
 
241
    /** Get a reference to the I standard variable.
 
242
     */
 
243
    virtual IqShaderData* I() = 0;
 
244
    /** Get a reference to the Ci standard variable.
 
245
     */
 
246
    virtual IqShaderData* Ci() = 0;
 
247
    /** Get a reference to the Oi standard variable.
 
248
     */
 
249
    virtual IqShaderData* Oi() = 0;
 
250
    /** Get a reference to the Ps standard variable.
 
251
     */
 
252
    virtual IqShaderData* Ps() = 0;
 
253
    /** Get a reference to the E standard variable.
 
254
     */
 
255
    virtual IqShaderData* E() = 0;
 
256
    /** Get a reference to the ncomps standard variable.
 
257
     */
 
258
    virtual IqShaderData* ncomps() = 0;
 
259
    /** Get a reference to the time standard variable.
 
260
     */
 
261
    virtual IqShaderData* time() = 0;
 
262
    /** Get a reference to the alpha standard variable.
 
263
     */
 
264
    virtual IqShaderData* alpha() = 0;
 
265
    /** Get a reference to the Ns standard variable.
 
266
     */
 
267
    virtual IqShaderData* Ns() = 0;
 
268
 
 
269
    virtual     TqBool  SO_init_illuminance() = 0;
 
270
    virtual     TqBool  SO_advance_illuminance() = 0;
 
271
 
 
272
    // ShadeOps
 
273
    virtual STD_SO      SO_radians( FLOATVAL degrees, DEFPARAM ) = 0;
 
274
    virtual STD_SO      SO_degrees( FLOATVAL radians, DEFPARAM ) = 0;
 
275
    virtual STD_SO      SO_sin( FLOATVAL a, DEFPARAM ) = 0;
 
276
    virtual STD_SO      SO_asin( FLOATVAL a, DEFPARAM ) = 0;
 
277
    virtual STD_SO      SO_cos( FLOATVAL a, DEFPARAM ) = 0;
 
278
    virtual STD_SO      SO_acos( FLOATVAL a, DEFPARAM ) = 0;
 
279
    virtual STD_SO      SO_tan( FLOATVAL a, DEFPARAM ) = 0;
 
280
    virtual STD_SO      SO_atan( FLOATVAL yoverx, DEFPARAM ) = 0;
 
281
    virtual STD_SO      SO_atan( FLOATVAL y, FLOATVAL x, DEFPARAM ) = 0;
 
282
    virtual STD_SO      SO_pow( FLOATVAL x, FLOATVAL y, DEFPARAM ) = 0;
 
283
    virtual STD_SO      SO_exp( FLOATVAL x, DEFPARAM ) = 0;
 
284
    virtual STD_SO      SO_sqrt( FLOATVAL x, DEFPARAM ) = 0;
 
285
    virtual STD_SO      SO_log( FLOATVAL x, DEFPARAM ) = 0;
 
286
    virtual STD_SO      SO_log( FLOATVAL x, FLOATVAL base, DEFPARAM ) = 0;
 
287
    virtual STD_SO      SO_mod( FLOATVAL a, FLOATVAL b, DEFPARAM ) = 0;
 
288
    virtual STD_SO      SO_abs( FLOATVAL x, DEFPARAM ) = 0;
 
289
    virtual STD_SO      SO_sign( FLOATVAL x, DEFPARAM ) = 0;
 
290
    virtual STD_SO      SO_min( FLOATVAL a, FLOATVAL b, DEFPARAMVAR ) = 0;
 
291
    virtual STD_SO      SO_max( FLOATVAL a, FLOATVAL b, DEFPARAMVAR ) = 0;
 
292
    virtual STD_SO      SO_pmin( POINTVAL a, POINTVAL b, DEFPARAMVAR ) = 0;
 
293
    virtual STD_SO      SO_pmax( POINTVAL a, POINTVAL b, DEFPARAMVAR ) = 0;
 
294
    virtual STD_SO      SO_cmin( COLORVAL a, COLORVAL b, DEFPARAMVAR ) = 0;
 
295
    virtual STD_SO      SO_cmax( COLORVAL a, COLORVAL b, DEFPARAMVAR ) = 0;
 
296
    virtual STD_SO      SO_clamp( FLOATVAL a, FLOATVAL _min, FLOATVAL _max, DEFPARAM ) = 0;
 
297
    virtual STD_SO      SO_pclamp( POINTVAL a, POINTVAL _min, POINTVAL _max, DEFPARAM ) = 0;
 
298
    virtual STD_SO      SO_cclamp( COLORVAL a, COLORVAL _min, COLORVAL _max, DEFPARAM ) = 0;
 
299
    virtual STD_SO      SO_floor( FLOATVAL x, DEFPARAM ) = 0;
 
300
    virtual STD_SO      SO_ceil( FLOATVAL x, DEFPARAM ) = 0;
 
301
    virtual STD_SO      SO_round( FLOATVAL x, DEFPARAM ) = 0;
 
302
    virtual STD_SO      SO_step( FLOATVAL _min, FLOATVAL value, DEFPARAM ) = 0;
 
303
    virtual STD_SO      SO_smoothstep( FLOATVAL _min, FLOATVAL _max, FLOATVAL value, DEFPARAM ) = 0;
 
304
    virtual STD_SO      SO_fspline( FLOATVAL value, DEFPARAMVAR ) = 0;
 
305
    virtual STD_SO      SO_cspline( FLOATVAL value, DEFPARAMVAR ) = 0;
 
306
    virtual STD_SO      SO_pspline( FLOATVAL value, DEFPARAMVAR ) = 0;
 
307
    virtual STD_SO      SO_sfspline( STRINGVAL basis, FLOATVAL value, DEFPARAMVAR ) = 0;
 
308
    virtual STD_SO      SO_scspline( STRINGVAL basis, FLOATVAL value, DEFPARAMVAR ) = 0;
 
309
    virtual STD_SO      SO_spspline( STRINGVAL basis, FLOATVAL value, DEFPARAMVAR ) = 0;
 
310
    virtual STD_SO      SO_fDu( FLOATVAL p, DEFPARAM ) = 0;
 
311
    virtual STD_SO      SO_fDv( FLOATVAL p, DEFPARAM ) = 0;
 
312
    virtual STD_SO      SO_fDeriv( FLOATVAL p, FLOATVAL den, DEFPARAM ) = 0;
 
313
    virtual STD_SO      SO_cDu( COLORVAL p, DEFPARAM ) = 0;
 
314
    virtual STD_SO      SO_cDv( COLORVAL p, DEFPARAM ) = 0;
 
315
    virtual STD_SO      SO_cDeriv( COLORVAL p, FLOATVAL den, DEFPARAM ) = 0;
 
316
    virtual STD_SO      SO_pDu( POINTVAL p, DEFPARAM ) = 0;
 
317
    virtual STD_SO      SO_pDv( POINTVAL p, DEFPARAM ) = 0;
 
318
    virtual STD_SO      SO_pDeriv( POINTVAL p, FLOATVAL den, DEFPARAM ) = 0;
 
319
    virtual STD_SO      SO_frandom( DEFPARAM ) = 0;
 
320
    virtual STD_SO      SO_crandom( DEFPARAM ) = 0;
 
321
    virtual STD_SO      SO_prandom( DEFPARAM ) = 0;
 
322
    virtual STD_SO      SO_fnoise1( FLOATVAL v, DEFPARAM ) = 0;
 
323
    virtual STD_SO      SO_fnoise2( FLOATVAL u, FLOATVAL v, DEFPARAM ) = 0;
 
324
    virtual STD_SO      SO_fnoise3( POINTVAL p, DEFPARAM ) = 0;
 
325
    virtual STD_SO      SO_fnoise4( POINTVAL p, FLOATVAL t, DEFPARAM ) = 0;
 
326
    virtual STD_SO      SO_cnoise1( FLOATVAL v, DEFPARAM ) = 0;
 
327
    virtual STD_SO      SO_cnoise2( FLOATVAL u, FLOATVAL v, DEFPARAM ) = 0;
 
328
    virtual STD_SO      SO_cnoise3( POINTVAL p, DEFPARAM ) = 0;
 
329
    virtual STD_SO      SO_cnoise4( POINTVAL p, FLOATVAL t, DEFPARAM ) = 0;
 
330
    virtual STD_SO      SO_pnoise1( FLOATVAL v, DEFPARAM ) = 0;
 
331
    virtual STD_SO      SO_pnoise2( FLOATVAL u, FLOATVAL v, DEFPARAM ) = 0;
 
332
    virtual STD_SO      SO_pnoise3( POINTVAL p, DEFPARAM ) = 0;
 
333
    virtual STD_SO      SO_pnoise4( POINTVAL p, FLOATVAL t, DEFPARAM ) = 0;
 
334
    virtual STD_SO      SO_setcomp( COLORVAL p, FLOATVAL i, FLOATVAL v, DEFVOIDPARAM ) = 0;
 
335
    virtual STD_SO      SO_setxcomp( POINTVAL p, FLOATVAL v, DEFVOIDPARAM ) = 0;
 
336
    virtual STD_SO      SO_setycomp( POINTVAL p, FLOATVAL v, DEFVOIDPARAM ) = 0;
 
337
    virtual STD_SO      SO_setzcomp( POINTVAL p, FLOATVAL v, DEFVOIDPARAM ) = 0;
 
338
    virtual STD_SO      SO_length( VECTORVAL V, DEFPARAM ) = 0;
 
339
    virtual STD_SO      SO_distance( POINTVAL P1, POINTVAL P2, DEFPARAM ) = 0;
 
340
    virtual STD_SO      SO_area( POINTVAL p, DEFPARAM ) = 0;
 
341
    virtual STD_SO      SO_normalize( VECTORVAL V, DEFPARAM ) = 0;
 
342
    virtual STD_SO      SO_faceforward( NORMALVAL N, VECTORVAL I, DEFPARAM ) = 0;
 
343
    virtual STD_SO      SO_faceforward2( NORMALVAL N, VECTORVAL I, NORMALVAL Nref, DEFPARAM ) = 0;
 
344
    virtual STD_SO      SO_reflect( VECTORVAL I, NORMALVAL N, DEFPARAM ) = 0;
 
345
    virtual STD_SO      SO_refract( VECTORVAL I, NORMALVAL N, FLOATVAL eta, DEFPARAM ) = 0;
 
346
    virtual STD_SO      SO_fresnel( VECTORVAL I, NORMALVAL N, FLOATVAL eta, FLOATVAL Kr, FLOATVAL Kt, DEFVOIDPARAM ) = 0;
 
347
    virtual STD_SO      SO_fresnel( VECTORVAL I, NORMALVAL N, FLOATVAL eta, FLOATVAL Kr, FLOATVAL Kt, VECTORVAL R, VECTORVAL T, DEFVOIDPARAM ) = 0;
 
348
    virtual STD_SO      SO_transform( STRINGVAL fromspace, STRINGVAL tospace, POINTVAL p, DEFPARAM ) = 0;
 
349
    virtual STD_SO      SO_transform( STRINGVAL tospace, POINTVAL p, DEFPARAM ) = 0;
 
350
    virtual STD_SO      SO_transformm( MATRIXVAL tospace, POINTVAL p, DEFPARAM ) = 0;
 
351
    virtual STD_SO      SO_vtransform( STRINGVAL fromspace, STRINGVAL tospace, VECTORVAL p, DEFPARAM ) = 0;
 
352
    virtual STD_SO      SO_vtransform( STRINGVAL tospace, VECTORVAL p, DEFPARAM ) = 0;
 
353
    virtual STD_SO      SO_vtransformm( MATRIXVAL tospace, VECTORVAL p, DEFPARAM ) = 0;
 
354
    virtual STD_SO      SO_ntransform( STRINGVAL fromspace, STRINGVAL tospace, NORMALVAL p, DEFPARAM ) = 0;
 
355
    virtual STD_SO      SO_ntransform( STRINGVAL tospace, NORMALVAL p, DEFPARAM ) = 0;
 
356
    virtual STD_SO      SO_ntransformm( MATRIXVAL tospace, NORMALVAL p, DEFPARAM ) = 0;
 
357
    virtual STD_SO      SO_depth( POINTVAL p, DEFPARAM ) = 0;
 
358
    virtual STD_SO      SO_calculatenormal( POINTVAL p, DEFPARAM ) = 0;
 
359
    virtual STD_SO      SO_cmix( COLORVAL color0, COLORVAL color1, FLOATVAL value, DEFPARAM ) = 0;
 
360
    virtual STD_SO      SO_fmix( FLOATVAL f0, FLOATVAL f1, FLOATVAL value, DEFPARAM ) = 0;
 
361
    virtual STD_SO      SO_pmix( POINTVAL p0, POINTVAL p1, FLOATVAL value, DEFPARAM ) = 0;
 
362
    virtual STD_SO      SO_vmix( VECTORVAL v0, VECTORVAL v1, FLOATVAL value, DEFPARAM ) = 0;
 
363
    virtual STD_SO      SO_nmix( NORMALVAL n0, NORMALVAL n1, FLOATVAL value, DEFPARAM ) = 0;
 
364
    virtual STD_SO      SO_ambient( DEFPARAM ) = 0;
 
365
    virtual STD_SO      SO_diffuse( NORMALVAL N, DEFPARAM ) = 0;
 
366
    virtual STD_SO      SO_specular( NORMALVAL N, VECTORVAL V, FLOATVAL roughness, DEFPARAM ) = 0;
 
367
    virtual STD_SO      SO_phong( NORMALVAL N, VECTORVAL V, FLOATVAL size, DEFPARAM ) = 0;
 
368
    virtual STD_SO      SO_trace( POINTVAL P, VECTORVAL R, DEFPARAM ) = 0;
 
369
    virtual STD_SO      SO_ftexture1( STRINGVAL name, FLOATVAL channel, DEFPARAMVAR ) = 0;
 
370
    virtual STD_SO      SO_ftexture2( STRINGVAL name, FLOATVAL channel, FLOATVAL s, FLOATVAL t, DEFPARAMVAR ) = 0;
 
371
    virtual STD_SO      SO_ftexture3( STRINGVAL name, FLOATVAL channel, FLOATVAL s1, FLOATVAL t1, FLOATVAL s2, FLOATVAL t2, FLOATVAL s3, FLOATVAL t3, FLOATVAL s4, FLOATVAL t4, DEFPARAMVAR ) = 0;
 
372
    virtual STD_SO      SO_ctexture1( STRINGVAL name, FLOATVAL channel, DEFPARAMVAR ) = 0;
 
373
    virtual STD_SO      SO_ctexture2( STRINGVAL name, FLOATVAL channel, FLOATVAL s, FLOATVAL t, DEFPARAMVAR ) = 0;
 
374
    virtual STD_SO      SO_ctexture3( STRINGVAL name, FLOATVAL channel, FLOATVAL s1, FLOATVAL t1, FLOATVAL s2, FLOATVAL t2, FLOATVAL s3, FLOATVAL t3, FLOATVAL s4, FLOATVAL t4, DEFPARAMVAR ) = 0;
 
375
    virtual STD_SO      SO_fenvironment2( STRINGVAL name, FLOATVAL channel, VECTORVAL R, DEFPARAMVAR ) = 0;
 
376
    virtual STD_SO      SO_fenvironment3( STRINGVAL name, FLOATVAL channel, VECTORVAL R1, VECTORVAL R2, VECTORVAL R3, VECTORVAL R4, DEFPARAMVAR ) = 0;
 
377
    virtual STD_SO      SO_cenvironment2( STRINGVAL name, FLOATVAL channel, VECTORVAL R, DEFPARAMVAR ) = 0;
 
378
    virtual STD_SO      SO_cenvironment3( STRINGVAL name, FLOATVAL channel, VECTORVAL R1, VECTORVAL R2, VECTORVAL R3, VECTORVAL R4, DEFPARAMVAR ) = 0;
 
379
    virtual STD_SO      SO_bump1( STRINGVAL name, FLOATVAL channel, DEFPARAMVAR ) = 0;
 
380
    virtual STD_SO      SO_bump2( STRINGVAL name, FLOATVAL channel, FLOATVAL s, FLOATVAL t, DEFPARAMVAR ) = 0;
 
381
    virtual STD_SO      SO_bump3( STRINGVAL name, FLOATVAL channel, FLOATVAL s1, FLOATVAL t1, FLOATVAL s2, FLOATVAL t2, FLOATVAL s3, FLOATVAL t3, FLOATVAL s4, FLOATVAL t4, DEFPARAMVAR ) = 0;
 
382
    virtual STD_SO      SO_shadow( STRINGVAL name, FLOATVAL channel, POINTVAL P, DEFPARAMVAR ) = 0;
 
383
    virtual STD_SO      SO_shadow1( STRINGVAL name, FLOATVAL channel, POINTVAL P1, POINTVAL P2, POINTVAL P3, POINTVAL P4, DEFPARAMVAR ) = 0;
 
384
    virtual STD_SO      SO_illuminance( POINTVAL P, FLOATVAL nsamples, DEFVOIDPARAM ) = 0;
 
385
    virtual STD_SO      SO_illuminance( POINTVAL P, VECTORVAL Axis, FLOATVAL Angle, FLOATVAL nsamples, DEFVOIDPARAM ) = 0;
 
386
    virtual STD_SO      SO_illuminate( POINTVAL P, VECTORVAL Axis, FLOATVAL Angle, DEFVOIDPARAM ) = 0;
 
387
    virtual STD_SO      SO_illuminate( POINTVAL P, DEFVOIDPARAM ) = 0;
 
388
    virtual STD_SO      SO_solar( VECTORVAL Axis, FLOATVAL Angle, DEFVOIDPARAM ) = 0;
 
389
    virtual STD_SO      SO_solar( DEFVOIDPARAM ) = 0;
 
390
    virtual STD_SO      SO_printf( STRINGVAL str, DEFVOIDPARAMVAR ) = 0;
 
391
    virtual STD_SO      SO_format( STRINGVAL str, DEFPARAMVAR ) = 0;
 
392
    virtual STD_SO      SO_concat( STRINGVAL stra, STRINGVAL strb, DEFPARAMVAR ) = 0;
 
393
    virtual STD_SO      SO_atmosphere( STRINGVAL name, IqShaderData* pV, DEFPARAM ) = 0;
 
394
    virtual STD_SO      SO_displacement( STRINGVAL name, IqShaderData* pV, DEFPARAM ) = 0;
 
395
    virtual STD_SO      SO_lightsource( STRINGVAL name, IqShaderData* pV, DEFPARAM ) = 0;
 
396
    virtual STD_SO      SO_surface( STRINGVAL name, IqShaderData* pV, DEFPARAM ) = 0;
 
397
    virtual STD_SO      SO_attribute( STRINGVAL name, IqShaderData* pV, DEFPARAM ) = 0;
 
398
    virtual STD_SO      SO_option( STRINGVAL name, IqShaderData* pV, DEFPARAM ) = 0;
 
399
    virtual STD_SO      SO_rendererinfo( STRINGVAL name, IqShaderData* pV, DEFPARAM ) = 0;
 
400
    virtual STD_SO      SO_incident( STRINGVAL name, IqShaderData* pV, DEFPARAM ) = 0;
 
401
    virtual STD_SO      SO_opposite( STRINGVAL name, IqShaderData* pV, DEFPARAM ) = 0;
 
402
    virtual STD_SO      SO_fcellnoise1( FLOATVAL v, DEFPARAM ) = 0;
 
403
    virtual STD_SO      SO_fcellnoise2( FLOATVAL u, FLOATVAL v, DEFPARAM ) = 0;
 
404
    virtual STD_SO      SO_fcellnoise3( POINTVAL p, DEFPARAM ) = 0;
 
405
    virtual STD_SO      SO_fcellnoise4( POINTVAL p, FLOATVAL v, DEFPARAM ) = 0;
 
406
    virtual STD_SO      SO_ccellnoise1( FLOATVAL v, DEFPARAM ) = 0;
 
407
    virtual STD_SO      SO_ccellnoise2( FLOATVAL u, FLOATVAL v, DEFPARAM ) = 0;
 
408
    virtual STD_SO      SO_ccellnoise3( POINTVAL p, DEFPARAM ) = 0;
 
409
    virtual STD_SO      SO_ccellnoise4( POINTVAL p, FLOATVAL v, DEFPARAM ) = 0;
 
410
    virtual STD_SO      SO_pcellnoise1( FLOATVAL v, DEFPARAM ) = 0;
 
411
    virtual STD_SO      SO_pcellnoise2( FLOATVAL u, FLOATVAL v, DEFPARAM ) = 0;
 
412
    virtual STD_SO      SO_pcellnoise3( POINTVAL p, DEFPARAM ) = 0;
 
413
    virtual STD_SO      SO_pcellnoise4( POINTVAL p, FLOATVAL v, DEFPARAM ) = 0;
 
414
    virtual STD_SO      SO_fpnoise1( FLOATVAL v, FLOATVAL period, DEFPARAM ) = 0;
 
415
    virtual STD_SO      SO_fpnoise2( FLOATVAL u, FLOATVAL v, FLOATVAL uperiod, FLOATVAL vperiod, DEFPARAM ) = 0;
 
416
    virtual STD_SO      SO_fpnoise3( POINTVAL p, POINTVAL pperiod, DEFPARAM ) = 0;
 
417
    virtual STD_SO      SO_fpnoise4( POINTVAL p, FLOATVAL t, POINTVAL pperiod, FLOATVAL tperiod, DEFPARAM ) = 0;
 
418
    virtual STD_SO      SO_cpnoise1( FLOATVAL v, FLOATVAL period, DEFPARAM ) = 0;
 
419
    virtual STD_SO      SO_cpnoise2( FLOATVAL u, FLOATVAL v, FLOATVAL uperiod, FLOATVAL vperiod, DEFPARAM ) = 0;
 
420
    virtual STD_SO      SO_cpnoise3( POINTVAL p, POINTVAL pperiod, DEFPARAM ) = 0;
 
421
    virtual STD_SO      SO_cpnoise4( POINTVAL p, FLOATVAL t, POINTVAL pperiod, FLOATVAL tperiod, DEFPARAM ) = 0;
 
422
    virtual STD_SO      SO_ppnoise1( FLOATVAL v, FLOATVAL period, DEFPARAM ) = 0;
 
423
    virtual STD_SO      SO_ppnoise2( FLOATVAL u, FLOATVAL v, FLOATVAL uperiod, FLOATVAL vperiod, DEFPARAM ) = 0;
 
424
    virtual STD_SO      SO_ppnoise3( POINTVAL p, POINTVAL pperiod, DEFPARAM ) = 0;
 
425
    virtual STD_SO      SO_ppnoise4( POINTVAL p, FLOATVAL t, POINTVAL pperiod, FLOATVAL tperiod, DEFPARAM ) = 0;
 
426
    virtual STD_SO      SO_ctransform( STRINGVAL fromspace, STRINGVAL tospace, COLORVAL c, DEFPARAM ) = 0;
 
427
    virtual STD_SO      SO_ctransform( STRINGVAL tospace, COLORVAL c, DEFPARAM ) = 0;
 
428
    virtual STD_SO      SO_ptlined( POINTVAL P0, POINTVAL P1, POINTVAL Q, DEFPARAM ) = 0;
 
429
    virtual STD_SO      SO_inversesqrt( FLOATVAL x, DEFPARAM ) = 0;
 
430
    virtual STD_SO      SO_match( STRINGVAL a, STRINGVAL b, DEFPARAM ) = 0;
 
431
    virtual STD_SO      SO_rotate( VECTORVAL Q, FLOATVAL angle, POINTVAL P0, POINTVAL P1, DEFPARAM ) = 0;
 
432
    virtual STD_SO      SO_filterstep( FLOATVAL edge, FLOATVAL s1, DEFPARAMVAR ) = 0;
 
433
    virtual STD_SO      SO_filterstep2( FLOATVAL edge, FLOATVAL s1, FLOATVAL s2, DEFPARAMVAR ) = 0;
 
434
    virtual STD_SO      SO_specularbrdf( VECTORVAL L, NORMALVAL N, VECTORVAL V, FLOATVAL rough, DEFPARAM ) = 0;
 
435
    virtual STD_SO      SO_setmcomp( MATRIXVAL M, FLOATVAL row, FLOATVAL column, FLOATVAL val, DEFVOIDPARAM ) = 0;
 
436
    virtual STD_SO      SO_determinant( MATRIXVAL M, DEFPARAM ) = 0;
 
437
    virtual STD_SO      SO_mtranslate( MATRIXVAL M, VECTORVAL V, DEFPARAM ) = 0;
 
438
    virtual STD_SO      SO_mrotate( MATRIXVAL M, FLOATVAL angle, VECTORVAL axis, DEFPARAM ) = 0;
 
439
    virtual STD_SO      SO_mscale( MATRIXVAL M, POINTVAL s, DEFPARAM ) = 0;
 
440
    virtual STD_SO      SO_fsplinea( FLOATVAL value, FLOATARRAYVAL a, DEFPARAM ) = 0;
 
441
    virtual STD_SO      SO_csplinea( FLOATVAL value, COLORARRAYVAL a, DEFPARAM ) = 0;
 
442
    virtual STD_SO      SO_psplinea( FLOATVAL value, POINTARRAYVAL a, DEFPARAM ) = 0;
 
443
    virtual STD_SO      SO_sfsplinea( STRINGVAL basis, FLOATVAL value, FLOATARRAYVAL a, DEFPARAM ) = 0;
 
444
    virtual STD_SO      SO_scsplinea( STRINGVAL basis, FLOATVAL value, COLORARRAYVAL a, DEFPARAM ) = 0;
 
445
    virtual STD_SO      SO_spsplinea( STRINGVAL basis, FLOATVAL value, POINTARRAYVAL a, DEFPARAM ) = 0;
 
446
    virtual STD_SO      SO_shadername( DEFPARAM ) = 0;
 
447
    virtual STD_SO      SO_shadername2( STRINGVAL shader, DEFPARAM ) = 0;
 
448
    virtual STD_SO      SO_textureinfo( STRINGVAL shader, STRINGVAL dataname, IqShaderData* pV, DEFPARAM ) = 0;
 
449
    virtual STD_SO      SO_bake_f( STRINGVAL shader, FLOATVAL s, FLOATVAL t, FLOATVAL f, DEFVOIDPARAMVAR) = 0;
 
450
    virtual STD_SO      SO_bake_3c( STRINGVAL shader, FLOATVAL s, FLOATVAL t, FLOATVAL f, DEFVOIDPARAMVAR) = 0;
 
451
    virtual STD_SO      SO_bake_3p( STRINGVAL shader, FLOATVAL s, FLOATVAL t, FLOATVAL f, DEFVOIDPARAMVAR) = 0;
 
452
    virtual STD_SO      SO_bake_3n( STRINGVAL shader, FLOATVAL s, FLOATVAL t, FLOATVAL f, DEFVOIDPARAMVAR) = 0;
 
453
    virtual STD_SO      SO_bake_3v( STRINGVAL shader, FLOATVAL s, FLOATVAL t, FLOATVAL f, DEFVOIDPARAMVAR) = 0;
 
454
    virtual STD_SO      SO_external(DSOMethod method, void *initData, DEFPARAMVAR) = 0;
 
455
    virtual     STD_SO  SO_occlusion( STRINGVAL occlmap, FLOATVAL channel, POINTVAL P, NORMALVAL N, FLOATVAL samples, DEFPARAMVAR ) = 0;
 
456
};
 
457
 
 
458
/** Templatised derivative function. Calculates the derivative of the provided stack entry with respect to u.
 
459
 */
 
460
template <class R>
 
461
R SO_DuType( IqShaderData* Var, TqInt i, IqShaderExecEnv* ps, R& Def )
 
462
{
 
463
    R Ret;
 
464
    TqInt uRes = ps->uGridRes();
 
465
    TqInt GridX = i % ( uRes + 1 );
 
466
 
 
467
    TqFloat fdu;
 
468
    ps->du() ->GetFloat( fdu );
 
469
 
 
470
    if ( fdu == 0 ) return ( Def );
 
471
 
 
472
    R v1, v2;
 
473
    if ( GridX < uRes )
 
474
    {
 
475
        Var->GetValue( v1, i + 1 );
 
476
        Var->GetValue( v2, i );
 
477
        Ret = ( v1 - v2 ) / fdu;
 
478
    }
 
479
    else
 
480
    {
 
481
        Var->GetValue( v1, i );
 
482
        Var->GetValue( v2, i - 1 );
 
483
        Ret = ( v1 - v2 ) / fdu;
 
484
    }
 
485
    return ( Ret );
 
486
}
 
487
 
 
488
 
 
489
/** Templatised derivative function. Calculates the derivative of the provided stack entry with respect to v.
 
490
 */
 
491
template <class R>
 
492
R SO_DvType( IqShaderData* Var, TqInt i, IqShaderExecEnv* ps, R& Def )
 
493
{
 
494
    R Ret;
 
495
    TqInt uRes = ps->uGridRes();
 
496
    TqInt vRes = ps->vGridRes();
 
497
    TqInt GridY = ( i / ( uRes + 1 ) );
 
498
 
 
499
    TqFloat fdv;
 
500
    ps->dv() ->GetFloat( fdv );
 
501
 
 
502
    if ( fdv == 0 ) return ( Def );
 
503
 
 
504
    R v1, v2;
 
505
    if ( GridY < vRes )
 
506
    {
 
507
        Var->GetValue( v1, i + uRes + 1 );
 
508
        Var->GetValue( v2, i );
 
509
        Ret = ( v1 - v2 ) / fdv;
 
510
    }
 
511
    else
 
512
    {
 
513
        Var->GetValue( v1, i );
 
514
        Var->GetValue( v2, i - ( uRes + 1 ) );
 
515
        Ret = ( v1 - v2 ) / fdv;
 
516
    }
 
517
    return ( Ret );
 
518
}
 
519
 
 
520
 
 
521
/** Templatised derivative function. Calculates the derivative of the provided stack entry with respect to a second stack entry.
 
522
 */
 
523
template <class R>
 
524
R SO_DerivType( IqShaderData* Var, IqShaderData* den, TqInt i, IqShaderExecEnv* ps )
 
525
{
 
526
    assert( NULL != Var );
 
527
 
 
528
    R Retu, Retv;
 
529
    TqInt uRes = ps->uGridRes();
 
530
    TqInt vRes = ps->vGridRes();
 
531
    TqInt GridX = i % ( uRes + 1 );
 
532
    TqInt GridY = ( i / ( uRes + 1 ) );
 
533
 
 
534
    R val1, val2;
 
535
    TqFloat u1 = 1.0f, u2 = 0.0f, v1 = 1.0f, v2 = 0.0f;
 
536
 
 
537
    // Calculate deriviative in u
 
538
    if ( GridX < uRes )
 
539
    {
 
540
        Var->GetValue( val1, i + 1 );
 
541
        Var->GetValue( val2, i );
 
542
        if ( NULL != den )
 
543
                {
 
544
            den->GetValue( u1, i + 1 );
 
545
            den->GetValue( u2, i );
 
546
                }
 
547
        Retu = ( val1 - val2 ) / ( u1 - u2 );
 
548
    }
 
549
    else
 
550
    {
 
551
        Var->GetValue( val1, i );
 
552
        Var->GetValue( val2, i - 1 );
 
553
        if ( NULL != den )
 
554
                {
 
555
            den->GetValue( u1, i );
 
556
            den->GetValue( u2, i - 1 );
 
557
                }
 
558
        Retu = ( val2 - val1 ) / ( u2 - u1 );
 
559
    }
 
560
 
 
561
    // Calculate deriviative in v
 
562
    if ( GridY < vRes )
 
563
    {
 
564
        Var->GetValue( val1, i + uRes + 1 );
 
565
        Var->GetValue( val2, i );
 
566
        if ( NULL != den )
 
567
                {
 
568
            den->GetValue( v1, i + uRes + 1 );
 
569
            den->GetValue( v2, i );
 
570
                }
 
571
        Retv = ( val1 - val2 ) / ( v1 - v2 );
 
572
    }
 
573
    else
 
574
    {
 
575
        Var->GetValue( val1, i );
 
576
        Var->GetValue( val2, i - ( uRes - 1 ) );
 
577
        if ( NULL != den )
 
578
                {
 
579
            den->GetValue( v1, i );
 
580
            den->GetValue( v2, i - ( uRes - 1 ) );
 
581
                }
 
582
        Retv = ( val2 - val1 ) / ( v2 - v1 );
 
583
    }
 
584
 
 
585
    return ( Retu + Retv );
 
586
}
 
587
 
 
588
 
 
589
//-----------------------------------------------------------------------
 
590
 
 
591
END_NAMESPACE( Aqsis )
 
592
 
 
593
 
 
594
#endif  //      ___ishadervariable_Loaded___