← Back to branch summary

~ubuntu-branches/ubuntu/natty/mesa/natty-proposed

« back to all changes in this revision

Viewing changes to src/gallium/auxiliary/draw/draw_pt_fetch_emit.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Hooker, Robert Hooker, Christopher James Halse Rogers
  • Date: 2010-09-14 08:55:40 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914085540-m4fpl0hdjlfd4jgz
Tags: 7.9~git20100909-0ubuntu1
https://launchpad.net/bugs/631413
https://launchpad.net/bugs/628930
https://launchpad.net/bugs/628727
https://launchpad.net/bugs/596292
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/630315
https://launchpad.net/bugs/613694
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/578619
https://launchpad.net/bugs/626943
https://launchpad.net/bugs/610541
https://launchpad.net/bugs/601052
[ Robert Hooker ]
* New upstream git snapshot up to commit 94118fe2d4b1e5 (LP: #631413)
* New features include ATI HD5xxx series support in r600, and a vastly
  improved glsl compiler.
* Remove pre-generated .pc's, use the ones generated at build time
  instead.
* Remove all references to mesa-utils now that its no longer shipped
  with the mesa source.
* Disable the experimental ARB_fragment_shader option by default on
  i915, it exposes incomplete functionality that breaks KDE compositing
  among other things. It can be enabled via driconf still. (LP: #628930).

[ Christopher James Halse Rogers ]
* debian/patches/04_osmesa_version.diff:
  - Refresh for new upstream
* Bugs fixed in this release:
  - Fixes severe rendering corruption in Unity on radeon (LP: #628727,
    LP: #596292, LP: #599741, LP: #630315, LP: #613694, LP: #599741).
  - Also fixes rendering in gnome-shell (LP: #578619).
  - Flickering in OpenGL apps on radeon (LP: #626943, LP: #610541).
  - Provides preliminary support for new intel chips (LP: #601052).
* debian/rules:
  - Update configure flags to match upstream reshuffling.
  - Explicitly remove gallium DRI drivers that we don't want to ship.
* Update debian/gbp.conf for this Maverick-specific packaging
* libegl1-mesa-dri-x11,kms: There are no longer separate kms or x11 drivers
  for EGL, libegl1-mesa-drivers now contains a single driver that provides
  both backends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/auxiliary/draw/draw_pt_fetch_emit.c
36
36
#include "draw/draw_vbuf.h"
37
37
#include "draw/draw_vertex.h"
38
38
#include "draw/draw_pt.h"
 
39
#include "draw/draw_gs.h"
39
40
#include "translate/translate.h"
40
41
#include "translate/translate_cache.h"
41
42
 
100
101
   boolean ok;
101
102
   struct translate_key key;
102
103
 
 
104
   unsigned gs_out_prim = (draw->gs.geometry_shader ? 
 
105
                           draw->gs.geometry_shader->output_primitive :
 
106
                           prim);
 
107
 
 
108
 
103
109
 
104
110
   ok = draw->render->set_primitive( draw->render, 
105
 
                                     prim );
 
111
                                     gs_out_prim );
106
112
   if (!ok) {
107
113
      assert(0);
108
114
      return;
129
135
      unsigned input_offset = src->src_offset;
130
136
      unsigned output_format;
131
137
 
132
 
      switch (vinfo->attrib[i].emit) {
133
 
      case EMIT_4UB:
134
 
         output_format = PIPE_FORMAT_R8G8B8A8_UNORM;
135
 
         emit_sz = 4 * sizeof(unsigned char);
136
 
         break;
137
 
      case EMIT_4F:
138
 
         output_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
139
 
         emit_sz = 4 * sizeof(float);
140
 
         break;
141
 
      case EMIT_3F:
142
 
         output_format = PIPE_FORMAT_R32G32B32_FLOAT;
143
 
         emit_sz = 3 * sizeof(float);
144
 
         break;
145
 
      case EMIT_2F:
146
 
         output_format = PIPE_FORMAT_R32G32_FLOAT;
147
 
         emit_sz = 2 * sizeof(float);
148
 
         break;
149
 
      case EMIT_1F:
150
 
         output_format = PIPE_FORMAT_R32_FLOAT;
151
 
         emit_sz = 1 * sizeof(float);
152
 
         break;
153
 
      case EMIT_1F_PSIZE:
 
138
      output_format = draw_translate_vinfo_format(vinfo->attrib[i].emit);
 
139
      emit_sz = draw_translate_vinfo_size(vinfo->attrib[i].emit);
 
140
 
 
141
      if (vinfo->attrib[i].emit == EMIT_OMIT)
 
142
         continue;
 
143
 
 
144
      if (vinfo->attrib[i].emit == EMIT_1F_PSIZE) {
154
145
         input_format = PIPE_FORMAT_R32_FLOAT;
155
146
         input_buffer = draw->pt.nr_vertex_buffers;
156
147
         input_offset = 0;
157
 
         output_format = PIPE_FORMAT_R32_FLOAT;
158
 
         emit_sz = 1 * sizeof(float);
159
 
         break;
160
 
      case EMIT_OMIT:
161
 
         continue;
162
 
      default:
163
 
         assert(0);
164
 
         output_format = PIPE_FORMAT_NONE;
165
 
         emit_sz = 0;
166
 
         continue;
167
148
      }
168
149
 
169
150
      key.element[i].type = TRANSLATE_ELEMENT_NORMAL;
193
174
      feme->translate->set_buffer(feme->translate, 
194
175
                                  draw->pt.nr_vertex_buffers, 
195
176
                                  &feme->point_size,
196
 
                                  0);
 
177
                                  0,
 
178
                                  ~0);
197
179
   }
198
180
   
199
181
   feme->point_size = draw->rasterizer->point_size;
203
185
                                  i, 
204
186
                                  ((char *)draw->pt.user.vbuffer[i] + 
205
187
                                   draw->pt.vertex_buffer[i].buffer_offset),
206
 
                                  draw->pt.vertex_buffer[i].stride );
 
188
                                  draw->pt.vertex_buffer[i].stride,
 
189
                                  draw->pt.vertex_buffer[i].max_index);
207
190
   }
208
191
 
209
192
   *max_vertices = (draw->render->max_vertex_buffer_bytes / 
210
193
                    (vinfo->size * 4));
211
 
 
212
 
   /* Return an even number of verts.
213
 
    * This prevents "parity" errors when splitting long triangle strips which
214
 
    * can lead to front/back culling mix-ups.
215
 
    * Every other triangle in a strip has an alternate front/back orientation
216
 
    * so splitting at an odd position can cause the orientation of subsequent
217
 
    * triangles to get reversed.
218
 
    */
219
 
   *max_vertices = *max_vertices & ~1;
220
194
}
221
195
 
222
196
 
227
201
                            const unsigned *fetch_elts,
228
202
                            unsigned fetch_count,
229
203
                            const ushort *draw_elts,
230
 
                            unsigned draw_count )
 
