1 /* 2 * Copyright 2011 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 */ 23 24 /** 25 * \file lower_distance.cpp 26 * 27 * This pass accounts for the difference between the way 28 * gl_ClipDistance is declared in standard GLSL (as an array of 29 * floats), and the way it is frequently implemented in hardware (as 30 * a pair of vec4s, with four clip distances packed into each). 31 * 32 * The declaration of gl_ClipDistance is replaced with a declaration 33 * of gl_ClipDistanceMESA, and any references to gl_ClipDistance are 34 * translated to refer to gl_ClipDistanceMESA with the appropriate 35 * swizzling of array indices. For instance: 36 * 37 * gl_ClipDistance[i] 38 * 39 * is translated into: 40 * 41 * gl_ClipDistanceMESA[i>>2][i&3] 42 * 43 * Since some hardware may not internally represent gl_ClipDistance as a pair 44 * of vec4's, this lowering pass is optional. To enable it, set the 45 * LowerCombinedClipCullDistance flag in gl_shader_compiler_options to true. 46 */ 47 48 #include "main/macros.h" 49 #include "glsl_symbol_table.h" 50 #include "ir_rvalue_visitor.h" 51 #include "ir.h" 52 #include "program/prog_instruction.h" /* For WRITEMASK_* */ 53 54 #define GLSL_CLIP_VAR_NAME "gl_ClipDistanceMESA" 55 56 namespace { 57 58 class lower_distance_visitor : public ir_rvalue_visitor { 59 public: 60 explicit lower_distance_visitor(gl_shader_stage shader_stage, 61 const char *in_name, int total_size, 62 int offset) 63 : progress(false), old_distance_out_var(NULL), 64 old_distance_in_var(NULL), new_distance_out_var(NULL), 65 new_distance_in_var(NULL), shader_stage(shader_stage), 66 in_name(in_name), total_size(total_size), offset(offset) 67 { 68 } 69 70 explicit lower_distance_visitor(gl_shader_stage shader_stage, 71 const char *in_name, 72 const lower_distance_visitor *orig, 73 int offset) 74 : progress(false), 75 old_distance_out_var(NULL), 76 old_distance_in_var(NULL), 77 new_distance_out_var(orig->new_distance_out_var), 78 new_distance_in_var(orig->new_distance_in_var), 79 shader_stage(shader_stage), 80 in_name(in_name), 81 total_size(orig->total_size), 82 offset(offset) 83 { 84 } 85 86 virtual ir_visitor_status visit(ir_variable *); 87 void create_indices(ir_rvalue*, ir_rvalue *&, ir_rvalue *&); 88 bool is_distance_vec8(ir_rvalue *ir); 89 ir_rvalue *lower_distance_vec8(ir_rvalue *ir); 90 virtual ir_visitor_status visit_leave(ir_assignment *); 91 void visit_new_assignment(ir_assignment *ir); 92 virtual ir_visitor_status visit_leave(ir_call *); 93 94 virtual void handle_rvalue(ir_rvalue **rvalue); 95 96 void fix_lhs(ir_assignment *); 97 98 bool progress; 99 100 /** 101 * Pointer to the declaration of gl_ClipDistance, if found. 102 * 103 * Note: 104 * 105 * - the in_var is for geometry and both tessellation shader inputs only. 106 * 107 * - since gl_ClipDistance is available in tessellation control, 108 * tessellation evaluation and geometry shaders as both an input 109 * and an output, it's possible for both old_distance_out_var 110 * and old_distance_in_var to be non-null. 111 */ 112 ir_variable *old_distance_out_var; 113 ir_variable *old_distance_in_var; 114 115 /** 116 * Pointer to the newly-created gl_ClipDistanceMESA variable. 117 */ 118 ir_variable *new_distance_out_var; 119 ir_variable *new_distance_in_var; 120 121 /** 122 * Type of shader we are compiling (e.g. MESA_SHADER_VERTEX) 123 */ 124 const gl_shader_stage shader_stage; 125 const char *in_name; 126 int total_size; 127 int offset; 128 }; 129 130 } /* anonymous namespace */ 131 132 /** 133 * Replace any declaration of 'in_name' as an array of floats with a 134 * declaration of gl_ClipDistanceMESA as an array of vec4's. 135 */ 136 ir_visitor_status 137 lower_distance_visitor::visit(ir_variable *ir) 138 { 139 ir_variable **old_var; 140 ir_variable **new_var; 141 142 if (!ir->name || strcmp(ir->name, in_name) != 0) 143 return visit_continue; 144 assert (ir->type->is_array()); 145 146 if (ir->data.mode == ir_var_shader_out) { 147 if (this->old_distance_out_var) 148 return visit_continue; 149 old_var = &old_distance_out_var; 150 new_var = &new_distance_out_var; 151 } else if (ir->data.mode == ir_var_shader_in) { 152 if (this->old_distance_in_var) 153 return visit_continue; 154 old_var = &old_distance_in_var; 155 new_var = &new_distance_in_var; 156 } else { 157 unreachable("not reached"); 158 } 159 160 this->progress = true; 161 162 *old_var = ir; 163 164 if (!(*new_var)) { 165 unsigned new_size = (total_size + 3) / 4; 166 167 /* Clone the old var so that we inherit all of its properties */ 168 *new_var = ir->clone(ralloc_parent(ir), NULL); 169 (*new_var)->name = ralloc_strdup(*new_var, GLSL_CLIP_VAR_NAME); 170 (*new_var)->data.max_array_access = new_size - 1; 171 (*new_var)->data.location = VARYING_SLOT_CLIP_DIST0; 172 173 if (!ir->type->fields.array->is_array()) { 174 /* gl_ClipDistance (used for vertex, tessellation evaluation and 175 * geometry output, and fragment input). 176 */ 177 assert((ir->data.mode == ir_var_shader_in && 178 this->shader_stage == MESA_SHADER_FRAGMENT) || 179 (ir->data.mode == ir_var_shader_out && 180 (this->shader_stage == MESA_SHADER_VERTEX || 181 this->shader_stage == MESA_SHADER_TESS_EVAL || 182 this->shader_stage == MESA_SHADER_GEOMETRY))); 183 184 assert (ir->type->fields.array == glsl_type::float_type); 185 186 /* And change the properties that we need to change */ 187 (*new_var)->type = glsl_type::get_array_instance(glsl_type::vec4_type, 188 new_size); 189 } else { 190 /* 2D gl_ClipDistance (used for tessellation control, tessellation 191 * evaluation and geometry input, and tessellation control output). 192 */ 193 assert((ir->data.mode == ir_var_shader_in && 194 (this->shader_stage == MESA_SHADER_GEOMETRY || 195 this->shader_stage == MESA_SHADER_TESS_EVAL)) || 196 this->shader_stage == MESA_SHADER_TESS_CTRL); 197 198 assert (ir->type->fields.array->fields.array == glsl_type::float_type); 199 200 /* And change the properties that we need to change */ 201 (*new_var)->type = glsl_type::get_array_instance( 202 glsl_type::get_array_instance(glsl_type::vec4_type, 203 new_size), 204 ir->type->array_size()); 205 } 206 ir->replace_with(*new_var); 207 } else { 208 ir->remove(); 209 } 210 211 return visit_continue; 212 } 213 214 215 /** 216 * Create the necessary GLSL rvalues to index into gl_ClipDistanceMESA based 217 * on the rvalue previously used to index into gl_ClipDistance. 218 * 219 * \param array_index Selects one of the vec4's in gl_ClipDistanceMESA 220 * \param swizzle_index Selects a component within the vec4 selected by 221 * array_index. 222 */ 223 void 224 lower_distance_visitor::create_indices(ir_rvalue *old_index, 225 ir_rvalue *&array_index, 226 ir_rvalue *&swizzle_index) 227 { 228 void *ctx = ralloc_parent(old_index); 229 230 /* Make sure old_index is a signed int so that the bitwise "shift" and 231 * "and" operations below type check properly. 232 */ 233 if (old_index->type != glsl_type::int_type) { 234 assert (old_index->type == glsl_type::uint_type); 235 old_index = new(ctx) ir_expression(ir_unop_u2i, old_index); 236 } 237 238 ir_constant *old_index_constant = old_index->constant_expression_value(); 239 if (old_index_constant) { 240 /* gl_ClipDistance is being accessed via a constant index. Don't bother 241 * creating expressions to calculate the lowered indices. Just create 242 * constants. 243 */ 244 int const_val = old_index_constant->get_int_component(0) + offset; 245 array_index = new(ctx) ir_constant(const_val / 4); 246 swizzle_index = new(ctx) ir_constant(const_val % 4); 247 } else { 248 /* Create a variable to hold the value of old_index (so that we 249 * don't compute it twice). 250 */ 251 ir_variable *old_index_var = new(ctx) ir_variable( 252 glsl_type::int_type, "distance_index", ir_var_temporary); 253 this->base_ir->insert_before(old_index_var); 254 this->base_ir->insert_before(new(ctx) ir_assignment( 255 new(ctx) ir_dereference_variable(old_index_var), old_index)); 256 257 /* Create the expression distance_index / 4. Do this as a bit 258 * shift because that's likely to be more efficient. 259 */ 260 array_index = new(ctx) ir_expression( 261 ir_binop_rshift, 262 new(ctx) ir_expression(ir_binop_add, 263 new(ctx) ir_dereference_variable(old_index_var), 264 new(ctx) ir_constant(offset)), 265 new(ctx) ir_constant(2)); 266 267 /* Create the expression distance_index % 4. Do this as a bitwise 268 * AND because that's likely to be more efficient. 269 */ 270 swizzle_index = new(ctx) ir_expression( 271 ir_binop_bit_and, 272 new(ctx) ir_expression(ir_binop_add, 273 new(ctx) ir_dereference_variable(old_index_var), 274 new(ctx) ir_constant(offset)), 275 new(ctx) ir_constant(3)); 276 } 277 } 278 279 280 /** 281 * Determine whether the given rvalue describes an array of 8 floats that 282 * needs to be lowered to an array of 2 vec4's; that is, determine whether it 283 * matches one of the following patterns: 284 * 285 * - gl_ClipDistance (if gl_ClipDistance is 1D) 286 * - gl_ClipDistance[i] (if gl_ClipDistance is 2D) 287 */ 288 bool 289 lower_distance_visitor::is_distance_vec8(ir_rvalue *ir) 290 { 291 /* Note that geometry shaders contain gl_ClipDistance both as an input 292 * (which is a 2D array) and an output (which is a 1D array), so it's 293 * possible for both this->old_distance_out_var and 294 * this->old_distance_in_var to be non-NULL in the same shader. 295 */ 296 297 if (!ir->type->is_array()) 298 return false; 299 if (ir->type->fields.array != glsl_type::float_type) 300 return false; 301 302 if (this->old_distance_out_var) { 303 if (ir->variable_referenced() == this->old_distance_out_var) 304 return true; 305 } 306 if (this->old_distance_in_var) { 307 assert(this->shader_stage == MESA_SHADER_TESS_CTRL || 308 this->shader_stage == MESA_SHADER_TESS_EVAL || 309 this->shader_stage == MESA_SHADER_GEOMETRY || 310 this->shader_stage == MESA_SHADER_FRAGMENT); 311 312 if (ir->variable_referenced() == this->old_distance_in_var) 313 return true; 314 } 315 return false; 316 } 317 318 319 /** 320 * If the given ir satisfies is_distance_vec8(), return new ir 321 * representing its lowered equivalent. That is, map: 322 * 323 * - gl_ClipDistance => gl_ClipDistanceMESA (if gl_ClipDistance is 1D) 324 * - gl_ClipDistance[i] => gl_ClipDistanceMESA[i] (if gl_ClipDistance is 2D) 325 * 326 * Otherwise return NULL. 327 */ 328 ir_rvalue * 329 lower_distance_visitor::lower_distance_vec8(ir_rvalue *ir) 330 { 331 if (!ir->type->is_array()) 332 return NULL; 333 if (ir->type->fields.array != glsl_type::float_type) 334 return NULL; 335 336 ir_variable **new_var = NULL; 337 if (this->old_distance_out_var) { 338 if (ir->variable_referenced() == this->old_distance_out_var) 339 new_var = &this->new_distance_out_var; 340 } 341 if (this->old_distance_in_var) { 342 if (ir->variable_referenced() == this->old_distance_in_var) 343 new_var = &this->new_distance_in_var; 344 } 345 if (new_var == NULL) 346 return NULL; 347 348 if (ir->as_dereference_variable()) { 349 return new(ralloc_parent(ir)) ir_dereference_variable(*new_var); 350 } else { 351 ir_dereference_array *array_ref = ir->as_dereference_array(); 352 assert(array_ref); 353 assert(array_ref->array->as_dereference_variable()); 354 355 return new(ralloc_parent(ir)) 356 ir_dereference_array(*new_var, array_ref->array_index); 357 } 358 } 359 360 361 void 362 lower_distance_visitor::handle_rvalue(ir_rvalue **rv) 363 { 364 if (*rv == NULL) 365 return; 366 367 ir_dereference_array *const array_deref = (*rv)->as_dereference_array(); 368 if (array_deref == NULL) 369 return; 370 371 /* Replace any expression that indexes one of the floats in gl_ClipDistance 372 * with an expression that indexes into one of the vec4's in 373 * gl_ClipDistanceMESA and accesses the appropriate component. 374 */ 375 ir_rvalue *lowered_vec8 = 376 this->lower_distance_vec8(array_deref->array); 377 if (lowered_vec8 != NULL) { 378 this->progress = true; 379 ir_rvalue *array_index; 380 ir_rvalue *swizzle_index; 381 this->create_indices(array_deref->array_index, array_index, swizzle_index); 382 void *mem_ctx = ralloc_parent(array_deref); 383 384 ir_dereference_array *const new_array_deref = 385 new(mem_ctx) ir_dereference_array(lowered_vec8, array_index); 386 387 ir_expression *const expr = 388 new(mem_ctx) ir_expression(ir_binop_vector_extract, 389 new_array_deref, 390 swizzle_index); 391 392 *rv = expr; 393 } 394 } 395 396 void 397 lower_distance_visitor::fix_lhs(ir_assignment *ir) 398 { 399 if (ir->lhs->ir_type == ir_type_expression) { 400 void *mem_ctx = ralloc_parent(ir); 401 ir_expression *const expr = (ir_expression *) ir->lhs; 402 403 /* The expression must be of the form: 404 * 405 * (vector_extract gl_ClipDistanceMESA[i], j). 406 */ 407 assert(expr->operation == ir_binop_vector_extract); 408 assert(expr->operands[0]->ir_type == ir_type_dereference_array); 409 assert(expr->operands[0]->type == glsl_type::vec4_type); 410 411 ir_dereference *const new_lhs = (ir_dereference *) expr->operands[0]; 412 ir->rhs = new(mem_ctx) ir_expression(ir_triop_vector_insert, 413 glsl_type::vec4_type, 414 new_lhs->clone(mem_ctx, NULL), 415 ir->rhs, 416 expr->operands[1]); 417 ir->set_lhs(new_lhs); 418 ir->write_mask = WRITEMASK_XYZW; 419 } 420 } 421 422 /** 423 * Replace any assignment having the 1D gl_ClipDistance (undereferenced) as 424 * its LHS or RHS with a sequence of assignments, one for each component of 425 * the array. Each of these assignments is lowered to refer to 426 * gl_ClipDistanceMESA as appropriate. 427 * 428 * We need to do a similar replacement for 2D gl_ClipDistance, however since 429 * it's an input, the only case we need to address is where a 1D slice of it 430 * is the entire RHS of an assignment, e.g.: 431 * 432 * foo = gl_in[i].gl_ClipDistance 433 */ 434 ir_visitor_status 435 lower_distance_visitor::visit_leave(ir_assignment *ir) 436 { 437 /* First invoke the base class visitor. This causes handle_rvalue() to be 438 * called on ir->rhs and ir->condition. 439 */ 440 ir_rvalue_visitor::visit_leave(ir); 441 442 if (this->is_distance_vec8(ir->lhs) || 443 this->is_distance_vec8(ir->rhs)) { 444 /* LHS or RHS of the assignment is the entire 1D gl_ClipDistance array 445 * (or a 1D slice of a 2D gl_ClipDistance input array). Since we are 446 * reshaping gl_ClipDistance from an array of floats to an array of 447 * vec4's, this isn't going to work as a bulk assignment anymore, so 448 * unroll it to element-by-element assignments and lower each of them. 449 * 450 * Note: to unroll into element-by-element assignments, we need to make 451 * clones of the LHS and RHS. This is safe because expressions and 452 * l-values are side-effect free. 453 */ 454 void *ctx = ralloc_parent(ir); 455 int array_size = ir->lhs->type->array_size(); 456 for (int i = 0; i < array_size; ++i) { 457 ir_dereference_array *new_lhs = new(ctx) ir_dereference_array( 458 ir->lhs->clone(ctx, NULL), new(ctx) ir_constant(i)); 459 ir_dereference_array *new_rhs = new(ctx) ir_dereference_array( 460 ir->rhs->clone(ctx, NULL), new(ctx) ir_constant(i)); 461 this->handle_rvalue((ir_rvalue **) &new_rhs); 462 463 /* Handle the LHS after creating the new assignment. This must 464 * happen in this order because handle_rvalue may replace the old LHS 465 * with an ir_expression of ir_binop_vector_extract. Since this is 466 * not a valide l-value, this will cause an assertion in the 467 * ir_assignment constructor to fail. 468 * 469 * If this occurs, replace the mangled LHS with a dereference of the 470 * vector, and replace the RHS with an ir_triop_vector_insert. 471 */ 472 ir_assignment *const assign = new(ctx) ir_assignment(new_lhs, new_rhs); 473 this->handle_rvalue((ir_rvalue **) &assign->lhs); 474 this->fix_lhs(assign); 475 476 this->base_ir->insert_before(assign); 477 } 478 ir->remove(); 479 480 return visit_continue; 481 } 482 483 /* Handle the LHS as if it were an r-value. Normally 484 * rvalue_visit(ir_assignment *) only visits the RHS, but we need to lower 485 * expressions in the LHS as well. 486 * 487 * This may cause the LHS to get replaced with an ir_expression of 488 * ir_binop_vector_extract. If this occurs, replace it with a dereference 489 * of the vector, and replace the RHS with an ir_triop_vector_insert. 490 */ 491 handle_rvalue((ir_rvalue **)&ir->lhs); 492 this->fix_lhs(ir); 493 494 return rvalue_visit(ir); 495 } 496 497 498 /** 499 * Set up base_ir properly and call visit_leave() on a newly created 500 * ir_assignment node. This is used in cases where we have to insert an 501 * ir_assignment in a place where we know the hierarchical visitor won't see 502 * it. 503 */ 504 void 505 lower_distance_visitor::visit_new_assignment(ir_assignment *ir) 506 { 507 ir_instruction *old_base_ir = this->base_ir; 508 this->base_ir = ir; 509 ir->accept(this); 510 this->base_ir = old_base_ir; 511 } 512 513 514 /** 515 * If a 1D gl_ClipDistance variable appears as an argument in an ir_call 516 * expression, replace it with a temporary variable, and make sure the ir_call 517 * is preceded and/or followed by assignments that copy the contents of the 518 * temporary variable to and/or from gl_ClipDistance. Each of these 519 * assignments is then lowered to refer to gl_ClipDistanceMESA. 520 * 521 * We need to do a similar replacement for 2D gl_ClipDistance, however since 522 * it's an input, the only case we need to address is where a 1D slice of it 523 * is passed as an "in" parameter to an ir_call, e.g.: 524 * 525 * foo(gl_in[i].gl_ClipDistance) 526 */ 527 ir_visitor_status 528 lower_distance_visitor::visit_leave(ir_call *ir) 529 { 530 void *ctx = ralloc_parent(ir); 531 532 const exec_node *formal_param_node = ir->callee->parameters.get_head_raw(); 533 const exec_node *actual_param_node = ir->actual_parameters.get_head_raw(); 534 while (!actual_param_node->is_tail_sentinel()) { 535 ir_variable *formal_param = (ir_variable *) formal_param_node; 536 ir_rvalue *actual_param = (ir_rvalue *) actual_param_node; 537 538 /* Advance formal_param_node and actual_param_node now so that we can 539 * safely replace actual_param with another node, if necessary, below. 540 */ 541 formal_param_node = formal_param_node->next; 542 actual_param_node = actual_param_node->next; 543 544 if (this->is_distance_vec8(actual_param)) { 545 /* User is trying to pass the whole 1D gl_ClipDistance array (or a 1D 546 * slice of a 2D gl_ClipDistance array) to a function call. Since we 547 * are reshaping gl_ClipDistance from an array of floats to an array 548 * of vec4's, this isn't going to work anymore, so use a temporary 549 * array instead. 550 */ 551 ir_variable *temp_clip_distance = new(ctx) ir_variable( 552 actual_param->type, "temp_clip_distance", ir_var_temporary); 553 this->base_ir->insert_before(temp_clip_distance); 554 actual_param->replace_with( 555 new(ctx) ir_dereference_variable(temp_clip_distance)); 556 if (formal_param->data.mode == ir_var_function_in 557 || formal_param->data.mode == ir_var_function_inout) { 558 /* Copy from gl_ClipDistance to the temporary before the call. 559 * Since we are going to insert this copy before the current 560 * instruction, we need to visit it afterwards to make sure it 561 * gets lowered. 562 */ 563 ir_assignment *new_assignment = new(ctx) ir_assignment( 564 new(ctx) ir_dereference_variable(temp_clip_distance), 565 actual_param->clone(ctx, NULL)); 566 this->base_ir->insert_before(new_assignment); 567 this->visit_new_assignment(new_assignment); 568 } 569 if (formal_param->data.mode == ir_var_function_out 570 || formal_param->data.mode == ir_var_function_inout) { 571 /* Copy from the temporary to gl_ClipDistance after the call. 572 * Since visit_list_elements() has already decided which 573 * instruction it's going to visit next, we need to visit 574 * afterwards to make sure it gets lowered. 575 */ 576 ir_assignment *new_assignment = new(ctx) ir_assignment( 577 actual_param->clone(ctx, NULL), 578 new(ctx) ir_dereference_variable(temp_clip_distance)); 579 this->base_ir->insert_after(new_assignment); 580 this->visit_new_assignment(new_assignment); 581 } 582 } 583 } 584 585 return rvalue_visit(ir); 586 } 587 588 namespace { 589 class lower_distance_visitor_counter : public ir_rvalue_visitor { 590 public: 591 explicit lower_distance_visitor_counter(void) 592 : in_clip_size(0), in_cull_size(0), 593 out_clip_size(0), out_cull_size(0) 594 { 595 } 596 597 virtual ir_visitor_status visit(ir_variable *); 598 virtual void handle_rvalue(ir_rvalue **rvalue); 599 600 int in_clip_size; 601 int in_cull_size; 602 int out_clip_size; 603 int out_cull_size; 604 }; 605 606 } 607 /** 608 * Count gl_ClipDistance and gl_CullDistance sizes. 609 */ 610 ir_visitor_status 611 lower_distance_visitor_counter::visit(ir_variable *ir) 612 { 613 int *clip_size, *cull_size; 614 615 if (!ir->name) 616 return visit_continue; 617 618 if (ir->data.mode == ir_var_shader_out) { 619 clip_size = &out_clip_size; 620 cull_size = &out_cull_size; 621 } else if (ir->data.mode == ir_var_shader_in) { 622 clip_size = &in_clip_size; 623 cull_size = &in_cull_size; 624 } else 625 return visit_continue; 626 627 if (ir->type->is_unsized_array()) 628 return visit_continue; 629 630 if (*clip_size == 0) { 631 if (!strcmp(ir->name, "gl_ClipDistance")) { 632 if (!ir->type->fields.array->is_array()) 633 *clip_size = ir->type->array_size(); 634 else 635 *clip_size = ir->type->fields.array->array_size(); 636 } 637 } 638 639 if (*cull_size == 0) { 640 if (!strcmp(ir->name, "gl_CullDistance")) { 641 if (!ir->type->fields.array->is_array()) 642 *cull_size = ir->type->array_size(); 643 else 644 *cull_size = ir->type->fields.array->array_size(); 645 } 646 } 647 return visit_continue; 648 } 649 650 void 651 lower_distance_visitor_counter::handle_rvalue(ir_rvalue **rv) 652 { 653 return; 654 } 655 656 bool 657 lower_clip_cull_distance(struct gl_shader_program *prog, 658 struct gl_linked_shader *shader) 659 { 660 int clip_size, cull_size; 661 662 lower_distance_visitor_counter count; 663 visit_list_elements(&count, shader->ir); 664 665 clip_size = MAX2(count.in_clip_size, count.out_clip_size); 666 cull_size = MAX2(count.in_cull_size, count.out_cull_size); 667 668 if (clip_size == 0 && cull_size == 0) 669 return false; 670 671 lower_distance_visitor v(shader->Stage, "gl_ClipDistance", clip_size + cull_size, 0); 672 visit_list_elements(&v, shader->ir); 673 674 lower_distance_visitor v2(shader->Stage, "gl_CullDistance", &v, clip_size); 675 visit_list_elements(&v2, shader->ir); 676 677 if (v2.new_distance_out_var) 678 shader->symbols->add_variable(v2.new_distance_out_var); 679 if (v2.new_distance_in_var) 680 shader->symbols->add_variable(v2.new_distance_in_var); 681 682 return v2.progress; 683 } 684
