← Back to branch summary

~ubuntu-branches/ubuntu/precise/mesa/precise-updates

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Robert Hooker
  • Date: 2012-02-02 12:05:48 UTC
  • mfrom: (1.7.1) (3.3.27 sid)
  • Revision ID: package-import@ubuntu.com-20120202120548-nvkma85jq0h4coix
Tags: 8.0~rc2-0ubuntu4
Drop drisearchdir handling, it is no longer needed with multiarch
and dri-alternates being removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/auxiliary/draw/draw_pt_emit.c
45
45
   const struct vertex_info *vinfo;
46
46
};
47
47
 
48
 
void draw_pt_emit_prepare( struct pt_emit *emit,
49
 
                           unsigned prim,
50
 
                           unsigned *max_vertices )
 
48
 
 
49
void
 
50
draw_pt_emit_prepare(struct pt_emit *emit,
 
51
                     unsigned prim,
 
52
                     unsigned *max_vertices)
51
53
{
52
54
   struct draw_context *draw = emit->draw;
53
55
   const struct vertex_info *vinfo;
54
56
   unsigned dst_offset;
55
57
   struct translate_key hw_key;
56
58
   unsigned i;
57
 
   boolean ok;
58
 
   
59
 
   /* XXX: need to flush to get prim_vbuf.c to release its allocation?? 
 
59
 
 
60
   /* XXX: need to flush to get prim_vbuf.c to release its allocation??
60
61
    */
61
62
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
62
63
 
63
 
 
64
64
   /* XXX: may need to defensively reset this later on as clipping can
65
65
    * clobber this state in the render backend.
66
66
    */
67
67
   emit->prim = prim;
68
68
 
69
 
   ok = draw->render->set_primitive(draw->render, emit->prim);
70
 
   if (!ok) {
71
 
      assert(0);
72
 
      return;
73
 
   }
 
69
   draw->render->set_primitive(draw->render, emit->prim);
74
70
 
75
71
   /* Must do this after set_primitive() above:
76
72
    */
77
73
   emit->vinfo = vinfo = draw->render->get_vertex_info(draw->render);
78
74
 
79
 
 
80
75
   /* Translate from pipeline vertices to hw vertices.
81
76
    */
82
77
   dst_offset = 0;
112
107
   hw_key.output_stride = vinfo->size * 4;
113
108
 
114
109
   if (!emit->translate ||
115
 
       translate_key_compare(&emit->translate->key, &hw_key) != 0)
116
 
   {
 
110
       translate_key_compare(&emit->translate->key, &hw_key) != 0) {
117
111
      translate_key_sanitize(&hw_key);
118
112
      emit->translate = translate_cache_find(emit->cache, &hw_key);
119
113
   }
120
114
 
121
 
   *max_vertices = (draw->render->max_vertex_buffer_bytes / 
 
115
   *max_vertices = (draw->render->max_vertex_buffer_bytes /
122
116
                    (vinfo->size * 4));
123
117
}
124
118
 
125
119
 
126
 
void draw_pt_emit( struct pt_emit *emit,
127
 
                         const struct draw_vertex_info *vert_info,
128
 
                         const struct draw_prim_info *prim_info)
 
120
void
 
121
draw_pt_emit(struct pt_emit *emit,
 
122
             const struct draw_vertex_info *vert_info,
 
123
             const struct draw_prim_info *prim_info)
129
124
{
130
125
   const float (*vertex_data)[4] = (const float (*)[4])vert_info->verts->data;
131
126
   unsigned vertex_count = vert_info->count;
137
132
   unsigned start, i;
138
133
   void *hw_verts;
139
134
 
140
 
   /* XXX: need to flush to get prim_vbuf.c to release its allocation?? 
 
135
   /* XXX: need to flush to get prim_vbuf.c to release its allocation??
141
136
    */
142
137
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
143
138
 
147
142
   /* XXX: and work out some way to coordinate the render primitive
148
143
    * between vbuf.c and here...
149
144
    */
150
 
   if (!draw->render->set_primitive(draw->render, emit->prim)) {
151
 
      assert(0);
152
 
      return;
153
 
   }
 
145
   draw->render->set_primitive(draw->render, emit->prim);
154
146
 
155
147
   render->allocate_vertices(render,
156
148
                             (ushort)translate->key.output_stride,
158
150
 
159
151
   hw_verts = render->map_vertices( render );
160
152
   if (!hw_verts) {
161
 
      assert(0);
 
153
      debug_warn_once("map of vertex buffer failed (out of memory?)");
162
154
      return;
163
155
   }
164
156
 
165
 
   translate->set_buffer(translate, 
166
 
                         0, 
 
157
   translate->set_buffer(translate,
 
158
                         0,
167
159
                         vertex_data,
168
160
                         stride,
169
161
                         ~0);
170
162
 
171
 
   translate->set_buffer(translate, 
172
 
                         1, 
 
163
   translate->set_buffer(translate,
 
164
                         1,
173
165
                         &draw->rasterizer->point_size,
174
166
                         0,
175
167
                         ~0);
176
168
 
177
169
   /* fetch/translate vertex attribs to fill hw_verts[] */
178
 
   translate->run( translate,
179
 
                   0, 
180
 
                   vertex_count,
181
 
                   draw->instance_id,
182
 
                   hw_verts );
 
170
   translate->run(translate,
 
171
                  0,
 
172
                  vertex_count,
 
173
                  draw->instance_id,
 
174
                  hw_verts );
183
175
 
184
 
   render->unmap_vertices( render, 
185
 
                           0, 
186
 
                           vertex_count - 1 );
 
176
   render->unmap_vertices(render, 0, vertex_count - 1);
187
177
 
188
178
   for (start = i = 0;
189
179
        i < prim_info->primitive_count;
198
188
}
199
189
 
200
190
 
201
 
void draw_pt_emit_linear(struct pt_emit *emit,
202
 
                         const struct draw_vertex_info *vert_info,
203
 
                         const struct draw_prim_info *prim_info)
 
191
void
 
192
draw_pt_emit_linear(struct pt_emit *emit,
 
193
                    const struct draw_vertex_info *vert_info,
 
194
                    const struct draw_prim_info *prim_info)
204
195
{
205
196
   const float (*vertex_data)[4] = (const float (*)[4])vert_info->verts->data;
206
197
   unsigned stride = vert_info->stride;
214
205
#if 0
215
206
   debug_printf("Linear emit\n");
216
207
#endif
217
 
   /* XXX: need to flush to get prim_vbuf.c to release its allocation?? 
 
208
   /* XXX: need to flush to get prim_vbuf.c to release its allocation??
218
209
    */
219
210
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
220
211
 
221
212
   /* XXX: and work out some way to coordinate the render primitive
222
213
    * between vbuf.c and here...
223
214
    */
224
 
   if (!draw->render->set_primitive(draw->render, emit->prim)) 
225
 
      goto fail;
 
215
   draw->render->set_primitive(draw->render, emit->prim);
226
216
 
227
217
   if (!render->allocate_vertices(render,
228
218
                                  (ushort)translate->key.output_stride,
250
240
      unsigned i;
251
241
      for (i = 0; i < count; i++) {
252
242
         debug_printf("\n\n%s vertex %d:\n", __FUNCTION__, i);
253
 
         draw_dump_emitted_vertex( emit->vinfo, 
254
 
                                   (const uint8_t *)hw_verts + 
 
243
         draw_dump_emitted_vertex( emit->vinfo,
 
244
                                   (const uint8_t *)hw_verts +
255
245
                                   translate->key.output_stride * i );
256
246
      }
257
247
   }
272
262
   return;
273
263
 
274
264
fail:
275
 
   assert(0);
 
265
   debug_warn_once("allocate or map of vertex buffer failed (out of memory?)");
276
266
   return;
277
267
}
278
268
 
279
 
struct pt_emit *draw_pt_emit_create( struct draw_context *draw )
 
269
 
 
270
struct pt_emit *
 
271
draw_pt_emit_create(struct draw_context *draw)
280
272
{
281
273
   struct pt_emit *emit = CALLOC_STRUCT(pt_emit);
282
274
   if (!emit)
292
284
   return emit;
293
285
}
294
286
 
295
 
void draw_pt_emit_destroy( struct pt_emit *emit )
 
287
 
 
288
void
 
289
draw_pt_emit_destroy(struct pt_emit *emit)
296
290
{
297
291
   if (emit->cache)
298
292
      translate_cache_destroy(emit->cache);