source: trunk/src/opengl/mesa/vb.c@ 3079

Last change on this file since 3079 was 2938, checked in by sandervl, 25 years ago

created
File size: 11.0 KB
Line 
1/* $Id: vb.c,v 1.1 2000-02-29 00:50:13 sandervl 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#ifdef PC_HEADER
32#include "all.h"
33#else
34#ifndef XFree86Server
35#include <stdlib.h>
36#include <stdio.h>
37#else
38#include "GL/xf86glx.h"
39#endif
40#include "types.h"
41#include "vb.h"
42#include "vbxform.h"
43#include "xform.h"
44#endif
45
46
47/*
48 * Allocate and initialize a vertex buffer.
49 */
50struct vertex_buffer *gl_vb_create_for_immediate( GLcontext *ctx )
51{
52 struct vertex_buffer *VB;
53 struct immediate *IM;
54 GLuint alignment = 32;
55
56 VB = CALLOC_STRUCT(vertex_buffer);
57 if (!VB)
58 return 0;
59
60 VB->ctx = ctx;
61 VB->ClipAndMask = CLIP_ALL_BITS;
62 VB->Size = VB_SIZE;
63 VB->FirstFree = VB_MAX;
64 VB->Type = VB_IMMEDIATE;
65 VB->Start = VB_START;
66 VB->pipeline = &ctx->CVA.elt;
67
68 gl_vector4f_alloc( &VB->Eye, 2, VEC_WRITABLE, VB_SIZE, alignment );
69 gl_vector4f_alloc( &VB->Clip, 2, VEC_WRITABLE, VB_SIZE, alignment );
70 gl_vector4f_alloc( &VB->Win, 2, VEC_WRITABLE, VB_SIZE, alignment );
71 gl_vector4ub_alloc( &VB->BColor, VEC_WRITABLE, VB_SIZE, alignment );
72 gl_vector1ui_alloc( &VB->BIndex, VEC_WRITABLE, VB_SIZE, alignment );
73
74 VB->ClipMask = (GLubyte *)MALLOC(sizeof(GLubyte) * VB_SIZE);
75 VB->UserClipMask = (GLubyte *)CALLOC(sizeof(GLubyte) * VB_SIZE);
76 VB->CullMask = (GLubyte *)MALLOC(sizeof(GLubyte) * VB_SIZE);
77 VB->NormCullMask = (GLubyte *)MALLOC(sizeof(GLubyte) * VB_SIZE);
78 VB->Spec[0] = (GLubyte (*)[4])MALLOC(sizeof(GLubyte) * 4 * VB_SIZE);
79 VB->Spec[1] = (GLubyte (*)[4])MALLOC(sizeof(GLubyte) * 4 * VB_SIZE);
80
81 IM = VB->IM = gl_immediate_alloc( ctx );
82
83 VB->store.Obj = &IM->v.Obj;
84 VB->store.Normal = &IM->v.Normal;
85 VB->store.Color = 0; /* not used */
86 VB->store.Index = 0; /* not used */
87 VB->store.EdgeFlag = &IM->v.EdgeFlag;
88 VB->store.TexCoord[0] = &IM->v.TexCoord[0];
89 VB->store.TexCoord[1] = &IM->v.TexCoord[1];
90 VB->store.Elt = &IM->v.Elt;
91
92 VB->LitColor[0] = VB->FoggedColor[0] = &IM->v.Color;
93 VB->LitColor[1] = VB->FoggedColor[1] = &VB->BColor;
94
95 VB->LitIndex[0] = VB->FoggedIndex[0] = &IM->v.Index;
96 VB->LitIndex[1] = VB->FoggedIndex[1] = &VB->BIndex;
97
98
99 VB->prev_buffer = IM;
100 /* prev_buffer is now also a reference for the immediate buffer */
101 IM->ref_count++;
102
103 if (ctx->Driver.RegisterVB)
104 ctx->Driver.RegisterVB( VB );
105
106 return VB;
107}
108
109
110
111struct vertex_buffer *gl_vb_create_for_cva( GLcontext *ctx, GLuint size )
112{
113 struct vertex_buffer *VB;
114 GLuint alignment = 32;
115
116 VB = CALLOC_STRUCT(vertex_buffer);
117 if (!VB)
118 return 0;
119
120 /* set non-zero fields */
121
122 VB->ctx = ctx;
123 VB->Type = VB_CVA_PRECALC;
124 VB->FirstFree = size;
125 VB->CullDone = 1;
126
127 size += VB_MAX_CLIPPED_VERTS;
128 VB->Size = size;
129 VB->ClipAndMask = CLIP_ALL_BITS;
130 VB->pipeline = &ctx->CVA.pre;
131
132 VB->ClipMask = (GLubyte *)MALLOC(sizeof(GLubyte) * size);
133 VB->UserClipMask = (GLubyte *)CALLOC(sizeof(GLubyte) * size);
134 VB->Spec[0] = (GLubyte (*)[4])MALLOC(sizeof(GLubyte) * 4 * size);
135 VB->Spec[1] = (GLubyte (*)[4])MALLOC(sizeof(GLubyte) * 4 * size);
136 VB->Flag = (GLuint *)MALLOC(sizeof(GLuint) * size);
137
138 gl_vector4f_alloc( &VB->Eye, 2, VEC_WRITABLE, size, alignment );
139 gl_vector4f_alloc( &VB->Clip, 2, VEC_WRITABLE, size, alignment );
140 gl_vector4f_alloc( &VB->Win, 2, VEC_WRITABLE, size, alignment );
141
142 VB->store.Obj = (GLvector4f *) CALLOC(sizeof(GLvector4f));
143 VB->store.Normal = (GLvector3f *) CALLOC(sizeof(GLvector3f));
144 VB->store.Color = 0;
145 VB->store.Index = 0;
146 VB->store.EdgeFlag = (GLvector1ub *) CALLOC(sizeof(GLvector1ub));
147 VB->store.TexCoord[0] = (GLvector4f *) CALLOC(sizeof(GLvector4f));
148 VB->store.TexCoord[1] = (GLvector4f *) CALLOC(sizeof(GLvector4f));
149 VB->store.Elt = (GLvector1ui *) CALLOC(sizeof(GLvector1ui));
150 VB->LitColor[0] = (GLvector4ub *) CALLOC(sizeof(GLvector4ub));
151 VB->LitColor[1] = (GLvector4ub *) CALLOC(sizeof(GLvector4ub));
152 VB->LitIndex[0] = (GLvector1ui *) CALLOC(sizeof(GLvector1ui));
153 VB->LitIndex[1] = (GLvector1ui *) CALLOC(sizeof(GLvector1ui));
154 VB->FoggedColor[0] = (GLvector4ub *) CALLOC(sizeof(GLvector4ub));
155 VB->FoggedColor[1] = (GLvector4ub *) CALLOC(sizeof(GLvector4ub));
156 VB->FoggedIndex[0] = (GLvector1ui *) CALLOC(sizeof(GLvector1ui));
157 VB->FoggedIndex[1] = (GLvector1ui *) CALLOC(sizeof(GLvector1ui));
158
159 VB->ColorPtr = VB->Color[0] = VB->LitColor[0];
160 VB->IndexPtr = VB->Index[0] = VB->LitIndex[0];
161 VB->Specular = VB->Spec[0];
162 VB->TexCoordPtr[0] = VB->store.TexCoord[0];
163 VB->TexCoordPtr[1] = VB->store.TexCoord[1];
164 VB->EdgeFlagPtr = VB->store.EdgeFlag;
165 VB->NormalPtr = VB->store.Normal;
166 VB->ObjPtr = VB->store.Obj;
167 VB->EltPtr = VB->store.Elt;
168
169 gl_vector4f_alloc( VB->store.Obj, 2, VEC_WRITABLE, size, alignment );
170 gl_vector3f_alloc( VB->store.Normal, VEC_WRITABLE, size, alignment );
171 gl_vector1ub_alloc( VB->store.EdgeFlag, VEC_WRITABLE, size, alignment );
172 gl_vector4f_alloc( VB->store.TexCoord[0], 2, VEC_WRITABLE, size, alignment );
173 gl_vector4f_alloc( VB->store.TexCoord[1], 2, VEC_WRITABLE, size, alignment );
174
175 /* TODO: allocate these on demand.
176 */
177 gl_vector4ub_alloc( VB->LitColor[0], VEC_WRITABLE, size, alignment );
178 gl_vector4ub_alloc( VB->LitColor[1], VEC_WRITABLE, size, alignment );
179 gl_vector1ui_alloc( VB->LitIndex[0], VEC_WRITABLE, size, alignment );
180 gl_vector1ui_alloc( VB->LitIndex[1], VEC_WRITABLE, size, alignment );
181 gl_vector4ub_alloc( VB->FoggedColor[0], VEC_WRITABLE, size, alignment );
182 gl_vector4ub_alloc( VB->FoggedColor[1], VEC_WRITABLE, size, alignment );
183 gl_vector1ui_alloc( VB->FoggedIndex[0], VEC_WRITABLE, size, alignment );
184 gl_vector1ui_alloc( VB->FoggedIndex[1], VEC_WRITABLE, size, alignment );
185
186
187
188 VB->prev_buffer = 0;
189 VB->Start = 0;
190
191 if (ctx->Driver.RegisterVB)
192 ctx->Driver.RegisterVB( VB );
193
194 return VB;
195}
196
197void gl_vb_free( struct vertex_buffer *VB )
198{
199 gl_vector4f_free( &VB->Eye );
200 gl_vector4f_free( &VB->Clip );
201 gl_vector4f_free( &VB->Win );
202 gl_vector4ub_free( &VB->BColor );
203 gl_vector1ui_free( &VB->BIndex );
204
205 if ( VB->prev_buffer && ! --VB->prev_buffer->ref_count )
206 gl_immediate_free( VB->prev_buffer );
207
208 if (VB->IM) {
209 if ( ! --VB->IM->ref_count )
210 gl_immediate_free( VB->IM );
211
212 FREE( VB->CullMask );
213 FREE( VB->NormCullMask );
214 } else {
215 if (VB->store.Elt)
216 gl_vector4f_free( VB->store.Obj ); FREE( VB->store.Obj );
217 gl_vector3f_free( VB->store.Normal ); FREE( VB->store.Normal );
218 gl_vector1ub_free( VB->store.EdgeFlag ); FREE( VB->store.EdgeFlag );
219 gl_vector4f_free( VB->store.TexCoord[0] ); FREE( VB->store.TexCoord[0]);
220 gl_vector4f_free( VB->store.TexCoord[1] ); FREE( VB->store.TexCoord[1]);
221
222 gl_vector4ub_free( VB->LitColor[0] ); FREE( VB->LitColor[0] );
223 gl_vector4ub_free( VB->LitColor[1] ); FREE( VB->LitColor[1] );
224 gl_vector1ui_free( VB->LitIndex[0] ); FREE( VB->LitIndex[0] );
225 gl_vector1ui_free( VB->LitIndex[1] ); FREE( VB->LitIndex[1] );
226
227 gl_vector4ub_free( VB->FoggedColor[0] ); FREE( VB->FoggedColor[0] );
228 gl_vector4ub_free( VB->FoggedColor[1] ); FREE( VB->FoggedColor[1] );
229 gl_vector1ui_free( VB->FoggedIndex[0] ); FREE( VB->FoggedIndex[0] );
230 gl_vector1ui_free( VB->FoggedIndex[1] ); FREE( VB->FoggedIndex[1] );
231
232 FREE( VB->Flag );
233 }
234
235 if (VB->tmp_f) FREE(VB->tmp_f);
236 if (VB->tmp_m) FREE(VB->tmp_m);
237 if (VB->EvaluatedFlags) FREE(VB->EvaluatedFlags);
238
239 FREE( VB->Spec[0] );
240 FREE( VB->Spec[1] );
241 FREE( VB->ClipMask );
242 FREE( VB->UserClipMask );
243
244 if (VB->ctx->Driver.UnregisterVB)
245 VB->ctx->Driver.UnregisterVB( VB );
246
247 FREE( VB );
248}
249
250
251struct immediate *gl_immediate_alloc( GLcontext *ctx )
252{
253 static int id = 0;
254 struct immediate *IM;
255 GLuint j;
256
257 if (ctx->freed_im_queue) {
258 IM = ctx->freed_im_queue;
259 ctx->freed_im_queue = IM->next;
260 ctx->nr_im_queued--;
261 IM->ref_count = 1;
262 return IM;
263 }
264
265 IM= (struct immediate *) MALLOC(sizeof(*IM));
266 if (!IM) return 0;
267
268 IM->id = id++;
269 IM->ref_count = 1;
270 IM->backref = ctx;
271 IM->maybe_transform_vb = gl_maybe_transform_vb;
272/* IM->Bounds = 0; */
273 IM->NormalLengths = 0;
274 IM->LastCalcedLength = 0;
275 IM->FlushElt = 0;
276 IM->LastPrimitive = VB_START;
277 IM->Count = VB_MAX; /* force clear of Flag. */
278 IM->Start = VB_START;
279 IM->Material = 0;
280 IM->MaterialMask = 0;
281
282 if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
283 fprintf(stderr, "alloc immediate %d\n", id);
284
285 gl_vector4f_init( &IM->v.Obj, VEC_WRITABLE, IM->Obj );
286 gl_vector3f_init( &IM->v.Normal, VEC_WRITABLE, IM->Normal );
287 gl_vector4ub_init( &IM->v.Color, VEC_WRITABLE, IM->Color );
288 gl_vector1ui_init( &IM->v.Index, VEC_WRITABLE, IM->Index );
289 gl_vector1ub_init( &IM->v.EdgeFlag, VEC_WRITABLE, IM->EdgeFlag );
290 gl_vector1ui_init( &IM->v.Elt, VEC_WRITABLE, IM->Elt );
291
292 for (j=0;j<MAX_TEXTURE_UNITS;j++) {
293 IM->TexCoordPtr[j] = IM->TexCoord[j];
294 gl_vector4f_init( &IM->v.TexCoord[j], VEC_WRITABLE, IM->TexCoord[j]);
295
296 /* Precalculate some flags and keep them in a handy place.
297 */
298 IM->TF1[j] = VERT_TEX0_1 << (j*NR_TEXSIZE_BITS);
299 IM->TF2[j] = VERT_TEX0_12 << (j*NR_TEXSIZE_BITS);
300 IM->TF3[j] = VERT_TEX0_123 << (j*NR_TEXSIZE_BITS);
301 IM->TF4[j] = VERT_TEX0_1234 << (j*NR_TEXSIZE_BITS);
302 }
303
304 return IM;
305}
306
307
308void gl_immediate_free( struct immediate *IM )
309{
310 GLcontext *ctx = IM->backref;
311
312 if (IM->NormalLengths) {
313 FREE( IM->NormalLengths );
314 IM->NormalLengths = 0;
315 IM->LastCalcedLength = 0;
316 }
317
318 if (IM->Material) {
319 FREE( IM->Material );
320 FREE( IM->MaterialMask );
321 IM->Material = 0;
322 IM->MaterialMask = 0;
323 }
324
325 if (ctx->nr_im_queued > 5) {
326 if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
327 fprintf(stderr, "really free immediate %d\n", IM->id);
328
329 FREE( IM );
330 }
331 else {
332 if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
333 fprintf(stderr, "requeue immediate %d\n", IM->id);
334
335 IM->next = ctx->freed_im_queue;
336 ctx->freed_im_queue = IM;
337 ctx->nr_im_queued++;
338 }
339}
Note: See TracBrowser for help on using the repository browser.