204
                            unsigned draw_count,
 
205
                            unsigned prim_flags )
231
206
{
232
207
   struct fetch_emit_middle_end *feme = (struct fetch_emit_middle_end *)middle;
233
208
   struct draw_context *draw = feme->draw;
237
212
    */
238
213
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
239
214
 
240
 
   if (fetch_count >= UNDEFINED_VERTEX_ID) {
241
 
      assert(0);
242
 
      return;
243
 
   }
244
 
 
245
215
   draw->render->allocate_vertices( draw->render,
246
216
                                    (ushort)feme->translate->key.output_stride,
247
217
                                    (ushort)fetch_count );
277
247
   /* XXX: Draw arrays path to avoid re-emitting index list again and
278
248
    * again.
279
249
    */
280
 
   draw->render->draw( draw->render, 
281
 
                       draw_elts, 
282
 
                       draw_count );
 
250
   draw->render->draw_elements( draw->render, 
 
251
                                draw_elts, 
 
252
                                draw_count );
283
253
 
284
254
   /* Done -- that was easy, wasn't it: 
285
255
    */
290
260
 
291
261
static void fetch_emit_run_linear( struct draw_pt_middle_end *middle,
292
262
                                   unsigned start,
293
 
                                   unsigned count )
 
263
                                   unsigned count,
 
264
                                   unsigned prim_flags )
294
265
{
295
266
   struct fetch_emit_middle_end *feme = (struct fetch_emit_middle_end *)middle;
296
267
   struct draw_context *draw = feme->draw;
300
271
    */
301
272
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
302
273
 
303
 
   if (count >= UNDEFINED_VERTEX_ID) 
304
 
      goto fail;
305
 
 
306
274
   if (!draw->render->allocate_vertices( draw->render,
307
275
                                         (ushort)feme->translate->key.output_stride,
308
276
                                         (ushort)count )) 
351
319
                                        unsigned start,
352
320
                                        unsigned count,
353
321
                                        const ushort *draw_elts,
354
 
                                        unsigned draw_count )
 
322
                                        unsigned draw_count,
 
323
                                        unsigned prim_flags )
355
324
{
356
325
   struct fetch_emit_middle_end *feme = (struct fetch_emit_middle_end *)middle;
357
326
   struct draw_context *draw = feme->draw;
361
330
    */
362
331
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
363
332
 
364
 
   if (count >= UNDEFINED_VERTEX_ID)
365
 
      return FALSE;
366
 
 
367
333
   if (!draw->render->allocate_vertices( draw->render,
368
334
                                         (ushort)feme->translate->key.output_stride,
369
335
                                         (ushort)count ))
386
352
   /* XXX: Draw arrays path to avoid re-emitting index list again and
387
353
    * again.
388
354
    */
389
 
   draw->render->draw( draw->render, 
390
 
                       draw_elts, 
391
 
                       draw_count );
 
355
   draw->render->draw_elements( draw->render, 
 
356
                                draw_elts, 
 
357
                                draw_count );
392
358
 
393
359
   /* Done -- that was easy, wasn't it:
394
360
    */