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 */
46static void
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 */
133static 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
222static void
223vbo_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 */
251void
252vbo_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
328end:
329   if (remap_vertex_store) {
330      save->buffer_ptr = vbo_save_map_vertex_store(ctx, save->vertex_store);
331   }
332}
333