1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25 /* Author:
26 * Keith Whitwell <keithw@vmware.com>
27 */
28
29 #include "main/glheader.h"
30 #include "main/bufferobj.h"
31 #include "main/context.h"
32 #include "main/imports.h"
33 #include "main/mtypes.h"
34 #include "main/macros.h"
35 #include "main/light.h"
36 #include "main/state.h"
37 #include "util/bitscan.h"
38
39 #include "vbo_context.h"
40
41
42 /**
43 * After playback, copy everything but the position from the
44 * last vertex to the saved state
45 */
46 static void
_playback_copy_to_current(struct gl_context * ctx,const struct vbo_save_vertex_list * node)47 _playback_copy_to_current(struct gl_context *ctx,
48 const struct vbo_save_vertex_list *node)
49 {
50 struct vbo_context *vbo = vbo_context(ctx);
51 fi_type vertex[VBO_ATTRIB_MAX * 4];
52 fi_type *data;
53 GLbitfield64 mask;
54 GLuint offset;
55
56 if (node->current_size == 0)
57 return;
58
59 if (node->current_data) {
60 data = node->current_data;
61 }
62 else {
63 data = vertex;
64
65 if (node->count)
66 offset = (node->buffer_offset +
67 (node->count-1) * node->vertex_size * sizeof(GLfloat));
68 else
69 offset = node->buffer_offset;
70
71 ctx->Driver.GetBufferSubData( ctx, offset,
72 node->vertex_size * sizeof(GLfloat),
73 data, node->vertex_store->bufferobj );
74
75 data += node->attrsz[0]; /* skip vertex position */
76 }
77
78 mask = node->enabled & (~BITFIELD64_BIT(VBO_ATTRIB_POS));
79 while (mask) {
80 const int i = u_bit_scan64(&mask);
81 fi_type *current = (fi_type *)vbo->currval[i].Ptr;
82 fi_type tmp[4];
83 assert(node->attrsz[i]);
84
85 COPY_CLEAN_4V_TYPE_AS_UNION(tmp,
86 node->attrsz[i],
87 data,
88 node->attrtype[i]);
89
90 if (node->attrtype[i] != vbo->currval[i].Type ||
91 memcmp(current, tmp, 4 * sizeof(GLfloat)) != 0) {
92 memcpy(current, tmp, 4 * sizeof(GLfloat));
93
94 vbo->currval[i].Size = node->attrsz[i];
95 vbo->currval[i]._ElementSize = vbo->currval[i].Size * sizeof(GLfloat);
96 vbo->currval[i].Type = node->attrtype[i];
97 vbo->currval[i].Integer =
98 vbo_attrtype_to_integer_flag(node->attrtype[i]);
99
100 if (i >= VBO_ATTRIB_FIRST_MATERIAL &&
101 i <= VBO_ATTRIB_LAST_MATERIAL)
102 ctx->NewState |= _NEW_LIGHT;
103
104 ctx->NewState |= _NEW_CURRENT_ATTRIB;
105 }
106
107 data += node->attrsz[i];
108 }
109
110 /* Colormaterial -- this kindof sucks.
111 */
112 if (ctx->Light.ColorMaterialEnabled) {
113 _mesa_update_color_material(ctx, ctx->Current.Attrib[VBO_ATTRIB_COLOR0]);
114 }
115
116 /* CurrentExecPrimitive
117 */
118 if (node->prim_count) {
119 const struct _mesa_prim *prim = &node->prim[node->prim_count - 1];
120 if (prim->end)
121 ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END;
122 else
123 ctx->Driver.CurrentExecPrimitive = prim->mode;
124 }
125 }
126
127
128
129 /**
130 * Treat the vertex storage as a VBO, define vertex arrays pointing
131 * into it:
132 */
vbo_bind_vertex_list(struct gl_context * ctx,const struct vbo_save_vertex_list * node)133 static void vbo_bind_vertex_list(struct gl_context *ctx,
134 const struct vbo_save_vertex_list *node)
135 {
136 struct vbo_context *vbo = vbo_context(ctx);
137 struct vbo_save_context *save = &vbo->save;
138 struct gl_vertex_array *arrays = save->arrays;
139 GLuint buffer_offset = node->buffer_offset;
140 const GLuint *map;
141 GLuint attr;
142 GLubyte node_attrsz[VBO_ATTRIB_MAX]; /* copy of node->attrsz[] */
143 GLenum node_attrtype[VBO_ATTRIB_MAX]; /* copy of node->attrtype[] */
144 GLbitfield64 varying_inputs = 0x0;
145
146 memcpy(node_attrsz, node->attrsz, sizeof(node->attrsz));
147 memcpy(node_attrtype, node->attrtype, sizeof(node->attrtype));
148
149 /* Install the default (ie Current) attributes first, then overlay
150 * all active ones.
151 */
152 switch (get_program_mode(ctx)) {
153 case VP_NONE:
154 for (attr = 0; attr < VERT_ATTRIB_FF_MAX; attr++) {
155 save->inputs[attr] = &vbo->currval[VBO_ATTRIB_POS+attr];
156 }
157 for (attr = 0; attr < MAT_ATTRIB_MAX; attr++) {
158 save->inputs[VERT_ATTRIB_GENERIC(attr)] =
159 &vbo->currval[VBO_ATTRIB_MAT_FRONT_AMBIENT+attr];
160 }
161 map = vbo->map_vp_none;
162 break;
163 case VP_ARB:
164 for (attr = 0; attr < VERT_ATTRIB_FF_MAX; attr++) {
165 save->inputs[attr] = &vbo->currval[VBO_ATTRIB_POS+attr];
166 }
167 for (attr = 0; attr < VERT_ATTRIB_GENERIC_MAX; attr++) {
168 save->inputs[VERT_ATTRIB_GENERIC(attr)] =
169 &vbo->currval[VBO_ATTRIB_GENERIC0+attr];
170 }
171 map = vbo->map_vp_arb;
172
173 /* check if VERT_ATTRIB_POS is not read but VERT_BIT_GENERIC0 is read.
174 * In that case we effectively need to route the data from
175 * glVertexAttrib(0, val) calls to feed into the GENERIC0 input.
176 */
177 if ((ctx->VertexProgram._Current->info.inputs_read &
178 VERT_BIT_POS) == 0 &&
179 (ctx->VertexProgram._Current->info.inputs_read &
180 VERT_BIT_GENERIC0)) {
181 save->inputs[VERT_ATTRIB_GENERIC0] = save->inputs[0];
182 node_attrsz[VERT_ATTRIB_GENERIC0] = node_attrsz[0];
183 node_attrtype[VERT_ATTRIB_GENERIC0] = node_attrtype[0];
184 node_attrsz[0] = 0;
185 }
186 break;
187 default:
188 assert(0);
189 }
190
191 for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
192 const GLuint src = map[attr];
193
194 if (node_attrsz[src]) {
195 /* override the default array set above */
196 save->inputs[attr] = &arrays[attr];
197
198 arrays[attr].Ptr = (const GLubyte *) NULL + buffer_offset;
199 arrays[attr].Size = node_attrsz[src];
200 arrays[attr].StrideB = node->vertex_size * sizeof(GLfloat);
201 arrays[attr].Type = node_attrtype[src];
202 arrays[attr].Integer =
203 vbo_attrtype_to_integer_flag(node_attrtype[src]);
204 arrays[attr].Format = GL_RGBA;
205 arrays[attr]._ElementSize = arrays[attr].Size * sizeof(GLfloat);
206 _mesa_reference_buffer_object(ctx,
207 &arrays[attr].BufferObj,
208 node->vertex_store->bufferobj);
209
210 assert(arrays[attr].BufferObj->Name);
211
212 buffer_offset += node_attrsz[src] * sizeof(GLfloat);
213 varying_inputs |= VERT_BIT(attr);
214 }
215 }
216
217 _mesa_set_varying_vp_inputs( ctx, varying_inputs );
218 ctx->NewDriverState |= ctx->DriverFlags.NewArray;
219 }
220
221
222 static void
vbo_save_loopback_vertex_list(struct gl_context * ctx,const struct vbo_save_vertex_list * list)223 vbo_save_loopback_vertex_list(struct gl_context *ctx,
224 const struct vbo_save_vertex_list *list)
225 {
226 const char *buffer =
227 ctx->Driver.MapBufferRange(ctx, 0,
228 list->vertex_store->bufferobj->Size,
229 GL_MAP_READ_BIT, /* ? */
230 list->vertex_store->bufferobj,
231 MAP_INTERNAL);
232
233 vbo_loopback_vertex_list(ctx,
234 (const GLfloat *)(buffer + list->buffer_offset),
235 list->attrsz,
236 list->prim,
237 list->prim_count,
238 list->wrap_count,
239 list->vertex_size);
240
241 ctx->Driver.UnmapBuffer(ctx, list->vertex_store->bufferobj,
242 MAP_INTERNAL);
243 }
244
245
246 /**
247 * Execute the buffer and save copied verts.
248 * This is called from the display list code when executing
249 * a drawing command.
250 */
251 void
vbo_save_playback_vertex_list(struct gl_context * ctx,void * data)252 vbo_save_playback_vertex_list(struct gl_context *ctx, void *data)
253 {
254 const struct vbo_save_vertex_list *node =
255 (const struct vbo_save_vertex_list *) data;
256 struct vbo_save_context *save = &vbo_context(ctx)->save;
257 GLboolean remap_vertex_store = GL_FALSE;
258
259 if (save->vertex_store && save->vertex_store->buffer) {
260 /* The vertex store is currently mapped but we're about to replay
261 * a display list. This can happen when a nested display list is
262 * being build with GL_COMPILE_AND_EXECUTE.
263 * We never want to have mapped vertex buffers when we're drawing.
264 * Unmap the vertex store, execute the list, then remap the vertex
265 * store.
266 */
267 vbo_save_unmap_vertex_store(ctx, save->vertex_store);
268 remap_vertex_store = GL_TRUE;
269 }
270
271 FLUSH_CURRENT(ctx, 0);
272
273 if (node->prim_count > 0) {
274
275 if (_mesa_inside_begin_end(ctx) && node->prim[0].begin) {
276 /* Error: we're about to begin a new primitive but we're already
277 * inside a glBegin/End pair.
278 */
279 _mesa_error(ctx, GL_INVALID_OPERATION,
280 "draw operation inside glBegin/End");
281 goto end;
282 }
283 else if (save->replay_flags) {
284 /* Various degenerate cases: translate into immediate mode
285 * calls rather than trying to execute in place.
286 */
287 vbo_save_loopback_vertex_list( ctx, node );
288
289 goto end;
290 }
291
292 if (ctx->NewState)
293 _mesa_update_state( ctx );
294
295 /* XXX also need to check if shader enabled, but invalid */
296 if ((ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) ||
297 (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled)) {
298 _mesa_error(ctx, GL_INVALID_OPERATION,
299 "glBegin (invalid vertex/fragment program)");
300 return;
301 }
302
303 vbo_bind_vertex_list( ctx, node );
304
305 vbo_draw_method(vbo_context(ctx), DRAW_DISPLAY_LIST);
306
307 /* Again...
308 */
309 if (ctx->NewState)
310 _mesa_update_state( ctx );
311
312 if (node->count > 0) {
313 vbo_context(ctx)->draw_prims(ctx,
314 node->prim,
315 node->prim_count,
316 NULL,
317 GL_TRUE,
318 0, /* Node is a VBO, so this is ok */
319 node->count - 1,
320 NULL, 0, NULL);
321 }
322 }
323
324 /* Copy to current?
325 */
326 _playback_copy_to_current( ctx, node );
327
328 end:
329 if (remap_vertex_store) {
330 save->buffer_ptr = vbo_save_map_vertex_store(ctx, save->vertex_store);
331 }
332 }
333