home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
NeXTSTEP 3.2 (Developer)
/
NS_dev_3.2.iso
/
NextDeveloper
/
Headers
/
ri
/
ri.h
< prev
next >
Wrap
C/C++ Source or Header
|
1992-12-02
|
29KB
|
684 lines
/*
* rihydra.h - temporary Hydra version of PRMan ri.h
* Derived from edit 1.27 of PRMan ri.h, should evenutally be reconciled
* with PRMan and one version should serve both PRMan and Hydra.
*/
/*-______________________________________________________________________
**
** Copyright (c) 1988 Pixar. All rights reserved. This program or
** documentation contains proprietary confidential information and trade
** secrets of Pixar. Reverse engineering of object code is prohibited.
** Use of copyright notice is precautionary and does not imply
** publication.
**
** RESTRICTED RIGHTS NOTICE
**
** Use, duplication, or disclosure by the Government is subject to
** restrictions as set forth in subdivision (b)(3)(ii) of the Rights in
** Technical Data and Computer Software clause at 252.227-7013.
**
** Pixar
** 3240 Kerner Blvd.
** San Rafael, CA 94901
**
** ______________________________________________________________________
*/
/*
* RenderMan Interface Standard Include File
*/
#ifndef RI_H
#define RI_H
/* Definitions of Abstract Types used in RI */
typedef short RtBoolean;
typedef long RtInt;
typedef float RtFloat;
typedef char *RtToken;
typedef RtFloat RtColor[3];
typedef RtFloat RtPoint[3];
typedef RtFloat RtMatrix[4][4];
typedef RtFloat RtBasis[4][4];
typedef RtFloat RtBound[6];
typedef char *RtString;
/*
* RtPointer should be void *, but too many C compilers
* handle this incorrectly, or are incapable of dealing
* with the use of RtPointer in subsequent typedefs.
*/
#ifdef __STDC__
typedef void *RtPointer;
#define RtVoid void
#else /* __STDC__ */
typedef char *RtPointer;
typedef int RtVoid;
#endif /* __STDC__ */
typedef RtFloat (*RtFloatFunc)();
typedef RtVoid (*RtFunc)();
#ifndef RtConst
#define RtConst
#endif
typedef RtPointer RtObjectHandle;
typedef RtPointer RtLightHandle;
/* Extern Declarations for Predefined RI Data Structures */
#define RI_FALSE 0
#define RI_TRUE (! RI_FALSE)
#define RI_INFINITY 1.0e38
#define RI_EPSILON 1.0e-10
#define RI_NULL ((RtToken)0)
extern RtToken RI_FRAMEBUFFER, RI_FILE;
extern RtToken RI_RGB, RI_RGBA, RI_RGBZ, RI_RGBAZ, RI_A, RI_Z, RI_AZ;
extern RtToken RI_PERSPECTIVE, RI_ORTHOGRAPHIC;
extern RtToken RI_HIDDEN, RI_PAINT;
extern RtToken RI_CONSTANT, RI_SMOOTH;
extern RtToken RI_ORIGIN, RI_FLATNESS, RI_TRIMDEVIATION, RI_FOV;
extern RtToken RI_AMBIENTLIGHT, RI_POINTLIGHT, RI_DISTANTLIGHT, RI_SPOTLIGHT;
extern RtToken RI_INTENSITY, RI_LIGHTCOLOR, RI_FROM, RI_TO, RI_CONEANGLE,
RI_CONEDELTAANGLE, RI_BEAMDISTRIBUTION;
extern RtToken RI_MATTE, RI_METAL, RI_SHINYMETAL;
extern RtToken RI_PLASTIC, RI_PAINTEDPLASTIC;
extern RtToken RI_KA, RI_KD, RI_KS, RI_ROUGHNESS, RI_SPECULARCOLOR;
extern RtToken RI_KR, RI_TEXTURENAME;
extern RtToken RI_DEPTHCUE, RI_FOG, RI_BUMPY;
extern RtToken RI_MINDISTANCE, RI_MAXDISTANCE, RI_BACKGROUND, RI_DISTANCE;
extern RtToken RI_AMPLITUDE;
extern RtToken RI_RASTER, RI_SCREEN, RI_CAMERA, RI_WORLD, RI_OBJECT;
extern RtToken RI_INSIDE, RI_OUTSIDE, RI_LH, RI_RH;
extern RtToken RI_P, RI_PZ, RI_PW, RI_N, RI_NP, RI_CS, RI_OS,
RI_S, RI_T, RI_ST;
extern RtToken RI_BILINEAR, RI_BICUBIC;
extern RtToken RI_PRIMITIVE, RI_INTERSECTION, RI_UNION, RI_DIFFERENCE;
extern RtToken RI_PERIODIC, RI_NONPERIODIC, RI_CLAMP, RI_BLACK;
extern RtToken RI_IGNORE, RI_PRINT, RI_ABORT, RI_HANDLER;
extern RtToken RI_COMMENT, RI_STRUCTURE;
extern RtToken RI_IDENTIFIER, RI_NAME, RI_SHADINGGROUP;
/* BEGIN HYDRA AND RMAN 4.0 TOKENS */
extern RtToken RI_LOCAL, RI_DEFAULTRENDERER, RI_DRAFT, RI_SERVER,
RI_FILEPATH, RI_FILEPOINTER, RI_TYPE, RI_FORMAT,
RI_ASCIIFILE, RI_BINARYFILE, RI_COORDINATESYSTEM,
RI_RENDERER, RI_QUERY, RI_OPEN, RI_CLOSE, RI_READ, RI_WRITE,
RI_PARAMETER, RI_STORAGECLASS, RI_TESSELATION, RI_DEFER,
RI_DIMENSION, RI_MACRO, RI_MACRO, RI_FLUSH, RI_UNBUFFERED,
RI_SYNCHRONOUS, RI_ASYNCHRONOUS, RI_WAIT, RI_SPACE,
RI_AMBIDEXTROUS, RI_NONE, RI_LINEAR, RI_CUBIC,
RI_IMAGE, RI_LIGHTSOURCE, RI_ADDRESS, RI_TOKEN,
RI_ALPHAPRECISION, RI_ATTRIBUTE, RI_COLORDIMENSIONS,
RI_COLORPRECISION, RI_COMMAND, RI_COMPRESSION, RI_CONTEXT,
RI_DECLARATION, RI_DETAILLEVEL, RI_DISPLACEMENT, RI_DISPLAY,
RI_GEOMETRICFIDELITY, RI_GEOMETRY, RI_HIDER, RI_IMAGER,
RI_INCLUDE, RI_LIGHT, RI_LZW, RI_NULLPOINTER, RI_OPENIMAGE,
RI_OPTION, RI_PATCH, RI_PICKSET, RI_PIXELASPECTRATIO,
RI_POLYGON, RI_QUADRIC, RI_RESOLUTION, RI_RESOURCE,
RI_SHADER, RI_SURFACE, RI_TRANSFORMATION, RI_UTILITY,
RI_VERSION, RI_VOLUME, RI_WINDOWID, RI_ZPRECISION,
RI_UNIFORM, RI_VARYING, RI_VERTEX, RI_COLOR, RI_FLOAT,
RI_INTEGER, RI_POINT, RI_STRING, RI_NOSURFACE,
RI_BOX, RI_TRIANGLE, RI_CATMULLROM, RI_GAUSSIAN, RI_SINC,
RI_BEZIER, RI_BSPLINE, RI_CATMULLROM, RI_HERMITE, RI_POWER,
RI_NOIMAGER, RI_NOAREALIGHT, RI_NOVOLUME, RI_NODISPLACEMENT,
RI_NOHIDER, RI_DEFAULTSURFACE, RI_BOUND, RI_RESIZE, RI_DENSITY,
RI_PICK, RI_NOTRANSFORMATION, RI_SKETCH, RI_PARAMETRIC,
RI_SHOWNXNYNZ, RI_IMAGEFILE, RI_TEXTURE, RI_DRAWING,
RI_ARCHIVE, RI_ARCHIVEFILE, RI_FASTEST, RI_HIGHESTQUALITY,
RI_POINTS, RI_GEOMETRICAPPROXIMATION, RI_LINES, RI_POLYGONS,
RI_DEVIATION, RI_MODE, RI_NOHUE, RI_LOCK, RI_CLIPPING,
RI_PICKING, RI_PICKTAG, RI_POINTER, RI_PICKABLE,
RI_SHADING, RI_AVERAGE, RI_TILING, RI_LIGHTING, RI_CULL,
RI_FLASH, RI_ZBUFFER, RI_INFO, RI_PRMAN;
/* END NEW TOKENS */
extern RtConst RtBasis RiBezierBasis, RiBSplineBasis, RiCatmullRomBasis,
RiHermiteBasis, RiPowerBasis;
#define RI_BEZIERSTEP ((RtInt)3)
#define RI_BSPLINESTEP ((RtInt)1)
#define RI_CATMULLROMSTEP ((RtInt)1)
#define RI_HERMITESTEP ((RtInt)2)
#define RI_POWERSTEP ((RtInt)4)
extern RtInt RiLastError;
/* Declarations of All the RenderMan Interface Subroutines */
/*
* TODO - reconcile Hydra prototypes with PRMan
*/
#define use_hydra_prototypes 1
#if defined(__STDC__)
extern RtFloat RiGaussianFilter(RtFloat x, RtFloat y,
RtFloat xwidth, RtFloat ywidth);
extern RtFloat RiBoxFilter(RtFloat x, RtFloat y,
RtFloat xwidth, RtFloat ywidth);
extern RtFloat RiTriangleFilter(RtFloat x, RtFloat y,
RtFloat xwidth, RtFloat ywidth);
extern RtFloat RiCatmullRomFilter(RtFloat x, RtFloat y,
RtFloat xwidth, RtFloat ywidth);
extern RtFloat RiSincFilter(RtFloat x, RtFloat y,
RtFloat xwidth, RtFloat ywidth);
extern RtFloat RiBesselFilter(RtFloat x, RtFloat y,
RtFloat xwidth, RtFloat ywidth);
#ifdef use_hydra_prototypes
RtVoid RiErrorAbort(RtInt type, RtInt severity, char *message,
RtToken routine, RtToken context);
RtVoid RiErrorDefault(RtInt type, RtInt severity, char *message,
RtToken routine, RtToken context);
RtVoid RiErrorIgnore(RtInt type, RtInt severity, char *message,
RtToken routine, RtToken context);
RtVoid RiErrorPrint(RtInt type, RtInt severity, char *message,
RtToken routine, RtToken context);
#else
extern RtVoid RiErrorDefault(RtInt code, RtInt severity, char *msg);
extern RtVoid RiErrorIgnore(RtInt code, RtInt severity, char *msg);
extern RtVoid RiErrorPrint(RtInt code, RtInt severity, char *msg);
extern RtVoid RiErrorAbort(RtInt code, RtInt severity, char *msg);
#endif
RtToken
RiDeclare(char *name, char *declaration);
extern RtVoid
#ifndef use_hydra_prototypes
RiBegin(RtToken name),
#endif
RiEnd(void),
RiFrameBegin(RtInt frame),
RiFrameEnd(void),
RiWorldBegin(void),
RiWorldEnd(void);
extern RtVoid
RiFormat(RtInt xres, RtInt yres, RtFloat aspect),
RiFrameAspectRatio(RtFloat aspect),
RiScreenWindow(RtFloat left, RtFloat right, RtFloat top, RtFloat bot),
RiCropWindow(RtFloat xmin, RtFloat xmax, RtFloat ymin, RtFloat ymax),
RiProjection(RtToken name, ...),
RiProjectionV(RtToken name, RtInt n, RtToken tokens[], RtPointer parms[]),
RiClipping(RtFloat hither, RtFloat yon),
RiDepthOfField(RtFloat fstop, RtFloat focallength, RtFloat focaldistance),
RiShutter(RtFloat min, RtFloat max);
extern RtVoid
RiPixelVariance(RtFloat variation),
RiPixelSamples(RtFloat xsamples, RtFloat ysamples),
RiPixelFilter(RtFloatFunc filterfunc, RtFloat xwidth, RtFloat ywidth),
RiExposure(RtFloat gain, RtFloat gamma),
RiImager(RtToken name, ...),
RiImagerV(RtToken name, RtInt n, RtToken tokens[], RtPointer parms[]),
#ifdef use_hydra_prototypes
RiQuantize(RtToken type, RtInt one, RtInt min, RtInt max, RtFloat ampl);
RtToken RiDisplay(char *image, RtToken type, RtToken mode, ...);
RtToken RiDisplayV(char *image, RtToken type, RtToken mode, RtInt parameterCount,
RtToken *tokens, RtPointer *valuePointers);
#else
RiQuantize(RtToken type, RtInt one, RtInt min, RtInt max, RtFloat ampl),
RiDisplay(char *name, RtToken type, RtToken mode, ...),
RiDisplayV(char *name, RtToken type, RtToken mode,
RtInt n, RtToken tokens[], RtPointer parms[]);
#endif
extern RtVoid
RiHider(RtToken type, ...),
RiHiderV(RtToken type, RtInt n, RtToken tokens[], RtPointer parms[]),
RiColorSamples(RtInt n, RtFloat nRGB[], RtFloat RGBn[]),
RiRelativeDetail(RtFloat relativedetail),
RiOption(RtToken name, ...),
RiOptionV(RtToken name, RtInt n, RtToken tokens[], RtPointer parms[]);
extern RtVoid
RiAttributeBegin(void),
RiAttributeEnd(void),
RiColor(RtColor color),
RiOpacity(RtColor color),
RiTextureCoordinates(RtFloat s1, RtFloat t1, RtFloat s2, RtFloat t2,
RtFloat s3, RtFloat t3, RtFloat s4, RtFloat t4);
#ifdef use_hydra_prototypes
RtToken RiLightSource(char *lightSource, RtToken light, ...);
RtToken RiLightSourceV(char *lightSource, RtToken light, RtInt parameterCount,
RtToken *tokens, RtPointer *valuePointers);
RtToken RiAreaLightSource(char *lightSource, RtToken light, ...);
RtToken RiAreaLightSourceV(char *lightSource, RtToken light, RtInt parameterCount,
RtToken *tokens, RtPointer *valuePointers);
#else
extern RtLightHandle
RiLightSource(RtToken name, ...),
RiLightSourceV(RtToken name, RtInt n, RtToken tokens[], RtPointer parms[]),
RiAreaLightSource(RtToken name, ...),
RiAreaLightSourceV(RtToken name,
RtInt n, RtToken tokens[], RtPointer parms[]);
#endif
extern RtVoid
#ifdef use_hydra_prototypes
RiIlluminate(RtToken lightSource, RtBoolean on),
#else
RiIlluminate(RtLightHandle light, RtBoolean onoff),
#endif
RiSurface(RtToken name, ...),
RiSurfaceV(RtToken name, RtInt n, RtToken tokens[], RtPointer parms[]),
RiAtmosphere(RtToken name, ...),
RiAtmosphereV(RtToken name, RtInt n, RtToken tokens[], RtPointer parms[]),
RiInterior(RtToken name, ...),
RiInteriorV(RtToken name, RtInt n, RtToken tokens[], RtPointer parms[]),
RiExterior(RtToken name, ...),
RiExteriorV(RtToken name, RtInt n, RtToken tokens[], RtPointer parms[]),
RiShadingRate(RtFloat size),
RiShadingInterpolation(RtToken type),
RiMatte(RtBoolean onoff);
extern RtVoid
RiBound(RtBound bound),
RiDetail(RtBound bound),
RiDetailRange(RtFloat minvis, RtFloat lowtran, RtFloat uptran,
RtFloat maxvis),
#ifndef use_hydra_prototypes /* if (3.1 spec) */
RiGeometricApproximation(RtToken type, RtFloat value),
#endif
RiOrientation(RtToken orientation),
RiReverseOrientation(void),
RiSides(RtInt sides);
extern RtVoid
RiIdentity(void),
RiTransform(RtMatrix transform),
RiConcatTransform(RtMatrix transform),
RiPerspective(RtFloat fov),
RiTranslate(RtFloat dx, RtFloat dy, RtFloat dz),
RiRotate(RtFloat angle, RtFloat dx, RtFloat dy, RtFloat dz),
RiScale(RtFloat sx, RtFloat sy, RtFloat sz),
RiSkew(RtFloat angle, RtFloat dx1, RtFloat dy1, RtFloat dz1,
RtFloat dx2, RtFloat dy2, RtFloat dz2),
RiDeformation(RtToken name, ...),
RiDeformationV(RtToken name, RtInt n, RtToken tokens[], RtPointer parms[]),
RiDisplacement(RtToken name, ...),
#ifdef use_hydra_prototypes
RiDisplacementV(RtToken name, RtInt n, RtToken tokens[], RtPointer parms[]);
RtToken RiCoordinateSystem(char *space);
#else
RiDisplacementV(RtToken name, RtInt n, RtToken tokens[], RtPointer parms[]),
RiCoordinateSystem(RtToken space);
#endif
extern RtPoint
*RiTransformPoints(RtToken fromspace, RtToken tospace, RtInt n,
RtPoint points[]);
extern RtVoid
RiTransformBegin(void),
RiTransformEnd(void);
extern RtVoid
RiAttribute(RtToken name, ...),
RiAttributeV(RtToken name, RtInt n, RtToken tokens[], RtPointer parms[]);
extern RtVoid
RiPolygon(RtInt nverts, ...),
RiPolygonV(RtInt nverts, RtInt n, RtToken tokens[], RtPointer parms[]),
RiGeneralPolygon(RtInt nloops, RtInt nverts[], ...),
RiGeneralPolygonV(RtInt nloops, RtInt nverts[],
RtInt n, RtToken tokens[], RtPointer parms[]),
RiPointsPolygons(RtInt npolys, RtInt nverts[], RtInt verts[], ...),
RiPointsPolygonsV(RtInt npolys, RtInt nverts[], RtInt verts[],
RtInt n, RtToken tokens[], RtPointer parms[]),
RiPointsGeneralPolygons(RtInt npolys, RtInt nloops[], RtInt nverts[],
RtInt verts[], ...),
RiPointsGeneralPolygonsV(RtInt npolys, RtInt nloops[], RtInt nverts[],
RtInt verts[], RtInt n, RtToken tokens[], RtPointer parms[]),
RiBasis(RtBasis ubasis, RtInt ustep, RtBasis vbasis, RtInt vstep),
RiPatch(RtToken type, ...),
RiPatchV(RtToken type, RtInt n, RtToken tokens[], RtPointer parms[]),
RiPatchMesh(RtToken type, RtInt nu, RtToken uwrap,
RtInt nv, RtToken vwrap, ...),
RiPatchMeshV(RtToken type, RtInt nu, RtToken uwrap,
RtInt nv, RtToken vwrap,
RtInt n, RtToken tokens[], RtPointer parms[]),
RiNuPatch(RtInt nu, RtInt uorder, RtFloat uknot[], RtFloat umin, RtFloat umax,
RtInt nv, RtInt vorder, RtFloat vknot[], RtFloat vmin,
RtFloat vmax, ...),
RiNuPatchV(RtInt nu, RtInt uorder, RtFloat uknot[], RtFloat umin,
RtFloat umax, RtInt nv, RtInt vorder, RtFloat vknot[],
RtFloat vmin, RtFloat vmax,
RtInt n, RtToken tokens[], RtPointer parms[]),
RiTrimCurve(RtInt nloops, RtInt ncurves[], RtInt order[], RtFloat knot[],
RtFloat min[], RtFloat max[], RtInt n[],
RtFloat u[], RtFloat v[], RtFloat w[]);
extern RtVoid
RiSphere(RtFloat radius, RtFloat zmin, RtFloat zmax, RtFloat tmax, ...),
RiSphereV(RtFloat radius, RtFloat zmin, RtFloat zmax, RtFloat tmax,
RtInt n, RtToken tokens[], RtPointer parms[]),
RiCone(RtFloat height, RtFloat radius, RtFloat tmax, ...),
RiConeV(RtFloat height, RtFloat radius, RtFloat tmax,
RtInt n, RtToken tokens[], RtPointer parms[]),
RiCylinder(RtFloat radius, RtFloat zmin, RtFloat zmax, RtFloat tmax, ...),
RiCylinderV(RtFloat radius, RtFloat zmin, RtFloat zmax, RtFloat tmax,
RtInt n, RtToken tokens[], RtPointer parms[]),
RiHyperboloid(RtPoint point1, RtPoint point2, RtFloat tmax, ...),
RiHyperboloidV(RtPoint point1, RtPoint point2, RtFloat tmax,
RtInt n, RtToken tokens[], RtPointer parms[]),
RiParaboloid(RtFloat rmax, RtFloat zmin, RtFloat zmax, RtFloat tmax, ...),
RiParaboloidV(RtFloat rmax, RtFloat zmin, RtFloat zmax, RtFloat tmax,
RtInt n, RtToken tokens[], RtPointer parms[]),
RiDisk(RtFloat height, RtFloat radius, RtFloat tmax, ...),
RiDiskV(RtFloat height, RtFloat radius, RtFloat tmax,
RtInt n, RtToken tokens[], RtPointer parms[]),
RiTorus(RtFloat majrad, RtFloat minrad, RtFloat phimin, RtFloat phimax,
RtFloat tmax, ...),
RiTorusV(RtFloat majrad, RtFloat minrad, RtFloat phimin, RtFloat phimax,
RtFloat tmax, RtInt n, RtToken tokens[], RtPointer parms[]),
RiProcedural(RtPointer data, RtBound bound,
RtFunc subdivfunc, RtFunc freefunc),
RiGeometry(RtToken type, ...),
RiGeometryV(RtToken type, RtInt n, RtToken tokens[], RtPointer parms[]);
extern RtVoid
RiSolidBegin(RtToken operation),
RiSolidEnd(void) ;
#ifdef use_hydra_prototypes
RtToken RiObjectBegin(RtToken handle);
#else
extern RtObjectHandle
RiObjectBegin(void);
#endif
extern RtVoid
RiObjectEnd(void),
#ifdef use_hydra_prototypes
RiObjectInstance(RtToken handle),
#else
RiObjectInstance(RtObjectHandle handle),
#endif
RiMotionBegin(RtInt n, ...),
RiMotionBeginV(RtInt n, RtFloat times[]),
RiMotionEnd(void) ;
#ifdef use_hydra_prototypes
RtToken RiMakeBumpV(RtToken image, char *map, RtToken sWrap, RtToken tWrap,
RtFloatFunc filterFunction, RtFloat sWidth, RtFloat tWidth,
RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtToken RiMakeCubeFaceEnvironmentV(RtToken plusXImage, RtToken minusXImage,
RtToken plusYImage, RtToken minusYImage,
RtToken plusZImage, RtToken minusZImage,
char *map, RtFloat fieldOfView,
RtFloatFunc filterFunction, RtFloat sWidth,
RtFloat tWidth, RtInt parameterCount,
RtToken *tokens, RtPointer *valuePointers);
RtToken RiMakeLatLongEnvironmentV(RtToken image, char *map, RtFloatFunc filterFunction,
RtFloat sWidth, RtFloat tWidth, RtInt parameterCount, RtToken *tokens,
RtPointer *valuePointers);
RtToken RiMakeShadowV(RtToken image, char *map, RtInt parameterCount,
RtToken *tokens, RtPointer *valuePointers);
RtToken RiMakeTextureV(RtToken image, char *map, RtToken sWrap, RtToken tWrap,
RtFloatFunc filterFunction, RtFloat sWidth, RtFloat tWidth,
RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtToken RiMakeBump(RtToken image, char *map, RtToken sWrap, RtToken tWrap,
RtFloatFunc filterFunction, RtFloat sWidth, RtFloat tWidth, ...);
RtToken RiMakeCubeFaceEnvironment(RtToken plusXImage, RtToken minusXImage,
RtToken plusYImage, RtToken minusYImage,
RtToken plusZImage, RtToken minusZImage,
char *map, RtFloat fieldOfView,
RtFloatFunc filterFunction, RtFloat sWidth,
RtFloat tWidth, ...);
RtToken RiMakeLatLongEnvironment(RtToken image, char *map,
RtFloatFunc filterFunction, RtFloat sWidth,
RtFloat tWidth, ...);
RtToken RiMakeShadow(RtToken image, char *map, ...);
RtToken RiMakeTexture(RtToken image, char *map, RtToken sWrap, RtToken tWrap,
RtFloatFunc filterFunction, RtFloat sWidth, RtFloat tWidth, ...);
#else
extern RtVoid
RiMakeTexture(char *pic, char *tex, RtToken swrap, RtToken twrap,
RtFloatFunc filterfunc, RtFloat swidth, RtFloat twidth, ...),
RiMakeTextureV(char *pic, char *tex, RtToken swrap, RtToken twrap,
RtFloatFunc filterfunc, RtFloat swidth, RtFloat twidth,
RtInt n, RtToken tokens[], RtPointer parms[]),
RiMakeBump(char *pic, char *tex, RtToken swrap, RtToken twrap,
RtFloatFunc filterfunc, RtFloat swidth, RtFloat twidth, ...),
RiMakeBumpV(char *pic, char *tex, RtToken swrap, RtToken twrap,
RtFloatFunc filterfunc, RtFloat swidth, RtFloat twidth,
RtInt n, RtToken tokens[], RtPointer parms[]),
RiMakeLatLongEnvironment(char *pic, char *tex, RtFloatFunc filterfunc,
RtFloat swidth, RtFloat twidth, ...),
RiMakeLatLongEnvironmentV(char *pic, char *tex, RtFloatFunc filterfunc,
RtFloat swidth, RtFloat twidth,
RtInt n, RtToken tokens[], RtPointer parms[]),
RiMakeCubeFaceEnvironment(char *px, char *nx, char *py, char *ny,
char *pz, char *nz, char *tex, RtFloat fov,
RtFloatFunc filterfunc, RtFloat swidth, RtFloat ywidth, ...),
RiMakeCubeFaceEnvironmentV(char *px, char *nx, char *py, char *ny,
char *pz, char *nz, char *tex, RtFloat fov,
RtFloatFunc filterfunc, RtFloat swidth, RtFloat ywidth,
RtInt n, RtToken tokens[], RtPointer parms[]),
RiMakeShadow(char *pic, char *tex, ...),
RiMakeShadowV(char *pic, char *tex,
RtInt n, RtToken tokens[], RtPointer parms[]);
#endif
#ifdef __cplusplus
typedef RtVoid (*_cplus_fcn_int_int_char_token_token)(RtInt, RtInt,
char *,RtToken, RtToken);
extern RtVoid
RiErrorHandler(_cplus_fcn_int_int_char_token_token);
#else
extern RtVoid
RiErrorHandler(RtVoid (*handler)(RtInt, RtInt, char *,
RtToken, RtToken));
#endif
extern RtVoid
RiErrorHandler(RtVoid (*handler)(RtInt, RtInt, char *, RtToken, RtToken));
extern RtVoid
RiArchiveRecord(RtToken type, char *format, ...);
/* OBSOLETE call: see RiErrorHandler */
extern RtVoid
RiErrorMode(RtToken mode, RtFunc handler);
#ifdef use_hydra_prototypes
/* Prototypes for functions in Hydra and not (yet) in PRMan */
RtVoid RiAbortError(RtToken routineName, RtToken type , RtInt severity , RtToken context , char message[ ]);
RtToken RiBegin(RtString name, ...);
RtToken RiBeginV(RtString name, RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtVoid RiCardV(RtPoint inp, RtPoint outp, RtInt n, RtToken tokens[], RtPointer parms[]);
RtVoid RiCard(RtPoint inp, RtPoint outp, ...);
RtVoid RiCircle(RtFloat radius, RtFloat thetaMaximum, ...);
RtVoid RiCircleV(RtFloat radius, RtFloat thetaMaximum, RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtToken RiContext(RtToken contextName, ...);
RtVoid RiCoordSysTransform(RtToken space);
RtToken RiCreateHandle(char *handle, RtToken type);
RtVoid RiFreeHandle(RtToken handle, RtToken type);
RtVoid RiCurve(RtToken spline, RtInt controlPointCount, RtToken wrap, ...);
RtVoid RiCurveV(RtToken spline, RtInt controlPointCount, RtToken wrap, RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtVoid RiDetailLevel(RtToken token,...);
RtVoid RiDetailLevelV(RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtVoid RiDrawing(RtToken shaderName, ...);
RtVoid RiDrawingV(RtToken shaderName, RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtVoid RiFreeParameter(RtToken dictionary, RtToken key, RtToken handle);
RtVoid RiFreeResource(RtToken dictionary, RtToken resource);
RtVoid RiGeometricApproximation(RtToken type, ...);
RtVoid RiGeometricApproximationV(RtToken type, RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtVoid RiGeometricRepresentation(RtToken type);
RtVoid RiIgnoreError(RtToken routineName, RtToken type , RtInt severity , RtToken context , char message[ ]);
RtVoid RiLine(RtInt nvertices, ...);
RtVoid RiLineV(RtInt nvertices, RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtVoid RiLineStyle(RtFloat width, RtInt n, RtFloat *pattern, RtToken cap, RtToken join);
RtToken RiMacroBegin(char *name, ...);
RtToken RiMacroBeginV(char *macro, RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtVoid RiMacroEnd(void);
RtVoid RiMacroInstance(char *name, ...);
RtVoid RiMacroInstanceV(RtToken macro, RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtVoid RiNuCurve(RtInt controlPointCount, RtInt order, RtFloat *knots, RtFloat minimum, RtFloat maximum, ...);
RtVoid RiNuCurveV(RtInt controlPointCount, RtInt order, RtFloat *knots, RtFloat minimum, RtFloat maximum, RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtToken RiParameter(RtToken dictionary, RtToken key, char *parameter, ...);
RtToken RiParameterV(RtToken dictName, RtToken key, char *parameter, RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtVoid RiPointsLines(RtInt nlines, RtInt *nvertices, RtInt *vertices, ...);
RtVoid RiPointsLinesV(RtInt nlines, RtInt *nvertices, RtInt *vertices, RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtVoid RiPreemptBegin(void);
RtVoid RiPreemptEnd(void);
RtVoid RiPrintError(RtToken routineName, RtToken type , RtInt severity , RtToken context , char message[ ]);
RtVoid RiReadArchive(char *name, RtVoid (*callback)(RtToken, char *, char *), ...);
RtVoid RiReadArchiveV(char *name, RtVoid (*callback)(RtToken, char *, char *), RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtToken RiResource(char *resource, RtToken type, ...);
RtToken RiResourceV(char *resource, RtToken type, RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
RtVoid RiShaderClose(RtToken resource);
RtBoolean RiShaderOpen(RtToken resource,RtInt parameterCount,RtToken *tokens,RtPointer *valuePointers);
RtVoid RiShaderQuery(RtToken resource,RtInt parameterCount,RtToken *tokens,RtPointer *valuePointers);
RtVoid RiShaderRead(RtToken resource, RtInt byteCount, unsigned char *data);
RtVoid RiShaderWrite(RtToken resource, RtInt byteCount, unsigned char *data);
RtVoid RiShadingInterval(RtFloat interval);
RtVoid RiSynchronize(RtToken mode);
RtVoid RiVersion(RtFloat version);
#endif
#else /* __STDC__ */
extern RtFloat RiGaussianFilter(), RiBoxFilter(),
RiTriangleFilter(), RiCatmullRomFilter(),
RiSincFilter(), RiBesselFilter();
extern RtVoid RiErrorIgnore();
extern RtVoid RiErrorPrint();
extern RtVoid RiErrorAbort();
extern RtToken RiDeclare();
extern RtVoid RiBegin(), RiEnd(),
RiFrameBegin(), RiFrameEnd(),
RiWorldBegin(), RiWorldEnd();
extern RtVoid RiFormat(), RiFrameAspectRatio(), RiScreenWindow(),
RiCropWindow(), RiProjection(), RiProjectionV(),
RiClipping(), RiDepthOfField(), RiShutter();
extern RtVoid RiPixelVariance(), RiPixelSamples(), RiPixelFilter(),
RiExposure(), RiImager(), RiImagerV(),
RiQuantize(), RiDisplay(), RiDisplayV();
extern RtVoid RiHider(), RiHiderV(), RiColorSamples(), RiRelativeDetail(),
RiOption(), RiOptionV();
extern RtVoid RiAttributeBegin(), RiAttributeEnd(),
RiColor(), RiOpacity(), RiTextureCoordinates();
extern RtLightHandle RiLightSource(), RiLightSourceV(),
RiAreaLightSource(), RiAreaLightSourceV();
extern RtVoid RiIlluminate(),
RiSurface(), RiSurfaceV(), RiAtmosphere(), RiAtmosphereV(),
RiInterior(), RiInteriorV(), RiExterior(), RiExteriorV(),
RiShadingRate(), RiShadingInterpolation(), RiMatte();
extern RtVoid RiBound(), RiDetail(), RiDetailRange(),
RiGeometricApproximation(),
RiOrientation(), RiReverseOrientation(), RiSides();
extern RtVoid RiIdentity(), RiTransform(), RiConcatTransform(),
RiPerspective(), RiTranslate(), RiRotate(), RiScale(), RiSkew(),
RiDeformation(), RiDeformationV(),
RiDisplacement(), RiDisplacementV(), RiCoordinateSystem();
extern RtPoint *RiTransformPoints();
extern RtVoid RiTransformBegin(), RiTransformEnd();
extern RtVoid RiAttribute(), RiAttributeV();
extern RtVoid RiPolygon(), RiPolygonV(),
RiGeneralPolygon(), RiGeneralPolygonV(),
RiPointsPolygons(), RiPointsPolygonsV(),
RiPointsGeneralPolygons(), RiPointsGeneralPolygonsV(),
RiBasis(), RiPatch(), RiPatchV(), RiPatchMesh(), RiPatchMeshV(),
RiNuPatch(), RiNuPatchV(), RiTrimCurve();
extern RtVoid RiSphere(), RiSphereV(), RiCone(), RiConeV(),
RiCylinder(), RiCylinderV(), RiHyperboloid(), RiHyperboloidV(),
RiParaboloid(), RiParaboloidV(), RiDisk(), RiDiskV(),
RiTorus(), RiTorusV(),
RiProcedural(), RiGeometry(), RiGeometryV();
extern RtVoid RiSolidBegin(), RiSolidEnd() ;
extern RtObjectHandle RiObjectBegin();
extern RtVoid RiObjectEnd(), RiObjectInstance(),
RiMotionBegin(), RiMotionBeginV(), RiMotionEnd() ;
extern RtVoid RiMakeTexture(), RiMakeTextureV(), RiMakeBump(), RiMakeBumpV(),
RiMakeLatLongEnvironment(), RiMakeLatLongEnvironmentV(),
RiMakeCubeFaceEnvironment(), RiMakeCubeFaceEnvironmentV(),
RiMakeShadow(), RiMakeShadowV();
extern RtVoid RiErrorHandler();
extern RtVoid RiArchiveRecord();
RtVoid RiReadArchive(char *name, RtFunc callback, ...),
RiReadArchiveV(char *name, RtFunc callback, RtInt parameterCount, RtToken *tokens, RtPointer *valuePointers);
/* OBSOLETE call: see RiErrorHandler */
extern RtVoid RiErrorMode() ;
#endif /* __STDC__ */
/*
Error Codes
1 - 10 System and File Errors
11 - 20 Program Limitations
21 - 40 State Errors
41 - 60 Parameter and Protocol Errors
61 - 80 Execution Errors
*/
#define RIE_NOERROR ((RtInt)0)
#define RIE_NOMEM ((RtInt)1) /* Out of memory */
#define RIE_SYSTEM ((RtInt)2) /* Miscellaneous system error */
#define RIE_NOFILE ((RtInt)3) /* File nonexistent */
#define RIE_BADFILE ((RtInt)4) /* Bad file format */
#define RIE_VERSION ((RtInt)5) /* File version mismatch */
#define RIE_INCAPABLE ((RtInt)11) /* Optional RI feature */
#define RIE_UNIMPLEMENT ((RtInt)12) /* Unimplemented feature */
#define RIE_LIMIT ((RtInt)13) /* Arbitrary program limit */
#define RIE_BUG ((RtInt)14) /* Probably a bug in renderer */
#define RIE_NOTSTARTED ((RtInt)23) /* RiBegin not called */
#define RIE_NESTING ((RtInt)24) /* Bad begin-end nesting */
#define RIE_NOTOPTIONS ((RtInt)25) /* Invalid state for options */
#define RIE_NOTATTRIBS ((RtInt)26) /* Invalid state for attribs */
#define RIE_NOTPRIMS ((RtInt)27) /* Invalid state for primitives */
#define RIE_ILLSTATE ((RtInt)28) /* Other invalid state */
#define RIE_BADMOTION ((RtInt)29) /* Badly formed motion block */
#define RIE_BADSOLID ((RtInt)30) /* Badly formed solid block */
#define RIE_BADTOKEN ((RtInt)41) /* Invalid token for request */
#define RIE_RANGE ((RtInt)42) /* Parameter out of range */
#define RIE_CONSISTENCY ((RtInt)43) /* Parameters inconsistent */
#define RIE_BADHANDLE ((RtInt)44) /* Bad object/light handle */
#define RIE_NOSHADER ((RtInt)45) /* Can't load requested shader */
#define RIE_MISSINGDATA ((RtInt)46) /* Required parameters not provided */
#define RIE_SYNTAX ((RtInt)47) /* Declare type syntax error */
#define RIE_MATH ((RtInt)61) /* Zerodivide, noninvert matrix, etc. */
/* Error severity levels */
#define RIE_INFO ((RtInt)0) /* Rendering stats and other info */
#define RIE_WARNING ((RtInt)1) /* Something seems wrong, maybe okay */
#define RIE_ERROR ((RtInt)2) /* Problem. Results may be wrong */
#define RIE_SEVERE ((RtInt)3) /* So bad you should probably abort */
#endif /* RI_H */