1 /************************************************************************** 2 * 3 * Copyright 2007 VMware, Inc. 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 VMWARE 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 <keithw@vmware.com> 31 */ 32 33 #ifndef DRAW_PT_H 34 #define DRAW_PT_H 35 36 #include "pipe/p_compiler.h" 37 38 struct draw_pt_middle_end; 39 struct draw_context; 40 struct draw_prim_info; 41 struct draw_vertex_info; 42 43 44 #define PT_SHADE 0x1 45 #define PT_CLIPTEST 0x2 46 #define PT_PIPELINE 0x4 47 #define PT_MAX_MIDDLE 0x8 48 49 50 /* The "front end" - prepare sets of fetch, draw elements for the 51 * middle end. 52 * 53 * The fetch elements are indices to the vertices. The draw elements are 54 * indices to the fetched vertices. When both arrays of elements are both 55 * linear, middle->run_linear is called; When only the fetch elements are 56 * linear, middle->run_linear_elts is called; Otherwise, middle->run is 57 * called. 58 * 59 * When the number of the draw elements exceeds max_vertex of the middle end, 60 * the draw elements (as well as the fetch elements) are splitted and the 61 * middle end is called multiple times. 62 * 63 * Currenly there is: 64 * - vsplit - catchall implementation, splits big prims 65 */ 66 struct draw_pt_front_end { 67 void (*prepare)( struct draw_pt_front_end *, 68 unsigned prim, 69 struct draw_pt_middle_end *, 70 unsigned opt ); 71 72 void (*run)( struct draw_pt_front_end *, 73 unsigned start, 74 unsigned count ); 75 76 void (*flush)( struct draw_pt_front_end *, unsigned flags ); 77 void (*destroy)( struct draw_pt_front_end * ); 78 }; 79 80 81 /* The "middle end" - prepares actual hardware vertices for the 82 * hardware backend. 83 * 84 * prim_flags is as defined by pipe_draw_info::flags. 85 * 86 * Currently two versions of this: 87 * - fetch, vertex shade, cliptest, prim-pipeline 88 * - fetch, emit (ie passthrough) 89 */ 90 struct draw_pt_middle_end { 91 void (*prepare)( struct draw_pt_middle_end *, 92 unsigned prim, 93 unsigned opt, 94 unsigned *max_vertices ); 95 96 /** 97 * Bind/update parameter state such as constants, viewport dims 98 * and clip planes. Basically, stuff which isn't "baked" into the 99 * shader or pipeline state. 100 */ 101 void (*bind_parameters)(struct draw_pt_middle_end *); 102 103 void (*run)( struct draw_pt_middle_end *, 104 const unsigned *fetch_elts, 105 unsigned fetch_count, 106 const ushort *draw_elts, 107 unsigned draw_count, 108 unsigned prim_flags ); 109 110 void (*run_linear)(struct draw_pt_middle_end *, 111 unsigned start, 112 unsigned count, 113 unsigned prim_flags ); 114 115 /* Transform all vertices in a linear range and then draw them with 116 * the supplied element list. May fail and return FALSE. 117 */ 118 boolean (*run_linear_elts)( struct draw_pt_middle_end *, 119 unsigned fetch_start, 120 unsigned fetch_count, 121 const ushort *draw_elts, 122 unsigned draw_count, 123 unsigned prim_flags ); 124 125 int (*get_max_vertex_count)( struct draw_pt_middle_end * ); 126 127 void (*finish)( struct draw_pt_middle_end * ); 128 void (*destroy)( struct draw_pt_middle_end * ); 129 }; 130 131 132 /* The "back end" - supplied by the driver, defined in draw_vbuf.h. 133 */ 134 struct vbuf_render; 135 struct vertex_header; 136 137 138 /* Frontends: 139 * 140 * Currently only the general-purpose vsplit implementation. 141 */ 142 struct draw_pt_front_end *draw_pt_vsplit(struct draw_context *draw); 143 144 145 /* Middle-ends: 146 * 147 * Currently one general-purpose case which can do all possibilities, 148 * at the slight expense of creating a vertex_header in some cases 149 * unecessarily. 150 * 151 * The special case fetch_emit code avoids pipeline vertices 152 * altogether and builds hardware vertices directly from API 153 * vertex_elements. 154 */ 155 struct draw_pt_middle_end *draw_pt_fetch_emit( struct draw_context *draw ); 156 struct draw_pt_middle_end *draw_pt_middle_fse( struct draw_context *draw ); 157 struct draw_pt_middle_end *draw_pt_fetch_pipeline_or_emit(struct draw_context *draw); 158 struct draw_pt_middle_end *draw_pt_fetch_pipeline_or_emit_llvm(struct draw_context *draw); 159 160 161 162 /******************************************************************************* 163 * HW vertex emit: 164 */ 165 struct pt_emit; 166 167 void draw_pt_emit_prepare( struct pt_emit *emit, 168 unsigned prim, 169 unsigned *max_vertices ); 170 171 void draw_pt_emit( struct pt_emit *emit, 172 const struct draw_vertex_info *vert_info, 173 const struct draw_prim_info *prim_info); 174 175 void draw_pt_emit_linear( struct pt_emit *emit, 176 const struct draw_vertex_info *vert_info, 177 const struct draw_prim_info *prim_info); 178 179 void draw_pt_emit_destroy( struct pt_emit *emit ); 180 181 struct pt_emit *draw_pt_emit_create( struct draw_context *draw ); 182 183 /******************************************************************************* 184 * HW stream output emit: 185 */ 186 struct pt_so_emit; 187 188 void draw_pt_so_emit_prepare(struct pt_so_emit *emit, boolean use_pre_clip_pos); 189 190 void draw_pt_so_emit( struct pt_so_emit *emit, 191 const struct draw_vertex_info *vert_info, 192 const struct draw_prim_info *prim_info ); 193 194 void draw_pt_so_emit_destroy( struct pt_so_emit *emit ); 195 196 struct pt_so_emit *draw_pt_so_emit_create( struct draw_context *draw ); 197 198 /******************************************************************************* 199 * API vertex fetch: 200 */ 201 202 struct pt_fetch; 203 void draw_pt_fetch_prepare( struct pt_fetch *fetch, 204 unsigned vertex_input_count, 205 unsigned vertex_size, 206 unsigned instance_id_index ); 207 208 void draw_pt_fetch_run( struct pt_fetch *fetch, 209 const unsigned *elts, 210 unsigned count, 211 char *verts ); 212 213 void draw_pt_fetch_run_linear( struct pt_fetch *fetch, 214 unsigned start, 215 unsigned count, 216 char *verts ); 217 218 void draw_pt_fetch_destroy( struct pt_fetch *fetch ); 219 220 struct pt_fetch *draw_pt_fetch_create( struct draw_context *draw ); 221 222 /******************************************************************************* 223 * Post-VS: cliptest, rhw, viewport 224 */ 225 struct pt_post_vs; 226 227 boolean draw_pt_post_vs_run( struct pt_post_vs *pvs, 228 struct draw_vertex_info *info, 229 const struct draw_prim_info *prim_info ); 230 231 void draw_pt_post_vs_prepare( struct pt_post_vs *pvs, 232 boolean clip_xy, 233 boolean clip_z, 234 boolean clip_user, 235 boolean guard_band, 236 boolean bypass_viewport, 237 boolean clip_halfz, 238 boolean need_edgeflags ); 239 240 struct pt_post_vs *draw_pt_post_vs_create( struct draw_context *draw ); 241 242 void draw_pt_post_vs_destroy( struct pt_post_vs *pvs ); 243 244 245 /******************************************************************************* 246 * Utils: 247 */ 248 void draw_pt_split_prim(unsigned prim, unsigned *first, unsigned *incr); 249 unsigned draw_pt_trim_count(unsigned count, unsigned first, unsigned incr); 250 251 252 #endif 253