1 /**************************************************************************
3 * Copyright 2020 Red Hat.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24 **************************************************************************/
25 #include "draw_tess.h"
27 #include "draw_llvm.h"
30 #include "tessellator/p_tessellator.h"
31 #include "nir/nir_to_tgsi_info.h"
32 #include "util/u_prim.h"
33 #include "util/u_math.h"
34 #include "util/u_memory.h"
37 draw_tes_get_input_index(int semantic
, int index
,
38 const struct tgsi_shader_info
*input_info
)
41 const ubyte
*input_semantic_names
= input_info
->output_semantic_name
;
42 const ubyte
*input_semantic_indices
= input_info
->output_semantic_index
;
43 for (i
= 0; i
< PIPE_MAX_SHADER_OUTPUTS
; i
++) {
44 if (input_semantic_names
[i
] == semantic
&&
45 input_semantic_indices
[i
] == index
)
52 #define DEBUG_INPUTS 0
54 llvm_fetch_tcs_input(struct draw_tess_ctrl_shader
*shader
,
55 const struct draw_prim_info
*input_prim_info
,
57 unsigned num_vertices
)
59 const float (*input_ptr
)[4];
60 float (*input_data
)[32][NUM_TCS_INPUTS
][TGSI_NUM_CHANNELS
] = &shader
->tcs_input
->data
;
63 unsigned input_vertex_stride
= shader
->input_vertex_stride
;
65 input_ptr
= shader
->input
;
66 for (i
= 0; i
< num_vertices
; i
++) {
67 const float (*input
)[4];
68 int vertex_idx
= prim_id
* num_vertices
+ i
;
69 if (input_prim_info
->linear
== FALSE
)
70 vertex_idx
= input_prim_info
->elts
[vertex_idx
];
72 debug_printf("%d) tcs vertex index = %d (prim idx = %d)\n",
75 input
= (const float (*)[4])((const char *)input_ptr
+ (vertex_idx
* input_vertex_stride
));
76 for (slot
= 0, vs_slot
= 0; slot
< shader
->info
.num_inputs
; ++slot
) {
77 vs_slot
= draw_tes_get_input_index(
78 shader
->info
.input_semantic_name
[slot
],
79 shader
->info
.input_semantic_index
[slot
],
82 debug_printf("VS/TCS signature mismatch!\n");
83 (*input_data
)[i
][slot
][0] = 0;
84 (*input_data
)[i
][slot
][1] = 0;
85 (*input_data
)[i
][slot
][2] = 0;
86 (*input_data
)[i
][slot
][3] = 0;
88 (*input_data
)[i
][slot
][0] = input
[vs_slot
][0];
89 (*input_data
)[i
][slot
][1] = input
[vs_slot
][1];
90 (*input_data
)[i
][slot
][2] = input
[vs_slot
][2];
91 (*input_data
)[i
][slot
][3] = input
[vs_slot
][3];
93 debug_printf("\t\t%p = %f %f %f %f\n", &(*input_data
)[i
][slot
][0],
94 (*input_data
)[i
][slot
][0],
95 (*input_data
)[i
][slot
][1],
96 (*input_data
)[i
][slot
][2],
97 (*input_data
)[i
][slot
][3]);
105 #define DEBUG_OUTPUTS 0
107 llvm_store_tcs_output(struct draw_tess_ctrl_shader
*shader
,
109 struct draw_vertex_info
*output_verts
,
112 float (*output_ptr
)[4];
113 float (*output_data
)[32][PIPE_MAX_SHADER_INPUTS
][TGSI_NUM_CHANNELS
] = &shader
->tcs_output
->data
;
115 unsigned num_vertices
= shader
->vertices_out
;
117 char *output
= (char *)output_verts
->verts
->data
;
118 output
+= vert_start
* output_verts
->stride
;
120 for (i
= 0; i
< num_vertices
; i
++) {
123 debug_printf("%d) tcs store vertex index = %d (prim idx = %d)\n",
126 output_ptr
= (float(*)[4])(output
+ (i
* output_verts
->stride
));
128 for (slot
= 0; slot
< shader
->info
.num_outputs
; ++slot
) {
129 output_ptr
[slot
][0] = (*output_data
)[i
][slot
][0];
130 output_ptr
[slot
][1] = (*output_data
)[i
][slot
][1];
131 output_ptr
[slot
][2] = (*output_data
)[i
][slot
][2];
132 output_ptr
[slot
][3] = (*output_data
)[i
][slot
][3];
134 debug_printf("\t\t%p = %f %f %f %f\n",
135 &output_ptr
[slot
][0],
139 output_ptr
[slot
][3]);
146 llvm_tcs_run(struct draw_tess_ctrl_shader
*shader
, uint32_t prim_id
)
148 shader
->current_variant
->jit_func(shader
->jit_context
, shader
->tcs_input
->data
, shader
->tcs_output
->data
, prim_id
,
149 shader
->draw
->pt
.vertices_per_patch
);
154 * Execute tess ctrl shader.
156 int draw_tess_ctrl_shader_run(struct draw_tess_ctrl_shader
*shader
,
157 const void *constants
[PIPE_MAX_CONSTANT_BUFFERS
],
158 const unsigned constants_size
[PIPE_MAX_CONSTANT_BUFFERS
],
159 const struct draw_vertex_info
*input_verts
,
160 const struct draw_prim_info
*input_prim
,
161 const struct tgsi_shader_info
*input_info
,
162 struct draw_vertex_info
*output_verts
,
163 struct draw_prim_info
*output_prims
)
165 const float (*input
)[4] = (const float (*)[4])input_verts
->verts
->data
;
166 unsigned num_outputs
= draw_total_tcs_outputs(shader
->draw
);
167 unsigned input_stride
= input_verts
->vertex_size
;
168 unsigned vertex_size
= sizeof(struct vertex_header
) + num_outputs
* 4 * sizeof(float);
169 unsigned num_patches
= input_prim
->count
/ shader
->draw
->pt
.vertices_per_patch
;
171 output_verts
->vertex_size
= vertex_size
;
172 output_verts
->stride
= output_verts
->vertex_size
;
173 output_verts
->verts
= NULL
;
174 output_verts
->count
= 0;
175 shader
->input
= input
;
176 shader
->input_vertex_stride
= input_stride
;
177 shader
->input_info
= input_info
;
179 output_prims
->linear
= TRUE
;
180 output_prims
->start
= 0;
181 output_prims
->elts
= NULL
;
182 output_prims
->count
= 0;
183 output_prims
->prim
= PIPE_PRIM_PATCHES
;
184 output_prims
->flags
= 0;
185 output_prims
->primitive_lengths
= NULL
;
186 output_prims
->primitive_count
= 0;
188 #ifdef LLVM_AVAILABLE
189 for (unsigned i
= 0; i
< num_patches
; i
++) {
190 uint32_t vert_start
= output_verts
->count
;
192 output_verts
->count
+= shader
->vertices_out
;
194 llvm_fetch_tcs_input(shader
, input_prim
, i
, shader
->draw
->pt
.vertices_per_patch
);
196 llvm_tcs_run(shader
, i
);
198 uint32_t old_verts
= util_align_npot(vert_start
, 16);
199 uint32_t new_verts
= util_align_npot(output_verts
->count
, 16);
200 uint32_t old_size
= output_verts
->vertex_size
* old_verts
;
201 uint32_t new_size
= output_verts
->vertex_size
* new_verts
;
202 output_verts
->verts
= REALLOC(output_verts
->verts
, old_size
, new_size
);
204 llvm_store_tcs_output(shader
, i
, output_verts
, vert_start
);
208 output_prims
->primitive_count
= num_patches
;
212 #ifdef LLVM_AVAILABLE
213 #define DEBUG_INPUTS 0
215 llvm_fetch_tes_input(struct draw_tess_eval_shader
*shader
,
216 const struct draw_prim_info
*input_prim_info
,
218 unsigned num_vertices
)
220 const float (*input_ptr
)[4];
221 float (*input_data
)[32][PIPE_MAX_SHADER_INPUTS
][TGSI_NUM_CHANNELS
] = &shader
->tes_input
->data
;
224 unsigned input_vertex_stride
= shader
->input_vertex_stride
;
226 input_ptr
= shader
->input
;
227 for (i
= 0; i
< num_vertices
; i
++) {
228 const float (*input
)[4];
229 int vertex_idx
= prim_id
* num_vertices
+ i
;
231 if (input_prim_info
->linear
== FALSE
)
232 vertex_idx
= input_prim_info
->elts
[vertex_idx
];
234 debug_printf("%d) tes vertex index = %d (prim idx = %d)\n",
237 input
= (const float (*)[4])((const char *)input_ptr
+ (vertex_idx
* input_vertex_stride
));
238 for (slot
= 0, vs_slot
= 0; slot
< shader
->info
.num_inputs
; ++slot
) {
239 vs_slot
= draw_tes_get_input_index(
240 shader
->info
.input_semantic_name
[slot
],
241 shader
->info
.input_semantic_index
[slot
],
244 debug_printf("TCS/TES signature mismatch!\n");
245 (*input_data
)[i
][slot
][0] = 0;
246 (*input_data
)[i
][slot
][1] = 0;
247 (*input_data
)[i
][slot
][2] = 0;
248 (*input_data
)[i
][slot
][3] = 0;
250 (*input_data
)[i
][slot
][0] = input
[vs_slot
][0];
251 (*input_data
)[i
][slot
][1] = input
[vs_slot
][1];
252 (*input_data
)[i
][slot
][2] = input
[vs_slot
][2];
253 (*input_data
)[i
][slot
][3] = input
[vs_slot
][3];
255 debug_printf("\t\t%p = %f %f %f %f\n",
257 (*input_data
)[i
][slot
][0],
258 (*input_data
)[i
][slot
][1],
259 (*input_data
)[i
][slot
][2],
260 (*input_data
)[i
][slot
][3]);
269 llvm_fetch_tess_factors(struct draw_tess_eval_shader
*shader
,
271 unsigned num_vertices
,
272 struct pipe_tessellation_factors
*factors
)
274 int outer_slot
= draw_tes_get_input_index(
275 TGSI_SEMANTIC_TESSOUTER
, 0, shader
->input_info
);
276 int inner_slot
= draw_tes_get_input_index(
277 TGSI_SEMANTIC_TESSINNER
, 0, shader
->input_info
);
278 const float (*input_ptr
)[4];
279 const float (*input
)[4];
280 input_ptr
= shader
->input
;
281 input
= (const float (*)[4])((const char *)input_ptr
+ ((patch_id
* num_vertices
) * shader
->input_vertex_stride
));
283 if (outer_slot
!= -1) {
284 for (unsigned i
= 0; i
< 4; i
++)
285 factors
->outer_tf
[i
] = input
[outer_slot
][i
];
287 for (unsigned i
= 0; i
< 4; i
++)
288 factors
->outer_tf
[i
] = shader
->draw
->default_outer_tess_level
[i
];
290 if (inner_slot
!= -1) {
291 for (unsigned i
= 0; i
< 2; i
++)
292 factors
->inner_tf
[i
] = input
[inner_slot
][i
];
294 for (unsigned i
= 0; i
< 2; i
++)
295 factors
->inner_tf
[i
] = shader
->draw
->default_inner_tess_level
[i
];
300 llvm_tes_run(struct draw_tess_eval_shader
*shader
,
302 struct pipe_tessellator_data
*tess_data
,
303 struct pipe_tessellation_factors
*tess_factors
,
304 struct vertex_header
*output
)
306 shader
->current_variant
->jit_func(shader
->jit_context
, shader
->tes_input
->data
, output
, prim_id
,
307 tess_data
->num_domain_points
, tess_data
->domain_points_u
, tess_data
->domain_points_v
,
308 tess_factors
->outer_tf
, tess_factors
->inner_tf
);
313 * Execute tess eval shader.
315 int draw_tess_eval_shader_run(struct draw_tess_eval_shader
*shader
,
316 const void *constants
[PIPE_MAX_CONSTANT_BUFFERS
],
317 const unsigned constants_size
[PIPE_MAX_CONSTANT_BUFFERS
],
318 unsigned num_input_vertices_per_patch
,
319 const struct draw_vertex_info
*input_verts
,
320 const struct draw_prim_info
*input_prim
,
321 const struct tgsi_shader_info
*input_info
,
322 struct draw_vertex_info
*output_verts
,
323 struct draw_prim_info
*output_prims
,
326 const float (*input
)[4] = (const float (*)[4])input_verts
->verts
->data
;
327 unsigned num_outputs
= draw_total_tes_outputs(shader
->draw
);
328 unsigned input_stride
= input_verts
->vertex_size
;
329 unsigned vertex_size
= sizeof(struct vertex_header
) + num_outputs
* 4 * sizeof(float);
331 output_verts
->vertex_size
= vertex_size
;
332 output_verts
->stride
= output_verts
->vertex_size
;
333 output_verts
->count
= 0;
334 output_verts
->verts
= NULL
;
336 output_prims
->linear
= FALSE
;
337 output_prims
->start
= 0;
338 output_prims
->elts
= NULL
;
339 output_prims
->count
= 0;
340 output_prims
->prim
= get_tes_output_prim(shader
);
341 output_prims
->flags
= 0;
342 output_prims
->primitive_lengths
= NULL
;
343 output_prims
->primitive_count
= 0;
345 shader
->input
= input
;
346 shader
->input_vertex_stride
= input_stride
;
347 shader
->input_info
= input_info
;
349 #ifdef LLVM_AVAILABLE
350 struct pipe_tessellation_factors factors
;
351 struct pipe_tessellator_data data
= { 0 };
352 struct pipe_tessellator
*ptess
= p_tess_init(shader
->prim_mode
,
354 !shader
->vertex_order_cw
,
356 for (unsigned i
= 0; i
< input_prim
->primitive_count
; i
++) {
357 uint32_t vert_start
= output_verts
->count
;
358 uint32_t prim_start
= output_prims
->primitive_count
;
359 uint32_t elt_start
= output_prims
->count
;
361 llvm_fetch_tess_factors(shader
, i
, num_input_vertices_per_patch
, &factors
);
363 /* tessellate with the factors for this primitive */
364 p_tessellate(ptess
, &factors
, &data
);
366 if (data
.num_domain_points
== 0)
369 uint32_t old_verts
= vert_start
;
370 uint32_t new_verts
= vert_start
+ util_align_npot(data
.num_domain_points
, 4);
371 uint32_t old_size
= output_verts
->vertex_size
* old_verts
;
372 uint32_t new_size
= output_verts
->vertex_size
* new_verts
;
373 output_verts
->verts
= REALLOC(output_verts
->verts
, old_size
, new_size
);
375 output_verts
->count
+= data
.num_domain_points
;
377 output_prims
->count
+= data
.num_indices
;
378 elts
= REALLOC(elts
, elt_start
* sizeof(uint16_t),
379 output_prims
->count
* sizeof(uint16_t));
381 for (unsigned i
= 0; i
< data
.num_indices
; i
++)
382 elts
[elt_start
+ i
] = vert_start
+ data
.indices
[i
];
384 llvm_fetch_tes_input(shader
, input_prim
, i
, num_input_vertices_per_patch
);
385 /* run once per primitive? */
386 char *output
= (char *)output_verts
->verts
;
387 output
+= vert_start
* vertex_size
;
388 llvm_tes_run(shader
, i
, &data
, &factors
, (struct vertex_header
*)output
);
390 uint32_t prim_len
= u_prim_vertex_count(output_prims
->prim
)->min
;
391 output_prims
->primitive_count
+= data
.num_indices
/ prim_len
;
392 output_prims
->primitive_lengths
= REALLOC(output_prims
->primitive_lengths
, prim_start
* sizeof(uint32_t),
393 output_prims
->primitive_count
* sizeof(uint32_t));
394 for (unsigned i
= prim_start
; i
< output_prims
->primitive_count
; i
++) {
395 output_prims
->primitive_lengths
[i
] = prim_len
;
398 p_tess_destroy(ptess
);
402 output_prims
->elts
= elts
;
406 struct draw_tess_ctrl_shader
*
407 draw_create_tess_ctrl_shader(struct draw_context
*draw
,
408 const struct pipe_shader_state
*state
)
410 #ifdef LLVM_AVAILABLE
411 boolean use_llvm
= draw
->llvm
!= NULL
;
412 struct llvm_tess_ctrl_shader
*llvm_tcs
= NULL
;
414 struct draw_tess_ctrl_shader
*tcs
;
416 #ifdef LLVM_AVAILABLE
418 llvm_tcs
= CALLOC_STRUCT(llvm_tess_ctrl_shader
);
423 tcs
= &llvm_tcs
->base
;
425 make_empty_list(&llvm_tcs
->variants
);
429 tcs
= CALLOC_STRUCT(draw_tess_ctrl_shader
);
438 nir_tgsi_scan_shader(state
->ir
.nir
, &tcs
->info
, true);
440 tcs
->vector_length
= 4;
441 tcs
->vertices_out
= tcs
->info
.properties
[TGSI_PROPERTY_TCS_VERTICES_OUT
];
442 #ifdef LLVM_AVAILABLE
445 tcs
->tcs_input
= align_malloc(sizeof(struct draw_tcs_inputs
), 16);
446 memset(tcs
->tcs_input
, 0, sizeof(struct draw_tcs_inputs
));
448 tcs
->tcs_output
= align_malloc(sizeof(struct draw_tcs_outputs
), 16);
449 memset(tcs
->tcs_output
, 0, sizeof(struct draw_tcs_outputs
));
451 tcs
->jit_context
= &draw
->llvm
->tcs_jit_context
;
452 llvm_tcs
->variant_key_size
=
453 draw_tcs_llvm_variant_key_size(
454 MAX2(tcs
->info
.file_max
[TGSI_FILE_SAMPLER
]+1,
455 tcs
->info
.file_max
[TGSI_FILE_SAMPLER_VIEW
]+1),
456 tcs
->info
.file_max
[TGSI_FILE_IMAGE
]+1);
462 void draw_bind_tess_ctrl_shader(struct draw_context
*draw
,
463 struct draw_tess_ctrl_shader
*dtcs
)
465 draw_do_flush(draw
, DRAW_FLUSH_STATE_CHANGE
);
467 draw
->tcs
.tess_ctrl_shader
= dtcs
;
469 draw
->tcs
.tess_ctrl_shader
= NULL
;
473 void draw_delete_tess_ctrl_shader(struct draw_context
*draw
,
474 struct draw_tess_ctrl_shader
*dtcs
)
479 #ifdef LLVM_AVAILABLE
481 struct llvm_tess_ctrl_shader
*shader
= llvm_tess_ctrl_shader(dtcs
);
483 struct draw_tcs_llvm_variant_list_item
*li
;
485 li
= first_elem(&shader
->variants
);
486 while(!at_end(&shader
->variants
, li
)) {
487 struct draw_tcs_llvm_variant_list_item
*next
= next_elem(li
);
488 draw_tcs_llvm_destroy_variant(li
->base
);
492 assert(shader
->variants_cached
== 0);
498 #ifdef LLVM_AVAILABLE
499 void draw_tcs_set_current_variant(struct draw_tess_ctrl_shader
*shader
,
500 struct draw_tcs_llvm_variant
*variant
)
502 shader
->current_variant
= variant
;
506 struct draw_tess_eval_shader
*
507 draw_create_tess_eval_shader(struct draw_context
*draw
,
508 const struct pipe_shader_state
*state
)
510 #ifdef LLVM_AVAILABLE
511 boolean use_llvm
= draw
->llvm
!= NULL
;
512 struct llvm_tess_eval_shader
*llvm_tes
= NULL
;
514 struct draw_tess_eval_shader
*tes
;
516 #ifdef LLVM_AVAILABLE
518 llvm_tes
= CALLOC_STRUCT(llvm_tess_eval_shader
);
523 tes
= &llvm_tes
->base
;
524 make_empty_list(&llvm_tes
->variants
);
528 tes
= CALLOC_STRUCT(draw_tess_eval_shader
);
537 nir_tgsi_scan_shader(state
->ir
.nir
, &tes
->info
, true);
539 tes
->prim_mode
= tes
->info
.properties
[TGSI_PROPERTY_TES_PRIM_MODE
];
540 tes
->spacing
= tes
->info
.properties
[TGSI_PROPERTY_TES_SPACING
];
541 tes
->vertex_order_cw
= tes
->info
.properties
[TGSI_PROPERTY_TES_VERTEX_ORDER_CW
];
542 tes
->point_mode
= tes
->info
.properties
[TGSI_PROPERTY_TES_POINT_MODE
];
544 tes
->vector_length
= 4;
546 tes
->position_output
= -1;
547 for (unsigned i
= 0; i
< tes
->info
.num_outputs
; i
++) {
548 if (tes
->info
.output_semantic_name
[i
] == TGSI_SEMANTIC_POSITION
&&
549 tes
->info
.output_semantic_index
[i
] == 0)
550 tes
->position_output
= i
;
551 if (tes
->info
.output_semantic_name
[i
] == TGSI_SEMANTIC_VIEWPORT_INDEX
)
552 tes
->viewport_index_output
= i
;
553 if (tes
->info
.output_semantic_name
[i
] == TGSI_SEMANTIC_CLIPDIST
) {
554 debug_assert(tes
->info
.output_semantic_index
[i
] <
555 PIPE_MAX_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT
);
556 tes
->ccdistance_output
[tes
->info
.output_semantic_index
[i
]] = i
;
560 #ifdef LLVM_AVAILABLE
563 tes
->tes_input
= align_malloc(sizeof(struct draw_tes_inputs
), 16);
564 memset(tes
->tes_input
, 0, sizeof(struct draw_tes_inputs
));
566 tes
->jit_context
= &draw
->llvm
->tes_jit_context
;
567 llvm_tes
->variant_key_size
=
568 draw_tes_llvm_variant_key_size(
569 MAX2(tes
->info
.file_max
[TGSI_FILE_SAMPLER
]+1,
570 tes
->info
.file_max
[TGSI_FILE_SAMPLER_VIEW
]+1),
571 tes
->info
.file_max
[TGSI_FILE_IMAGE
]+1);
577 void draw_bind_tess_eval_shader(struct draw_context
*draw
,
578 struct draw_tess_eval_shader
*dtes
)
580 draw_do_flush(draw
, DRAW_FLUSH_STATE_CHANGE
);
582 draw
->tes
.tess_eval_shader
= dtes
;
583 draw
->tes
.position_output
= dtes
->position_output
;
585 draw
->tes
.tess_eval_shader
= NULL
;
589 void draw_delete_tess_eval_shader(struct draw_context
*draw
,
590 struct draw_tess_eval_shader
*dtes
)
595 #ifdef LLVM_AVAILABLE
597 struct llvm_tess_eval_shader
*shader
= llvm_tess_eval_shader(dtes
);
598 struct draw_tes_llvm_variant_list_item
*li
;
600 li
= first_elem(&shader
->variants
);
601 while(!at_end(&shader
->variants
, li
)) {
602 struct draw_tes_llvm_variant_list_item
*next
= next_elem(li
);
603 draw_tes_llvm_destroy_variant(li
->base
);
607 assert(shader
->variants_cached
== 0);
608 align_free(dtes
->tes_input
);
614 #ifdef LLVM_AVAILABLE
615 void draw_tes_set_current_variant(struct draw_tess_eval_shader
*shader
,
616 struct draw_tes_llvm_variant
*variant
)
618 shader
->current_variant
= variant
;
622 enum pipe_prim_type
get_tes_output_prim(struct draw_tess_eval_shader
*shader
)
624 if (shader
->point_mode
)
625 return PIPE_PRIM_POINTS
;
626 else if (shader
->prim_mode
== PIPE_PRIM_LINES
)
627 return PIPE_PRIM_LINES
;
629 return PIPE_PRIM_TRIANGLES
;