1/* 2 Copyright (C) Intel Corp. 2006. All Rights Reserved. 3 Intel funded Tungsten Graphics to 4 develop this 3D driver. 5 6 Permission is hereby granted, free of charge, to any person obtaining 7 a 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, sublicense, 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 16 portions of the Software. 17 18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 21 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE 22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 26 **********************************************************************/ 27 /* 28 * Authors: 29 * Keith Whitwell <keithw@vmware.com> 30 */ 31 32 33#include "main/macros.h" 34#include "main/enums.h" 35#include "program/program.h" 36 37#include "brw_clip.h" 38 39 40struct brw_reg get_tmp( struct brw_clip_compile *c ) 41{ 42 struct brw_reg tmp = brw_vec4_grf(c->last_tmp, 0); 43 44 if (++c->last_tmp > c->prog_data.total_grf) 45 c->prog_data.total_grf = c->last_tmp; 46 47 return tmp; 48} 49 50static void release_tmp( struct brw_clip_compile *c, struct brw_reg tmp ) 51{ 52 if (tmp.nr == c->last_tmp-1) 53 c->last_tmp--; 54} 55 56 57static struct brw_reg make_plane_ud(GLuint x, GLuint y, GLuint z, GLuint w) 58{ 59 return brw_imm_ud((w<<24) | (z<<16) | (y<<8) | x); 60} 61 62 63void brw_clip_init_planes( struct brw_clip_compile *c ) 64{ 65 struct brw_codegen *p = &c->func; 66 67 if (!c->key.nr_userclip) { 68 brw_MOV(p, get_element_ud(c->reg.fixed_planes, 0), make_plane_ud( 0, 0, 0xff, 1)); 69 brw_MOV(p, get_element_ud(c->reg.fixed_planes, 1), make_plane_ud( 0, 0, 1, 1)); 70 brw_MOV(p, get_element_ud(c->reg.fixed_planes, 2), make_plane_ud( 0, 0xff, 0, 1)); 71 brw_MOV(p, get_element_ud(c->reg.fixed_planes, 3), make_plane_ud( 0, 1, 0, 1)); 72 brw_MOV(p, get_element_ud(c->reg.fixed_planes, 4), make_plane_ud(0xff, 0, 0, 1)); 73 brw_MOV(p, get_element_ud(c->reg.fixed_planes, 5), make_plane_ud( 1, 0, 0, 1)); 74 } 75} 76 77 78 79#define W 3 80 81/* Project 'pos' to screen space (or back again), overwrite with results: 82 */ 83void brw_clip_project_position(struct brw_clip_compile *c, struct brw_reg pos ) 84{ 85 struct brw_codegen *p = &c->func; 86 87 /* calc rhw 88 */ 89 brw_math_invert(p, get_element(pos, W), get_element(pos, W)); 90 91 /* value.xyz *= value.rhw 92 */ 93 brw_set_default_access_mode(p, BRW_ALIGN_16); 94 brw_MUL(p, brw_writemask(pos, WRITEMASK_XYZ), pos, 95 brw_swizzle(pos, BRW_SWIZZLE_WWWW)); 96 brw_set_default_access_mode(p, BRW_ALIGN_1); 97} 98 99 100static void brw_clip_project_vertex( struct brw_clip_compile *c, 101 struct brw_indirect vert_addr ) 102{ 103 struct brw_codegen *p = &c->func; 104 struct brw_reg tmp = get_tmp(c); 105 GLuint hpos_offset = brw_varying_to_offset(&c->vue_map, VARYING_SLOT_POS); 106 GLuint ndc_offset = brw_varying_to_offset(&c->vue_map, 107 BRW_VARYING_SLOT_NDC); 108 109 /* Fixup position. Extract from the original vertex and re-project 110 * to screen space: 111 */ 112 brw_MOV(p, tmp, deref_4f(vert_addr, hpos_offset)); 113 brw_clip_project_position(c, tmp); 114 brw_MOV(p, deref_4f(vert_addr, ndc_offset), tmp); 115 116 release_tmp(c, tmp); 117} 118 119 120 121 122/* Interpolate between two vertices and put the result into a0.0. 123 * Increment a0.0 accordingly. 124 * 125 * Beware that dest_ptr can be equal to v0_ptr! 126 */ 127void brw_clip_interp_vertex( struct brw_clip_compile *c, 128 struct brw_indirect dest_ptr, 129 struct brw_indirect v0_ptr, /* from */ 130 struct brw_indirect v1_ptr, /* to */ 131 struct brw_reg t0, 132 bool force_edgeflag) 133{ 134 struct brw_codegen *p = &c->func; 135 struct brw_reg t_nopersp, v0_ndc_copy; 136 GLuint slot; 137 138 /* Just copy the vertex header: 139 */ 140 /* 141 * After CLIP stage, only first 256 bits of the VUE are read 142 * back on Ironlake, so needn't change it 143 */ 144 brw_copy_indirect_to_indirect(p, dest_ptr, v0_ptr, 1); 145 146 147 /* First handle the 3D and NDC interpolation, in case we 148 * need noperspective interpolation. Doing it early has no 149 * performance impact in any case. 150 */ 151 152 /* Take a copy of the v0 NDC coordinates, in case dest == v0. */ 153 if (c->key.contains_noperspective_varying) { 154 GLuint offset = brw_varying_to_offset(&c->vue_map, 155 BRW_VARYING_SLOT_NDC); 156 v0_ndc_copy = get_tmp(c); 157 brw_MOV(p, v0_ndc_copy, deref_4f(v0_ptr, offset)); 158 } 159 160 /* Compute the new 3D position 161 * 162 * dest_hpos = v0_hpos * (1 - t0) + v1_hpos * t0 163 */ 164 { 165 GLuint delta = brw_varying_to_offset(&c->vue_map, VARYING_SLOT_POS); 166 struct brw_reg tmp = get_tmp(c); 167 brw_MUL(p, vec4(brw_null_reg()), deref_4f(v1_ptr, delta), t0); 168 brw_MAC(p, tmp, negate(deref_4f(v0_ptr, delta)), t0); 169 brw_ADD(p, deref_4f(dest_ptr, delta), deref_4f(v0_ptr, delta), tmp); 170 release_tmp(c, tmp); 171 } 172 173 /* Recreate the projected (NDC) coordinate in the new vertex header */ 174 brw_clip_project_vertex(c, dest_ptr); 175 176 /* If we have noperspective attributes, 177 * we need to compute the screen-space t 178 */ 179 if (c->key.contains_noperspective_varying) { 180 GLuint delta = brw_varying_to_offset(&c->vue_map, 181 BRW_VARYING_SLOT_NDC); 182 struct brw_reg tmp = get_tmp(c); 183 t_nopersp = get_tmp(c); 184 185 /* t_nopersp = vec4(v1.xy, dest.xy) */ 186 brw_MOV(p, t_nopersp, deref_4f(v1_ptr, delta)); 187 brw_MOV(p, tmp, deref_4f(dest_ptr, delta)); 188 brw_set_default_access_mode(p, BRW_ALIGN_16); 189 brw_MOV(p, 190 brw_writemask(t_nopersp, WRITEMASK_ZW), 191 brw_swizzle(tmp, BRW_SWIZZLE_XYXY)); 192 193 /* t_nopersp = vec4(v1.xy, dest.xy) - v0.xyxy */ 194 brw_ADD(p, t_nopersp, t_nopersp, 195 negate(brw_swizzle(v0_ndc_copy, BRW_SWIZZLE_XYXY))); 196 197 /* Add the absolute values of the X and Y deltas so that if 198 * the points aren't in the same place on the screen we get 199 * nonzero values to divide. 200 * 201 * After that, we have vert1 - vert0 in t_nopersp.x and 202 * vertnew - vert0 in t_nopersp.y 203 * 204 * t_nopersp = vec2(|v1.x -v0.x| + |v1.y -v0.y|, 205 * |dest.x-v0.x| + |dest.y-v0.y|) 206 */ 207 brw_ADD(p, 208 brw_writemask(t_nopersp, WRITEMASK_XY), 209 brw_abs(brw_swizzle(t_nopersp, BRW_SWIZZLE_XZXZ)), 210 brw_abs(brw_swizzle(t_nopersp, BRW_SWIZZLE_YWYW))); 211 brw_set_default_access_mode(p, BRW_ALIGN_1); 212 213 /* If the points are in the same place, just substitute a 214 * value to avoid divide-by-zero 215 */ 216 brw_CMP(p, vec1(brw_null_reg()), BRW_CONDITIONAL_EQ, 217 vec1(t_nopersp), 218 brw_imm_f(0)); 219 brw_IF(p, BRW_EXECUTE_1); 220 brw_MOV(p, t_nopersp, brw_imm_vf4(brw_float_to_vf(1.0), 221 brw_float_to_vf(0.0), 222 brw_float_to_vf(0.0), 223 brw_float_to_vf(0.0))); 224 brw_ENDIF(p); 225 226 /* Now compute t_nopersp = t_nopersp.y/t_nopersp.x and broadcast it. */ 227 brw_math_invert(p, get_element(t_nopersp, 0), get_element(t_nopersp, 0)); 228 brw_MUL(p, vec1(t_nopersp), vec1(t_nopersp), 229 vec1(suboffset(t_nopersp, 1))); 230 brw_set_default_access_mode(p, BRW_ALIGN_16); 231 brw_MOV(p, t_nopersp, brw_swizzle(t_nopersp, BRW_SWIZZLE_XXXX)); 232 brw_set_default_access_mode(p, BRW_ALIGN_1); 233 234 release_tmp(c, tmp); 235 release_tmp(c, v0_ndc_copy); 236 } 237 238 /* Now we can iterate over each attribute 239 * (could be done in pairs?) 240 */ 241 for (slot = 0; slot < c->vue_map.num_slots; slot++) { 242 int varying = c->vue_map.slot_to_varying[slot]; 243 GLuint delta = brw_vue_slot_to_offset(slot); 244 245 /* HPOS, NDC already handled above */ 246 if (varying == VARYING_SLOT_POS || varying == BRW_VARYING_SLOT_NDC) 247 continue; 248 249 250 if (varying == VARYING_SLOT_EDGE) { 251 if (force_edgeflag) 252 brw_MOV(p, deref_4f(dest_ptr, delta), brw_imm_f(1)); 253 else 254 brw_MOV(p, deref_4f(dest_ptr, delta), deref_4f(v0_ptr, delta)); 255 } else if (varying == VARYING_SLOT_PSIZ) { 256 /* PSIZ doesn't need interpolation because it isn't used by the 257 * fragment shader. 258 */ 259 } else if (varying < VARYING_SLOT_MAX) { 260 /* This is a true vertex result (and not a special value for the VUE 261 * header), so interpolate: 262 * 263 * New = attr0 + t*attr1 - t*attr0 264 * 265 * Unless the attribute is flat shaded -- in which case just copy 266 * from one of the sources (doesn't matter which; already copied from pv) 267 */ 268 GLuint interp = c->key.interp_mode[slot]; 269 270 if (interp != INTERP_MODE_FLAT) { 271 struct brw_reg tmp = get_tmp(c); 272 struct brw_reg t = 273 interp == INTERP_MODE_NOPERSPECTIVE ? t_nopersp : t0; 274 275 brw_MUL(p, 276 vec4(brw_null_reg()), 277 deref_4f(v1_ptr, delta), 278 t); 279 280 brw_MAC(p, 281 tmp, 282 negate(deref_4f(v0_ptr, delta)), 283 t); 284 285 brw_ADD(p, 286 deref_4f(dest_ptr, delta), 287 deref_4f(v0_ptr, delta), 288 tmp); 289 290 release_tmp(c, tmp); 291 } 292 else { 293 brw_MOV(p, 294 deref_4f(dest_ptr, delta), 295 deref_4f(v0_ptr, delta)); 296 } 297 } 298 } 299 300 if (c->vue_map.num_slots % 2) { 301 GLuint delta = brw_vue_slot_to_offset(c->vue_map.num_slots); 302 303 brw_MOV(p, deref_4f(dest_ptr, delta), brw_imm_f(0)); 304 } 305 306 if (c->key.contains_noperspective_varying) 307 release_tmp(c, t_nopersp); 308} 309 310void brw_clip_emit_vue(struct brw_clip_compile *c, 311 struct brw_indirect vert, 312 enum brw_urb_write_flags flags, 313 GLuint header) 314{ 315 struct brw_codegen *p = &c->func; 316 bool allocate = flags & BRW_URB_WRITE_ALLOCATE; 317 318 brw_clip_ff_sync(c); 319 320 /* Any URB entry that is allocated must subsequently be used or discarded, 321 * so it doesn't make sense to mark EOT and ALLOCATE at the same time. 322 */ 323 assert(!(allocate && (flags & BRW_URB_WRITE_EOT))); 324 325 /* Copy the vertex from vertn into m1..mN+1: 326 */ 327 brw_copy_from_indirect(p, brw_message_reg(1), vert, c->nr_regs); 328 329 /* Overwrite PrimType and PrimStart in the message header, for 330 * each vertex in turn: 331 */ 332 brw_MOV(p, get_element_ud(c->reg.R0, 2), brw_imm_ud(header)); 333 334 335 /* Send each vertex as a separate write to the urb. This 336 * is different to the concept in brw_sf_emit.c, where 337 * subsequent writes are used to build up a single urb 338 * entry. Each of these writes instantiates a separate 339 * urb entry - (I think... what about 'allocate'?) 340 */ 341 brw_urb_WRITE(p, 342 allocate ? c->reg.R0 : retype(brw_null_reg(), BRW_REGISTER_TYPE_UD), 343 0, 344 c->reg.R0, 345 flags, 346 c->nr_regs + 1, /* msg length */ 347 allocate ? 1 : 0, /* response_length */ 348 0, /* urb offset */ 349 BRW_URB_SWIZZLE_NONE); 350} 351 352 353 354void brw_clip_kill_thread(struct brw_clip_compile *c) 355{ 356 struct brw_codegen *p = &c->func; 357 358 brw_clip_ff_sync(c); 359 /* Send an empty message to kill the thread and release any 360 * allocated urb entry: 361 */ 362 brw_urb_WRITE(p, 363 retype(brw_null_reg(), BRW_REGISTER_TYPE_UD), 364 0, 365 c->reg.R0, 366 BRW_URB_WRITE_UNUSED | BRW_URB_WRITE_EOT_COMPLETE, 367 1, /* msg len */ 368 0, /* response len */ 369 0, 370 BRW_URB_SWIZZLE_NONE); 371} 372 373 374 375 376struct brw_reg brw_clip_plane0_address( struct brw_clip_compile *c ) 377{ 378 return brw_address(c->reg.fixed_planes); 379} 380 381 382struct brw_reg brw_clip_plane_stride( struct brw_clip_compile *c ) 383{ 384 if (c->key.nr_userclip) { 385 return brw_imm_uw(16); 386 } 387 else { 388 return brw_imm_uw(4); 389 } 390} 391 392 393/* Distribute flatshaded attributes from provoking vertex prior to 394 * clipping. 395 */ 396void brw_clip_copy_flatshaded_attributes( struct brw_clip_compile *c, 397 GLuint to, GLuint from ) 398{ 399 struct brw_codegen *p = &c->func; 400 401 for (int i = 0; i < c->vue_map.num_slots; i++) { 402 if (c->key.interp_mode[i] == INTERP_MODE_FLAT) { 403 brw_MOV(p, 404 byte_offset(c->reg.vertex[to], brw_vue_slot_to_offset(i)), 405 byte_offset(c->reg.vertex[from], brw_vue_slot_to_offset(i))); 406 } 407 } 408} 409 410 411 412void brw_clip_init_clipmask( struct brw_clip_compile *c ) 413{ 414 struct brw_codegen *p = &c->func; 415 struct brw_reg incoming = get_element_ud(c->reg.R0, 2); 416 417 /* Shift so that lowest outcode bit is rightmost: 418 */ 419 brw_SHR(p, c->reg.planemask, incoming, brw_imm_ud(26)); 420 421 if (c->key.nr_userclip) { 422 struct brw_reg tmp = retype(vec1(get_tmp(c)), BRW_REGISTER_TYPE_UD); 423 424 /* Rearrange userclip outcodes so that they come directly after 425 * the fixed plane bits. 426 */ 427 if (p->devinfo->ver == 5 || p->devinfo->verx10 == 45) 428 brw_AND(p, tmp, incoming, brw_imm_ud(0xff<<14)); 429 else 430 brw_AND(p, tmp, incoming, brw_imm_ud(0x3f<<14)); 431 432 brw_SHR(p, tmp, tmp, brw_imm_ud(8)); 433 brw_OR(p, c->reg.planemask, c->reg.planemask, tmp); 434 435 release_tmp(c, tmp); 436 } 437} 438 439void brw_clip_ff_sync(struct brw_clip_compile *c) 440{ 441 struct brw_codegen *p = &c->func; 442 443 if (p->devinfo->ver == 5) { 444 brw_AND(p, brw_null_reg(), c->reg.ff_sync, brw_imm_ud(0x1)); 445 brw_inst_set_cond_modifier(p->devinfo, brw_last_inst, BRW_CONDITIONAL_Z); 446 brw_IF(p, BRW_EXECUTE_1); 447 { 448 brw_OR(p, c->reg.ff_sync, c->reg.ff_sync, brw_imm_ud(0x1)); 449 brw_ff_sync(p, 450 c->reg.R0, 451 0, 452 c->reg.R0, 453 1, /* allocate */ 454 1, /* response length */ 455 0 /* eot */); 456 } 457 brw_ENDIF(p); 458 brw_set_default_predicate_control(p, BRW_PREDICATE_NONE); 459 } 460} 461 462void brw_clip_init_ff_sync(struct brw_clip_compile *c) 463{ 464 struct brw_codegen *p = &c->func; 465 466 if (p->devinfo->ver == 5) { 467 brw_MOV(p, c->reg.ff_sync, brw_imm_ud(0)); 468 } 469} 470