home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / System / Mesa-3.1 / src / vb.h < prev    next >
C/C++ Source or Header  |  2000-01-07  |  9KB  |  331 lines
  1. /* $Id: vb.h,v 1.4 1999/10/19 18:37:05 keithw Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.1
  6.  * 
  7.  * Copyright (C) 1999  Brian Paul   All Rights Reserved.
  8.  * 
  9.  * Permission is hereby granted, free of charge, to any person obtaining a
  10.  * copy of this software and associated documentation files (the "Software"),
  11.  * to deal in the Software without restriction, including without limitation
  12.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13.  * and/or sell copies of the Software, and to permit persons to whom the
  14.  * Software is furnished to do so, subject to the following conditions:
  15.  * 
  16.  * The above copyright notice and this permission notice shall be included
  17.  * in all copies or substantial portions of the Software.
  18.  * 
  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  */
  26.  
  27.  
  28.  
  29.  
  30.  
  31. /* OVERVIEW: 
  32.  *
  33.  * The vertices between glBegin() and glEnd() are accumulated in the
  34.  * vertex buffer.  When either the vertex buffer becomes filled or a
  35.  * state change outside the glBegin()/glEnd() is made, we must flush
  36.  * the buffer.
  37.  * 
  38.  * That is, we apply the vertex transformations, compute lighting,
  39.  * fog, texture coordinates etc.  Then, we can render the vertices as
  40.  * points, lines or polygons by calling the gl_render_vb() function in
  41.  * render.c
  42.  *
  43.  * When we're outside of a glBegin/glEnd pair the information in this
  44.  * structure is retained pending either of the flushing events
  45.  * described above.  
  46.  */
  47.  
  48. #ifndef VB_H
  49. #define VB_H
  50.  
  51.  
  52. #ifdef HAVE_CONFIG_H
  53. #include "conf.h"
  54. #endif
  55.  
  56. #include "GL/gl.h"
  57. #include "vector.h"
  58. #include "matrix.h"
  59. #include "config.h"
  60.  
  61.  
  62. enum {
  63.    VB_IMMEDIATE,
  64.    VB_CVA_PRECALC
  65. };
  66.  
  67.  
  68.  
  69. /* 
  70.  */
  71. struct vertex_data
  72. {
  73.    GLfloat (*Obj)[4];
  74.    GLfloat (*Normal)[3];
  75.    GLubyte (*Color)[4];
  76.    GLuint   *Index;
  77.    GLubyte  *EdgeFlag;
  78.    GLfloat (*TexCoord[MAX_TEXTURE_UNITS])[4];
  79.    GLuint   *Elt;
  80. };
  81.  
  82. struct vertex_arrays
  83. {
  84.    GLvector4f  Obj;
  85.    GLvector3f  Normal;
  86.    GLvector4ub Color;
  87.    GLvector1ui Index;
  88.    GLvector1ub EdgeFlag;
  89.    GLvector4f  TexCoord[MAX_TEXTURE_UNITS];
  90.    GLvector1ui Elt;     
  91. };
  92.  
  93. struct vertex_array_pointers
  94. {
  95.    GLvector4f  *Obj;
  96.    GLvector3f  *Normal;
  97.    GLvector4ub *Color;
  98.    GLvector1ui *Index;
  99.    GLvector1ub *EdgeFlag;
  100.    GLvector4f  *TexCoord[MAX_TEXTURE_UNITS];
  101.    GLvector1ui *Elt;     
  102. };
  103.  
  104.  
  105. /* Move to using pointers to this struct in the immediate structs -
  106.  * this is too big to keep 94 unused copies (7K) lying around in
  107.  * display lists.  
  108.  */
  109. struct gl_material 
  110. {
  111.    GLfloat Ambient[4];
  112.    GLfloat Diffuse[4];
  113.    GLfloat Specular[4];
  114.    GLfloat Emission[4];
  115.    GLfloat Shininess;
  116.    GLfloat AmbientIndex;    /* for color index lighting */
  117.    GLfloat DiffuseIndex;    /* for color index lighting */
  118.    GLfloat SpecularIndex;    /* for color index lighting */
  119. };
  120.  
  121.  
  122. /* KW: Represents everything that can take place between a begin and
  123.  * end, and can represent multiple begin/end pairs.  This plus *any*
  124.  * state variable (GLcontext) should be all you need to replay the
  125.  * represented begin/end pairs as if they took place in that state.  
  126.  *
  127.  * Thus this is sufficient for both immediate and compiled modes, but
  128.  * we could/should throw some elements away for compiled mode if we
  129.  * know they were empty. 
  130.  */
  131. struct immediate 
  132. { 
  133.    struct immediate *next;    /* for cache of free IM's */
  134.    GLuint id, ref_count;
  135.  
  136.    /* This must be saved when immediates are shared in display lists.
  137.     */
  138.    GLuint Start, Count;
  139.    GLuint LastData;        /* count or count+1 */
  140.    GLuint AndFlag, OrFlag, BeginState;
  141.    GLuint LastPrimitive;    
  142.  
  143.    GLuint ArrayAndFlags;    /* precalc'ed for glArrayElt */
  144.    GLuint ArrayIncr;
  145.    GLuint ArrayEltFlush;
  146.    GLuint FlushElt;
  147.  
  148.    GLuint TF1[2];        /* precalc'ed for glTexCoord */
  149.    GLuint TF2[2];
  150.    GLuint TF3[2];
  151.    GLuint TF4[2];
  152.  
  153.    GLuint  Primitive[VB_SIZE];    /* GLubyte would do... */
  154.    GLuint  NextPrimitive[VB_SIZE]; 
  155.  
  156.    /* allocate storage for these on demand:
  157.     */
  158.    struct  gl_material (*Material)[2]; 
  159.    GLuint  *MaterialMask;       
  160.  
  161.    GLfloat (*TexCoordPtr[MAX_TEXTURE_UNITS])[4]; 
  162.  
  163.    struct vertex_arrays v;
  164.    
  165.    struct gl_context *backref;            
  166.    void (*maybe_transform_vb)( struct immediate * );
  167.  
  168.    /* Normal lengths, zero if not available.
  169.     */
  170.    GLfloat   *NormalLengths;
  171.    GLuint     LastCalcedLength;
  172.  
  173.    GLuint  Flag[VB_SIZE];
  174.    GLubyte Color[VB_SIZE][4];
  175.    GLfloat Obj[VB_SIZE][4];
  176.    GLfloat Normal[VB_SIZE][3];
  177.    GLfloat TexCoord[MAX_TEXTURE_UNITS][VB_SIZE][4];
  178.    GLuint  Elt[VB_SIZE];
  179.    GLubyte EdgeFlag[VB_SIZE];
  180.    GLuint  Index[VB_SIZE];
  181. };
  182.  
  183.  
  184.  
  185. /* Not so big on storage these days, although still has pointers to
  186.  * arrays used for temporary results.
  187.  */
  188. struct vertex_buffer
  189. {
  190.    /* Pointers to enable multiple vertex_buffers - required for
  191.     * CVA, should also be useful for the PMesa people.
  192.     *
  193.     * Driver_data is alloc'ed in Driver.RegisterVB(), if required.
  194.     */
  195.    struct gl_context *ctx;
  196.    struct gl_pipeline *pipeline;
  197.    void *driver_data;
  198.  
  199.  
  200.    /* Data easily accessible by immediate mode fuctions: There is no
  201.     * guarentee on the driver side that processed data will end up or
  202.     * even pass through here.  Use the GLvector pointers below.
  203.     *
  204.     * If we are not compiling, ctx->input points to this struct, in which
  205.     * case the values will be scribbled during transform_vb.
  206.     */
  207.    struct immediate *IM;            
  208.    struct vertex_array_pointers store;    
  209.  
  210.    /* Where to find outstanding untransformed vertices.
  211.     */
  212.    struct immediate *prev_buffer;
  213.  
  214.  
  215.    GLuint     Type;
  216.    GLuint     Size, Start, Count;
  217.    GLuint     Free, FirstFree;
  218.    GLuint     CopyStart;
  219.    GLuint     Parity, Ovf;
  220.    GLuint     PurgeFlags;
  221.    GLuint     IndirectCount;    /* defaults to count */
  222.    GLuint     OrFlag, SavedOrFlag;
  223.    GLuint     EarlyCull;
  224.    GLuint     Culled, CullDone;
  225.  
  226.    /* Pointers to input data - default to buffers in 'im' above.
  227.     */
  228.    GLvector4f  *ObjPtr;
  229.    GLvector3f  *NormalPtr;
  230.    GLvector4ub *ColorPtr;
  231.    GLvector1ui *IndexPtr;
  232.    GLvector1ub *EdgeFlagPtr;
  233.    GLvector4f  *TexCoordPtr[MAX_TEXTURE_UNITS];
  234.    GLvector1ui *EltPtr;
  235.    GLuint      *Flag, FlagMax;
  236.    struct      gl_material (*Material)[2];
  237.    GLuint      *MaterialMask;       
  238.  
  239.    GLuint      *NextPrimitive; 
  240.    GLuint      *Primitive;     
  241.    GLuint      LastPrimitive;
  242.  
  243.    GLfloat (*BoundsPtr)[3];    /* Bounds for cull check */
  244.    GLfloat  *NormalLengthPtr;    /* Array of precomputed inv. normal lengths */
  245.    
  246.  
  247.    /* Holds malloced storage for pipeline data not supplied by 
  248.     * the immediate struct.
  249.     */
  250.    GLvector4f Eye;
  251.    GLvector4f Clip;
  252.    GLvector4f Win;
  253.    GLvector4ub BColor;        /* not used in cva */
  254.    GLvector1ui BIndex;        /* not used in cva */
  255.    GLubyte (*Specular)[4];
  256.    GLubyte (*Spec[2])[4];
  257.  
  258.    /* Temporary storage - may point into IM, or be dynamically
  259.     * allocated (for cva).  
  260.     */
  261.    GLubyte *ClipMask;
  262.    GLubyte *UserClipMask;
  263.    
  264.    /* Internal values.  Where these point depends on whether
  265.     * there were any identity matrices defined as transformations
  266.     * in the pipeline.
  267.     */
  268.    GLvector4f *EyePtr;
  269.    GLvector4f *ClipPtr;
  270.    GLvector4f *Unprojected;
  271.    GLvector4f *Projected;
  272.    GLvector4f *CurrentTexCoord;
  273.    GLuint     *Indirect;           /* For eval rescue and cva render */
  274.  
  275.  
  276.    /* Currently active colors
  277.     */
  278.    GLvector4ub *Color[2];
  279.    GLvector1ui *Index[2];
  280.  
  281.    /* Storage for colors which have been lit but not yet fogged.  
  282.     * Required for CVA, just point into store for normal VB's.
  283.     */
  284.    GLvector4ub *LitColor[2];
  285.    GLvector1ui *LitIndex[2];
  286.    GLvector4ub *FoggedColor[2];
  287.    GLvector1ui *FoggedIndex[2];
  288.    
  289.  
  290.    /* Temporary values used in texgen.
  291.     */
  292.    GLfloat (*tmp_f)[3];
  293.    GLfloat *tmp_m;
  294.  
  295.    /* Temporary values used in eval.
  296.     */
  297.    GLuint *EvaluatedFlags;
  298.  
  299.    /* Not used for cva: 
  300.     */
  301.    GLubyte *NormCullStart;
  302.    GLubyte *CullMask;            /* Results of vertex culling */
  303.    GLubyte *NormCullMask;       /* Compressed onto shared normals */
  304.  
  305.  
  306.    GLubyte ClipOrMask;        /* bitwise-OR of all ClipMask[] values */
  307.    GLubyte ClipAndMask;        /* bitwise-AND of all ClipMask[] values */
  308.    GLubyte CullFlag[2];
  309.    GLubyte CullMode;        /* see flags below */
  310.  
  311.    GLuint CopyCount;        /* max 3 vertices to copy after transform */
  312.    GLuint Copy[3];
  313.    GLfloat CopyProj[3][4];    /* temporary store for projected clip coords */
  314. };
  315.  
  316.  
  317. extern struct vertex_buffer *gl_alloc_vb( GLcontext *ctx );
  318. extern struct immediate *gl_alloc_immediate( GLcontext *ctx );
  319. extern void gl_free_immediate( struct immediate *im );
  320.  
  321. extern struct vertex_buffer *gl_vb_create_for_immediate( GLcontext *ctx );
  322. extern struct vertex_buffer *gl_vb_create_for_cva( GLcontext *ctx, 
  323.                            GLuint size );
  324. extern void gl_vb_free( struct vertex_buffer * );
  325. extern struct immediate *gl_immediate_alloc( GLcontext *ctx );
  326. extern void gl_immediate_free( struct immediate *im );
  327.  
  328.  
  329. #endif
  330.  
  331.