← Back to branch summary

~ubuntu-branches/ubuntu/breezy/aqsis/breezy

« back to all changes in this revision

Viewing changes to libri2rib/output.h

  • Committer: Bazaar Package Importer
  • Author(s): Will Newton
  • Date: 2004-12-07 20:06:49 UTC
  • Revision ID: james.westby@ubuntu.com-20041207200649-fccswkrvp4oc8lmn
Tags: upstream-0.9.3
Import upstream version 0.9.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
libri2rib/output.h
 
1
// -*- C++ -*-
 
2
// Aqsis
 
3
// Copyright  1997 - 2001, Paul C. Gregory
 
4
//
 
5
// Contact: pgregory@aqsis.com
 
6
//
 
7
// This library is free software; you can redistribute it and/or
 
8
// modify it under the terms of the GNU Lesser General Public
 
9
// License as published by the Free Software Foundation; either
 
10
// version 2.1 of the License, or (at your option) any later version.
 
11
//
 
12
// This library is distributed in the hope that it will be useful,
 
13
// but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
15
// General Public License for more details.
 
16
//
 
17
// You should have received a copy of the GNU General Public
 
18
// License along with this library; if not, write to the Free Software
 
19
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
20
 
 
21
/** \file
 
22
 *  \brief Libri2rib output base class
 
23
 *  \author Lionel J. Lacour (intuition01@online.fr)
 
24
 */
 
25
 
 
26
#ifndef RI2RIB_OUTPUT_H
 
27
#define RI2RIB_OUTPUT_H 1
 
28
 
 
29
#include <fstream>
 
30
#include <stack>
 
31
#include <string>
 
32
#include <sstream>
 
33
#include "aqsis.h"
 
34
#include "ri.h"
 
35
#include "dictionary.h"
 
36
#include "options.h"
 
37
#include "outstream.h"
 
38
 
 
39
 
 
40
START_NAMESPACE( libri2rib )
 
41
 
 
42
 
 
43
class CqOutput
 
