1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program Tester Core 3 * ---------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Texture utilities. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "tcuTextureUtil.hpp" 25 #include "tcuVectorUtil.hpp" 26 #include "deRandom.hpp" 27 #include "deMath.h" 28 #include "deMemory.h" 29 30 #include <limits> 31 32 namespace tcu 33 { 34 35 static inline float sRGBChannelToLinear (float cs) 36 { 37 if (cs <= 0.04045) 38 return cs / 12.92f; 39 else 40 return deFloatPow((cs + 0.055f) / 1.055f, 2.4f); 41 } 42 43 static const deUint32 s_srgb8Lut[256] = 44 { 45 #include "tcuSRGB8Lut.inl" 46 }; 47 48 static inline float sRGB8ChannelToLinear (deUint32 cs) 49 { 50 DE_ASSERT(cs < 256); 51 52 // \note This triggers UB, but in practice it doesn't cause any problems 53 return ((const float*)s_srgb8Lut)[cs]; 54 } 55 56 static inline float linearChannelToSRGB (float cl) 57 { 58 if (cl <= 0.0f) 59 return 0.0f; 60 else if (cl < 0.0031308f) 61 return 12.92f*cl; 62 else if (cl < 1.0f) 63 return 1.055f*deFloatPow(cl, 0.41666f) - 0.055f; 64 else 65 return 1.0f; 66 } 67 68 //! Convert sRGB to linear colorspace 69 Vec4 sRGBToLinear (const Vec4& cs) 70 { 71 return Vec4(sRGBChannelToLinear(cs[0]), 72 sRGBChannelToLinear(cs[1]), 73 sRGBChannelToLinear(cs[2]), 74 cs[3]); 75 } 76 77 Vec4 sRGB8ToLinear (const UVec4& cs) 78 { 79 return Vec4(sRGB8ChannelToLinear(cs[0]), 80 sRGB8ChannelToLinear(cs[1]), 81 sRGB8ChannelToLinear(cs[2]), 82 1.0f); 83 } 84 85 Vec4 sRGBA8ToLinear (const UVec4& cs) 86 { 87 return Vec4(sRGB8ChannelToLinear(cs[0]), 88 sRGB8ChannelToLinear(cs[1]), 89 sRGB8ChannelToLinear(cs[2]), 90 (float)cs[3] / 255.0f); 91 } 92 93 //! Convert from linear to sRGB colorspace 94 Vec4 linearToSRGB (const Vec4& cl) 95 { 96 return Vec4(linearChannelToSRGB(cl[0]), 97 linearChannelToSRGB(cl[1]), 98 linearChannelToSRGB(cl[2]), 99 cl[3]); 100 } 101 102 bool isSRGB (TextureFormat format) 103 { 104 // make sure to update this if type table is updated 105 DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 21); 106 107 return format.order == TextureFormat::sR || 108 format.order == TextureFormat::sRG || 109 format.order == TextureFormat::sRGB || 110 format.order == TextureFormat::sRGBA || 111 format.order == TextureFormat::sBGR || 112 format.order == TextureFormat::sBGRA; 113 } 114 115 bool isCombinedDepthStencilType (TextureFormat::ChannelType type) 116 { 117 // make sure to update this if type table is updated 118 DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 38); 119 120 return type == TextureFormat::UNSIGNED_INT_16_8_8 || 121 type == TextureFormat::UNSIGNED_INT_24_8 || 122 type == TextureFormat::UNSIGNED_INT_24_8_REV || 123 type == TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV; 124 } 125 126 bool hasStencilComponent (TextureFormat::ChannelOrder order) 127 { 128 DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 21); 129 130 switch (order) 131 { 132 case TextureFormat::S: 133 case TextureFormat::DS: 134 return true; 135 136 default: 137 return false; 138 } 139 } 140 141 bool hasDepthComponent (TextureFormat::ChannelOrder order) 142 { 143 DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 21); 144 145 switch (order) 146 { 147 case TextureFormat::D: 148 case TextureFormat::DS: 149 return true; 150 151 default: 152 return false; 153 } 154 } 155 156 //! Get texture channel class for format 157 TextureChannelClass getTextureChannelClass (TextureFormat::ChannelType channelType) 158 { 159 // make sure this table is updated if format table is updated 160 DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 38); 161 162 switch (channelType) 163 { 164 case TextureFormat::SNORM_INT8: return TEXTURECHANNELCLASS_SIGNED_FIXED_POINT; 165 case TextureFormat::SNORM_INT16: return TEXTURECHANNELCLASS_SIGNED_FIXED_POINT; 166 case TextureFormat::SNORM_INT32: return TEXTURECHANNELCLASS_SIGNED_FIXED_POINT; 167 case TextureFormat::UNORM_INT8: return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 168 case TextureFormat::UNORM_INT16: return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 169 case TextureFormat::UNORM_INT24: return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 170 case TextureFormat::UNORM_INT32: return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 171 case TextureFormat::UNORM_BYTE_44: return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 172 case TextureFormat::UNORM_SHORT_565: return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 173 case TextureFormat::UNORM_SHORT_555: return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 174 case TextureFormat::UNORM_SHORT_4444: return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 175 case TextureFormat::UNORM_SHORT_5551: return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 176 case TextureFormat::UNORM_SHORT_1555: return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 177 case TextureFormat::UNSIGNED_BYTE_44: return TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 178 case TextureFormat::UNSIGNED_SHORT_565: return TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 179 case TextureFormat::UNSIGNED_SHORT_4444: return TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 180 case TextureFormat::UNSIGNED_SHORT_5551: return TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 181 case TextureFormat::UNORM_INT_101010: return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 182 case TextureFormat::SNORM_INT_1010102_REV: return TEXTURECHANNELCLASS_SIGNED_FIXED_POINT; 183 case TextureFormat::UNORM_INT_1010102_REV: return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 184 case TextureFormat::SIGNED_INT_1010102_REV: return TEXTURECHANNELCLASS_SIGNED_INTEGER; 185 case TextureFormat::UNSIGNED_INT_1010102_REV: return TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 186 case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: return TEXTURECHANNELCLASS_FLOATING_POINT; 187 case TextureFormat::UNSIGNED_INT_999_E5_REV: return TEXTURECHANNELCLASS_FLOATING_POINT; 188 case TextureFormat::UNSIGNED_INT_16_8_8: return TEXTURECHANNELCLASS_LAST; //!< packed unorm16-x8-uint8 189 case TextureFormat::UNSIGNED_INT_24_8: return TEXTURECHANNELCLASS_LAST; //!< packed unorm24-uint8 190 case TextureFormat::UNSIGNED_INT_24_8_REV: return TEXTURECHANNELCLASS_LAST; //!< packed unorm24-uint8 191 case TextureFormat::SIGNED_INT8: return TEXTURECHANNELCLASS_SIGNED_INTEGER; 192 case TextureFormat::SIGNED_INT16: return TEXTURECHANNELCLASS_SIGNED_INTEGER; 193 case TextureFormat::SIGNED_INT32: return TEXTURECHANNELCLASS_SIGNED_INTEGER; 194 case TextureFormat::UNSIGNED_INT8: return TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 195 case TextureFormat::UNSIGNED_INT16: return TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 196 case TextureFormat::UNSIGNED_INT24: return TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 197 case TextureFormat::UNSIGNED_INT32: return TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 198 case TextureFormat::HALF_FLOAT: return TEXTURECHANNELCLASS_FLOATING_POINT; 199 case TextureFormat::FLOAT: return TEXTURECHANNELCLASS_FLOATING_POINT; 200 case TextureFormat::FLOAT64: return TEXTURECHANNELCLASS_FLOATING_POINT; 201 case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: return TEXTURECHANNELCLASS_LAST; //!< packed float32-pad24-uint8 202 default: 203 DE_FATAL("Unknown channel type"); 204 return TEXTURECHANNELCLASS_LAST; 205 } 206 } 207 208 bool isAccessValid (TextureFormat format, TextureAccessType type) 209 { 210 DE_ASSERT(isValid(format)); 211 212 if (format.order == TextureFormat::DS) 213 { 214 // It is never allowed to access combined depth-stencil format with getPixel(). 215 // Instead either getPixDepth() or getPixStencil(), or effective depth- or stencil- 216 // access must be used. 217 return false; 218 } 219 else if (format.order == TextureFormat::D) 220 return type == TEXTUREACCESSTYPE_FLOAT; 221 else if (format.order == TextureFormat::S) 222 return type == TEXTUREACCESSTYPE_UNSIGNED_INT; 223 else 224 { 225 // A few packed color formats have access type restrictions 226 if (format.type == TextureFormat::UNSIGNED_INT_11F_11F_10F_REV || 227 format.type == TextureFormat::UNSIGNED_INT_999_E5_REV) 228 return type == TEXTUREACCESSTYPE_FLOAT; 229 else 230 return true; 231 } 232 } 233 234 /*--------------------------------------------------------------------*//*! 235 * \brief Get access to subregion of pixel buffer 236 * \param access Parent access object 237 * \param x X offset 238 * \param y Y offset 239 * \param z Z offset 240 * \param width Width 241 * \param height Height 242 * \param depth Depth 243 * \return Access object that targets given subregion of parent access object 244 *//*--------------------------------------------------------------------*/ 245 ConstPixelBufferAccess getSubregion (const ConstPixelBufferAccess& access, int x, int y, int z, int width, int height, int depth) 246 { 247 DE_ASSERT(de::inBounds(x, 0, access.getWidth())); 248 DE_ASSERT(de::inRange(x+width, x+1, access.getWidth())); 249 250 DE_ASSERT(de::inBounds(y, 0, access.getHeight())); 251 DE_ASSERT(de::inRange(y+height, y+1, access.getHeight())); 252 253 DE_ASSERT(de::inBounds(z, 0, access.getDepth())); 254 DE_ASSERT(de::inRange(z+depth, z+1, access.getDepth())); 255 256 return ConstPixelBufferAccess(access.getFormat(), tcu::IVec3(width, height, depth), access.getPitch(), 257 (const deUint8*)access.getDataPtr() + access.getPixelPitch()*x + access.getRowPitch()*y + access.getSlicePitch()*z); 258 } 259 260 /*--------------------------------------------------------------------*//*! 261 * \brief Get access to subregion of pixel buffer 262 * \param access Parent access object 263 * \param x X offset 264 * \param y Y offset 265 * \param z Z offset 266 * \param width Width 267 * \param height Height 268 * \param depth Depth 269 * \return Access object that targets given subregion of parent access object 270 *//*--------------------------------------------------------------------*/ 271 PixelBufferAccess getSubregion (const PixelBufferAccess& access, int x, int y, int z, int width, int height, int depth) 272 { 273 DE_ASSERT(de::inBounds(x, 0, access.getWidth())); 274 DE_ASSERT(de::inRange(x+width, x+1, access.getWidth())); 275 276 DE_ASSERT(de::inBounds(y, 0, access.getHeight())); 277 DE_ASSERT(de::inRange(y+height, y+1, access.getHeight())); 278 279 DE_ASSERT(de::inBounds(z, 0, access.getDepth())); 280 DE_ASSERT(de::inRange(z+depth, z+1, access.getDepth())); 281 282 return PixelBufferAccess(access.getFormat(), tcu::IVec3(width, height, depth), access.getPitch(), 283 (deUint8*)access.getDataPtr() + access.getPixelPitch()*x + access.getRowPitch()*y + access.getSlicePitch()*z); 284 } 285 286 /*--------------------------------------------------------------------*//*! 287 * \brief Get access to subregion of pixel buffer 288 * \param access Parent access object 289 * \param x X offset 290 * \param y Y offset 291 * \param width Width 292 * \param height Height 293 * \return Access object that targets given subregion of parent access object 294 *//*--------------------------------------------------------------------*/ 295 PixelBufferAccess getSubregion (const PixelBufferAccess& access, int x, int y, int width, int height) 296 { 297 return getSubregion(access, x, y, 0, width, height, 1); 298 } 299 300 /*--------------------------------------------------------------------*//*! 301 * \brief Get access to subregion of pixel buffer 302 * \param access Parent access object 303 * \param x X offset 304 * \param y Y offset 305 * \param width Width 306 * \param height Height 307 * \return Access object that targets given subregion of parent access object 308 *//*--------------------------------------------------------------------*/ 309 ConstPixelBufferAccess getSubregion (const ConstPixelBufferAccess& access, int x, int y, int width, int height) 310 { 311 return getSubregion(access, x, y, 0, width, height, 1); 312 } 313 314 /*--------------------------------------------------------------------*//*! 315 * \brief Flip rows in Y direction 316 * \param access Access object 317 * \return Modified access object where Y coordinates are reversed 318 *//*--------------------------------------------------------------------*/ 319 PixelBufferAccess flipYAccess (const PixelBufferAccess& access) 320 { 321 const int rowPitch = access.getRowPitch(); 322 const int offsetToLast = rowPitch*(access.getHeight()-1); 323 const tcu::IVec3 pitch (access.getPixelPitch(), -rowPitch, access.getSlicePitch()); 324 325 return PixelBufferAccess(access.getFormat(), access.getSize(), pitch, (deUint8*)access.getDataPtr() + offsetToLast); 326 } 327 328 /*--------------------------------------------------------------------*//*! 329 * \brief Flip rows in Y direction 330 * \param access Access object 331 * \return Modified access object where Y coordinates are reversed 332 *//*--------------------------------------------------------------------*/ 333 ConstPixelBufferAccess flipYAccess (const ConstPixelBufferAccess& access) 334 { 335 const int rowPitch = access.getRowPitch(); 336 const int offsetToLast = rowPitch*(access.getHeight()-1); 337 const tcu::IVec3 pitch (access.getPixelPitch(), -rowPitch, access.getSlicePitch()); 338 339 return ConstPixelBufferAccess(access.getFormat(), access.getSize(), pitch, (deUint8*)access.getDataPtr() + offsetToLast); 340 } 341 342 static Vec2 getFloatChannelValueRange (TextureFormat::ChannelType channelType) 343 { 344 // make sure this table is updated if format table is updated 345 DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 38); 346 347 float cMin = 0.0f; 348 float cMax = 0.0f; 349 350 switch (channelType) 351 { 352 // Signed normalized formats. 353 case TextureFormat::SNORM_INT8: 354 case TextureFormat::SNORM_INT16: 355 case TextureFormat::SNORM_INT32: 356 case TextureFormat::SNORM_INT_1010102_REV: cMin = -1.0f; cMax = 1.0f; break; 357 358 // Unsigned normalized formats. 359 case TextureFormat::UNORM_INT8: 360 case TextureFormat::UNORM_INT16: 361 case TextureFormat::UNORM_INT24: 362 case TextureFormat::UNORM_INT32: 363 case TextureFormat::UNORM_BYTE_44: 364 case TextureFormat::UNORM_SHORT_565: 365 case TextureFormat::UNORM_SHORT_555: 366 case TextureFormat::UNORM_SHORT_4444: 367 case TextureFormat::UNORM_SHORT_5551: 368 case TextureFormat::UNORM_SHORT_1555: 369 case TextureFormat::UNORM_INT_101010: 370 case TextureFormat::UNORM_INT_1010102_REV: cMin = 0.0f; cMax = 1.0f; break; 371 372 // Misc formats. 373 case TextureFormat::SIGNED_INT8: cMin = -128.0f; cMax = 127.0f; break; 374 case TextureFormat::SIGNED_INT16: cMin = -32768.0f; cMax = 32767.0f; break; 375 case TextureFormat::SIGNED_INT32: cMin = -2147483648.0f; cMax = 2147483647.0f; break; 376 case TextureFormat::UNSIGNED_INT8: cMin = 0.0f; cMax = 255.0f; break; 377 case TextureFormat::UNSIGNED_INT16: cMin = 0.0f; cMax = 65535.0f; break; 378 case TextureFormat::UNSIGNED_INT24: cMin = 0.0f; cMax = 16777215.0f; break; 379 case TextureFormat::UNSIGNED_INT32: cMin = 0.0f; cMax = 4294967295.f; break; 380 case TextureFormat::HALF_FLOAT: cMin = -1e3f; cMax = 1e3f; break; 381 case TextureFormat::FLOAT: cMin = -1e5f; cMax = 1e5f; break; 382 case TextureFormat::FLOAT64: cMin = -1e5f; cMax = 1e5f; break; 383 case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: cMin = 0.0f; cMax = 1e4f; break; 384 case TextureFormat::UNSIGNED_INT_999_E5_REV: cMin = 0.0f; cMax = 1e5f; break; 385 case TextureFormat::UNSIGNED_BYTE_44: cMin = 0.0f; cMax = 15.f; break; 386 case TextureFormat::UNSIGNED_SHORT_4444: cMin = 0.0f; cMax = 15.f; break; 387 388 default: 389 DE_ASSERT(false); 390 } 391 392 return Vec2(cMin, cMax); 393 } 394 395 /*--------------------------------------------------------------------*//*! 396 * \brief Get standard parameters for testing texture format 397 * 398 * Returns TextureFormatInfo that describes good parameters for exercising 399 * given TextureFormat. Parameters include value ranges per channel and 400 * suitable lookup scaling and bias in order to reduce result back to 401 * 0..1 range. 402 *//*--------------------------------------------------------------------*/ 403 TextureFormatInfo getTextureFormatInfo (const TextureFormat& format) 404 { 405 // Special cases. 406 if (format.type == TextureFormat::UNSIGNED_INT_1010102_REV) 407 return TextureFormatInfo(Vec4( 0.0f, 0.0f, 0.0f, 0.0f), 408 Vec4( 1023.0f, 1023.0f, 1023.0f, 3.0f), 409 Vec4(1.0f/1023.f, 1.0f/1023.0f, 1.0f/1023.0f, 1.0f/3.0f), 410 Vec4( 0.0f, 0.0f, 0.0f, 0.0f)); 411 if (format.type == TextureFormat::SIGNED_INT_1010102_REV) 412 return TextureFormatInfo(Vec4( -512.0f, -512.0f, -512.0f, -2.0f), 413 Vec4( 511.0f, 511.0f, 511.0f, 1.0f), 414 Vec4(1.0f/1023.f, 1.0f/1023.0f, 1.0f/1023.0f, 1.0f/3.0f), 415 Vec4( 0.5f, 0.5f, 0.5f, 0.5f)); 416 else if (format.order == TextureFormat::D || format.order == TextureFormat::DS) 417 return TextureFormatInfo(Vec4(0.0f, 0.0f, 0.0f, 0.0f), 418 Vec4(1.0f, 1.0f, 1.0f, 0.0f), 419 Vec4(1.0f, 1.0f, 1.0f, 1.0f), 420 Vec4(0.0f, 0.0f, 0.0f, 0.0f)); // Depth / stencil formats. 421 else if (format == TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_5551)) 422 return TextureFormatInfo(Vec4(0.0f, 0.0f, 0.0f, 0.5f), 423 Vec4(1.0f, 1.0f, 1.0f, 1.5f), 424 Vec4(1.0f, 1.0f, 1.0f, 1.0f), 425 Vec4(0.0f, 0.0f, 0.0f, 0.0f)); 426 else if (format.type == TextureFormat::UNSIGNED_SHORT_5551) 427 return TextureFormatInfo(Vec4( 0.0f, 0.0f, 0.0f, 0.0f), 428 Vec4( 31.0f, 31.0f, 31.0f, 1.0f), 429 Vec4(1.0f/31.f, 1.0f/31.0f, 1.0f/31.0f, 1.0f), 430 Vec4( 0.0f, 0.0f, 0.0f, 0.0f)); 431 else if (format.type == TextureFormat::UNSIGNED_SHORT_565) 432 return TextureFormatInfo(Vec4( 0.0f, 0.0f, 0.0f, 0.0f), 433 Vec4( 31.0f, 63.0f, 31.0f, 0.0f), 434 Vec4(1.0f/31.f, 1.0f/63.0f, 1.0f/31.0f, 1.0f), 435 Vec4( 0.0f, 0.0f, 0.0f, 0.0f)); 436 437 const Vec2 cRange = getFloatChannelValueRange(format.type); 438 const TextureSwizzle::Channel* map = getChannelReadSwizzle(format.order).components; 439 const BVec4 chnMask = BVec4(deInRange32(map[0], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE, 440 deInRange32(map[1], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE, 441 deInRange32(map[2], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE, 442 deInRange32(map[3], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE); 443 const float scale = 1.0f / (cRange[1] - cRange[0]); 444 const float bias = -cRange[0] * scale; 445 446 return TextureFormatInfo(select(cRange[0], 0.0f, chnMask), 447 select(cRange[1], 0.0f, chnMask), 448 select(scale, 1.0f, chnMask), 449 select(bias, 0.0f, chnMask)); 450 } 451 452 IVec4 getFormatMinIntValue (const TextureFormat& format) 453 { 454 DE_ASSERT(getTextureChannelClass(format.type) == TEXTURECHANNELCLASS_SIGNED_INTEGER); 455 456 switch (format.type) 457 { 458 case TextureFormat::SIGNED_INT8: return IVec4(std::numeric_limits<deInt8>::min()); 459 case TextureFormat::SIGNED_INT16: return IVec4(std::numeric_limits<deInt16>::min()); 460 case TextureFormat::SIGNED_INT32: return IVec4(std::numeric_limits<deInt32>::min()); 461 462 default: 463 DE_FATAL("Invalid channel type"); 464 return IVec4(0); 465 } 466 } 467 468 IVec4 getFormatMaxIntValue (const TextureFormat& format) 469 { 470 DE_ASSERT(getTextureChannelClass(format.type) == TEXTURECHANNELCLASS_SIGNED_INTEGER); 471 472 switch (format.type) 473 { 474 case TextureFormat::SIGNED_INT8: return IVec4(std::numeric_limits<deInt8>::max()); 475 case TextureFormat::SIGNED_INT16: return IVec4(std::numeric_limits<deInt16>::max()); 476 case TextureFormat::SIGNED_INT32: return IVec4(std::numeric_limits<deInt32>::max()); 477 478 default: 479 DE_FATAL("Invalid channel type"); 480 return IVec4(0); 481 } 482 } 483 484 UVec4 getFormatMaxUintValue (const TextureFormat& format) 485 { 486 DE_ASSERT(getTextureChannelClass(format.type) == TEXTURECHANNELCLASS_UNSIGNED_INTEGER); 487 488 if (format == TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT_1010102_REV)) 489 return UVec4(1023u, 1023u, 1023u, 3u); 490 491 switch (format.type) 492 { 493 case TextureFormat::UNSIGNED_INT8: return UVec4(std::numeric_limits<deUint8>::max()); 494 case TextureFormat::UNSIGNED_INT16: return UVec4(std::numeric_limits<deUint16>::max()); 495 case TextureFormat::UNSIGNED_INT24: return UVec4(0xffffffu); 496 case TextureFormat::UNSIGNED_INT32: return UVec4(std::numeric_limits<deUint32>::max()); 497 498 default: 499 DE_FATAL("Invalid channel type"); 500 return UVec4(0); 501 } 502 } 503 504 static IVec4 getChannelBitDepth (TextureFormat::ChannelType channelType) 505 { 506 // make sure this table is updated if format table is updated 507 DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 38); 508 509 switch (channelType) 510 { 511 case TextureFormat::SNORM_INT8: return IVec4(8); 512 case TextureFormat::SNORM_INT16: return IVec4(16); 513 case TextureFormat::SNORM_INT32: return IVec4(32); 514 case TextureFormat::UNORM_INT8: return IVec4(8); 515 case TextureFormat::UNORM_INT16: return IVec4(16); 516 case TextureFormat::UNORM_INT24: return IVec4(24); 517 case TextureFormat::UNORM_INT32: return IVec4(32); 518 case TextureFormat::UNORM_BYTE_44: return IVec4(4,4,0,0); 519 case TextureFormat::UNORM_SHORT_565: return IVec4(5,6,5,0); 520 case TextureFormat::UNORM_SHORT_4444: return IVec4(4); 521 case TextureFormat::UNORM_SHORT_555: return IVec4(5,5,5,0); 522 case TextureFormat::UNORM_SHORT_5551: return IVec4(5,5,5,1); 523 case TextureFormat::UNORM_SHORT_1555: return IVec4(1,5,5,5); 524 case TextureFormat::UNSIGNED_BYTE_44: return IVec4(4,4,0,0); 525 case TextureFormat::UNSIGNED_SHORT_565: return IVec4(5,6,5,0); 526 case TextureFormat::UNSIGNED_SHORT_4444: return IVec4(4); 527 case TextureFormat::UNSIGNED_SHORT_5551: return IVec4(5,5,5,1); 528 case TextureFormat::UNORM_INT_101010: return IVec4(10,10,10,0); 529 case TextureFormat::SNORM_INT_1010102_REV: return IVec4(10,10,10,2); 530 case TextureFormat::UNORM_INT_1010102_REV: return IVec4(10,10,10,2); 531 case TextureFormat::SIGNED_INT8: return IVec4(8); 532 case TextureFormat::SIGNED_INT16: return IVec4(16); 533 case TextureFormat::SIGNED_INT32: return IVec4(32); 534 case TextureFormat::UNSIGNED_INT8: return IVec4(8); 535 case TextureFormat::UNSIGNED_INT16: return IVec4(16); 536 case TextureFormat::UNSIGNED_INT24: return IVec4(24); 537 case TextureFormat::UNSIGNED_INT32: return IVec4(32); 538 case TextureFormat::SIGNED_INT_1010102_REV: return IVec4(10,10,10,2); 539 case TextureFormat::UNSIGNED_INT_1010102_REV: return IVec4(10,10,10,2); 540 case TextureFormat::UNSIGNED_INT_16_8_8: return IVec4(16,8,0,0); 541 case TextureFormat::UNSIGNED_INT_24_8: return IVec4(24,8,0,0); 542 case TextureFormat::UNSIGNED_INT_24_8_REV: return IVec4(24,8,0,0); 543 case TextureFormat::HALF_FLOAT: return IVec4(16); 544 case TextureFormat::FLOAT: return IVec4(32); 545 case TextureFormat::FLOAT64: return IVec4(64); 546 case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: return IVec4(11,11,10,0); 547 case TextureFormat::UNSIGNED_INT_999_E5_REV: return IVec4(9,9,9,0); 548 case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: return IVec4(32,8,0,0); 549 default: 550 DE_ASSERT(false); 551 return IVec4(0); 552 } 553 } 554 555 IVec4 getTextureFormatBitDepth (const TextureFormat& format) 556 { 557 const IVec4 chnBits = getChannelBitDepth(format.type); 558 const TextureSwizzle::Channel* map = getChannelReadSwizzle(format.order).components; 559 const BVec4 chnMask = BVec4(deInRange32(map[0], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE, 560 deInRange32(map[1], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE, 561 deInRange32(map[2], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE, 562 deInRange32(map[3], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE); 563 const IVec4 chnSwz = IVec4((chnMask[0]) ? ((int)map[0]) : (0), 564 (chnMask[1]) ? ((int)map[1]) : (0), 565 (chnMask[2]) ? ((int)map[2]) : (0), 566 (chnMask[3]) ? ((int)map[3]) : (0)); 567 568 return select(chnBits.swizzle(chnSwz.x(), chnSwz.y(), chnSwz.z(), chnSwz.w()), IVec4(0), chnMask); 569 } 570 571 static IVec4 getChannelMantissaBitDepth (TextureFormat::ChannelType channelType) 572 { 573 // make sure this table is updated if format table is updated 574 DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 38); 575 576 switch (channelType) 577 { 578 case TextureFormat::SNORM_INT8: 579 case TextureFormat::SNORM_INT16: 580 case TextureFormat::SNORM_INT32: 581 case TextureFormat::UNORM_INT8: 582 case TextureFormat::UNORM_INT16: 583 case TextureFormat::UNORM_INT24: 584 case TextureFormat::UNORM_INT32: 585 case TextureFormat::UNORM_BYTE_44: 586 case TextureFormat::UNORM_SHORT_565: 587 case TextureFormat::UNORM_SHORT_4444: 588 case TextureFormat::UNORM_SHORT_555: 589 case TextureFormat::UNORM_SHORT_5551: 590 case TextureFormat::UNORM_SHORT_1555: 591 case TextureFormat::UNSIGNED_BYTE_44: 592 case TextureFormat::UNSIGNED_SHORT_565: 593 case TextureFormat::UNSIGNED_SHORT_4444: 594 case TextureFormat::UNSIGNED_SHORT_5551: 595 case TextureFormat::UNORM_INT_101010: 596 case TextureFormat::SNORM_INT_1010102_REV: 597 case TextureFormat::UNORM_INT_1010102_REV: 598 case TextureFormat::SIGNED_INT8: 599 case TextureFormat::SIGNED_INT16: 600 case TextureFormat::SIGNED_INT32: 601 case TextureFormat::UNSIGNED_INT8: 602 case TextureFormat::UNSIGNED_INT16: 603 case TextureFormat::UNSIGNED_INT24: 604 case TextureFormat::UNSIGNED_INT32: 605 case TextureFormat::SIGNED_INT_1010102_REV: 606 case TextureFormat::UNSIGNED_INT_1010102_REV: 607 case TextureFormat::UNSIGNED_INT_16_8_8: 608 case TextureFormat::UNSIGNED_INT_24_8: 609 case TextureFormat::UNSIGNED_INT_24_8_REV: 610 case TextureFormat::UNSIGNED_INT_999_E5_REV: 611 return getChannelBitDepth(channelType); 612 613 case TextureFormat::HALF_FLOAT: return IVec4(10); 614 case TextureFormat::FLOAT: return IVec4(23); 615 case TextureFormat::FLOAT64: return IVec4(52); 616 case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: return IVec4(6,6,5,0); 617 case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: return IVec4(23,8,0,0); 618 default: 619 DE_ASSERT(false); 620 return IVec4(0); 621 } 622 } 623 624 IVec4 getTextureFormatMantissaBitDepth (const TextureFormat& format) 625 { 626 const IVec4 chnBits = getChannelMantissaBitDepth(format.type); 627 const TextureSwizzle::Channel* map = getChannelReadSwizzle(format.order).components; 628 const BVec4 chnMask = BVec4(deInRange32(map[0], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE, 629 deInRange32(map[1], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE, 630 deInRange32(map[2], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE, 631 deInRange32(map[3], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE); 632 const IVec4 chnSwz = IVec4((chnMask[0]) ? ((int)map[0]) : (0), 633 (chnMask[1]) ? ((int)map[1]) : (0), 634 (chnMask[2]) ? ((int)map[2]) : (0), 635 (chnMask[3]) ? ((int)map[3]) : (0)); 636 637 return select(chnBits.swizzle(chnSwz.x(), chnSwz.y(), chnSwz.z(), chnSwz.w()), IVec4(0), chnMask); 638 } 639 640 BVec4 getTextureFormatChannelMask (const TextureFormat& format) 641 { 642 const TextureSwizzle::Channel* const map = getChannelReadSwizzle(format.order).components; 643 return BVec4(deInRange32(map[0], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE, 644 deInRange32(map[1], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE, 645 deInRange32(map[2], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE, 646 deInRange32(map[3], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE); 647 } 648 649 static inline float linearInterpolate (float t, float minVal, float maxVal) 650 { 651 return minVal + (maxVal - minVal) * t; 652 } 653 654 static inline Vec4 linearInterpolate (float t, const Vec4& a, const Vec4& b) 655 { 656 return a + (b - a) * t; 657 } 658 659 enum 660 { 661 CLEAR_OPTIMIZE_THRESHOLD = 128, 662 CLEAR_OPTIMIZE_MAX_PIXEL_SIZE = 8 663 }; 664 665 inline void fillRow (const PixelBufferAccess& dst, int y, int z, int pixelSize, const deUint8* pixel) 666 { 667 DE_ASSERT(dst.getPixelPitch() == pixelSize); // only tightly packed 668 669 deUint8* dstPtr = (deUint8*)dst.getPixelPtr(0, y, z); 670 int width = dst.getWidth(); 671 672 if (pixelSize == 8 && deIsAlignedPtr(dstPtr, pixelSize)) 673 { 674 deUint64 val; 675 memcpy(&val, pixel, sizeof(val)); 676 677 for (int i = 0; i < width; i++) 678 ((deUint64*)dstPtr)[i] = val; 679 } 680 else if (pixelSize == 4 && deIsAlignedPtr(dstPtr, pixelSize)) 681 { 682 deUint32 val; 683 memcpy(&val, pixel, sizeof(val)); 684 685 for (int i = 0; i < width; i++) 686 ((deUint32*)dstPtr)[i] = val; 687 } 688 else 689 { 690 for (int i = 0; i < width; i++) 691 for (int j = 0; j < pixelSize; j++) 692 dstPtr[i*pixelSize+j] = pixel[j]; 693 } 694 } 695 696 void clear (const PixelBufferAccess& access, const Vec4& color) 697 { 698 const int pixelSize = access.getFormat().getPixelSize(); 699 const int pixelPitch = access.getPixelPitch(); 700 const bool rowPixelsTightlyPacked = (pixelSize == pixelPitch); 701 702 if (access.getWidth()*access.getHeight()*access.getDepth() >= CLEAR_OPTIMIZE_THRESHOLD && 703 pixelSize < CLEAR_OPTIMIZE_MAX_PIXEL_SIZE && rowPixelsTightlyPacked) 704 { 705 // Convert to destination format. 706 union 707 { 708 deUint8 u8[CLEAR_OPTIMIZE_MAX_PIXEL_SIZE]; 709 deUint64 u64; // Forces 64-bit alignment. 710 } pixel; 711 DE_STATIC_ASSERT(sizeof(pixel) == CLEAR_OPTIMIZE_MAX_PIXEL_SIZE); 712 PixelBufferAccess(access.getFormat(), 1, 1, 1, 0, 0, &pixel.u8[0]).setPixel(color, 0, 0); 713 714 for (int z = 0; z < access.getDepth(); z++) 715 for (int y = 0; y < access.getHeight(); y++) 716 fillRow(access, y, z, pixelSize, &pixel.u8[0]); 717 } 718 else 719 { 720 for (int z = 0; z < access.getDepth(); z++) 721 for (int y = 0; y < access.getHeight(); y++) 722 for (int x = 0; x < access.getWidth(); x++) 723 access.setPixel(color, x, y, z); 724 } 725 } 726 727 void clear (const PixelBufferAccess& access, const IVec4& color) 728 { 729 const int pixelSize = access.getFormat().getPixelSize(); 730 const int pixelPitch = access.getPixelPitch(); 731 const bool rowPixelsTightlyPacked = (pixelSize == pixelPitch); 732 733 if (access.getWidth()*access.getHeight()*access.getDepth() >= CLEAR_OPTIMIZE_THRESHOLD && 734 pixelSize < CLEAR_OPTIMIZE_MAX_PIXEL_SIZE && rowPixelsTightlyPacked) 735 { 736 // Convert to destination format. 737 union 738 { 739 deUint8 u8[CLEAR_OPTIMIZE_MAX_PIXEL_SIZE]; 740 deUint64 u64; // Forces 64-bit alignment. 741 } pixel; 742 DE_STATIC_ASSERT(sizeof(pixel) == CLEAR_OPTIMIZE_MAX_PIXEL_SIZE); 743 PixelBufferAccess(access.getFormat(), 1, 1, 1, 0, 0, &pixel.u8[0]).setPixel(color, 0, 0); 744 745 for (int z = 0; z < access.getDepth(); z++) 746 for (int y = 0; y < access.getHeight(); y++) 747 fillRow(access, y, z, pixelSize, &pixel.u8[0]); 748 } 749 else 750 { 751 for (int z = 0; z < access.getDepth(); z++) 752 for (int y = 0; y < access.getHeight(); y++) 753 for (int x = 0; x < access.getWidth(); x++) 754 access.setPixel(color, x, y, z); 755 } 756 } 757 758 void clear (const PixelBufferAccess& access, const UVec4& color) 759 { 760 clear(access, color.cast<deInt32>()); 761 } 762 763 void clearDepth (const PixelBufferAccess& access, float depth) 764 { 765 DE_ASSERT(access.getFormat().order == TextureFormat::DS || access.getFormat().order == TextureFormat::D); 766 767 clear(getEffectiveDepthStencilAccess(access, Sampler::MODE_DEPTH), tcu::Vec4(depth, 0.0f, 0.0f, 0.0f)); 768 } 769 770 void clearStencil (const PixelBufferAccess& access, int stencil) 771 { 772 DE_ASSERT(access.getFormat().order == TextureFormat::DS || access.getFormat().order == TextureFormat::S); 773 774 clear(getEffectiveDepthStencilAccess(access, Sampler::MODE_STENCIL), tcu::UVec4(stencil, 0u, 0u, 0u)); 775 } 776 777 static void fillWithComponentGradients1D (const PixelBufferAccess& access, const Vec4& minVal, const Vec4& maxVal) 778 { 779 DE_ASSERT(access.getHeight() == 1); 780 for (int x = 0; x < access.getWidth(); x++) 781 { 782 float s = ((float)x + 0.5f) / (float)access.getWidth(); 783 784 float r = linearInterpolate(s, minVal.x(), maxVal.x()); 785 float g = linearInterpolate(s, minVal.y(), maxVal.y()); 786 float b = linearInterpolate(s, minVal.z(), maxVal.z()); 787 float a = linearInterpolate(s, minVal.w(), maxVal.w()); 788 789 access.setPixel(tcu::Vec4(r, g, b, a), x, 0); 790 } 791 } 792 793 static void fillWithComponentGradients2D (const PixelBufferAccess& access, const Vec4& minVal, const Vec4& maxVal) 794 { 795 for (int y = 0; y < access.getHeight(); y++) 796 { 797 for (int x = 0; x < access.getWidth(); x++) 798 { 799 float s = ((float)x + 0.5f) / (float)access.getWidth(); 800 float t = ((float)y + 0.5f) / (float)access.getHeight(); 801 802 float r = linearInterpolate(( s + t) *0.5f, minVal.x(), maxVal.x()); 803 float g = linearInterpolate(( s + (1.0f-t))*0.5f, minVal.y(), maxVal.y()); 804 float b = linearInterpolate(((1.0f-s) + t) *0.5f, minVal.z(), maxVal.z()); 805 float a = linearInterpolate(((1.0f-s) + (1.0f-t))*0.5f, minVal.w(), maxVal.w()); 806 807 access.setPixel(tcu::Vec4(r, g, b, a), x, y); 808 } 809 } 810 } 811 812 static void fillWithComponentGradients3D (const PixelBufferAccess& dst, const Vec4& minVal, const Vec4& maxVal) 813 { 814 for (int z = 0; z < dst.getDepth(); z++) 815 { 816 for (int y = 0; y < dst.getHeight(); y++) 817 { 818 for (int x = 0; x < dst.getWidth(); x++) 819 { 820 float s = ((float)x + 0.5f) / (float)dst.getWidth(); 821 float t = ((float)y + 0.5f) / (float)dst.getHeight(); 822 float p = ((float)z + 0.5f) / (float)dst.getDepth(); 823 824 float r = linearInterpolate(s, minVal.x(), maxVal.x()); 825 float g = linearInterpolate(t, minVal.y(), maxVal.y()); 826 float b = linearInterpolate(p, minVal.z(), maxVal.z()); 827 float a = linearInterpolate(1.0f - (s+t+p)/3.0f, minVal.w(), maxVal.w()); 828 829 dst.setPixel(tcu::Vec4(r, g, b, a), x, y, z); 830 } 831 } 832 } 833 } 834 835 void fillWithComponentGradients (const PixelBufferAccess& access, const Vec4& minVal, const Vec4& maxVal) 836 { 837 if (isCombinedDepthStencilType(access.getFormat().type)) 838 { 839 const bool hasDepth = access.getFormat().order == tcu::TextureFormat::DS || access.getFormat().order == tcu::TextureFormat::D; 840 const bool hasStencil = access.getFormat().order == tcu::TextureFormat::DS || access.getFormat().order == tcu::TextureFormat::S; 841 842 DE_ASSERT(hasDepth || hasStencil); 843 844 // For combined formats, treat D and S as separate channels 845 if (hasDepth) 846 fillWithComponentGradients(getEffectiveDepthStencilAccess(access, tcu::Sampler::MODE_DEPTH), minVal, maxVal); 847 if (hasStencil) 848 fillWithComponentGradients(getEffectiveDepthStencilAccess(access, tcu::Sampler::MODE_STENCIL), minVal.swizzle(3,2,1,0), maxVal.swizzle(3,2,1,0)); 849 } 850 else 851 { 852 if (access.getHeight() == 1 && access.getDepth() == 1) 853 fillWithComponentGradients1D(access, minVal, maxVal); 854 else if (access.getDepth() == 1) 855 fillWithComponentGradients2D(access, minVal, maxVal); 856 else 857 fillWithComponentGradients3D(access, minVal, maxVal); 858 } 859 } 860 861 static void fillWithGrid1D (const PixelBufferAccess& access, int cellSize, const Vec4& colorA, const Vec4& colorB) 862 { 863 for (int x = 0; x < access.getWidth(); x++) 864 { 865 int mx = (x / cellSize) % 2; 866 867 if (mx) 868 access.setPixel(colorB, x, 0); 869 else 870 access.setPixel(colorA, x, 0); 871 } 872 } 873 874 static void fillWithGrid2D (const PixelBufferAccess& access, int cellSize, const Vec4& colorA, const Vec4& colorB) 875 { 876 for (int y = 0; y < access.getHeight(); y++) 877 { 878 for (int x = 0; x < access.getWidth(); x++) 879 { 880 int mx = (x / cellSize) % 2; 881 int my = (y / cellSize) % 2; 882 883 if (mx ^ my) 884 access.setPixel(colorB, x, y); 885 else 886 access.setPixel(colorA, x, y); 887 } 888 } 889 } 890 891 static void fillWithGrid3D (const PixelBufferAccess& access, int cellSize, const Vec4& colorA, const Vec4& colorB) 892 { 893 for (int z = 0; z < access.getDepth(); z++) 894 { 895 for (int y = 0; y < access.getHeight(); y++) 896 { 897 for (int x = 0; x < access.getWidth(); x++) 898 { 899 int mx = (x / cellSize) % 2; 900 int my = (y / cellSize) % 2; 901 int mz = (z / cellSize) % 2; 902 903 if (mx ^ my ^ mz) 904 access.setPixel(colorB, x, y, z); 905 else 906 access.setPixel(colorA, x, y, z); 907 } 908 } 909 } 910 } 911 912 void fillWithGrid (const PixelBufferAccess& access, int cellSize, const Vec4& colorA, const Vec4& colorB) 913 { 914 if (isCombinedDepthStencilType(access.getFormat().type)) 915 { 916 const bool hasDepth = access.getFormat().order == tcu::TextureFormat::DS || access.getFormat().order == tcu::TextureFormat::D; 917 const bool hasStencil = access.getFormat().order == tcu::TextureFormat::DS || access.getFormat().order == tcu::TextureFormat::S; 918 919 DE_ASSERT(hasDepth || hasStencil); 920 921 // For combined formats, treat D and S as separate channels 922 if (hasDepth) 923 fillWithGrid(getEffectiveDepthStencilAccess(access, tcu::Sampler::MODE_DEPTH), cellSize, colorA, colorB); 924 if (hasStencil) 925 fillWithGrid(getEffectiveDepthStencilAccess(access, tcu::Sampler::MODE_STENCIL), cellSize, colorA.swizzle(3,2,1,0), colorB.swizzle(3,2,1,0)); 926 } 927 else 928 { 929 if (access.getHeight() == 1 && access.getDepth() == 1) 930 fillWithGrid1D(access, cellSize, colorA, colorB); 931 else if (access.getDepth() == 1) 932 fillWithGrid2D(access, cellSize, colorA, colorB); 933 else 934 fillWithGrid3D(access, cellSize, colorA, colorB); 935 } 936 } 937 938 void fillWithRepeatableGradient (const PixelBufferAccess& access, const Vec4& colorA, const Vec4& colorB) 939 { 940 for (int y = 0; y < access.getHeight(); y++) 941 { 942 for (int x = 0; x < access.getWidth(); x++) 943 { 944 float s = ((float)x + 0.5f) / (float)access.getWidth(); 945 float t = ((float)y + 0.5f) / (float)access.getHeight(); 946 947 float a = s > 0.5f ? (2.0f - 2.0f*s) : 2.0f*s; 948 float b = t > 0.5f ? (2.0f - 2.0f*t) : 2.0f*t; 949 950 float p = deFloatClamp(deFloatSqrt(a*a + b*b), 0.0f, 1.0f); 951 access.setPixel(linearInterpolate(p, colorA, colorB), x, y); 952 } 953 } 954 } 955 956 void fillWithRGBAQuads (const PixelBufferAccess& dst) 957 { 958 TCU_CHECK_INTERNAL(dst.getDepth() == 1); 959 int width = dst.getWidth(); 960 int height = dst.getHeight(); 961 int left = width/2; 962 int top = height/2; 963 964 clear(getSubregion(dst, 0, 0, 0, left, top, 1), Vec4(1.0f, 0.0f, 0.0f, 1.0f)); 965 clear(getSubregion(dst, left, 0, 0, width-left, top, 1), Vec4(0.0f, 1.0f, 0.0f, 1.0f)); 966 clear(getSubregion(dst, 0, top, 0, left, height-top, 1), Vec4(0.0f, 0.0f, 1.0f, 0.0f)); 967 clear(getSubregion(dst, left, top, 0, width-left, height-top, 1), Vec4(0.5f, 0.5f, 0.5f, 1.0f)); 968 } 969 970 // \todo [2012-11-13 pyry] There is much better metaballs code in CL SIR value generators. 971 void fillWithMetaballs (const PixelBufferAccess& dst, int numBalls, deUint32 seed) 972 { 973 TCU_CHECK_INTERNAL(dst.getDepth() == 1); 974 std::vector<Vec2> points(numBalls); 975 de::Random rnd(seed); 976 977 for (int i = 0; i < numBalls; i++) 978 { 979 float x = rnd.getFloat(); 980 float y = rnd.getFloat(); 981 points[i] = (Vec2(x, y)); 982 } 983 984 for (int y = 0; y < dst.getHeight(); y++) 985 for (int x = 0; x < dst.getWidth(); x++) 986 { 987 Vec2 p((float)x/(float)dst.getWidth(), (float)y/(float)dst.getHeight()); 988 989 float sum = 0.0f; 990 for (std::vector<Vec2>::const_iterator i = points.begin(); i != points.end(); i++) 991 { 992 Vec2 d = p - *i; 993 float f = 0.01f / (d.x()*d.x() + d.y()*d.y()); 994 995 sum += f; 996 } 997 998 dst.setPixel(Vec4(sum), x, y); 999 } 1000 } 1001 1002 void copy (const PixelBufferAccess& dst, const ConstPixelBufferAccess& src) 1003 { 1004 DE_ASSERT(src.getSize() == dst.getSize()); 1005 1006 const int width = dst.getWidth(); 1007 const int height = dst.getHeight(); 1008 const int depth = dst.getDepth(); 1009 1010 const int srcPixelSize = src.getFormat().getPixelSize(); 1011 const int dstPixelSize = dst.getFormat().getPixelSize(); 1012 const int srcPixelPitch = src.getPixelPitch(); 1013 const int dstPixelPitch = dst.getPixelPitch(); 1014 const bool srcTightlyPacked = (srcPixelSize == srcPixelPitch); 1015 const bool dstTightlyPacked = (dstPixelSize == dstPixelPitch); 1016 1017 const bool srcHasDepth = (src.getFormat().order == tcu::TextureFormat::DS || src.getFormat().order == tcu::TextureFormat::D); 1018 const bool srcHasStencil = (src.getFormat().order == tcu::TextureFormat::DS || src.getFormat().order == tcu::TextureFormat::S); 1019 const bool dstHasDepth = (dst.getFormat().order == tcu::TextureFormat::DS || dst.getFormat().order == tcu::TextureFormat::D); 1020 const bool dstHasStencil = (dst.getFormat().order == tcu::TextureFormat::DS || dst.getFormat().order == tcu::TextureFormat::S); 1021 1022 if (src.getFormat() == dst.getFormat() && srcTightlyPacked && dstTightlyPacked) 1023 { 1024 // Fast-path for matching formats. 1025 for (int z = 0; z < depth; z++) 1026 for (int y = 0; y < height; y++) 1027 deMemcpy(dst.getPixelPtr(0, y, z), src.getPixelPtr(0, y, z), srcPixelSize*width); 1028 } 1029 else if (src.getFormat() == dst.getFormat()) 1030 { 1031 // Bit-exact copy for matching formats. 1032 for (int z = 0; z < depth; z++) 1033 for (int y = 0; y < height; y++) 1034 for (int x = 0; x < width; x++) 1035 deMemcpy(dst.getPixelPtr(x, y, z), src.getPixelPtr(x, y, z), srcPixelSize); 1036 } 1037 else if (srcHasDepth || srcHasStencil || dstHasDepth || dstHasStencil) 1038 { 1039 DE_ASSERT((srcHasDepth && dstHasDepth) || (srcHasStencil && dstHasStencil)); // must have at least one common channel 1040 1041 if (dstHasDepth && srcHasDepth) 1042 { 1043 for (int z = 0; z < depth; z++) 1044 for (int y = 0; y < height; y++) 1045 for (int x = 0; x < width; x++) 1046 dst.setPixDepth(src.getPixDepth(x, y, z), x, y, z); 1047 } 1048 else if (dstHasDepth && !srcHasDepth) 1049 { 1050 // consistency with color copies 1051 tcu::clearDepth(dst, 0.0f); 1052 } 1053 1054 if (dstHasStencil && srcHasStencil) 1055 { 1056 for (int z = 0; z < depth; z++) 1057 for (int y = 0; y < height; y++) 1058 for (int x = 0; x < width; x++) 1059 dst.setPixStencil(src.getPixStencil(x, y, z), x, y, z); 1060 } 1061 else if (dstHasStencil && !srcHasStencil) 1062 { 1063 // consistency with color copies 1064 tcu::clearStencil(dst, 0u); 1065 } 1066 } 1067 else 1068 { 1069 TextureChannelClass srcClass = getTextureChannelClass(src.getFormat().type); 1070 TextureChannelClass dstClass = getTextureChannelClass(dst.getFormat().type); 1071 bool srcIsInt = srcClass == TEXTURECHANNELCLASS_SIGNED_INTEGER || srcClass == TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 1072 bool dstIsInt = dstClass == TEXTURECHANNELCLASS_SIGNED_INTEGER || dstClass == TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 1073 1074 if (srcIsInt && dstIsInt) 1075 { 1076 for (int z = 0; z < depth; z++) 1077 for (int y = 0; y < height; y++) 1078 for (int x = 0; x < width; x++) 1079 dst.setPixel(src.getPixelInt(x, y, z), x, y, z); 1080 } 1081 else 1082 { 1083 for (int z = 0; z < depth; z++) 1084 for (int y = 0; y < height; y++) 1085 for (int x = 0; x < width; x++) 1086 dst.setPixel(src.getPixel(x, y, z), x, y, z); 1087 } 1088 } 1089 } 1090 1091 void scale (const PixelBufferAccess& dst, const ConstPixelBufferAccess& src, Sampler::FilterMode filter) 1092 { 1093 DE_ASSERT(filter == Sampler::NEAREST || filter == Sampler::LINEAR); 1094 1095 Sampler sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, 1096 filter, filter, 0.0f, false); 1097 1098 float sX = (float)src.getWidth() / (float)dst.getWidth(); 1099 float sY = (float)src.getHeight() / (float)dst.getHeight(); 1100 float sZ = (float)src.getDepth() / (float)dst.getDepth(); 1101 1102 if (dst.getDepth() == 1 && src.getDepth() == 1) 1103 { 1104 for (int y = 0; y < dst.getHeight(); y++) 1105 for (int x = 0; x < dst.getWidth(); x++) 1106 dst.setPixel(src.sample2D(sampler, filter, ((float)x+0.5f)*sX, ((float)y+0.5f)*sY, 0), x, y); 1107 } 1108 else 1109 { 1110 for (int z = 0; z < dst.getDepth(); z++) 1111 for (int y = 0; y < dst.getHeight(); y++) 1112 for (int x = 0; x < dst.getWidth(); x++) 1113 dst.setPixel(src.sample3D(sampler, filter, ((float)x+0.5f)*sX, ((float)y+0.5f)*sY, ((float)z+0.5f)*sZ), x, y, z); 1114 } 1115 } 1116 1117 void estimatePixelValueRange (const ConstPixelBufferAccess& access, Vec4& minVal, Vec4& maxVal) 1118 { 1119 const TextureFormat& format = access.getFormat(); 1120 1121 switch (getTextureChannelClass(format.type)) 1122 { 1123 case TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 1124 // Normalized unsigned formats. 1125 minVal = Vec4(0.0f); 1126 maxVal = Vec4(1.0f); 1127 break; 1128 1129 case TEXTURECHANNELCLASS_SIGNED_FIXED_POINT: 1130 // Normalized signed formats. 1131 minVal = Vec4(-1.0f); 1132 maxVal = Vec4(+1.0f); 1133 break; 1134 1135 default: 1136 // \note Samples every 4/8th pixel. 1137 minVal = Vec4(std::numeric_limits<float>::max()); 1138 maxVal = Vec4(std::numeric_limits<float>::min()); 1139 1140 for (int z = 0; z < access.getDepth(); z += 2) 1141 { 1142 for (int y = 0; y < access.getHeight(); y += 2) 1143 { 1144 for (int x = 0; x < access.getWidth(); x += 2) 1145 { 1146 Vec4 p = access.getPixel(x, y, z); 1147 1148 minVal[0] = (deFloatIsNaN(p[0]) ? minVal[0] : de::min(minVal[0], p[0])); 1149 minVal[1] = (deFloatIsNaN(p[1]) ? minVal[1] : de::min(minVal[1], p[1])); 1150 minVal[2] = (deFloatIsNaN(p[2]) ? minVal[2] : de::min(minVal[2], p[2])); 1151 minVal[3] = (deFloatIsNaN(p[3]) ? minVal[3] : de::min(minVal[3], p[3])); 1152 1153 maxVal[0] = (deFloatIsNaN(p[0]) ? maxVal[0] : de::max(maxVal[0], p[0])); 1154 maxVal[1] = (deFloatIsNaN(p[1]) ? maxVal[1] : de::max(maxVal[1], p[1])); 1155 maxVal[2] = (deFloatIsNaN(p[2]) ? maxVal[2] : de::max(maxVal[2], p[2])); 1156 maxVal[3] = (deFloatIsNaN(p[3]) ? maxVal[3] : de::max(maxVal[3], p[3])); 1157 } 1158 } 1159 } 1160 break; 1161 } 1162 } 1163 1164 void computePixelScaleBias (const ConstPixelBufferAccess& access, Vec4& scale, Vec4& bias) 1165 { 1166 Vec4 minVal, maxVal; 1167 estimatePixelValueRange(access, minVal, maxVal); 1168 1169 const float eps = 0.0001f; 1170 1171 for (int c = 0; c < 4; c++) 1172 { 1173 if (maxVal[c] - minVal[c] < eps) 1174 { 1175 scale[c] = (maxVal[c] < eps) ? 1.0f : (1.0f / maxVal[c]); 1176 bias[c] = (c == 3) ? (1.0f - maxVal[c]*scale[c]) : (0.0f - minVal[c]*scale[c]); 1177 } 1178 else 1179 { 1180 scale[c] = 1.0f / (maxVal[c] - minVal[c]); 1181 bias[c] = 0.0f - minVal[c]*scale[c]; 1182 } 1183 } 1184 } 1185 1186 int getCubeArrayFaceIndex (CubeFace face) 1187 { 1188 DE_ASSERT((int)face >= 0 && face < CUBEFACE_LAST); 1189 1190 switch (face) 1191 { 1192 case CUBEFACE_POSITIVE_X: return 0; 1193 case CUBEFACE_NEGATIVE_X: return 1; 1194 case CUBEFACE_POSITIVE_Y: return 2; 1195 case CUBEFACE_NEGATIVE_Y: return 3; 1196 case CUBEFACE_POSITIVE_Z: return 4; 1197 case CUBEFACE_NEGATIVE_Z: return 5; 1198 1199 default: 1200 return -1; 1201 } 1202 } 1203 1204 deUint32 packRGB999E5 (const tcu::Vec4& color) 1205 { 1206 const int mBits = 9; 1207 const int eBits = 5; 1208 const int eBias = 15; 1209 const int eMax = (1<<eBits)-1; 1210 const float maxVal = (float)(((1<<mBits) - 1) * (1<<(eMax-eBias))) / (float)(1<<mBits); 1211 1212 float rc = deFloatClamp(color[0], 0.0f, maxVal); 1213 float gc = deFloatClamp(color[1], 0.0f, maxVal); 1214 float bc = deFloatClamp(color[2], 0.0f, maxVal); 1215 float maxc = de::max(rc, de::max(gc, bc)); 1216 int expp = de::max(-eBias - 1, deFloorFloatToInt32(deFloatLog2(maxc))) + 1 + eBias; 1217 float e = deFloatPow(2.0f, (float)(expp-eBias-mBits)); 1218 int maxs = deFloorFloatToInt32(maxc / e + 0.5f); 1219 1220 deUint32 exps = maxs == (1<<mBits) ? expp+1 : expp; 1221 deUint32 rs = (deUint32)deClamp32(deFloorFloatToInt32(rc / e + 0.5f), 0, (1<<9)-1); 1222 deUint32 gs = (deUint32)deClamp32(deFloorFloatToInt32(gc / e + 0.5f), 0, (1<<9)-1); 1223 deUint32 bs = (deUint32)deClamp32(deFloorFloatToInt32(bc / e + 0.5f), 0, (1<<9)-1); 1224 1225 DE_ASSERT((exps & ~((1<<5)-1)) == 0); 1226 DE_ASSERT((rs & ~((1<<9)-1)) == 0); 1227 DE_ASSERT((gs & ~((1<<9)-1)) == 0); 1228 DE_ASSERT((bs & ~((1<<9)-1)) == 0); 1229 1230 return rs | (gs << 9) | (bs << 18) | (exps << 27); 1231 } 1232 1233 // Sampler utils 1234 1235 static const void* addOffset (const void* ptr, int numBytes) 1236 { 1237 return (const deUint8*)ptr + numBytes; 1238 } 1239 1240 static void* addOffset (void* ptr, int numBytes) 1241 { 1242 return (deUint8*)ptr + numBytes; 1243 } 1244 1245 template <typename AccessType> 1246 static AccessType toSamplerAccess (const AccessType& baseAccess, Sampler::DepthStencilMode mode) 1247 { 1248 // make sure to update this if type table is updated 1249 DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 38); 1250 1251 if (!isCombinedDepthStencilType(baseAccess.getFormat().type)) 1252 return baseAccess; 1253 else 1254 { 1255 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 1256 const deUint32 uint32ByteOffsetBits0To8 = 0; //!< least significant byte in the lowest address 1257 const deUint32 uint32ByteOffsetBits0To24 = 0; 1258 const deUint32 uint32ByteOffsetBits8To32 = 1; 1259 const deUint32 uint32ByteOffsetBits16To32 = 2; 1260 const deUint32 uint32ByteOffsetBits24To32 = 3; 1261 #else 1262 const deUint32 uint32ByteOffsetBits0To8 = 3; //!< least significant byte in the highest address 1263 const deUint32 uint32ByteOffsetBits0To24 = 1; 1264 const deUint32 uint32ByteOffsetBits8To32 = 0; 1265 const deUint32 uint32ByteOffsetBits16To32 = 0; 1266 const deUint32 uint32ByteOffsetBits24To32 = 0; 1267 #endif 1268 1269 // Sampled channel must exist 1270 DE_ASSERT(baseAccess.getFormat().order == TextureFormat::DS || 1271 (mode == Sampler::MODE_DEPTH && baseAccess.getFormat().order == TextureFormat::D) || 1272 (mode == Sampler::MODE_STENCIL && baseAccess.getFormat().order == TextureFormat::S)); 1273 1274 // combined formats have multiple channel classes, detect on sampler settings 1275 switch (baseAccess.getFormat().type) 1276 { 1277 case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: 1278 { 1279 if (mode == Sampler::MODE_DEPTH) 1280 { 1281 // select the float component 1282 return AccessType(TextureFormat(TextureFormat::D, TextureFormat::FLOAT), 1283 baseAccess.getSize(), 1284 baseAccess.getPitch(), 1285 baseAccess.getDataPtr()); 1286 } 1287 else if (mode == Sampler::MODE_STENCIL) 1288 { 1289 // select the uint 8 component 1290 return AccessType(TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), 1291 baseAccess.getSize(), 1292 baseAccess.getPitch(), 1293 addOffset(baseAccess.getDataPtr(), 4 + uint32ByteOffsetBits0To8)); 1294 } 1295 else 1296 { 1297 // unknown sampler mode 1298 DE_ASSERT(false); 1299 return AccessType(); 1300 } 1301 } 1302 1303 case TextureFormat::UNSIGNED_INT_16_8_8: 1304 { 1305 if (mode == Sampler::MODE_DEPTH) 1306 { 1307 // select the unorm16 component 1308 return AccessType(TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT16), 1309 baseAccess.getSize(), 1310 baseAccess.getPitch(), 1311 addOffset(baseAccess.getDataPtr(), uint32ByteOffsetBits16To32)); 1312 } 1313 else if (mode == Sampler::MODE_STENCIL) 1314 { 1315 // select the uint 8 component 1316 return AccessType(TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), 1317 baseAccess.getSize(), 1318 baseAccess.getPitch(), 1319 addOffset(baseAccess.getDataPtr(), uint32ByteOffsetBits0To8)); 1320 } 1321 else 1322 { 1323 // unknown sampler mode 1324 DE_ASSERT(false); 1325 return AccessType(); 1326 } 1327 } 1328 1329 case TextureFormat::UNSIGNED_INT_24_8: 1330 { 1331 if (mode == Sampler::MODE_DEPTH) 1332 { 1333 // select the unorm24 component 1334 return AccessType(TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT24), 1335 baseAccess.getSize(), 1336 baseAccess.getPitch(), 1337 addOffset(baseAccess.getDataPtr(), uint32ByteOffsetBits8To32)); 1338 } 1339 else if (mode == Sampler::MODE_STENCIL) 1340 { 1341 // select the uint 8 component 1342 return AccessType(TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), 1343 baseAccess.getSize(), 1344 baseAccess.getPitch(), 1345 addOffset(baseAccess.getDataPtr(), uint32ByteOffsetBits0To8)); 1346 } 1347 else 1348 { 1349 // unknown sampler mode 1350 DE_ASSERT(false); 1351 return AccessType(); 1352 } 1353 } 1354 1355 case TextureFormat::UNSIGNED_INT_24_8_REV: 1356 { 1357 if (mode == Sampler::MODE_DEPTH) 1358 { 1359 // select the unorm24 component 1360 return AccessType(TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT24), 1361 baseAccess.getSize(), 1362 baseAccess.getPitch(), 1363 addOffset(baseAccess.getDataPtr(), uint32ByteOffsetBits0To24)); 1364 } 1365 else if (mode == Sampler::MODE_STENCIL) 1366 { 1367 // select the uint 8 component 1368 return AccessType(TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), 1369 baseAccess.getSize(), 1370 baseAccess.getPitch(), 1371 addOffset(baseAccess.getDataPtr(), uint32ByteOffsetBits24To32)); 1372 } 1373 else 1374 { 1375 // unknown sampler mode 1376 DE_ASSERT(false); 1377 return AccessType(); 1378 } 1379 } 1380 1381 default: 1382 { 1383 // unknown combined format 1384 DE_ASSERT(false); 1385 return AccessType(); 1386 } 1387 } 1388 } 1389 } 1390 1391 PixelBufferAccess getEffectiveDepthStencilAccess (const PixelBufferAccess& baseAccess, Sampler::DepthStencilMode mode) 1392 { 1393 return toSamplerAccess<PixelBufferAccess>(baseAccess, mode); 1394 } 1395 1396 ConstPixelBufferAccess getEffectiveDepthStencilAccess (const ConstPixelBufferAccess& baseAccess, Sampler::DepthStencilMode mode) 1397 { 1398 return toSamplerAccess<ConstPixelBufferAccess>(baseAccess, mode); 1399 } 1400 1401 TextureFormat getEffectiveDepthStencilTextureFormat (const TextureFormat& baseFormat, Sampler::DepthStencilMode mode) 1402 { 1403 return toSamplerAccess(ConstPixelBufferAccess(baseFormat, IVec3(0, 0, 0), DE_NULL), mode).getFormat(); 1404 } 1405 1406 template <typename ViewType> 1407 ViewType getEffectiveTView (const ViewType& src, std::vector<tcu::ConstPixelBufferAccess>& storage, const tcu::Sampler& sampler) 1408 { 1409 storage.resize(src.getNumLevels()); 1410 1411 ViewType view = ViewType(src.getNumLevels(), &storage[0]); 1412 1413 for (int levelNdx = 0; levelNdx < src.getNumLevels(); ++levelNdx) 1414 storage[levelNdx] = tcu::getEffectiveDepthStencilAccess(src.getLevel(levelNdx), sampler.depthStencilMode); 1415 1416 return view; 1417 } 1418 1419 tcu::TextureCubeView getEffectiveTView (const tcu::TextureCubeView& src, std::vector<tcu::ConstPixelBufferAccess>& storage, const tcu::Sampler& sampler) 1420 { 1421 storage.resize(tcu::CUBEFACE_LAST * src.getNumLevels()); 1422 1423 const tcu::ConstPixelBufferAccess* storagePtrs[tcu::CUBEFACE_LAST] = 1424 { 1425 &storage[0 * src.getNumLevels()], 1426 &storage[1 * src.getNumLevels()], 1427 &storage[2 * src.getNumLevels()], 1428 &storage[3 * src.getNumLevels()], 1429 &storage[4 * src.getNumLevels()], 1430 &storage[5 * src.getNumLevels()], 1431 }; 1432 1433 tcu::TextureCubeView view = tcu::TextureCubeView(src.getNumLevels(), storagePtrs); 1434 1435 for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; ++faceNdx) 1436 for (int levelNdx = 0; levelNdx < src.getNumLevels(); ++levelNdx) 1437 storage[faceNdx * src.getNumLevels() + levelNdx] = tcu::getEffectiveDepthStencilAccess(src.getLevelFace(levelNdx, (tcu::CubeFace)faceNdx), sampler.depthStencilMode); 1438 1439 return view; 1440 } 1441 1442 tcu::Texture1DView getEffectiveTextureView (const tcu::Texture1DView& src, std::vector<tcu::ConstPixelBufferAccess>& storage, const tcu::Sampler& sampler) 1443 { 1444 return getEffectiveTView(src, storage, sampler); 1445 } 1446 1447 tcu::Texture2DView getEffectiveTextureView (const tcu::Texture2DView& src, std::vector<tcu::ConstPixelBufferAccess>& storage, const tcu::Sampler& sampler) 1448 { 1449 return getEffectiveTView(src, storage, sampler); 1450 } 1451 1452 tcu::Texture3DView getEffectiveTextureView (const tcu::Texture3DView& src, std::vector<tcu::ConstPixelBufferAccess>& storage, const tcu::Sampler& sampler) 1453 { 1454 return getEffectiveTView(src, storage, sampler); 1455 } 1456 1457 tcu::Texture1DArrayView getEffectiveTextureView (const tcu::Texture1DArrayView& src, std::vector<tcu::ConstPixelBufferAccess>& storage, const tcu::Sampler& sampler) 1458 { 1459 return getEffectiveTView(src, storage, sampler); 1460 } 1461 1462 tcu::Texture2DArrayView getEffectiveTextureView (const tcu::Texture2DArrayView& src, std::vector<tcu::ConstPixelBufferAccess>& storage, const tcu::Sampler& sampler) 1463 { 1464 return getEffectiveTView(src, storage, sampler); 1465 } 1466 1467 tcu::TextureCubeView getEffectiveTextureView (const tcu::TextureCubeView& src, std::vector<tcu::ConstPixelBufferAccess>& storage, const tcu::Sampler& sampler) 1468 { 1469 return getEffectiveTView(src, storage, sampler); 1470 } 1471 1472 tcu::TextureCubeArrayView getEffectiveTextureView (const tcu::TextureCubeArrayView& src, std::vector<tcu::ConstPixelBufferAccess>& storage, const tcu::Sampler& sampler) 1473 { 1474 return getEffectiveTView(src, storage, sampler); 1475 } 1476 1477 //! Returns the effective swizzle of a border color. The effective swizzle is the 1478 //! equal to first writing an RGBA color with a write swizzle and then reading 1479 //! it back using a read swizzle, i.e. BorderSwizzle(c) == readSwizzle(writeSwizzle(C)) 1480 static const TextureSwizzle& getBorderColorReadSwizzle (TextureFormat::ChannelOrder order) 1481 { 1482 // make sure to update these tables when channel orders are updated 1483 DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 21); 1484 1485 static const TextureSwizzle INV = {{ TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; 1486 static const TextureSwizzle R = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; 1487 static const TextureSwizzle A = {{ TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_3 }}; 1488 static const TextureSwizzle I = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0 }}; 1489 static const TextureSwizzle L = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ONE }}; 1490 static const TextureSwizzle LA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3 }}; 1491 static const TextureSwizzle RG = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; 1492 static const TextureSwizzle RA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_3 }}; 1493 static const TextureSwizzle RGB = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_ONE }}; 1494 static const TextureSwizzle RGBA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_3 }}; 1495 static const TextureSwizzle D = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; 1496 static const TextureSwizzle S = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; 1497 1498 const TextureSwizzle* swizzle; 1499 1500 switch (order) 1501 { 1502 case TextureFormat::R: swizzle = &R; break; 1503 case TextureFormat::A: swizzle = &A; break; 1504 case TextureFormat::I: swizzle = &I; break; 1505 case TextureFormat::L: swizzle = &L; break; 1506 case TextureFormat::LA: swizzle = &LA; break; 1507 case TextureFormat::RG: swizzle = &RG; break; 1508 case TextureFormat::RA: swizzle = &RA; break; 1509 case TextureFormat::RGB: swizzle = &RGB; break; 1510 case TextureFormat::RGBA: swizzle = &RGBA; break; 1511 case TextureFormat::ARGB: swizzle = &RGBA; break; 1512 case TextureFormat::BGR: swizzle = &RGB; break; 1513 case TextureFormat::BGRA: swizzle = &RGBA; break; 1514 case TextureFormat::sR: swizzle = &R; break; 1515 case TextureFormat::sRG: swizzle = &RG; break; 1516 case TextureFormat::sRGB: swizzle = &RGB; break; 1517 case TextureFormat::sRGBA: swizzle = &RGBA; break; 1518 case TextureFormat::sBGR: swizzle = &RGB; break; 1519 case TextureFormat::sBGRA: swizzle = &RGBA; break; 1520 case TextureFormat::D: swizzle = &D; break; 1521 case TextureFormat::S: swizzle = &S; break; 1522 1523 case TextureFormat::DS: 1524 DE_ASSERT(false); // combined depth-stencil border color? 1525 swizzle = &INV; 1526 break; 1527 1528 default: 1529 DE_ASSERT(false); 1530 swizzle = &INV; 1531 break; 1532 } 1533 1534 #ifdef DE_DEBUG 1535 1536 { 1537 // check that BorderSwizzle(c) == readSwizzle(writeSwizzle(C)) 1538 const TextureSwizzle& readSwizzle = getChannelReadSwizzle(order); 1539 const TextureSwizzle& writeSwizzle = getChannelWriteSwizzle(order); 1540 1541 for (int ndx = 0; ndx < 4; ++ndx) 1542 { 1543 TextureSwizzle::Channel writeRead = readSwizzle.components[ndx]; 1544 if (deInRange32(writeRead, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == DE_TRUE) 1545 writeRead = writeSwizzle.components[(int)writeRead]; 1546 DE_ASSERT(writeRead == swizzle->components[ndx]); 1547 } 1548 } 1549 1550 #endif 1551 1552 return *swizzle; 1553 } 1554 1555 static tcu::UVec4 getNBitUnsignedIntegerVec4MaxValue (const tcu::IVec4& numBits) 1556 { 1557 return tcu::UVec4((numBits[0] > 0) ? (deUintMaxValue32(numBits[0])) : (0), 1558 (numBits[1] > 0) ? (deUintMaxValue32(numBits[1])) : (0), 1559 (numBits[2] > 0) ? (deUintMaxValue32(numBits[2])) : (0), 1560 (numBits[3] > 0) ? (deUintMaxValue32(numBits[3])) : (0)); 1561 } 1562 1563 static tcu::IVec4 getNBitSignedIntegerVec4MaxValue (const tcu::IVec4& numBits) 1564 { 1565 return tcu::IVec4((numBits[0] > 0) ? (deIntMaxValue32(numBits[0])) : (0), 1566 (numBits[1] > 0) ? (deIntMaxValue32(numBits[1])) : (0), 1567 (numBits[2] > 0) ? (deIntMaxValue32(numBits[2])) : (0), 1568 (numBits[3] > 0) ? (deIntMaxValue32(numBits[3])) : (0)); 1569 } 1570 1571 static tcu::IVec4 getNBitSignedIntegerVec4MinValue (const tcu::IVec4& numBits) 1572 { 1573 return tcu::IVec4((numBits[0] > 0) ? (deIntMinValue32(numBits[0])) : (0), 1574 (numBits[1] > 0) ? (deIntMinValue32(numBits[1])) : (0), 1575 (numBits[2] > 0) ? (deIntMinValue32(numBits[2])) : (0), 1576 (numBits[3] > 0) ? (deIntMinValue32(numBits[3])) : (0)); 1577 } 1578 1579 static tcu::Vec4 getTextureBorderColorFloat (const TextureFormat& format, const Sampler& sampler) 1580 { 1581 const tcu::TextureChannelClass channelClass = getTextureChannelClass(format.type); 1582 const TextureSwizzle::Channel* channelMap = getBorderColorReadSwizzle(format.order).components; 1583 const bool isFloat = channelClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT; 1584 const bool isSigned = channelClass != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 1585 const float valueMin = (isSigned) ? (-1.0f) : (0.0f); 1586 const float valueMax = 1.0f; 1587 Vec4 result; 1588 1589 DE_ASSERT(channelClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT || 1590 channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT || 1591 channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT); 1592 1593 for (int c = 0; c < 4; c++) 1594 { 1595 const TextureSwizzle::Channel map = channelMap[c]; 1596 if (map == TextureSwizzle::CHANNEL_ZERO) 1597 result[c] = 0.0f; 1598 else if (map == TextureSwizzle::CHANNEL_ONE) 1599 result[c] = 1.0f; 1600 else if (isFloat) 1601 { 1602 // floating point values are not clamped 1603 result[c] = sampler.borderColor.getAccess<float>()[(int)map]; 1604 } 1605 else 1606 { 1607 // fixed point values are clamped to a representable range 1608 result[c] = de::clamp(sampler.borderColor.getAccess<float>()[(int)map], valueMin, valueMax); 1609 } 1610 } 1611 1612 return result; 1613 } 1614 1615 static tcu::IVec4 getTextureBorderColorInt (const TextureFormat& format, const Sampler& sampler) 1616 { 1617 const tcu::TextureChannelClass channelClass = getTextureChannelClass(format.type); 1618 const TextureSwizzle::Channel* channelMap = getBorderColorReadSwizzle(format.order).components; 1619 const IVec4 channelBits = getChannelBitDepth(format.type); 1620 const IVec4 valueMin = getNBitSignedIntegerVec4MinValue(channelBits); 1621 const IVec4 valueMax = getNBitSignedIntegerVec4MaxValue(channelBits); 1622 IVec4 result; 1623 1624 DE_ASSERT(channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER); 1625 DE_UNREF(channelClass); 1626 1627 for (int c = 0; c < 4; c++) 1628 { 1629 const TextureSwizzle::Channel map = channelMap[c]; 1630 if (map == TextureSwizzle::CHANNEL_ZERO) 1631 result[c] = 0; 1632 else if (map == TextureSwizzle::CHANNEL_ONE) 1633 result[c] = 1; 1634 else 1635 { 1636 // integer values are clamped to a representable range 1637 result[c] = de::clamp(sampler.borderColor.getAccess<deInt32>()[(int)map], valueMin[(int)map], valueMax[(int)map]); 1638 } 1639 } 1640 1641 return result; 1642 } 1643 1644 static tcu::UVec4 getTextureBorderColorUint (const TextureFormat& format, const Sampler& sampler) 1645 { 1646 const tcu::TextureChannelClass channelClass = getTextureChannelClass(format.type); 1647 const TextureSwizzle::Channel* channelMap = getBorderColorReadSwizzle(format.order).components; 1648 const IVec4 channelBits = getChannelBitDepth(format.type); 1649 const UVec4 valueMax = getNBitUnsignedIntegerVec4MaxValue(channelBits); 1650 UVec4 result; 1651 1652 DE_ASSERT(channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER); 1653 DE_UNREF(channelClass); 1654 1655 for (int c = 0; c < 4; c++) 1656 { 1657 const TextureSwizzle::Channel map = channelMap[c]; 1658 if (map == TextureSwizzle::CHANNEL_ZERO) 1659 result[c] = 0; 1660 else if (map == TextureSwizzle::CHANNEL_ONE) 1661 result[c] = 1; 1662 else 1663 { 1664 // integer values are clamped to a representable range 1665 result[c] = de::min(sampler.borderColor.getAccess<deUint32>()[(int)map], valueMax[(int)map]); 1666 } 1667 } 1668 1669 return result; 1670 } 1671 1672 template <typename ScalarType> 1673 tcu::Vector<ScalarType, 4> sampleTextureBorder (const TextureFormat& format, const Sampler& sampler) 1674 { 1675 const tcu::TextureChannelClass channelClass = getTextureChannelClass(format.type); 1676 1677 switch (channelClass) 1678 { 1679 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: 1680 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT: 1681 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 1682 return getTextureBorderColorFloat(format, sampler).cast<ScalarType>(); 1683 1684 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: 1685 return getTextureBorderColorInt(format, sampler).cast<ScalarType>(); 1686 1687 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: 1688 return getTextureBorderColorUint(format, sampler).cast<ScalarType>(); 1689 1690 default: 1691 DE_ASSERT(false); 1692 return tcu::Vector<ScalarType, 4>(); 1693 } 1694 } 1695 1696 // instantiation 1697 template tcu::Vector<float, 4> sampleTextureBorder (const TextureFormat& format, const Sampler& sampler); 1698 template tcu::Vector<deInt32, 4> sampleTextureBorder (const TextureFormat& format, const Sampler& sampler); 1699 template tcu::Vector<deUint32, 4> sampleTextureBorder (const TextureFormat& format, const Sampler& sampler); 1700 1701 } // tcu 1702
