<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN"> <html><head><title>OpenRM - RM Library (rmtypes.h)</title></head> <body bgcolor=white fgcolor=black> <table width="100%" border=2 cellspacing=0 cellpadding=0 bgcolor="khaki" valign="center"> <th><img src="./images/ormsg.gif"> </th> </table> <spacer type=vertical size=15> <h2>Index of OpenRM - RM Library</h2> <spacer type=vertical size=15> <a name="RMcolor1D"><b>RMcolor1D</b> <pre> typedef struct RMcolor1D { float lum; } RMcolor1D; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMcolor2D"><b>RMcolor2D</b> <pre> typedef struct RMcolor2D { float lum, alpha; } RMcolor2D; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMcolor3D"><b>RMcolor3D</b> <pre> typedef struct RMcolor3D { float r, g, b; } RMcolor3D; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMcolor4D"><b>RMcolor4D</b> <pre> typedef struct RMcolor4D { float r, g, b, a; } RMcolor4D; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMvertex2D"><b>RMvertex2D</b> <pre> typedef struct RMvertex2D { float x, y; } RMvertex2D; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMvertex3D"><b>RMvertex3D</b> <pre> typedef struct RMvertex3D { float x, y, z; } RMvertex3D; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMvertex4D"><b>RMvertex4D</b> <pre> typedef struct RMvertex4D { float x, y, z, w; } RMvertex4D; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMmatrix"><b>RMmatrix</b> <pre> typedef struct RMmatrix { float m[4][4]; } RMmatrix; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMcacheKey;"><b>RMcacheKey;</b> <pre> typedef unsigned int RMcacheKey; #define RM_CACHEKEY_UNINITIALIZED_VALUE (unsigned int)(-1) #if 0 /* 64 bit cache key */ typedef unsigned long RMcacheKey; #endif typedef struct RMinternalMarker2D { int npts; int gl_begin_flag; RMvertex2D *vlist; } RMinternalMarker2D; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMvisMap"><b>RMvisMap</b> <pre> typedef struct RMvisMap { int nentries; float r[MAX_VIS_CMAP_ENTRIES]; float g[MAX_VIS_CMAP_ENTRIES]; float b[MAX_VIS_CMAP_ENTRIES]; float a[MAX_VIS_CMAP_ENTRIES]; float transfer_min, transfer_max; } RMvisMap; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMbitmap"><b>RMbitmap</b> <pre> typedef struct RMbitmap { int w, h; int bytes_per_scanline; int pbsize; unsigned char *pixeldata; } RMbitmap; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMimage"><b>RMimage</b> <pre> typedef struct RMimage { /* configuration */ int ndims; /* 2 or 3, set implicitly by user */ int w, h, d; /* set by user */ RMenum image_format; /* set by user: RM_IMAGE_RGB, etc. */ RMenum image_type; /* set by user: RM_IMAGE_BYTE, etc. */ float xzoom, yzoom; /* for 2d images only, user supplied, default 1.0, 1.0 */ /* pixel data */ RMenum copy_flag; /* set by user */ void *pixeldata; /* set by user */ void (*appfreefunc)(void *); /* set by user */ /* colormap */ RMvisMap *vismap; /* set by user, default NULL */ /* scale & bias */ float scale, bias; /* internals, private */ int bytes_per_component; /* computed by RM */ int bytes_per_scanline; /* computed by RM */ int elements; /* computed by RM */ #if 0 /* display list stuff removed 10/5/2000 */ int d1; RMenum dirty_flag; #endif unsigned int pbsize; /* internal, component manager */ int compListIndx; /* internal, context cache key */ RMcacheKey cacheKey; } RMimage; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMcamera2D"><b>RMcamera2D</b> <pre> typedef struct RMcamera2D { float xmin, ymin, xmax, ymax; /* defines extents of camera (like a viewport, but in R2 world coords) */ float aspect_ratio; } RMcamera2D; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMcamera3D"><b>RMcamera3D</b> <pre> typedef struct RMcamera3D { /* camera points */ RMvertex3D eye; RMvertex3D at; RMvertex3D up; float hither, yon; /* near & far */ float fov; /* field of view angle in degrees in the Y direction */ float aspect; /* aspect ratio (width / height) --> field of view angle in X direction */ RMenum projection; /* may be RM_PROJECTION_PERSPECTIVE or RM_PROJECTION_ORTHOGRAPHIC */ RMenum isStereo; /* flag for stereo (RM_TRUE or RM_FALSE) */ float degrees_eye_separation; /* for stereo cameras only */ float focalDistance; /* for stereo cameras only */ } RMcamera3D; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMtextProps"><b>RMtextProps</b> <pre> typedef struct RMtextProps { int fontEnum; /* one of RM_FONT_SERIF,RM_FONT_SANS, RM_FONT_MONO, RM_FONT_SYMBOL */ RMenum italicEnum; /* RM_TRUE or RM_FALSE */ RMenum boldEnum; /* RM_TRUE or RM_FALSE */ int sizeEnum; /* enum of RM_FONT_XXS, RM_FONT_XS, RM_FONT_S, RM_FONT_M, RM_FONT_L, RM_FONT_XL, RM_FONT_XXL */ RMenum hJustify, vJustify; int listbase; /* OpenGL dislay list base (computed by RM at runtime) */ int listoffset; /* OpenGL display list stuff (computed by RM at runtime) */ void *fontinfo; int compListIndx; } RMtextProps; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMclipPlane"><b>RMclipPlane</b> <pre> typedef struct RMclipPlane { RMenum enabled; /* RM_TRUE, RM_FALSE */ RMvertex3D point; RMvertex3D normal; /* (point, normal) parametrization */ float a, b, c, d; /* plane equation */ } RMclipPlane; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMlight"><b>RMlight</b> <pre> typedef struct RMlight { /* individual light ala OpenGL Light (see glLight) */ RMenum ltype; /* RM_LIGHT_POINT, RM_LIGHT_DIRECTIONAL, RM_SPOT */ RMcolor4D ambientLightColor; RMcolor4D diffuseLightColor; RMcolor4D specularLightColor; RMvertex3D lightXYZ; /* position for point and spot lights, direction for directional light sources */ float spotCutoff; /* [0.0, 90.0] degrees */ float spotExponent; /* default = 0.0, higher numbers produce more focused spots */ RMvertex3D spotDirection; float constantAttenuation; float linearAttenuation; float quadraticAttenuation; RMenum enabled; /* RM_TRUE or RM_FALSE */ } RMlight; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMlightModel"><b>RMlightModel</b> <pre> typedef struct RMlightModel { /* light model parms ala OpenGL Light Model (see glLightModel) */ RMcolor4D globalAmbient; GLenum twoSideEnable; GLenum localViewerEnable; } RMlightModel; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMtexture"><b>RMtexture</b> <pre> typedef struct RMtexture { RMimage *images[RM_MAX_MIPMAPS]; int dims; /* 1, 2 or 3d texture */ int nmipmaps; /* number of mipmaps associated w/this texture */ #if 0 GLuint tname; /* generated by glGenTextures */ #endif /* flags for OpenGL */ GLenum mag_filter_mode; /* for GL_TEXTURE_MAG_FILTER */ GLenum min_filter_mode; /* for GL_TEXTURE_MIN_FILTER */ GLenum wrap_mode; /* applied to each of u, v, w */ /* OpenGL has extra options for texel storage modes */ GLenum *oglTexelFormat; /* GL_RGBA, GL_RGB, etc. default is GL_RGBA */ /* environment modes */ GLenum envMode; /* see man glTexEnv */ RMcolor4D *blendColor; /* see man glTexEnv */ int borderWidth; /* texture border */ /* residency status currently not used. */ RMenum residency_status; /* internal: RM_TRUE or RM_FALSE */ /* for the component manager */ int compListIndx; /* internal, context cache keys for texture IDs and texture data */ RMcacheKey cacheKeyID; RMcacheKey cacheKeyData; /* reference counting - indicates whether or not a shared texture is assigned as a scene parameter to an RMnode */ int refCount; } RMtexture; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMfog"><b>RMfog</b> <pre> typedef struct RMfog { GLenum fogMode; /* GL_LINEAR, GL_EXP or GL_EXP2, def GL_LINEAR */ GLfloat fogDensity; /* default = 1.0 */ GLfloat fogStart; /* default is 0.0 */ GLfloat fogEnd; /* default is 1 */ RMcolor4D fogColor; /* default is 0,0,0,0 */ } RMfog; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMstate"><b>RMstate</b> <pre> typedef struct RMstate { RMmatrix model; /* model transformations */ RMmatrix view; /* viewing transformations */ RMmatrix modelView; /* combined model & view (OGL style) */ RMmatrix projection; /* projection matrix */ RMmatrix composite; /* model*view*projection */ RMmatrix pick; /* pick matrix */ RMmatrix textureMatrix; /* texture matrix */ RMmatrix projection_inverse; /* inverse of the concatenated view & projection matrices (?) */ RMmatrix vpm; /* viewport matrix - from NDC to window */ float vp[4]; /* (x, y) VP location + (w, h) VP width & height */ float aspect_ratio; float focal_length; int w, h; /* window width & height */ RMenum rendermode; RMenum renderpass; RMenum which_channel; /* used */ RMtexture *texture; /* current texture */ int texture_mode; /* if current texture, GL_TEXTURE_2D, etc. */ int attrib_stack_depth; /* current attribute stack depth */ /* material properties */ RMcolor4D ambient; RMcolor4D diffuse; RMcolor4D specular; RMcolor4D emissive; RMcolor4D unlit_color; float specular_exponent; float opacity; /* line & point style */ float pointsize; RMenum linewidth; RMenum linestyle; /* render mode parms */ RMenum shademodel; /* polygon face properties */ RMenum poly_mode_face; RMenum poly_mode_drawstyle; RMenum cull_mode; /* cull faces? [RM_CULL_NONE, RM_CULL_FRONT, RM_CULL_BACK, RM_CULL_FRONT_AND_BACK] */ RMenum front_face; /* vertex winding? [RM_CCW, RM_CW] */ /* clip planes */ RMclipPlane *cp0; RMclipPlane *cp1; RMclipPlane *cp2; RMclipPlane *cp3; RMclipPlane *cp4; RMclipPlane *cp5; /* fog */ RMenum fogActive; /* RM_TRUE if fog is active */ RMfog fog; /* rather than creating copies */ /* lighting */ RMlightModel *lmodel; RMlight *lightSources[RM_MAX_LIGHTS]; /* text */ RMtextProps *textProps; int frameNumber; /* internal use only */ RMenum colorMaterialActive; RMenum lightingActive; } RMstate; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMnode"><b>RMnode</b> <pre> typedef struct RMnode { /* scene graph topology */ struct RMnode *parent; int nchildren; struct RMnode **children; /* here's the geometry */ int nprims; void **prims; /* properties */ _surface_properties *sprops; _rendermode_properties *rprops; internals_RMsceneParms *scene_parms; /* fb clear control */ internals_RMfbClear *fbClear; /* bounding box info */ _bounding_box bbox; RMvertex3D center; /* transformation info */ internals_RMtransformationStruct *transforms; /* misc scheduling info about the object */ _object_info object_info; /* callbacks */ int (*viewPretraverseCallback) (const struct RMnode *, const RMstate *); int (*viewPosttraverseCallback) (const struct RMnode *, const RMstate *); int (*renderPretraverseCallback) (const struct RMnode *, const RMstate *); int (*renderPosttraverseCallback) (const struct RMnode *, const RMstate *); int (*viewSwitchCallback) (const struct RMnode *, const RMstate *); /* * 7/22/02. added view (stage) render order callback. note that the * switch callback and renderOrder callbacks are (or should be) * mutually-exclusive. such mutual-exclusivity is not reflected in * the data structure or in the API at this time. */ int (*viewRenderOrderCallback) (const struct RMnode *, const RMstate *, int *orderIndices, int nChildren); /* client data stuff - not multistage safe! (1/2001) */ void *clientData; void (*clientDataFreeFunc) (struct RMnode *, void *); int refcount; /* attribute mask */ GLuint attribMask; /* optional mutex */ RMmutex *nodeMutex; /* internal, component manager */ int compListIndx; } RMnode; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMcontextCache"><b>RMcontextCache</b> <pre> typedef struct RMcontextCache { /* for RMprimitives */ GLuint *primDisplayListIDs; RMcacheKey *primCacheKeys; int numPrimDisplayListIDs; int numPrimCacheKeys; /* for RMimages */ GLuint *imgDisplayListIDs; RMcacheKey *imgCacheKeys; int numImgDisplayListIDs; int numImgCacheKeys; /* for RMtextures */ GLuint *textureIDs; RMcacheKey *textureIDCacheKeys; /* textureID management */ RMcacheKey *textureDataCacheKeys; /* texture image data status */ int numTextureIDs; int numTextureIDCacheKeys; int numTextureDataCacheKeys; /* need to add this stuff VVVV */ /* RM-built display lists for quadrics objects */ GLuint *sphereIDs; GLuint *coneIDs, *flipConeIDs; GLuint *cylinderIDs, *flipCylinderIDs; /* pre-rendered bitmap font glyph display list IDs */ RMfontRegistry *pipeFontRegistry; } RMcontextCache; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMpipe"><b>RMpipe</b> <pre> typedef struct RMpipe { /* stuff common to all environments/OpenGL implementations */ RMenum offscreen; /* RM_TRUE for offscreen formats, RM_FALSE otherwise */ RMenum processingMode; RMenum channel_format; int xwindow_width, xwindow_height; int xflags; RMenum opaque3DEnable, transparent3DEnable, opaque2DEnable; RMenum initMatrixStack; /* RM_TRUE or RM_FALSE */ int frameNumber; /* global control over use of display lists */ RMenum displayListEnableBool; /* Context Cache stuff */ RMcontextCache *contextCache; /* the context cache */ void *displayLists; /* multistage rendering buffers. Note: these are NOT OpenGL display lists!! This buffer contains structures generated by the view-stage traversal that are consumed by the draw-stage traversal */ void *mtControl; /* multistage process/thread control structure */ #ifdef RM_X /* stuff specific to X */ Display *xdisplay; XVisualInfo *xvisual; Window xdrawable; GLXContext glxcontext; Colormap xcolormap; #endif #ifdef RM_WIN /* stuff specific to Win32 */ HDC hdc; HWND hwnd; HGLRC hRC; #endif #ifdef RM_CR /* stuff specific to Chromium */ int contextCR; RMpipeCRvariables *crStuff; /* see rmcr.c */ #endif int myRank, globalNPE; RMenum targetPlatform; /* pipe callbacks, all platforms */ /* 1. render function */ void (*channel_render_func)(RMnode *t, struct RMpipe *p); /* * 2. optional app callback invoked after rendering, but before * the "swapbuffers" call. can be used to perform synchronization * between multiple rendering engines. */ void (*postRenderBarrierFunc)(struct RMpipe *p); /* 3. color and depth buffer acquisition, swap buffer function */ void (*postrenderfunc)(const RMimage *, RMenum whichBufferEnum); void (*postrender_depthbufferfunc)(const RMimage *, RMenum whichBufferEnum); /* 4. swap buffers func */ RMenum (*swapBuffersFunc)(const struct RMpipe *); /* 5. shutdown function */ void (*shutdownFunc)(struct RMpipe *); /* private stuff */ /* * 12/26/02 - specialized barrier functions added during Chromium work. * for now, these funcs are added outside of the RM_CR def to minimize * the amount of arch-specific stuff. */ void (*postFBClearBarrierFunc)(const struct RMpipe *p); /* * context creation function - a per-platform thing */ RMenum (*createContextFunc)(struct RMpipe *p); /* * stuff related to constant time rendering */ #define MAX_FRAME_SAMPLES 6 int targetFrameRate; /* frames per sec, set by user */ RMtime timePerFrame; /* fps converted to sec/usec */ double timePerFrameMS; /* ms per frame */ RMtime lastTimeStart; /* when was last frame started? */ RMtime lastRenderTime; /* elapsed time for last rendering */ /* the timeSyncFunc is used as a post-render, pre-swapbuffers rendezvous point */ void (*timeSyncFunc)(struct RMpipe *p); } RMpipe; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMprimitiveDataBlob"><b>RMprimitiveDataBlob</b> <pre> typedef struct RMprimitiveDataBlob { void *ptr; /* pointer to the stuff */ RMenum copyflag; int nthings; /* how many things there are */ int blobtype; /* what kind of blob? */ int stride; /* size of individual thing */ int veclen; /* vector length of data supplied */ void (*appfreefunc)(void *); /* the app-supplied free function for when the copy-flag is set to RM_DONT_COPY_DATA */ } RMprimitiveDataBlob; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMprimitive"><b>RMprimitive</b> <pre> typedef struct RMprimitive { RMenum type; RMprimitiveDataBlob *blobs; /* methods, data, flags */ void (*renderfunc) OGLPRIMPARMLIST(); /* RMprimitive stores a pointer to the primitive draw method */ void *clientData; void (*clientDataFreeFunc) (struct RMprimitive *p, void *cd); void *p1; /* stuff that doesn't really fit into blobs */ /* misc stuff - usage depends upon app */ unsigned int flags1; unsigned int model_flag; int display_list_enable; /* old stuff for compatibility */ int utility; /* internal, component manager */ int compListIndx; /* internal, context cache key */ RMcacheKey cacheKey; /* bounding box stuff */ RMvertex3D *bmin, *bmax; RMenum (*primitiveComputeBoundingBoxFunc)(struct RMprimitive *); } RMprimitive; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> <a name="RMpick"><b>RMpick</b> <pre> typedef struct RMpick { RMnode *node; float zval; /* NDC z-value */ unsigned int index; /* object index */ unsigned int prim_index; /* primitive index */ } RMpick; </pre> <i>librm library source file: rmtypes.h </i><hr width="75%"> <br> </body></html>