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
48
49void
50draw_pt_emit_prepare(struct pt_emit *emit,
51                     unsigned prim,
52                     unsigned *max_vertices)
53{
54   struct draw_context *draw = emit->draw;
55   const struct vertex_info *vinfo;
56   unsigned dst_offset;
57   struct translate_key hw_key;
58   unsigned i;
59
60   /* XXX: need to flush to get prim_vbuf.c to release its allocation??
61    */
62   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
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   draw->render->set_primitive(draw->render, emit->prim);
70
71   /* Must do this after set_primitive() above:
72    */
73   emit->vinfo = vinfo = draw->render->get_vertex_info(draw->render);
74
75   /* Translate from pipeline vertices to hw vertices.
76    */
77   dst_offset = 0;
78   for (i = 0; i < vinfo->num_attribs; i++) {
79      unsigned emit_sz = 0;
80      unsigned src_buffer = 0;
81      unsigned output_format;
82      unsigned src_offset = (vinfo->attrib[i].src_index * 4 * sizeof(float) );
83
84      output_format = draw_translate_vinfo_format(vinfo->attrib[i].emit);
85      emit_sz = draw_translate_vinfo_size(vinfo->attrib[i].emit);
86
87      /* doesn't handle EMIT_OMIT */
88      assert(emit_sz != 0);
89
90      if (vinfo->attrib[i].emit == EMIT_1F_PSIZE) {
91	 src_buffer = 1;
92	 src_offset = 0;
93      }
94
95      hw_key.element[i].type = TRANSLATE_ELEMENT_NORMAL;
96      hw_key.element[i].input_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
97      hw_key.element[i].input_buffer = src_buffer;
98      hw_key.element[i].input_offset = src_offset;
99      hw_key.element[i].instance_divisor = 0;
100      hw_key.element[i].output_format = output_format;
101      hw_key.element[i].output_offset = dst_offset;
102
103      dst_offset += emit_sz;
104   }
105
106   hw_key.nr_elements = vinfo->num_attribs;
107   hw_key.output_stride = vinfo->size * 4;
108
109   if (!emit->translate ||
110       translate_key_compare(&emit->translate->key, &hw_key) != 0) {
111      translate_key_sanitize(&hw_key);
112      emit->translate = translate_cache_find(emit->cache, &hw_key);
113   }
114
115   *max_vertices = (draw->render->max_vertex_buffer_bytes /
116                    (vinfo->size * 4));
117}
118
119
120void
121draw_pt_emit(struct pt_emit *emit,
122             const struct draw_vertex_info *vert_info,
123             const struct draw_prim_info *prim_info)
124{
125   const float (*vertex_data)[4] = (const float (*)[4])vert_info->verts->data;
126   unsigned vertex_count = vert_info->count;
127   unsigned stride = vert_info->stride;
128   const ushort *elts = prim_info->elts;
129   struct draw_context *draw = emit->draw;
130   struct translate *translate = emit->translate;
131   struct vbuf_render *render = draw->render;
132   unsigned start, i;
133   void *hw_verts;
134
135   /* XXX: need to flush to get prim_vbuf.c to release its allocation??
136    */
137   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
138
139   if (vertex_count == 0)
140      return;
141
142   /* XXX: and work out some way to coordinate the render primitive
143    * between vbuf.c and here...
144    */
145   draw->render->set_primitive(draw->render, emit->prim);
146
147   render->allocate_vertices(render,
148                             (ushort)translate->key.output_stride,
149                             (ushort)vertex_count);
150
151   hw_verts = render->map_vertices( render );
152   if (!hw_verts) {
153      debug_warn_once("map of vertex buffer failed (out of memory?)");
154      return;
155   }
156
157   translate->set_buffer(translate,
158			 0,
159			 vertex_data,
160			 stride,
161			 ~0);
162
163   translate->set_buffer(translate,
164			 1,
165			 &draw->rasterizer->point_size,
166			 0,
167			 ~0);
168
169   /* fetch/translate vertex attribs to fill hw_verts[] */
170   translate->run(translate,
171		  0,
172		  vertex_count,
173                  draw->instance_id,
174		  hw_verts );
175
176   render->unmap_vertices(render, 0, vertex_count - 1);
177
178   for (start = i = 0;
179        i < prim_info->primitive_count;
180        start += prim_info->primitive_lengths[i], i++)
181   {
182      render->draw_elements(render,
183                            elts + start,
184                            prim_info->primitive_lengths[i]);
185   }
186
187   render->release_vertices(render);
188}
189
190
191void
192draw_pt_emit_linear(struct pt_emit *emit,
193                    const struct draw_vertex_info *vert_info,
194                    const struct draw_prim_info *prim_info)
195{
196   const float (*vertex_data)[4] = (const float (*)[4])vert_info->verts->data;
197   unsigned stride = vert_info->stride;
198   unsigned count = vert_info->count;
199   struct draw_context *draw = emit->draw;
200   struct translate *translate = emit->translate;
201   struct vbuf_render *render = draw->render;
202   void *hw_verts;
203   unsigned start, i;
204
205#if 0
206   debug_printf("Linear emit\n");
207#endif
208   /* XXX: need to flush to get prim_vbuf.c to release its allocation??
209    */
210   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
211
212   /* XXX: and work out some way to coordinate the render primitive
213    * between vbuf.c and here...
214    */
215   draw->render->set_primitive(draw->render, emit->prim);
216
217   if (!render->allocate_vertices(render,
218                                  (ushort)translate->key.output_stride,
219                                  (ushort)count))
220      goto fail;
221
222   hw_verts = render->map_vertices( render );
223   if (!hw_verts)
224      goto fail;
225
226   translate->set_buffer(translate, 0,
227			 vertex_data, stride, count - 1);
228
229   translate->set_buffer(translate, 1,
230			 &draw->rasterizer->point_size,
231			 0, ~0);
232
233   translate->run(translate,
234                  0,
235                  count,
236                  draw->instance_id,
237                  hw_verts);
238
239   if (0) {
240      unsigned i;
241      for (i = 0; i < count; i++) {
242         debug_printf("\n\n%s vertex %d:\n", __FUNCTION__, i);
243         draw_dump_emitted_vertex( emit->vinfo,
244                                   (const uint8_t *)hw_verts +
245                                   translate->key.output_stride * i );
246      }
247   }
248
249   render->unmap_vertices( render, 0, count - 1 );
250
251   for (start = i = 0;
252        i < prim_info->primitive_count;
253        start += prim_info->primitive_lengths[i], i++)
254   {
255      render->draw_arrays(render,
256                          start,
257                          prim_info->primitive_lengths[i]);
258   }
259
260   render->release_vertices(render);
261
262   return;
263
264fail:
265   debug_warn_once("allocate or map of vertex buffer failed (out of memory?)");
266   return;
267}
268
269
270struct pt_emit *
271draw_pt_emit_create(struct draw_context *draw)
272{
273   struct pt_emit *emit = CALLOC_STRUCT(pt_emit);
274   if (!emit)
275      return NULL;
276
277   emit->draw = draw;
278   emit->cache = translate_cache_create();
279   if (!emit->cache) {
280      FREE(emit);
281      return NULL;
282   }
283
284   return emit;
285}
286
287
288void
289draw_pt_emit_destroy(struct pt_emit *emit)
290{
291   if (emit->cache)
292      translate_cache_destroy(emit->cache);
293
294   FREE(emit);
295}
296