draw_pipe.c revision cb136a93aba4dc64db7e446b0fbc36c9172e4017
1/************************************************************************** 2 * 3 * Copyright 2007 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 /* 29 * Authors: 30 * Keith Whitwell <keith@tungstengraphics.com> 31 */ 32 33#include "draw/draw_private.h" 34#include "draw/draw_pipe.h" 35#include "util/u_debug.h" 36 37 38 39boolean draw_pipeline_init( struct draw_context *draw ) 40{ 41 /* create pipeline stages */ 42 draw->pipeline.wide_line = draw_wide_line_stage( draw ); 43 draw->pipeline.wide_point = draw_wide_point_stage( draw ); 44 draw->pipeline.stipple = draw_stipple_stage( draw ); 45 draw->pipeline.unfilled = draw_unfilled_stage( draw ); 46 draw->pipeline.twoside = draw_twoside_stage( draw ); 47 draw->pipeline.offset = draw_offset_stage( draw ); 48 draw->pipeline.clip = draw_clip_stage( draw ); 49 draw->pipeline.flatshade = draw_flatshade_stage( draw ); 50 draw->pipeline.cull = draw_cull_stage( draw ); 51 draw->pipeline.validate = draw_validate_stage( draw ); 52 draw->pipeline.first = draw->pipeline.validate; 53 54 if (!draw->pipeline.wide_line || 55 !draw->pipeline.wide_point || 56 !draw->pipeline.stipple || 57 !draw->pipeline.unfilled || 58 !draw->pipeline.twoside || 59 !draw->pipeline.offset || 60 !draw->pipeline.clip || 61 !draw->pipeline.flatshade || 62 !draw->pipeline.cull || 63 !draw->pipeline.validate) 64 return FALSE; 65 66 /* these defaults are oriented toward the needs of softpipe */ 67 draw->pipeline.wide_point_threshold = 1000000.0; /* infinity */ 68 draw->pipeline.wide_line_threshold = 1.0; 69 draw->pipeline.wide_point_sprites = FALSE; 70 draw->pipeline.line_stipple = TRUE; 71 draw->pipeline.point_sprite = TRUE; 72 73 return TRUE; 74} 75 76 77void draw_pipeline_destroy( struct draw_context *draw ) 78{ 79 if (draw->pipeline.wide_line) 80 draw->pipeline.wide_line->destroy( draw->pipeline.wide_line ); 81 if (draw->pipeline.wide_point) 82 draw->pipeline.wide_point->destroy( draw->pipeline.wide_point ); 83 if (draw->pipeline.stipple) 84 draw->pipeline.stipple->destroy( draw->pipeline.stipple ); 85 if (draw->pipeline.unfilled) 86 draw->pipeline.unfilled->destroy( draw->pipeline.unfilled ); 87 if (draw->pipeline.twoside) 88 draw->pipeline.twoside->destroy( draw->pipeline.twoside ); 89 if (draw->pipeline.offset) 90 draw->pipeline.offset->destroy( draw->pipeline.offset ); 91 if (draw->pipeline.clip) 92 draw->pipeline.clip->destroy( draw->pipeline.clip ); 93 if (draw->pipeline.flatshade) 94 draw->pipeline.flatshade->destroy( draw->pipeline.flatshade ); 95 if (draw->pipeline.cull) 96 draw->pipeline.cull->destroy( draw->pipeline.cull ); 97 if (draw->pipeline.validate) 98 draw->pipeline.validate->destroy( draw->pipeline.validate ); 99 if (draw->pipeline.aaline) 100 draw->pipeline.aaline->destroy( draw->pipeline.aaline ); 101 if (draw->pipeline.aapoint) 102 draw->pipeline.aapoint->destroy( draw->pipeline.aapoint ); 103 if (draw->pipeline.pstipple) 104 draw->pipeline.pstipple->destroy( draw->pipeline.pstipple ); 105 if (draw->pipeline.rasterize) 106 draw->pipeline.rasterize->destroy( draw->pipeline.rasterize ); 107} 108 109 110 111/** 112 * Build primitive to render a point with vertex at v0. 113 */ 114static void do_point( struct draw_context *draw, 115 const char *v0 ) 116{ 117 struct prim_header prim; 118 119 prim.flags = 0; 120 prim.pad = 0; 121 prim.v[0] = (struct vertex_header *)v0; 122 123 draw->pipeline.first->point( draw->pipeline.first, &prim ); 124} 125 126 127/** 128 * Build primitive to render a line with vertices at v0, v1. 129 * \param flags bitmask of DRAW_PIPE_EDGE_x, DRAW_PIPE_RESET_STIPPLE 130 */ 131static void do_line( struct draw_context *draw, 132 ushort flags, 133 const char *v0, 134 const char *v1 ) 135{ 136 struct prim_header prim; 137 138 prim.flags = flags; 139 prim.pad = 0; 140 prim.v[0] = (struct vertex_header *)v0; 141 prim.v[1] = (struct vertex_header *)v1; 142 143 draw->pipeline.first->line( draw->pipeline.first, &prim ); 144} 145 146 147/** 148 * Build primitive to render a triangle with vertices at v0, v1, v2. 149 * \param flags bitmask of DRAW_PIPE_EDGE_x, DRAW_PIPE_RESET_STIPPLE 150 */ 151static void do_triangle( struct draw_context *draw, 152 ushort flags, 153 char *v0, 154 char *v1, 155 char *v2 ) 156{ 157 struct prim_header prim; 158 159 prim.v[0] = (struct vertex_header *)v0; 160 prim.v[1] = (struct vertex_header *)v1; 161 prim.v[2] = (struct vertex_header *)v2; 162 prim.flags = flags; 163 prim.pad = 0; 164 165 draw->pipeline.first->tri( draw->pipeline.first, &prim ); 166} 167 168 169/* 170 * Set up macros for draw_pt_decompose.h template code. 171 * This code uses vertex indexes / elements. 172 */ 173 174/* emit first quad vertex as first vertex in triangles */ 175#define QUAD_FIRST_PV(i0,i1,i2,i3) \ 176 do_triangle( draw, \ 177 ( DRAW_PIPE_RESET_STIPPLE | \ 178 DRAW_PIPE_EDGE_FLAG_0 | \ 179 DRAW_PIPE_EDGE_FLAG_1 ), \ 180 verts + stride * elts[i0], \ 181 verts + stride * elts[i1], \ 182 verts + stride * elts[i2]); \ 183 do_triangle( draw, \ 184 ( DRAW_PIPE_EDGE_FLAG_1 | \ 185 DRAW_PIPE_EDGE_FLAG_2 ), \ 186 verts + stride * elts[i0], \ 187 verts + stride * elts[i2], \ 188 verts + stride * elts[i3]) 189 190/* emit last quad vertex as last vertex in triangles */ 191#define QUAD_LAST_PV(i0,i1,i2,i3) \ 192 do_triangle( draw, \ 193 ( DRAW_PIPE_RESET_STIPPLE | \ 194 DRAW_PIPE_EDGE_FLAG_0 | \ 195 DRAW_PIPE_EDGE_FLAG_2 ), \ 196 verts + stride * elts[i0], \ 197 verts + stride * elts[i1], \ 198 verts + stride * elts[i3]); \ 199 do_triangle( draw, \ 200 ( DRAW_PIPE_EDGE_FLAG_0 | \ 201 DRAW_PIPE_EDGE_FLAG_1 ), \ 202 verts + stride * elts[i1], \ 203 verts + stride * elts[i2], \ 204 verts + stride * elts[i3]) 205 206#define TRIANGLE(flags,i0,i1,i2) \ 207 do_triangle( draw, \ 208 elts[i0], /* flags */ \ 209 verts + stride * (elts[i0] & ~DRAW_PIPE_FLAG_MASK), \ 210 verts + stride * (elts[i1] & ~DRAW_PIPE_FLAG_MASK), \ 211 verts + stride * (elts[i2] & ~DRAW_PIPE_FLAG_MASK) ); 212 213#define LINE(flags,i0,i1) \ 214 do_line( draw, \ 215 elts[i0], \ 216 verts + stride * (elts[i0] & ~DRAW_PIPE_FLAG_MASK), \ 217 verts + stride * (elts[i1] & ~DRAW_PIPE_FLAG_MASK) ); 218 219#define POINT(i0) \ 220 do_point( draw, \ 221 verts + stride * elts[i0] ) 222 223#define FUNC pipe_run 224#define ARGS \ 225 struct draw_context *draw, \ 226 unsigned prim, \ 227 struct vertex_header *vertices, \ 228 unsigned stride, \ 229 const ushort *elts 230 231#define LOCAL_VARS \ 232 char *verts = (char *)vertices; \ 233 boolean flatfirst = (draw->rasterizer->flatshade && \ 234 draw->rasterizer->flatshade_first); \ 235 unsigned i; \ 236 ushort flags 237 238#define FLUSH 239 240#include "draw_pt_decompose.h" 241#undef ARGS 242#undef LOCAL_VARS 243 244 245 246/** 247 * Code to run the pipeline on a fairly arbitrary collection of vertices. 248 * For drawing indexed primitives. 249 * 250 * Vertex headers must be pre-initialized with the 251 * UNDEFINED_VERTEX_ID, this code will cause that id to become 252 * overwritten, so it may have to be reset if there is the intention 253 * to reuse the vertices. 254 * 255 * This code provides a callback to reset the vertex id's which the 256 * draw_vbuf.c code uses when it has to perform a flush. 257 */ 258void draw_pipeline_run( struct draw_context *draw, 259 unsigned prim, 260 struct vertex_header *vertices, 261 unsigned vertex_count, 262 unsigned stride, 263 const ushort *elts, 264 unsigned count ) 265{ 266 char *verts = (char *)vertices; 267 268 draw->pipeline.verts = verts; 269 draw->pipeline.vertex_stride = stride; 270 draw->pipeline.vertex_count = vertex_count; 271 272 pipe_run(draw, prim, vertices, stride, elts, count); 273 274 draw->pipeline.verts = NULL; 275 draw->pipeline.vertex_count = 0; 276} 277 278 279 280/* 281 * Set up macros for draw_pt_decompose.h template code. 282 * This code is for non-indexed (aka linear) rendering (no elts). 283 */ 284 285/* emit first quad vertex as first vertex in triangles */ 286#define QUAD_FIRST_PV(i0,i1,i2,i3) \ 287 do_triangle( draw, \ 288 ( DRAW_PIPE_RESET_STIPPLE | \ 289 DRAW_PIPE_EDGE_FLAG_0 | \ 290 DRAW_PIPE_EDGE_FLAG_1 ), \ 291 verts + stride * ((i0) & ~DRAW_PIPE_FLAG_MASK), \ 292 verts + stride * (i1), \ 293 verts + stride * (i2)); \ 294 do_triangle( draw, \ 295 ( DRAW_PIPE_EDGE_FLAG_1 | \ 296 DRAW_PIPE_EDGE_FLAG_2 ), \ 297 verts + stride * ((i0) & ~DRAW_PIPE_FLAG_MASK), \ 298 verts + stride * (i2), \ 299 verts + stride * (i3)) 300 301/* emit last quad vertex as last vertex in triangles */ 302#define QUAD_LAST_PV(i0,i1,i2,i3) \ 303 do_triangle( draw, \ 304 ( DRAW_PIPE_RESET_STIPPLE | \ 305 DRAW_PIPE_EDGE_FLAG_0 | \ 306 DRAW_PIPE_EDGE_FLAG_2 ), \ 307 verts + stride * ((i0) & ~DRAW_PIPE_FLAG_MASK), \ 308 verts + stride * (i1), \ 309 verts + stride * (i3)); \ 310 do_triangle( draw, \ 311 ( DRAW_PIPE_EDGE_FLAG_0 | \ 312 DRAW_PIPE_EDGE_FLAG_1 ), \ 313 verts + stride * ((i1) & ~DRAW_PIPE_FLAG_MASK), \ 314 verts + stride * (i2), \ 315 verts + stride * (i3)) 316 317#define TRIANGLE(flags,i0,i1,i2) \ 318 do_triangle( draw, \ 319 flags, /* flags */ \ 320 verts + stride * ((i0) & ~DRAW_PIPE_FLAG_MASK), \ 321 verts + stride * (i1), \ 322 verts + stride * (i2)) 323 324#define LINE(flags,i0,i1) \ 325 do_line( draw, \ 326 flags, \ 327 verts + stride * ((i0) & ~DRAW_PIPE_FLAG_MASK), \ 328 verts + stride * (i1)) 329 330#define POINT(i0) \ 331 do_point( draw, \ 332 verts + stride * i0 ) 333 334#define FUNC pipe_run_linear 335#define ARGS \ 336 struct draw_context *draw, \ 337 unsigned prim, \ 338 struct vertex_header *vertices, \ 339 unsigned stride 340 341#define LOCAL_VARS \ 342 char *verts = (char *)vertices; \ 343 boolean flatfirst = (draw->rasterizer->flatshade && \ 344 draw->rasterizer->flatshade_first); \ 345 unsigned i; \ 346 ushort flags 347 348#define FLUSH 349 350#include "draw_pt_decompose.h" 351 352 353/* 354 * For drawing non-indexed primitives. 355 */ 356void draw_pipeline_run_linear( struct draw_context *draw, 357 unsigned prim, 358 struct vertex_header *vertices, 359 unsigned count, 360 unsigned stride ) 361{ 362 char *verts = (char *)vertices; 363 draw->pipeline.verts = verts; 364 draw->pipeline.vertex_stride = stride; 365 draw->pipeline.vertex_count = count; 366 367 pipe_run_linear(draw, prim, vertices, stride, count); 368 369 draw->pipeline.verts = NULL; 370 draw->pipeline.vertex_count = 0; 371} 372 373 374void draw_pipeline_flush( struct draw_context *draw, 375 unsigned flags ) 376{ 377 draw->pipeline.first->flush( draw->pipeline.first, flags ); 378 draw->pipeline.first = draw->pipeline.validate; 379} 380