r300_texture_desc.c revision d99ec708afbb785ce05031661222b38c9447059f
1/* 2 * Copyright 2008 Corbin Simpson <MostAwesomeDude@gmail.com> 3 * Copyright 2010 Marek Olšák <maraeo@gmail.com> 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * on the rights to use, copy, modify, merge, publish, distribute, sub 9 * license, and/or sell copies of the Software, and to permit persons to whom 10 * the Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, 20 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 21 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 22 * USE OR OTHER DEALINGS IN THE SOFTWARE. */ 23 24#include "r300_texture_desc.h" 25 26#include "r300_context.h" 27#include "r300_winsys.h" 28 29#include "util/u_format.h" 30 31/* Returns the number of pixels that the texture should be aligned to 32 * in the given dimension. */ 33unsigned r300_get_pixel_alignment(enum pipe_format format, 34 unsigned num_samples, 35 enum r300_buffer_tiling microtile, 36 enum r300_buffer_tiling macrotile, 37 enum r300_dim dim, boolean is_rs690) 38{ 39 static const unsigned table[2][5][3][2] = 40 { 41 { 42 /* Macro: linear linear linear 43 Micro: linear tiled square-tiled */ 44 {{ 32, 1}, { 8, 4}, { 0, 0}}, /* 8 bits per pixel */ 45 {{ 16, 1}, { 8, 2}, { 4, 4}}, /* 16 bits per pixel */ 46 {{ 8, 1}, { 4, 2}, { 0, 0}}, /* 32 bits per pixel */ 47 {{ 4, 1}, { 2, 2}, { 0, 0}}, /* 64 bits per pixel */ 48 {{ 2, 1}, { 0, 0}, { 0, 0}} /* 128 bits per pixel */ 49 }, 50 { 51 /* Macro: tiled tiled tiled 52 Micro: linear tiled square-tiled */ 53 {{256, 8}, {64, 32}, { 0, 0}}, /* 8 bits per pixel */ 54 {{128, 8}, {64, 16}, {32, 32}}, /* 16 bits per pixel */ 55 {{ 64, 8}, {32, 16}, { 0, 0}}, /* 32 bits per pixel */ 56 {{ 32, 8}, {16, 16}, { 0, 0}}, /* 64 bits per pixel */ 57 {{ 16, 8}, { 0, 0}, { 0, 0}} /* 128 bits per pixel */ 58 } 59 }; 60 61 static const unsigned aa_block[2] = {4, 8}; 62 unsigned tile = 0; 63 unsigned pixsize = util_format_get_blocksize(format); 64 65 assert(macrotile <= R300_BUFFER_TILED); 66 assert(microtile <= R300_BUFFER_SQUARETILED); 67 assert(pixsize <= 16); 68 assert(dim <= DIM_HEIGHT); 69 70 if (num_samples > 1) { 71 /* Multisampled textures have their own alignment scheme. */ 72 if (pixsize == 4) 73 tile = aa_block[dim]; 74 /* XXX FP16 AA. */ 75 } else { 76 /* Standard alignment. */ 77 tile = table[macrotile][util_logbase2(pixsize)][microtile][dim]; 78 if (macrotile == 0 && is_rs690 && dim == DIM_WIDTH) { 79 int align; 80 int h_tile; 81 h_tile = table[macrotile][util_logbase2(pixsize)][microtile][DIM_HEIGHT]; 82 align = 64 / (pixsize * h_tile); 83 if (tile < align) 84 tile = align; 85 } 86 } 87 88 assert(tile); 89 return tile; 90} 91 92/* Return true if macrotiling should be enabled on the miplevel. */ 93static boolean r300_texture_macro_switch(struct r300_resource *tex, 94 unsigned level, 95 boolean rv350_mode, 96 enum r300_dim dim) 97{ 98 unsigned tile, texdim; 99 100 tile = r300_get_pixel_alignment(tex->b.b.b.format, tex->b.b.b.nr_samples, 101 tex->tex.microtile, R300_BUFFER_TILED, dim, 0); 102 if (dim == DIM_WIDTH) { 103 texdim = u_minify(tex->tex.width0, level); 104 } else { 105 texdim = u_minify(tex->tex.height0, level); 106 } 107 108 /* See TX_FILTER1_n.MACRO_SWITCH. */ 109 if (rv350_mode) { 110 return texdim >= tile; 111 } else { 112 return texdim > tile; 113 } 114} 115 116/** 117 * Return the stride, in bytes, of the texture image of the given texture 118 * at the given level. 119 */ 120static unsigned r300_texture_get_stride(struct r300_screen *screen, 121 struct r300_resource *tex, 122 unsigned level) 123{ 124 unsigned tile_width, width, stride; 125 boolean is_rs690 = (screen->caps.family == CHIP_FAMILY_RS600 || 126 screen->caps.family == CHIP_FAMILY_RS690 || 127 screen->caps.family == CHIP_FAMILY_RS740); 128 129 if (tex->tex.stride_in_bytes_override) 130 return tex->tex.stride_in_bytes_override; 131 132 /* Check the level. */ 133 if (level > tex->b.b.b.last_level) { 134 SCREEN_DBG(screen, DBG_TEX, "%s: level (%u) > last_level (%u)\n", 135 __FUNCTION__, level, tex->b.b.b.last_level); 136 return 0; 137 } 138 139 width = u_minify(tex->tex.width0, level); 140 141 if (util_format_is_plain(tex->b.b.b.format)) { 142 tile_width = r300_get_pixel_alignment(tex->b.b.b.format, 143 tex->b.b.b.nr_samples, 144 tex->tex.microtile, 145 tex->tex.macrotile[level], 146 DIM_WIDTH, is_rs690); 147 width = align(width, tile_width); 148 149 stride = util_format_get_stride(tex->b.b.b.format, width); 150 /* The alignment to 32 bytes is sort of implied by the layout... */ 151 return stride; 152 } else { 153 return align(util_format_get_stride(tex->b.b.b.format, width), is_rs690 ? 64 : 32); 154 } 155} 156 157static unsigned r300_texture_get_nblocksy(struct r300_resource *tex, 158 unsigned level, 159 boolean *out_aligned_for_cbzb) 160{ 161 unsigned height, tile_height; 162 163 height = u_minify(tex->tex.height0, level); 164 165 /* Mipmapped and 3D textures must have their height aligned to POT. */ 166 if ((tex->b.b.b.target != PIPE_TEXTURE_1D && 167 tex->b.b.b.target != PIPE_TEXTURE_2D && 168 tex->b.b.b.target != PIPE_TEXTURE_RECT) || 169 tex->b.b.b.last_level != 0) { 170 height = util_next_power_of_two(height); 171 } 172 173 if (util_format_is_plain(tex->b.b.b.format)) { 174 tile_height = r300_get_pixel_alignment(tex->b.b.b.format, 175 tex->b.b.b.nr_samples, 176 tex->tex.microtile, 177 tex->tex.macrotile[level], 178 DIM_HEIGHT, 0); 179 height = align(height, tile_height); 180 181 /* See if the CBZB clear can be used on the buffer, 182 * taking the texture size into account. */ 183 if (out_aligned_for_cbzb) { 184 if (tex->tex.macrotile[level]) { 185 /* When clearing, the layer (width*height) is horizontally split 186 * into two, and the upper and lower halves are cleared by the CB 187 * and ZB units, respectively. Therefore, the number of macrotiles 188 * in the Y direction must be even. */ 189 190 /* Align the height so that there is an even number of macrotiles. 191 * Do so for 3 or more macrotiles in the Y direction. */ 192 if (level == 0 && tex->b.b.b.last_level == 0 && 193 (tex->b.b.b.target == PIPE_TEXTURE_1D || 194 tex->b.b.b.target == PIPE_TEXTURE_2D || 195 tex->b.b.b.target == PIPE_TEXTURE_RECT) && 196 height >= tile_height * 3) { 197 height = align(height, tile_height * 2); 198 } 199 200 *out_aligned_for_cbzb = height % (tile_height * 2) == 0; 201 } else { 202 *out_aligned_for_cbzb = FALSE; 203 } 204 } 205 } 206 207 return util_format_get_nblocksy(tex->b.b.b.format, height); 208} 209 210static void r300_texture_3d_fix_mipmapping(struct r300_screen *screen, 211 struct r300_resource *tex) 212{ 213 /* The kernels <= 2.6.34-rc4 compute the size of mipmapped 3D textures 214 * incorrectly. This is a workaround to prevent CS from being rejected. */ 215 216 unsigned i, size; 217 218 if (!screen->rws->get_value(screen->rws, R300_VID_DRM_2_3_0) && 219 tex->b.b.b.target == PIPE_TEXTURE_3D && 220 tex->b.b.b.last_level > 0) { 221 size = 0; 222 223 for (i = 0; i <= tex->b.b.b.last_level; i++) { 224 size += tex->tex.stride_in_bytes[i] * 225 r300_texture_get_nblocksy(tex, i, FALSE); 226 } 227 228 size *= tex->tex.depth0; 229 tex->tex.size_in_bytes = size; 230 } 231} 232 233/* Get a width in pixels from a stride in bytes. */ 234static unsigned stride_to_width(enum pipe_format format, 235 unsigned stride_in_bytes) 236{ 237 return (stride_in_bytes / util_format_get_blocksize(format)) * 238 util_format_get_blockwidth(format); 239} 240 241static void r300_setup_miptree(struct r300_screen *screen, 242 struct r300_resource *tex, 243 boolean align_for_cbzb) 244{ 245 struct pipe_resource *base = &tex->b.b.b; 246 unsigned stride, size, layer_size, nblocksy, i; 247 boolean rv350_mode = screen->caps.family >= CHIP_FAMILY_R350; 248 boolean aligned_for_cbzb; 249 250 tex->tex.size_in_bytes = 0; 251 252 SCREEN_DBG(screen, DBG_TEXALLOC, 253 "r300: Making miptree for texture, format %s\n", 254 util_format_short_name(base->format)); 255 256 for (i = 0; i <= base->last_level; i++) { 257 /* Let's see if this miplevel can be macrotiled. */ 258 tex->tex.macrotile[i] = 259 (tex->tex.macrotile[0] == R300_BUFFER_TILED && 260 r300_texture_macro_switch(tex, i, rv350_mode, DIM_WIDTH) && 261 r300_texture_macro_switch(tex, i, rv350_mode, DIM_HEIGHT)) ? 262 R300_BUFFER_TILED : R300_BUFFER_LINEAR; 263 264 stride = r300_texture_get_stride(screen, tex, i); 265 266 /* Compute the number of blocks in Y, see if the CBZB clear can be 267 * used on the texture. */ 268 aligned_for_cbzb = FALSE; 269 if (align_for_cbzb && tex->tex.cbzb_allowed[i]) 270 nblocksy = r300_texture_get_nblocksy(tex, i, &aligned_for_cbzb); 271 else 272 nblocksy = r300_texture_get_nblocksy(tex, i, NULL); 273 274 layer_size = stride * nblocksy; 275 276 if (base->nr_samples) { 277 layer_size *= base->nr_samples; 278 } 279 280 if (base->target == PIPE_TEXTURE_CUBE) 281 size = layer_size * 6; 282 else 283 size = layer_size * u_minify(tex->tex.depth0, i); 284 285 tex->tex.offset_in_bytes[i] = tex->tex.size_in_bytes; 286 tex->tex.size_in_bytes = tex->tex.offset_in_bytes[i] + size; 287 tex->tex.layer_size_in_bytes[i] = layer_size; 288 tex->tex.stride_in_bytes[i] = stride; 289 tex->tex.stride_in_pixels[i] = stride_to_width(tex->b.b.b.format, stride); 290 tex->tex.cbzb_allowed[i] = tex->tex.cbzb_allowed[i] && aligned_for_cbzb; 291 292 SCREEN_DBG(screen, DBG_TEXALLOC, "r300: Texture miptree: Level %d " 293 "(%dx%dx%d px, pitch %d bytes) %d bytes total, macrotiled %s\n", 294 i, u_minify(tex->tex.width0, i), u_minify(tex->tex.height0, i), 295 u_minify(tex->tex.depth0, i), stride, tex->tex.size_in_bytes, 296 tex->tex.macrotile[i] ? "TRUE" : "FALSE"); 297 } 298} 299 300static void r300_setup_flags(struct r300_resource *tex) 301{ 302 tex->tex.uses_stride_addressing = 303 !util_is_power_of_two(tex->b.b.b.width0) || 304 (tex->tex.stride_in_bytes_override && 305 stride_to_width(tex->b.b.b.format, 306 tex->tex.stride_in_bytes_override) != tex->b.b.b.width0); 307 308 tex->tex.is_npot = 309 tex->tex.uses_stride_addressing || 310 !util_is_power_of_two(tex->b.b.b.height0) || 311 !util_is_power_of_two(tex->b.b.b.depth0); 312} 313 314static void r300_setup_cbzb_flags(struct r300_screen *rscreen, 315 struct r300_resource *tex) 316{ 317 unsigned i, bpp; 318 boolean first_level_valid; 319 320 bpp = util_format_get_blocksizebits(tex->b.b.b.format); 321 322 /* 1) The texture must be point-sampled, 323 * 2) The depth must be 16 or 32 bits. 324 * 3) If the midpoint ZB offset is not aligned to 2048, it returns garbage 325 * with certain texture sizes. Macrotiling ensures the alignment. */ 326 first_level_valid = tex->b.b.b.nr_samples <= 1 && 327 (bpp == 16 || bpp == 32) && 328 tex->tex.macrotile[0]; 329 330 if (SCREEN_DBG_ON(rscreen, DBG_NO_CBZB)) 331 first_level_valid = FALSE; 332 333 for (i = 0; i <= tex->b.b.b.last_level; i++) 334 tex->tex.cbzb_allowed[i] = first_level_valid && tex->tex.macrotile[i]; 335} 336 337static unsigned r300_pixels_to_dwords(unsigned stride, 338 unsigned height, 339 unsigned xblock, unsigned yblock) 340{ 341 return (align(stride, xblock) * align(height, yblock)) / (xblock * yblock); 342} 343 344static void r300_setup_hyperz_properties(struct r300_screen *screen, 345 struct r300_resource *tex) 346{ 347 /* The tile size of 1 DWORD in ZMASK RAM is: 348 * 349 * GPU Pipes 4x4 mode 8x8 mode 350 * ------------------------------------------ 351 * R580 4P/1Z 32x32 64x64 352 * RV570 3P/1Z 48x16 96x32 353 * RV530 1P/2Z 32x16 64x32 354 * 1P/1Z 16x16 32x32 355 */ 356 static unsigned zmask_blocks_x_per_dw[4] = {4, 8, 12, 8}; 357 static unsigned zmask_blocks_y_per_dw[4] = {4, 4, 4, 8}; 358 359 /* In HIZ RAM, one dword is always 8x8 pixels (each byte is 4x4 pixels), 360 * but the blocks have very weird ordering. 361 * 362 * With 2 pipes and an image of size 8xY, where Y >= 1, 363 * clearing 4 dwords clears blocks like this: 364 * 365 * 01012323 366 * 367 * where numbers correspond to dword indices. The blocks are interleaved 368 * in the X direction, so the alignment must be 4x1 blocks (32x8 pixels). 369 * 370 * With 4 pipes and an image of size 8xY, where Y >= 4, 371 * clearing 8 dwords clears blocks like this: 372 * 01012323 373 * 45456767 374 * 01012323 375 * 45456767 376 * where numbers correspond to dword indices. The blocks are interleaved 377 * in both directions, so the alignment must be 4x4 blocks (32x32 pixels) 378 */ 379 static unsigned hiz_align_x[4] = {8, 32, 48, 32}; 380 static unsigned hiz_align_y[4] = {8, 8, 8, 32}; 381 382 if (util_format_is_depth_or_stencil(tex->b.b.b.format) && 383 util_format_get_blocksizebits(tex->b.b.b.format) == 32 && 384 tex->tex.microtile) { 385 unsigned i, pipes; 386 387 if (screen->caps.family == CHIP_FAMILY_RV530) { 388 pipes = screen->caps.num_z_pipes; 389 } else { 390 pipes = screen->caps.num_frag_pipes; 391 } 392 393 for (i = 0; i <= tex->b.b.b.last_level; i++) { 394 unsigned zcomp_numdw, zcompsize, hiz_numdw, stride, height; 395 396 stride = align(tex->tex.stride_in_pixels[i], 16); 397 height = u_minify(tex->b.b.b.height0, i); 398 399 /* The 8x8 compression mode needs macrotiling. */ 400 zcompsize = screen->caps.z_compress == R300_ZCOMP_8X8 && 401 tex->tex.macrotile[i] && 402 tex->b.b.b.nr_samples <= 1 ? 8 : 4; 403 404 /* Get the ZMASK buffer size in dwords. */ 405 zcomp_numdw = r300_pixels_to_dwords(stride, height, 406 zmask_blocks_x_per_dw[pipes-1] * zcompsize, 407 zmask_blocks_y_per_dw[pipes-1] * zcompsize); 408 409 /* Check whether we have enough ZMASK memory. */ 410 if (util_format_get_blocksizebits(tex->b.b.b.format) == 32 && 411 zcomp_numdw <= screen->caps.zmask_ram * pipes) { 412 tex->tex.zmask_dwords[i] = zcomp_numdw; 413 tex->tex.zcomp8x8[i] = zcompsize == 8; 414 415 tex->tex.zmask_stride_in_pixels[i] = 416 align(stride, zmask_blocks_x_per_dw[pipes-1] * zcompsize); 417 } else { 418 tex->tex.zmask_dwords[i] = 0; 419 tex->tex.zcomp8x8[i] = FALSE; 420 tex->tex.zmask_stride_in_pixels[i] = 0; 421 } 422 423 /* Now setup HIZ. */ 424 stride = align(stride, hiz_align_x[pipes-1]); 425 height = align(height, hiz_align_y[pipes-1]); 426 427 /* Get the HIZ buffer size in dwords. */ 428 hiz_numdw = (stride * height) / (8*8 * pipes); 429 430 /* Check whether we have enough HIZ memory. */ 431 if (hiz_numdw <= screen->caps.hiz_ram * pipes) { 432 tex->tex.hiz_dwords[i] = hiz_numdw; 433 tex->tex.hiz_stride_in_pixels[i] = stride; 434 } else { 435 tex->tex.hiz_dwords[i] = 0; 436 tex->tex.hiz_stride_in_pixels[i] = 0; 437 } 438 } 439 } 440} 441 442static void r300_setup_tiling(struct r300_screen *screen, 443 struct r300_resource *tex) 444{ 445 struct r300_winsys_screen *rws = screen->rws; 446 enum pipe_format format = tex->b.b.b.format; 447 boolean rv350_mode = screen->caps.family >= CHIP_FAMILY_R350; 448 boolean is_zb = util_format_is_depth_or_stencil(format); 449 boolean dbg_no_tiling = SCREEN_DBG_ON(screen, DBG_NO_TILING); 450 451 tex->tex.microtile = R300_BUFFER_LINEAR; 452 tex->tex.macrotile[0] = R300_BUFFER_LINEAR; 453 454 if (!util_format_is_plain(format)) { 455 return; 456 } 457 458 /* If height == 1, disable microtiling except for zbuffer. */ 459 if (!is_zb && (tex->b.b.b.height0 == 1 || dbg_no_tiling)) { 460 return; 461 } 462 463 /* Set microtiling. */ 464 switch (util_format_get_blocksize(format)) { 465 case 1: 466 case 4: 467 case 8: 468 tex->tex.microtile = R300_BUFFER_TILED; 469 break; 470 471 case 2: 472 if (rws->get_value(rws, R300_VID_DRM_2_1_0)) { 473 tex->tex.microtile = R300_BUFFER_SQUARETILED; 474 } 475 break; 476 } 477 478 if (dbg_no_tiling) { 479 return; 480 } 481 482 /* Set macrotiling. */ 483 if (r300_texture_macro_switch(tex, 0, rv350_mode, DIM_WIDTH) && 484 r300_texture_macro_switch(tex, 0, rv350_mode, DIM_HEIGHT)) { 485 tex->tex.macrotile[0] = R300_BUFFER_TILED; 486 } 487} 488 489static void r300_tex_print_info(struct r300_resource *tex, 490 const char *func) 491{ 492 fprintf(stderr, 493 "r300: %s: Macro: %s, Micro: %s, Pitch: %i, Dim: %ix%ix%i, " 494 "LastLevel: %i, Size: %i, Format: %s\n", 495 func, 496 tex->tex.macrotile[0] ? "YES" : " NO", 497 tex->tex.microtile ? "YES" : " NO", 498 tex->tex.stride_in_pixels[0], 499 tex->b.b.b.width0, tex->b.b.b.height0, tex->b.b.b.depth0, 500 tex->b.b.b.last_level, tex->tex.size_in_bytes, 501 util_format_short_name(tex->b.b.b.format)); 502} 503 504boolean r300_texture_desc_init(struct r300_screen *rscreen, 505 struct r300_resource *tex, 506 const struct pipe_resource *base) 507{ 508 tex->b.b.b.target = base->target; 509 tex->b.b.b.format = base->format; 510 tex->b.b.b.width0 = base->width0; 511 tex->b.b.b.height0 = base->height0; 512 tex->b.b.b.depth0 = base->depth0; 513 tex->b.b.b.array_size = base->array_size; 514 tex->b.b.b.last_level = base->last_level; 515 tex->b.b.b.nr_samples = base->nr_samples; 516 tex->tex.width0 = base->width0; 517 tex->tex.height0 = base->height0; 518 tex->tex.depth0 = base->depth0; 519 520 r300_setup_flags(tex); 521 522 /* Align a 3D NPOT texture to POT. */ 523 if (base->target == PIPE_TEXTURE_3D && tex->tex.is_npot) { 524 tex->tex.width0 = util_next_power_of_two(tex->tex.width0); 525 tex->tex.height0 = util_next_power_of_two(tex->tex.height0); 526 tex->tex.depth0 = util_next_power_of_two(tex->tex.depth0); 527 } 528 529 /* Setup tiling. */ 530 if (tex->tex.microtile == R300_BUFFER_SELECT_LAYOUT) { 531 r300_setup_tiling(rscreen, tex); 532 } 533 534 r300_setup_cbzb_flags(rscreen, tex); 535 536 /* Setup the miptree description. */ 537 r300_setup_miptree(rscreen, tex, TRUE); 538 /* If the required buffer size is larger the given max size, 539 * try again without the alignment for the CBZB clear. */ 540 if (tex->buf_size && tex->tex.size_in_bytes > tex->buf_size) { 541 r300_setup_miptree(rscreen, tex, FALSE); 542 } 543 544 r300_texture_3d_fix_mipmapping(rscreen, tex); 545 r300_setup_hyperz_properties(rscreen, tex); 546 547 if (tex->buf_size) { 548 /* Make sure the buffer we got is large enough. */ 549 if (tex->tex.size_in_bytes > tex->buf_size) { 550 fprintf(stderr, "r300: texture_desc_init: The buffer is not " 551 "large enough. Got: %i, Need: %i, Info:\n", 552 tex->buf_size, tex->tex.size_in_bytes); 553 r300_tex_print_info(tex, "texture_desc_init"); 554 return FALSE; 555 } 556 557 tex->tex.buffer_size_in_bytes = tex->buf_size; 558 } else { 559 tex->tex.buffer_size_in_bytes = tex->tex.size_in_bytes; 560 } 561 562 if (SCREEN_DBG_ON(rscreen, DBG_TEX)) 563 r300_tex_print_info(tex, "texture_desc_init"); 564 565 return TRUE; 566} 567 568unsigned r300_texture_get_offset(struct r300_resource *tex, 569 unsigned level, unsigned layer) 570{ 571 unsigned offset = tex->tex.offset_in_bytes[level]; 572 573 switch (tex->b.b.b.target) { 574 case PIPE_TEXTURE_3D: 575 case PIPE_TEXTURE_CUBE: 576 return offset + layer * tex->tex.layer_size_in_bytes[level]; 577 578 default: 579 assert(layer == 0); 580 return offset; 581 } 582} 583