draw_pt_emit.c revision 8c3cc83432bbbc190b0f71f87e3e9583ae11f0b2
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 struct draw_vertex_info *vert_info, 131 const struct draw_prim_info *prim_info) 132{ 133 const float (*vertex_data)[4] = (const float (*)[4])vert_info->verts->data; 134 unsigned vertex_count = vert_info->count; 135 unsigned stride = vert_info->stride; 136 const ushort *elts = prim_info->elts; 137 struct draw_context *draw = emit->draw; 138 struct translate *translate = emit->translate; 139 struct vbuf_render *render = draw->render; 140 unsigned start, i; 141 void *hw_verts; 142 143 /* XXX: need to flush to get prim_vbuf.c to release its allocation?? 144 */ 145 draw_do_flush( draw, DRAW_FLUSH_BACKEND ); 146 147 if (vertex_count == 0) 148 return; 149 150 if (vertex_count >= UNDEFINED_VERTEX_ID) { 151 assert(0); 152 return; 153 } 154 155 /* XXX: and work out some way to coordinate the render primitive 156 * between vbuf.c and here... 157 */ 158 if (!draw->render->set_primitive(draw->render, emit->prim)) { 159 assert(0); 160 return; 161 } 162 163 render->allocate_vertices(render, 164 (ushort)translate->key.output_stride, 165 (ushort)vertex_count); 166 167 hw_verts = render->map_vertices( render ); 168 if (!hw_verts) { 169 assert(0); 170 return; 171 } 172 173 translate->set_buffer(translate, 174 0, 175 vertex_data, 176 stride, 177 ~0); 178 179 translate->set_buffer(translate, 180 1, 181 &draw->rasterizer->point_size, 182 0, 183 ~0); 184 185 /* fetch/translate vertex attribs to fill hw_verts[] */ 186 translate->run( translate, 187 0, 188 vertex_count, 189 draw->instance_id, 190 hw_verts ); 191 192 render->unmap_vertices( render, 193 0, 194 vertex_count - 1 ); 195 196 for (start = i = 0; 197 i < prim_info->primitive_count; 198 start += prim_info->primitive_lengths[i], i++) 199 { 200 render->draw_elements(render, 201 elts + start, 202 prim_info->primitive_lengths[i]); 203 } 204 205 render->release_vertices(render); 206} 207 208 209void draw_pt_emit_linear(struct pt_emit *emit, 210 const struct draw_vertex_info *vert_info, 211 const struct draw_prim_info *prim_info) 212{ 213 const float (*vertex_data)[4] = (const float (*)[4])vert_info->verts->data; 214 unsigned stride = vert_info->stride; 215 unsigned count = vert_info->count; 216 struct draw_context *draw = emit->draw; 217 struct translate *translate = emit->translate; 218 struct vbuf_render *render = draw->render; 219 void *hw_verts; 220 unsigned start, i; 221 222#if 0 223 debug_printf("Linear emit\n"); 224#endif 225 /* XXX: need to flush to get prim_vbuf.c to release its allocation?? 226 */ 227 draw_do_flush( draw, DRAW_FLUSH_BACKEND ); 228 229 if (count >= UNDEFINED_VERTEX_ID) 230 goto fail; 231 232 /* XXX: and work out some way to coordinate the render primitive 233 * between vbuf.c and here... 234 */ 235 if (!draw->render->set_primitive(draw->render, emit->prim)) 236 goto fail; 237 238 if (!render->allocate_vertices(render, 239 (ushort)translate->key.output_stride, 240 (ushort)count)) 241 goto fail; 242 243 hw_verts = render->map_vertices( render ); 244 if (!hw_verts) 245 goto fail; 246 247 translate->set_buffer(translate, 0, 248 vertex_data, stride, count - 1); 249 250 translate->set_buffer(translate, 1, 251 &draw->rasterizer->point_size, 252 0, ~0); 253 254 translate->run(translate, 255 0, 256 count, 257 draw->instance_id, 258 hw_verts); 259 260 if (0) { 261 unsigned i; 262 for (i = 0; i < count; i++) { 263 debug_printf("\n\n%s vertex %d:\n", __FUNCTION__, i); 264 draw_dump_emitted_vertex( emit->vinfo, 265 (const uint8_t *)hw_verts + 266 translate->key.output_stride * i ); 267 } 268 } 269 270 render->unmap_vertices( render, 0, count - 1 ); 271 272 for (start = i = 0; 273 i < prim_info->primitive_count; 274 start += prim_info->primitive_lengths[i], i++) 275 { 276 render->draw_arrays(render, 277 start, 278 prim_info->primitive_lengths[i]); 279 } 280 281 render->release_vertices(render); 282 283 return; 284 285fail: 286 assert(0); 287 return; 288} 289 290struct pt_emit *draw_pt_emit_create( struct draw_context *draw ) 291{ 292 struct pt_emit *emit = CALLOC_STRUCT(pt_emit); 293 if (!emit) 294 return NULL; 295 296 emit->draw = draw; 297 emit->cache = translate_cache_create(); 298 if (!emit->cache) { 299 FREE(emit); 300 return NULL; 301 } 302 303 return emit; 304} 305 306void draw_pt_emit_destroy( struct pt_emit *emit ) 307{ 308 if (emit->cache) 309 translate_cache_destroy(emit->cache); 310 311 FREE(emit); 312} 313