draw_pt_emit.c revision c217d94cca357d38e244754747a1bd15e9cf2557 
1/**************************************************************************
2 *
3 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * 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
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28#include "util/u_memory.h"
29#include "draw/draw_context.h"
30#include "draw/draw_private.h"
31#include "draw/draw_vbuf.h"
32#include "draw/draw_vertex.h"
33#include "draw/draw_pt.h"
34#include "translate/translate.h"
35#include "translate/translate_cache.h"
36
37struct pt_emit {
38   struct draw_context *draw;
39
40   struct translate *translate;
41
42   struct translate_cache *cache;
43   unsigned prim;
44
45   const struct vertex_info *vinfo;
46};
47
48void draw_pt_emit_prepare( struct pt_emit *emit,
49			   unsigned prim,
50                           unsigned *max_vertices )
51{
52   struct draw_context *draw = emit->draw;
53   const struct vertex_info *vinfo;
54   unsigned dst_offset;
55   struct translate_key hw_key;
56   unsigned i;
57   boolean ok;
58
59   /* XXX: need to flush to get prim_vbuf.c to release its allocation??
60    */
61   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
62
63
64   /* XXX: may need to defensively reset this later on as clipping can
65    * clobber this state in the render backend.
66    */
67   emit->prim = prim;
68
69   ok = draw->render->set_primitive(draw->render, emit->prim);
70   if (!ok) {
71      assert(0);
72      return;
73   }
74
75   /* Must do this after set_primitive() above:
76    */
77   emit->vinfo = vinfo = draw->render->get_vertex_info(draw->render);
78
79
80   /* Translate from pipeline vertices to hw vertices.
81    */
82   dst_offset = 0;
83   for (i = 0; i < vinfo->num_attribs; i++) {
84      unsigned emit_sz = 0;
85      unsigned src_buffer = 0;
86      unsigned output_format;
87      unsigned src_offset = (vinfo->attrib[i].src_index * 4 * sizeof(float) );
88
89      output_format = draw_translate_vinfo_format(vinfo->attrib[i].emit);
90      emit_sz = draw_translate_vinfo_size(vinfo->attrib[i].emit);
91
92      /* doesn't handle EMIT_OMIT */
93      assert(emit_sz != 0);
94
95      if (vinfo->attrib[i].emit == EMIT_1F_PSIZE) {
96	 src_buffer = 1;
97	 src_offset = 0;
98      }
99
100      hw_key.element[i].type = TRANSLATE_ELEMENT_NORMAL;
101      hw_key.element[i].input_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
102      hw_key.element[i].input_buffer = src_buffer;
103      hw_key.element[i].input_offset = src_offset;
104      hw_key.element[i].instance_divisor = 0;
105      hw_key.element[i].output_format = output_format;
106      hw_key.element[i].output_offset = dst_offset;
107
108      dst_offset += emit_sz;
109   }
110
111   hw_key.nr_elements = vinfo->num_attribs;
112   hw_key.output_stride = vinfo->size * 4;
113
114   if (!emit->translate ||
115       translate_key_compare(&emit->translate->key, &hw_key) != 0)
116   {
117      translate_key_sanitize(&hw_key);
118      emit->translate = translate_cache_find(emit->cache, &hw_key);
119   }
120
121   *max_vertices = (draw->render->max_vertex_buffer_bytes /
122                    (vinfo->size * 4));
123
124   /* even number */
125   *max_vertices = *max_vertices & ~1;
126}
127
128
129void draw_pt_emit( struct pt_emit *emit,
130		   const float (*vertex_data)[4],
131		   unsigned vertex_count,
132		   unsigned stride,
133		   const ushort *elts,
134		   unsigned count )
135{
136   struct draw_context *draw = emit->draw;
137   struct translate *translate = emit->translate;
138   struct vbuf_render *render = draw->render;
139   void *hw_verts;
140
141   /* XXX: need to flush to get prim_vbuf.c to release its allocation??
142    */
143   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
144
145   if (vertex_count == 0)
146      return;
147
148   if (vertex_count >= UNDEFINED_VERTEX_ID) {
149      assert(0);
150      return;
151   }
152
153   /* XXX: and work out some way to coordinate the render primitive
154    * between vbuf.c and here...
155    */
156   if (!draw->render->set_primitive(draw->render, emit->prim)) {
157      assert(0);
158      return;
159   }
160
161   render->allocate_vertices(render,
162                             (ushort)translate->key.output_stride,
163                             (ushort)vertex_count);
164
165   hw_verts = render->map_vertices( render );
166   if (!hw_verts) {
167      assert(0);
168      return;
169   }
170
171   translate->set_buffer(translate,
172			 0,
173			 vertex_data,
174			 stride,
175			 ~0);
176
177   translate->set_buffer(translate,
178			 1,
179			 &draw->rasterizer->point_size,
180			 0,
181			 ~0);
182
183   translate->run( translate,
184		   0,
185		   vertex_count,
186                   draw->instance_id,
187		   hw_verts );
188
189   render->unmap_vertices( render,
190                           0,
191                           vertex_count - 1 );
192
193   render->draw_elements(render,
194                         elts,
195                         count);
196
197   render->release_vertices(render);
198}
199
200
201void draw_pt_emit_linear(struct pt_emit *emit,
202                         const float (*vertex_data)[4],
203                         unsigned stride,
204                         unsigned count)
205{
206   struct draw_context *draw = emit->draw;
207   struct translate *translate = emit->translate;
208   struct vbuf_render *render = draw->render;
209   void *hw_verts;
210
211#if 0
212   debug_printf("Linear emit\n");
213#endif
214   /* XXX: need to flush to get prim_vbuf.c to release its allocation??
215    */
216   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
217
218   if (count >= UNDEFINED_VERTEX_ID)
219      goto fail;
220
221   /* XXX: and work out some way to coordinate the render primitive
222    * between vbuf.c and here...
223    */
224   if (!draw->render->set_primitive(draw->render, emit->prim))
225      goto fail;
226
227   if (!render->allocate_vertices(render,
228                                  (ushort)translate->key.output_stride,
229                                  (ushort)count))
230      goto fail;
231
232   hw_verts = render->map_vertices( render );
233   if (!hw_verts)
234      goto fail;
235
236   translate->set_buffer(translate, 0,
237			 vertex_data, stride, count - 1);
238
239   translate->set_buffer(translate, 1,
240			 &draw->rasterizer->point_size,
241			 0, ~0);
242
243   translate->run(translate,
244                  0,
245                  count,
246                  draw->instance_id,
247                  hw_verts);
248
249   if (0) {
250      unsigned i;
251      for (i = 0; i < count; i++) {
252         debug_printf("\n\n%s vertex %d:\n", __FUNCTION__, i);
253         draw_dump_emitted_vertex( emit->vinfo,
254                                   (const uint8_t *)hw_verts +
255                                   translate->key.output_stride * i );
256      }
257   }
258
259   render->unmap_vertices( render, 0, count - 1 );
260
261   render->draw_arrays(render, 0, count);
262
263   render->release_vertices(render);
264
265   return;
266
267fail:
268   assert(0);
269   return;
270}
271
272struct pt_emit *draw_pt_emit_create( struct draw_context *draw )
273{
274   struct pt_emit *emit = CALLOC_STRUCT(pt_emit);
275   if (!emit)
276      return NULL;
277
278   emit->draw = draw;
279   emit->cache = translate_cache_create();
280   if (!emit->cache) {
281      FREE(emit);
282      return NULL;
283   }
284
285   return emit;
286}
287
288void draw_pt_emit_destroy( struct pt_emit *emit )
289{
290   if (emit->cache)
291      translate_cache_destroy(emit->cache);
292
293   FREE(emit);
294}
295