44
{
 
45
protected:
 
46
    enum EqFunctions{ Declare, FrameBegin, FrameEnd, WorldBegin,
 
47
                      WorldEnd, ObjectBegin, ObjectEnd, ObjectInstance,
 
48
                      AttributeBegin, AttributeEnd, TransformBegin, TransformEnd,
 
49
                      SolidBegin, SolidEnd, MotionBegin, MotionEnd,
 
50
                      Format, FrameAspectRatio, ScreenWindow, CropWindow,
 
51
                      Projection, Clipping, ClippingPlane, DepthOfField,
 
52
                      Shutter, PixelVariance, PixelSamples, PixelFilter,
 
53
                      Exposure, Imager, Quantize, Display,
 
54
                      Hider, ColorSamples, RelativeDetail, Option,
 
55
                      Color, Opacity, TextureCoordinates, LightSource,
 
56
                      AreaLightSource, Illuminate, Surface, Atmosphere,
 
57
                      Interior, Exterior, ShadingRate, ShadingInterpolation,
 
58
                      Matte, Bound, Detail, DetailRange,
 
59
                      GeometricApproximation, Basis, TrimCurve, Orientation,
 
60
                      ReverseOrientation, Sides, Displacement, Identity,
 
61
                      Transform, ConcatTransform, Perspective, Translate,
 
62
                      Rotate, Scale, Skew, Deformation,
 
63
                      CoordinateSystem, CoordSysTransform, Attribute, Polygon,
 
64
                      GeneralPolygon, PointsPolygons, PointsGeneralPolygons, Patch,
 
65
                      PatchMesh, NuPatch, Sphere, Cone,
 
66
                      Cylinder, Hyperboloid, Paraboloid, Disk,
 
67
                      Torus, Blobby, Points, Curves,
 
68
                      SubdivisionMesh, Procedural, Geometry, MakeTexture,
 
69
                      MakeBump, MakeLatLongEnvironment, MakeCubeFaceEnvironment, MakeShadow,
 
70
                      ArchiveRecord, ReadArchive, ErrorHandler, LAST_Function };
 
71
    // block types (used to check context nesting)
 
72
    enum EqBlocks{
 
73
        B_Ri, B_Frame, B_World, B_Attribute, B_Transform, B_Solid, B_Object, 
 
74
        B_Motion
 
75
    };
 
76
private:
 
77
    CqDictionary m_Dictionary;
 
78
 
 
79
    RtInt m_ColorNComps;
 
80
    RtInt m_ObjectHandle;
 
81
    RtInt m_LightHandle;
 
82
 
 
83
    struct SqSteps
 
84
    {
 
85
        RtInt uStep;
 
86
        RtInt vStep;
 
87
    };
 
88
    std::stack<SqSteps> m_Steps;
 
89
 
 
90
    std::vector<EqBlocks> m_nesting;
 
91
    bool beginNesting(EqBlocks type);
 
92
    bool endNesting(EqBlocks type);
 
93
    bool nestingContains(EqBlocks type) const;
 
94
 
 
95
    void push();
 
96
    void pop();
 
97
 
 
98
    void printPL ( RtInt n, RtToken tokens[], RtPointer parms[],
 
99
                   RtInt vertex = 1, RtInt varying = 1, RtInt uniform = 1, RtInt facevarying = 1 );
 
100
    std::string getFilterFuncName ( RtFilterFunc, const char * ) const;
 
101
 
 
102
    CqOutput( CqOutput const & )
 
103
    {}
 
104
    CqOutput const &operator=( CqOutput const & )
 
105
    {
 
106
        return * this;
 
107
    }
 
108
 
 
109
protected:
 
110
    SqOptions::EqIndentation m_Indentation;
 
111
    TqInt m_IndentSize;
 
112
    TqInt m_IndentLevel;
 
113
 
 
114
    CqStream *out;
 
115
 
 
116
    virtual void printHeader()
 
117
    {}
 
118
    virtual void printRequest( const char *, EqFunctions )
 
119
    {}
 
120
    virtual void printInteger( const RtInt )
 
121
    {}
 
122
    virtual void printFloat( const RtFloat )
 
123
    {}
 
124
    virtual void printString( std::string & )
 
125
    {}
 
126
    virtual void printSpace()
 
127
    {}
 
128
    virtual void printEOL()
 
129
    {}
 
130
 
 
131
    virtual void printArray ( RtInt n, RtInt *p )
 
132
    {}
 
133
    virtual void printArray ( RtInt n, RtFloat *p )
 
134
    {}
 
135
    virtual void printArray ( RtInt n, RtToken *p )
 
136
    {}
 
137
    virtual void printToken ( RtToken t )
 
138
    {}
 
139
    virtual void printCharP ( const char *c )
 
140
    {}
 
141
    virtual void print( const char *c )
 
142
    {}
 
143
 
 
144
public:
 
145
    CqOutput( const char *, int fdesc,
 
146
              SqOptions::EqCompression,
 
147
              SqOptions::EqIndentation, TqInt isize );
 
148
    virtual ~CqOutput();
 
149
 
 
150
    RtToken RiDeclare( const char *name, const char *declaration );
 
151
 
 
152
    /* RenderMan State machine */
 
153
    RtVoid RiBegin( RtToken name );
 
154
    RtVoid RiEnd( );
 
155
 
 
156
    RtVoid RiFrameBegin( RtInt frame );
 
157
    RtVoid RiFrameEnd( );
 
158
 
 
159
    RtVoid RiWorldBegin( );
 
160
    RtVoid RiWorldEnd( );
 
161
 
 
162
    RtObjectHandle RiObjectBegin( );
 
163
    RtVoid RiObjectEnd( );
 
164
    RtVoid RiObjectInstance( RtObjectHandle handle );
 
165
 
 
166
    RtVoid RiAttributeBegin( );
 
167
    RtVoid RiAttributeEnd( );
 
168
 
 
169
    RtVoid RiTransformBegin( );
 
170
    RtVoid RiTransformEnd( );
 
171
 
 
172
    RtVoid RiSolidBegin( RtToken operation );
 
173
    RtVoid RiSolidEnd( );
 
174
 
 
175
    RtVoid RiMotionBeginV( RtInt n, RtFloat times[] );
 
176
    RtVoid RiMotionEnd( );
 
177
 
 
178
 
 
179
    /* CAMERA OPTIONS */
 
180
    RtVoid RiFormat ( RtInt xres, RtInt yres, RtFloat aspect );
 
181
    RtVoid RiFrameAspectRatio ( RtFloat aspect );
 
182
    RtVoid RiScreenWindow ( RtFloat left, RtFloat right, RtFloat bot, RtFloat top );
 
183
    RtVoid RiCropWindow ( RtFloat xmin, RtFloat xmax, RtFloat ymin, RtFloat ymax );
 
184
    RtVoid RiProjectionV ( const char *name, RtInt n, RtToken tokens[], RtPointer parms[] );
 
185
    RtVoid RiClipping( RtFloat hither, RtFloat yon );
 
186
    RtVoid RiClippingPlane( RtFloat x, RtFloat y, RtFloat z, RtFloat nx, RtFloat ny, RtFloat nz );
 
187
    RtVoid RiDepthOfField ( RtFloat fstop, RtFloat focallength, RtFloat focaldistance );
 
188
    RtVoid RiShutter( RtFloat min, RtFloat max );
 
189
 
 
190
    /* DISPLAY OPTIONS */
 
191
    RtVoid RiPixelVariance( RtFloat variation );
 
192
    RtVoid RiPixelSamples( RtFloat xsamples, RtFloat ysamples );
 
193
    RtVoid RiPixelFilter( RtFilterFunc filterfunc, RtFloat xwidth, RtFloat ywidth );
 
194
    RtVoid RiExposure( RtFloat gain, RtFloat gamma );
 
195
    RtVoid RiImagerV( const char *name, RtInt n, RtToken tokens[], RtPointer parms[] );
 
196
    RtVoid RiQuantize( RtToken type, RtInt one, RtInt min, RtInt max, RtFloat ampl );
 
197
    RtVoid RiDisplayV( const char *name, RtToken type, RtToken mode,
 
198
                       RtInt n, RtToken tokens[], RtPointer parms[] );
 
199
 
 
200
    /* ADDITIONAL OPTIONS */
 
201
    RtVoid RiHiderV( const char *type, RtInt n, RtToken tokens[], RtPointer parms[] );
 
202
    RtVoid RiColorSamples( RtInt n, RtFloat nRGB[], RtFloat RGBn[] );
 
203
    RtVoid RiRelativeDetail( RtFloat relativedetail );
 
204
    RtVoid RiOptionV( const char *name, RtInt n, RtToken tokens[], RtPointer parms[] );
 
205
 
 
206
 
 
207
    /* SHADING ATTRIBUTES */
 
208
    RtVoid RiColor( RtColor color );
 
209
    RtVoid RiOpacity( RtColor color );
 
210
    RtVoid RiTextureCoordinates( RtFloat s1, RtFloat t1, RtFloat s2, RtFloat t2,
 
211
                                 RtFloat s3, RtFloat t3, RtFloat s4, RtFloat t4 );
 
212
    RtLightHandle RiLightSourceV( const char *name, RtInt n, RtToken tokens[], RtPointer parms[] );
 
213
    RtLightHandle RiAreaLightSourceV( const char *name,
 
214
                                      RtInt n, RtToken tokens[], RtPointer parms[] );
 
215
    RtVoid RiIlluminate( RtLightHandle light, RtBoolean onoff );
 
216
    RtVoid RiSurfaceV( const char *name, RtInt n, RtToken tokens[], RtPointer parms[] );
 
217
    RtVoid RiAtmosphereV( const char *name, RtInt n, RtToken tokens[], RtPointer parms[] );
 
218
    RtVoid RiInteriorV( const char *name, RtInt n, RtToken tokens[], RtPointer parms[] );
 
219
    RtVoid RiExteriorV( const char *name, RtInt n, RtToken tokens[], RtPointer parms[] );
 
220
    RtVoid RiShadingRate( RtFloat size );
 
221
    RtVoid RiShadingInterpolation( RtToken type );
 
222
    RtVoid RiMatte( RtBoolean onoff );
 
223
 
 
224
    /* GEOMETRY ATTRIBUTES */
 
225
    RtVoid RiBound( RtBound );
 
226
    RtVoid RiDetail( RtBound );
 
227
    RtVoid RiDetailRange( RtFloat minvis, RtFloat lowtran, RtFloat uptran, RtFloat maxvis );
 
228
    RtVoid RiGeometricApproximation( RtToken type, RtFloat value );
 
229
    RtVoid RiBasis( RtBasis ubasis, RtInt ustep, RtBasis vbasis, RtInt vstep );
 
230
    RtVoid RiTrimCurve( RtInt nloops, RtInt ncurves[], RtInt order[],
 
231
                        RtFloat knot[], RtFloat min[], RtFloat max[], RtInt n[],
 
232
                        RtFloat u[], RtFloat v[], RtFloat w[] );
 
233
    RtVoid RiOrientation( RtToken orientation );
 
234
    RtVoid RiReverseOrientation( );
 
235
    RtVoid RiSides( RtInt sides );
 
236
    RtVoid RiDisplacementV( const char *name, RtInt n, RtToken tokens[], RtPointer parms[] );
 
237
 
 
238
    /* TRANSFORMATIONS */
 
239
    RtVoid RiIdentity( );
 
240
    RtVoid RiTransform( RtMatrix transform );
 
241
    RtVoid RiConcatTransform( RtMatrix transform );
 
242
    RtVoid RiPerspective( RtFloat fov );
 
243
    RtVoid RiTranslate( RtFloat dx, RtFloat dy, RtFloat dz );
 
244
    RtVoid RiRotate( RtFloat angle, RtFloat dx, RtFloat dy, RtFloat dz );
 
245
    RtVoid RiScale( RtFloat sx, RtFloat sy, RtFloat sz );
 
246
    RtVoid RiSkew( RtFloat angle, RtFloat dx1, RtFloat dy1, RtFloat dz1,
 
247
                   RtFloat dx2, RtFloat dy2, RtFloat dz2 );
 
248
    RtVoid RiDeformationV( const char *name, RtInt n, RtToken tokens[], RtPointer parms[] );
 
249
    RtVoid RiCoordinateSystem( RtToken space );
 
250
    RtVoid RiCoordSysTransform( RtToken space );
 
251
 
 
252
    RtVoid RiAttributeV( const char *name, RtInt n, RtToken tokens[], RtPointer parms[] );
 
253
 
 
254
    /* PRIMITIVES */
 
255
    RtVoid RiPolygonV( RtInt nverts, RtInt n, RtToken tokens[], RtPointer parms[] );
 
256
    RtVoid RiGeneralPolygonV( RtInt nloops, RtInt nverts[], RtInt n,
 
257
                              RtToken tokens[], RtPointer parms[] );
 
258
    RtVoid RiPointsPolygonsV( RtInt npolys, RtInt nverts[], RtInt verts[], RtInt n,
 
259
                              RtToken tokens[], RtPointer parms[] );
 
260
    RtVoid RiPointsGeneralPolygonsV( RtInt npolys, RtInt nloops[], RtInt nverts[],
 
261
                                     RtInt verts[], RtInt n, RtToken tokens[],
 
262
                                     RtPointer parms[] );
 
263
    RtVoid RiPatchV( RtToken type, RtInt n, RtToken tokens[], RtPointer parms[] );
 
264
    RtVoid RiPatchMeshV( RtToken type, RtInt nu, RtToken uwrap,
 
265
                         RtInt nv, RtToken vwrap, RtInt n, RtToken tokens[],
 
266
                         RtPointer parms[] );
 
267
    RtVoid RiNuPatchV( RtInt nu, RtInt uorder, RtFloat uknot[], RtFloat umin,
 
268
                       RtFloat umax, RtInt nv, RtInt vorder, RtFloat vknot[],
 
269
                       RtFloat vmin, RtFloat vmax,
 
270
                       RtInt n, RtToken tokens[], RtPointer parms[] );
 
271
 
 
272
    RtVoid RiSphereV( RtFloat radius, RtFloat zmin, RtFloat zmax, RtFloat tmax,
 
273
                      RtInt n, RtToken tokens[], RtPointer parms[] );
 
274
    RtVoid RiConeV( RtFloat height, RtFloat radius, RtFloat tmax,
 
275
                    RtInt n, RtToken tokens[], RtPointer parms[] );
 
276
    RtVoid RiCylinderV( RtFloat radius, RtFloat zmin, RtFloat zmax, RtFloat tmax,
 
277
                        RtInt n, RtToken tokens[], RtPointer parms[] );
 
278
    RtVoid RiHyperboloidV( RtPoint point1, RtPoint point2, RtFloat tmax,
 
279
                           RtInt n, RtToken tokens[], RtPointer parms[] );
 
280
    RtVoid RiParaboloidV( RtFloat rmax, RtFloat zmin, RtFloat zmax, RtFloat tmax,
 
281
                          RtInt n, RtToken tokens[], RtPointer parms[] );
 
282
    RtVoid RiDiskV( RtFloat height, RtFloat radius, RtFloat tmax,
 
283
                    RtInt n, RtToken tokens[], RtPointer parms[] );
 
284
    RtVoid RiTorusV( RtFloat majrad, RtFloat minrad, RtFloat phimin, RtFloat phimax,
 
285
                     RtFloat tmax, RtInt n, RtToken tokens[], RtPointer parms[] );
 
286
 
 
287
    RtVoid RiBlobbyV( RtInt nleaf, RtInt ncode, RtInt code[],
 
288
                      RtInt nflt, RtFloat flt[],
 
289
                      RtInt nstr, RtToken str[],
 
290
                      RtInt n, RtToken tokens[], RtPointer parms[] );
 
291
    RtVoid RiPointsV( RtInt npoints,
 
292
                      RtInt n, RtToken tokens[], RtPointer parms[] );
 
293
    RtVoid RiCurvesV( RtToken type, RtInt ncurves,
 
294
                      RtInt nvertices[], RtToken wrap,
 
295
                      RtInt n, RtToken tokens[], RtPointer parms[] );
 
296
    RtVoid RiSubdivisionMeshV( RtToken mask, RtInt nf, RtInt nverts[],
 
297
                               RtInt verts[],
 
298
                               RtInt ntags, RtToken tags[], RtInt numargs[],
 
299
                               RtInt intargs[], RtFloat floatargs[],
 
300
                               RtInt n, RtToken tokens[], RtPointer parms[] );
 
301
 
 
302
 
 
303
    RtVoid RiProcedural( RtPointer data, RtBound bound,
 
304
                         RtVoid ( *subdivfunc ) ( RtPointer, RtFloat ),
 
305
                         RtVoid ( *freefunc ) ( RtPointer ) );
 
306
    RtVoid RiGeometryV( RtToken type, RtInt n, RtToken tokens[],
 
307
                        RtPointer parms[] );
 
308
 
 
309
    /* MISC */
 
310
    RtVoid RiMakeTextureV( const char *pic, const char *tex, RtToken swrap, RtToken twrap,
 
311
                           RtFilterFunc filterfunc, RtFloat swidth, RtFloat twidth,
 
312
                           RtInt n, RtToken tokens[], RtPointer parms[] );
 
313
    RtVoid RiMakeBumpV( const char *pic, const char *tex, RtToken swrap, RtToken twrap,
 
314
                        RtFilterFunc filterfunc, RtFloat swidth, RtFloat twidth,
 
315
                        RtInt n, RtToken tokens[], RtPointer parms[] );
 
316
    RtVoid RiMakeLatLongEnvironmentV( const char *pic, const char *tex, RtFilterFunc filterfunc,
 
317
                                      RtFloat swidth, RtFloat twidth,
 
318
                                      RtInt n, RtToken tokens[], RtPointer parms[] );
 
319
    RtVoid RiMakeCubeFaceEnvironmentV( const char *px, const char *nx, const char *py, const char *ny,
 
320
                                       const char *pz, const char *nz, const char *tex, RtFloat fov,
 
321
                                       RtFilterFunc filterfunc, RtFloat swidth,
 
322
                                       RtFloat ywidth,
 
323
                                       RtInt n, RtToken tokens[], RtPointer parms[] );
 
324
    RtVoid RiMakeShadowV( const char *pic, const char *tex,
 
325
                          RtInt n, RtToken tokens[], RtPointer parms[] );
 
326
 
 
327
    /* ARCHIVE */
 
328
    RtVoid RiArchiveRecord( RtToken type, std::string );
 
329
    RtVoid RiReadArchiveV( RtToken name, RtArchiveCallback callback,
 
330
                           RtInt n, RtToken tokens[], RtPointer parms[] );
 
331
 
 
332
    /* ERROR HANDLER */
 
333
    RtVoid RiErrorHandler( RtErrorFunc handler );
 
334
};
 
335
 
 
336
 
 
337
END_NAMESPACE( libri2rib )
 
338
#endif