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 Reference Texture Implementation. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "tcuTexture.hpp" 25 #include "deInt32.h" 26 #include "deFloat16.h" 27 #include "deMath.h" 28 #include "deMemory.h" 29 #include "tcuTestLog.hpp" 30 #include "tcuSurface.hpp" 31 #include "tcuFloat.hpp" 32 #include "tcuTextureUtil.hpp" 33 #include "deStringUtil.hpp" 34 #include "deArrayUtil.hpp" 35 36 #include <limits> 37 38 namespace tcu 39 { 40 41 // \note No sign. Denorms are supported. 42 typedef Float<deUint32, 5, 6, 15, FLOAT_SUPPORT_DENORM> Float11; 43 typedef Float<deUint32, 5, 5, 15, FLOAT_SUPPORT_DENORM> Float10; 44 45 namespace 46 { 47 48 // Optimized getters for common formats. 49 // \todo [2012-11-14 pyry] Use intrinsics if available. 50 51 inline Vec4 readRGBA8888Float (const deUint8* ptr) { return Vec4(ptr[0]/255.0f, ptr[1]/255.0f, ptr[2]/255.0f, ptr[3]/255.0f); } 52 inline Vec4 readRGB888Float (const deUint8* ptr) { return Vec4(ptr[0]/255.0f, ptr[1]/255.0f, ptr[2]/255.0f, 1.0f); } 53 inline IVec4 readRGBA8888Int (const deUint8* ptr) { return IVec4(ptr[0], ptr[1], ptr[2], ptr[3]); } 54 inline IVec4 readRGB888Int (const deUint8* ptr) { return IVec4(ptr[0], ptr[1], ptr[2], 1); } 55 56 // Optimized setters. 57 58 inline void writeRGBA8888Int (deUint8* ptr, const IVec4& val) 59 { 60 ptr[0] = (deUint8)de::clamp(val[0], 0, 255); 61 ptr[1] = (deUint8)de::clamp(val[1], 0, 255); 62 ptr[2] = (deUint8)de::clamp(val[2], 0, 255); 63 ptr[3] = (deUint8)de::clamp(val[3], 0, 255); 64 } 65 66 inline void writeRGB888Int (deUint8* ptr, const IVec4& val) 67 { 68 ptr[0] = (deUint8)de::clamp(val[0], 0, 255); 69 ptr[1] = (deUint8)de::clamp(val[1], 0, 255); 70 ptr[2] = (deUint8)de::clamp(val[2], 0, 255); 71 } 72 73 inline void writeRGBA8888Float (deUint8* ptr, const Vec4& val) 74 { 75 ptr[0] = floatToU8(val[0]); 76 ptr[1] = floatToU8(val[1]); 77 ptr[2] = floatToU8(val[2]); 78 ptr[3] = floatToU8(val[3]); 79 } 80 81 inline void writeRGB888Float (deUint8* ptr, const Vec4& val) 82 { 83 ptr[0] = floatToU8(val[0]); 84 ptr[1] = floatToU8(val[1]); 85 ptr[2] = floatToU8(val[2]); 86 } 87 88 inline void writeUint24 (deUint8* dst, deUint32 val) 89 { 90 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 91 dst[0] = (deUint8)((val & 0x0000FFu) >> 0u); 92 dst[1] = (deUint8)((val & 0x00FF00u) >> 8u); 93 dst[2] = (deUint8)((val & 0xFF0000u) >> 16u); 94 #else 95 dst[0] = (deUint8)((val & 0xFF0000u) >> 16u); 96 dst[1] = (deUint8)((val & 0x00FF00u) >> 8u); 97 dst[2] = (deUint8)((val & 0x0000FFu) >> 0u); 98 #endif 99 } 100 101 inline deUint32 readUint24 (const deUint8* src) 102 { 103 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 104 return (((deUint32)src[0]) << 0u) | 105 (((deUint32)src[1]) << 8u) | 106 (((deUint32)src[2]) << 16u); 107 #else 108 return (((deUint32)src[0]) << 16u) | 109 (((deUint32)src[1]) << 8u) | 110 (((deUint32)src[2]) << 0u); 111 #endif 112 } 113 114 inline deUint8 readUint32Low8 (const deUint8* src) 115 { 116 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 117 const deUint32 uint32ByteOffsetBits0To8 = 0; //!< least significant byte in the lowest address 118 #else 119 const deUint32 uint32ByteOffsetBits0To8 = 3; //!< least significant byte in the highest address 120 #endif 121 122 return src[uint32ByteOffsetBits0To8]; 123 } 124 125 inline deUint8 readUint32High8 (const deUint8* src) 126 { 127 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 128 const deUint32 uint32ByteOffsetBits24To32 = 3; 129 #else 130 const deUint32 uint32ByteOffsetBits24To32 = 0; 131 #endif 132 133 return src[uint32ByteOffsetBits24To32]; 134 } 135 136 inline void writeUint32Low8 (deUint8* dst, deUint8 val) 137 { 138 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 139 const deUint32 uint32ByteOffsetBits0To8 = 0; //!< least significant byte in the lowest address 140 #else 141 const deUint32 uint32ByteOffsetBits0To8 = 3; //!< least significant byte in the highest address 142 #endif 143 144 dst[uint32ByteOffsetBits0To8] = val; 145 } 146 147 inline void writeUint32High8 (deUint8* dst, deUint8 val) 148 { 149 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 150 const deUint32 uint32ByteOffsetBits24To32 = 3; 151 #else 152 const deUint32 uint32ByteOffsetBits24To32 = 0; 153 #endif 154 155 dst[uint32ByteOffsetBits24To32] = val; 156 } 157 158 inline deUint32 readUint32High16 (const deUint8* src) 159 { 160 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 161 const deUint32 uint32ByteOffset16To32 = 2; 162 #else 163 const deUint32 uint32ByteOffset16To32 = 0; 164 #endif 165 166 return *(const deUint16*)(src + uint32ByteOffset16To32); 167 } 168 169 inline void writeUint32High16 (deUint8* dst, deUint16 val) 170 { 171 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 172 const deUint32 uint32ByteOffset16To32 = 2; 173 #else 174 const deUint32 uint32ByteOffset16To32 = 0; 175 #endif 176 177 *(deUint16*)(dst + uint32ByteOffset16To32) = val; 178 } 179 180 inline deUint32 readUint32Low24 (const deUint8* src) 181 { 182 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 183 const deUint32 uint32ByteOffset0To24 = 0; 184 #else 185 const deUint32 uint32ByteOffset0To24 = 1; 186 #endif 187 188 return readUint24(src + uint32ByteOffset0To24); 189 } 190 191 inline deUint32 readUint32High24 (const deUint8* src) 192 { 193 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 194 const deUint32 uint32ByteOffset8To32 = 1; 195 #else 196 const deUint32 uint32ByteOffset8To32 = 0; 197 #endif 198 199 return readUint24(src + uint32ByteOffset8To32); 200 } 201 202 inline void writeUint32Low24 (deUint8* dst, deUint32 val) 203 { 204 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 205 const deUint32 uint32ByteOffset0To24 = 0; 206 #else 207 const deUint32 uint32ByteOffset0To24 = 1; 208 #endif 209 210 writeUint24(dst + uint32ByteOffset0To24, val); 211 } 212 213 inline void writeUint32High24 (deUint8* dst, deUint32 val) 214 { 215 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 216 const deUint32 uint32ByteOffset8To32 = 1; 217 #else 218 const deUint32 uint32ByteOffset8To32 = 0; 219 #endif 220 221 writeUint24(dst + uint32ByteOffset8To32, val); 222 } 223 224 // \todo [2011-09-21 pyry] Move to tcutil? 225 template <typename T> 226 inline T convertSatRte (float f) 227 { 228 // \note Doesn't work for 64-bit types 229 DE_STATIC_ASSERT(sizeof(T) < sizeof(deUint64)); 230 DE_STATIC_ASSERT((-3 % 2 != 0) && (-4 % 2 == 0)); 231 232 deInt64 minVal = std::numeric_limits<T>::min(); 233 deInt64 maxVal = std::numeric_limits<T>::max(); 234 float q = deFloatFrac(f); 235 deInt64 intVal = (deInt64)(f-q); 236 237 // Rounding. 238 if (q == 0.5f) 239 { 240 if (intVal % 2 != 0) 241 intVal++; 242 } 243 else if (q > 0.5f) 244 intVal++; 245 // else Don't add anything 246 247 // Saturate. 248 intVal = de::max(minVal, de::min(maxVal, intVal)); 249 250 return (T)intVal; 251 } 252 253 inline deUint32 convertSatRteUint24 (float f) 254 { 255 const deUint32 rounded = convertSatRte<deUint32>(f); 256 const deUint32 maxUint24 = 0xFFFFFFu; 257 return de::min(rounded, maxUint24); 258 } 259 260 inline deUint16 convertSatRteUint10 (float f) 261 { 262 const deUint16 rounded = convertSatRte<deUint16>(f); 263 const deUint16 maxUint10 = 0x3FFu; 264 return de::min(rounded, maxUint10); 265 } 266 267 inline deUint16 convertSatRteUint12 (float f) 268 { 269 const deUint16 rounded = convertSatRte<deUint16>(f); 270 const deUint16 maxUint12 = 0xFFFu; 271 return de::min(rounded, maxUint12); 272 } 273 274 inline float channelToFloat (const deUint8* value, TextureFormat::ChannelType type) 275 { 276 // make sure this table is updated if format table is updated 277 DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 40); 278 279 switch (type) 280 { 281 case TextureFormat::SNORM_INT8: return de::max(-1.0f, (float)*((const deInt8*)value) / 127.0f); 282 case TextureFormat::SNORM_INT16: return de::max(-1.0f, (float)*((const deInt16*)value) / 32767.0f); 283 case TextureFormat::SNORM_INT32: return de::max(-1.0f, (float)*((const deInt32*)value) / 2147483647.0f); 284 case TextureFormat::UNORM_INT8: return (float)*((const deUint8*)value) / 255.0f; 285 case TextureFormat::UNORM_INT16: return (float)*((const deUint16*)value) / 65535.0f; 286 case TextureFormat::UNORM_INT24: return (float)readUint24(value) / 16777215.0f; 287 case TextureFormat::UNORM_INT32: return (float)*((const deUint32*)value) / 4294967295.0f; 288 case TextureFormat::SIGNED_INT8: return (float)*((const deInt8*)value); 289 case TextureFormat::SIGNED_INT16: return (float)*((const deInt16*)value); 290 case TextureFormat::SIGNED_INT32: return (float)*((const deInt32*)value); 291 case TextureFormat::UNSIGNED_INT8: return (float)*((const deUint8*)value); 292 case TextureFormat::UNSIGNED_INT16: return (float)*((const deUint16*)value); 293 case TextureFormat::UNSIGNED_INT24: return (float)readUint24(value); 294 case TextureFormat::UNSIGNED_INT32: return (float)*((const deUint32*)value); 295 case TextureFormat::HALF_FLOAT: return deFloat16To32(*(const deFloat16*)value); 296 case TextureFormat::FLOAT: return *((const float*)value); 297 case TextureFormat::FLOAT64: return (float)*((const double*)value); 298 case TextureFormat::UNORM_SHORT_10: return (float)((*((const deUint16*)value)) >> 6u) / 1023.0f; 299 case TextureFormat::UNORM_SHORT_12: return (float)((*((const deUint16*)value)) >> 4u) / 4095.0f; 300 default: 301 DE_ASSERT(DE_FALSE); 302 return 0.0f; 303 } 304 } 305 306 inline int channelToInt (const deUint8* value, TextureFormat::ChannelType type) 307 { 308 // make sure this table is updated if format table is updated 309 DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 40); 310 311 switch (type) 312 { 313 case TextureFormat::SNORM_INT8: return (int)*((const deInt8*)value); 314 case TextureFormat::SNORM_INT16: return (int)*((const deInt16*)value); 315 case TextureFormat::SNORM_INT32: return (int)*((const deInt32*)value); 316 case TextureFormat::UNORM_INT8: return (int)*((const deUint8*)value); 317 case TextureFormat::UNORM_INT16: return (int)*((const deUint16*)value); 318 case TextureFormat::UNORM_INT24: return (int)readUint24(value); 319 case TextureFormat::UNORM_INT32: return (int)*((const deUint32*)value); 320 case TextureFormat::SIGNED_INT8: return (int)*((const deInt8*)value); 321 case TextureFormat::SIGNED_INT16: return (int)*((const deInt16*)value); 322 case TextureFormat::SIGNED_INT32: return (int)*((const deInt32*)value); 323 case TextureFormat::UNSIGNED_INT8: return (int)*((const deUint8*)value); 324 case TextureFormat::UNSIGNED_INT16: return (int)*((const deUint16*)value); 325 case TextureFormat::UNSIGNED_INT24: return (int)readUint24(value); 326 case TextureFormat::UNSIGNED_INT32: return (int)*((const deUint32*)value); 327 case TextureFormat::HALF_FLOAT: return (int)deFloat16To32(*(const deFloat16*)value); 328 case TextureFormat::FLOAT: return (int)*((const float*)value); 329 case TextureFormat::FLOAT64: return (int)*((const double*)value); 330 case TextureFormat::UNORM_SHORT_10: return (int)((*(((const deUint16*)value))) >> 6u); 331 case TextureFormat::UNORM_SHORT_12: return (int)((*(((const deUint16*)value))) >> 4u); 332 default: 333 DE_ASSERT(DE_FALSE); 334 return 0; 335 } 336 } 337 338 void floatToChannel (deUint8* dst, float src, TextureFormat::ChannelType type) 339 { 340 // make sure this table is updated if format table is updated 341 DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 40); 342 343 switch (type) 344 { 345 case TextureFormat::SNORM_INT8: *((deInt8*)dst) = convertSatRte<deInt8> (src * 127.0f); break; 346 case TextureFormat::SNORM_INT16: *((deInt16*)dst) = convertSatRte<deInt16> (src * 32767.0f); break; 347 case TextureFormat::SNORM_INT32: *((deInt32*)dst) = convertSatRte<deInt32> (src * 2147483647.0f); break; 348 case TextureFormat::UNORM_INT8: *((deUint8*)dst) = convertSatRte<deUint8> (src * 255.0f); break; 349 case TextureFormat::UNORM_INT16: *((deUint16*)dst) = convertSatRte<deUint16> (src * 65535.0f); break; 350 case TextureFormat::UNORM_INT24: writeUint24(dst, convertSatRteUint24 (src * 16777215.0f)); break; 351 case TextureFormat::UNORM_INT32: *((deUint32*)dst) = convertSatRte<deUint32> (src * 4294967295.0f); break; 352 case TextureFormat::SIGNED_INT8: *((deInt8*)dst) = convertSatRte<deInt8> (src); break; 353 case TextureFormat::SIGNED_INT16: *((deInt16*)dst) = convertSatRte<deInt16> (src); break; 354 case TextureFormat::SIGNED_INT32: *((deInt32*)dst) = convertSatRte<deInt32> (src); break; 355 case TextureFormat::UNSIGNED_INT8: *((deUint8*)dst) = convertSatRte<deUint8> (src); break; 356 case TextureFormat::UNSIGNED_INT16: *((deUint16*)dst) = convertSatRte<deUint16> (src); break; 357 case TextureFormat::UNSIGNED_INT24: writeUint24(dst, convertSatRteUint24 (src)); break; 358 case TextureFormat::UNSIGNED_INT32: *((deUint32*)dst) = convertSatRte<deUint32> (src); break; 359 case TextureFormat::HALF_FLOAT: *((deFloat16*)dst) = deFloat32To16 (src); break; 360 case TextureFormat::FLOAT: *((float*)dst) = src; break; 361 case TextureFormat::FLOAT64: *((double*)dst) = (double)src; break; 362 case TextureFormat::UNORM_SHORT_10: *((deUint16*)dst) = (deUint16)(convertSatRteUint10(src * 1023.0f) << 6u); break; 363 case TextureFormat::UNORM_SHORT_12: *((deUint16*)dst) = (deUint16)(convertSatRteUint12(src * 4095.0f) << 4u); break; 364 default: 365 DE_ASSERT(DE_FALSE); 366 } 367 } 368 369 template <typename T, typename S> 370 static inline T convertSat (S src) 371 { 372 S min = (S)std::numeric_limits<T>::min(); 373 S max = (S)std::numeric_limits<T>::max(); 374 375 if (src < min) 376 return (T)min; 377 else if (src > max) 378 return (T)max; 379 else 380 return (T)src; 381 } 382 383 template <typename S> 384 static inline deUint32 convertSatUint24 (S src) 385 { 386 S min = (S)0u; 387 S max = (S)0xFFFFFFu; 388 389 if (src < min) 390 return (deUint32)min; 391 else if (src > max) 392 return (deUint32)max; 393 else 394 return (deUint32)src; 395 } 396 397 template <typename S> 398 static inline deUint16 convertSatUint10 (S src) 399 { 400 S min = (S)0u; 401 S max = (S)0x3FFu; 402 403 if (src < min) 404 return (deUint16)min; 405 else if (src > max) 406 return (deUint16)max; 407 else 408 return (deUint16)src; 409 } 410 411 template <typename S> 412 static inline deUint16 convertSatUint12 (S src) 413 { 414 S min = (S)0u; 415 S max = (S)0xFFFu; 416 417 if (src < min) 418 return (deUint16)min; 419 else if (src > max) 420 return (deUint16)max; 421 else 422 return (deUint16)src; 423 } 424 425 void intToChannel (deUint8* dst, int src, TextureFormat::ChannelType type) 426 { 427 // make sure this table is updated if format table is updated 428 DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 40); 429 430 switch (type) 431 { 432 case TextureFormat::SNORM_INT8: *((deInt8*)dst) = convertSat<deInt8> (src); break; 433 case TextureFormat::SNORM_INT16: *((deInt16*)dst) = convertSat<deInt16> (src); break; 434 case TextureFormat::UNORM_INT8: *((deUint8*)dst) = convertSat<deUint8> (src); break; 435 case TextureFormat::UNORM_INT16: *((deUint16*)dst) = convertSat<deUint16> (src); break; 436 case TextureFormat::UNORM_INT24: writeUint24(dst, convertSatUint24 (src)); break; 437 case TextureFormat::SIGNED_INT8: *((deInt8*)dst) = convertSat<deInt8> (src); break; 438 case TextureFormat::SIGNED_INT16: *((deInt16*)dst) = convertSat<deInt16> (src); break; 439 case TextureFormat::SIGNED_INT32: *((deInt32*)dst) = convertSat<deInt32> (src); break; 440 case TextureFormat::UNSIGNED_INT8: *((deUint8*)dst) = convertSat<deUint8> ((deUint32)src); break; 441 case TextureFormat::UNSIGNED_INT16: *((deUint16*)dst) = convertSat<deUint16> ((deUint32)src); break; 442 case TextureFormat::UNSIGNED_INT24: writeUint24(dst, convertSatUint24 ((deUint32)src)); break; 443 case TextureFormat::UNSIGNED_INT32: *((deUint32*)dst) = convertSat<deUint32> ((deUint32)src); break; 444 case TextureFormat::HALF_FLOAT: *((deFloat16*)dst) = deFloat32To16((float)src); break; 445 case TextureFormat::FLOAT: *((float*)dst) = (float)src; break; 446 case TextureFormat::FLOAT64: *((double*)dst) = (double)src; break; 447 case TextureFormat::UNORM_SHORT_10: *((deUint16*)dst) = (deUint16)(convertSatUint10(src) << 6u); break; 448 case TextureFormat::UNORM_SHORT_12: *((deUint16*)dst) = (deUint16)(convertSatUint12(src) << 4u); break; 449 default: 450 DE_ASSERT(DE_FALSE); 451 } 452 } 453 454 inline float channelToUnormFloat (deUint32 src, int bits) 455 { 456 const deUint32 maxVal = (1u << bits) - 1; 457 458 // \note Will lose precision if bits > 23 459 return (float)src / (float)maxVal; 460 } 461 462 //! Extend < 32b signed integer to 32b 463 inline deInt32 signExtend (deUint32 src, int bits) 464 { 465 const deUint32 signBit = 1u << (bits-1); 466 467 src |= ~((src & signBit) - 1); 468 469 return (deInt32)src; 470 } 471 472 inline float channelToSnormFloat (deUint32 src, int bits) 473 { 474 const deUint32 range = (1u << (bits-1)) - 1; 475 476 // \note Will lose precision if bits > 24 477 return de::max(-1.0f, (float)signExtend(src, bits) / (float)range); 478 } 479 480 inline deUint32 unormFloatToChannel (float src, int bits) 481 { 482 const deUint32 maxVal = (1u << bits) - 1; 483 const deUint32 intVal = convertSatRte<deUint32>(src * (float)maxVal); 484 485 return de::min(intVal, maxVal); 486 } 487 488 inline deUint32 snormFloatToChannel (float src, int bits) 489 { 490 const deInt32 range = (deInt32)((1u << (bits-1)) - 1u); 491 const deUint32 mask = (1u << bits) - 1; 492 const deInt32 intVal = convertSatRte<deInt32>(src * (float)range); 493 494 return (deUint32)de::clamp(intVal, -range, range) & mask; 495 } 496 497 inline deUint32 uintToChannel (deUint32 src, int bits) 498 { 499 const deUint32 maxVal = (1u << bits) - 1; 500 return de::min(src, maxVal); 501 } 502 503 inline deUint32 intToChannel (deInt32 src, int bits) 504 { 505 const deInt32 minVal = -(deInt32)(1u << (bits-1)); 506 const deInt32 maxVal = (deInt32)((1u << (bits-1)) - 1u); 507 const deUint32 mask = (1u << bits) - 1; 508 509 return (deUint32)de::clamp(src, minVal, maxVal) & mask; 510 } 511 512 tcu::Vec4 unpackRGB999E5 (deUint32 color) 513 { 514 const int mBits = 9; 515 const int eBias = 15; 516 517 deUint32 exp = color >> 27; 518 deUint32 bs = (color >> 18) & ((1<<9)-1); 519 deUint32 gs = (color >> 9) & ((1<<9)-1); 520 deUint32 rs = color & ((1<<9)-1); 521 522 float e = deFloatPow(2.0f, (float)((int)exp - eBias - mBits)); 523 float r = (float)rs * e; 524 float g = (float)gs * e; 525 float b = (float)bs * e; 526 527 return tcu::Vec4(r, g, b, 1.0f); 528 } 529 530 bool isColorOrder (TextureFormat::ChannelOrder order) 531 { 532 DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 21); 533 534 switch (order) 535 { 536 case TextureFormat::R: 537 case TextureFormat::A: 538 case TextureFormat::I: 539 case TextureFormat::L: 540 case TextureFormat::LA: 541 case TextureFormat::RG: 542 case TextureFormat::RA: 543 case TextureFormat::RGB: 544 case TextureFormat::RGBA: 545 case TextureFormat::ARGB: 546 case TextureFormat::BGR: 547 case TextureFormat::BGRA: 548 case TextureFormat::sR: 549 case TextureFormat::sRG: 550 case TextureFormat::sRGB: 551 case TextureFormat::sRGBA: 552 case TextureFormat::sBGR: 553 case TextureFormat::sBGRA: 554 return true; 555 556 default: 557 return false; 558 } 559 } 560 561 } // anonymous 562 563 bool isValid (TextureFormat format) 564 { 565 const bool isColor = isColorOrder(format.order); 566 567 switch (format.type) 568 { 569 case TextureFormat::SNORM_INT8: 570 case TextureFormat::SNORM_INT16: 571 case TextureFormat::SNORM_INT32: 572 return isColor; 573 574 case TextureFormat::UNORM_INT8: 575 case TextureFormat::UNORM_INT16: 576 case TextureFormat::UNORM_INT24: 577 case TextureFormat::UNORM_INT32: 578 return isColor || format.order == TextureFormat::D; 579 580 case TextureFormat::UNORM_BYTE_44: 581 case TextureFormat::UNSIGNED_BYTE_44: 582 return format.order == TextureFormat::RG; 583 584 case TextureFormat::UNORM_SHORT_565: 585 case TextureFormat::UNORM_SHORT_555: 586 case TextureFormat::UNSIGNED_SHORT_565: 587 return format.order == TextureFormat::RGB || format.order == TextureFormat::BGR; 588 589 case TextureFormat::UNORM_SHORT_4444: 590 case TextureFormat::UNORM_SHORT_5551: 591 case TextureFormat::UNSIGNED_SHORT_4444: 592 case TextureFormat::UNSIGNED_SHORT_5551: 593 return format.order == TextureFormat::RGBA || format.order == TextureFormat::BGRA; 594 595 case TextureFormat::UNORM_SHORT_1555: 596 return format.order == TextureFormat::ARGB; 597 598 case TextureFormat::UNORM_INT_101010: 599 return format.order == TextureFormat::RGB; 600 601 case TextureFormat::SNORM_INT_1010102_REV: 602 case TextureFormat::UNORM_INT_1010102_REV: 603 case TextureFormat::SIGNED_INT_1010102_REV: 604 case TextureFormat::UNSIGNED_INT_1010102_REV: 605 return format.order == TextureFormat::RGBA || format.order == TextureFormat::BGRA; 606 607 case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: 608 case TextureFormat::UNSIGNED_INT_999_E5_REV: 609 return format.order == TextureFormat::RGB; 610 611 case TextureFormat::UNSIGNED_INT_16_8_8: 612 return format.order == TextureFormat::DS; 613 614 case TextureFormat::UNSIGNED_INT_24_8: 615 case TextureFormat::UNSIGNED_INT_24_8_REV: 616 return format.order == TextureFormat::D || format.order == TextureFormat::DS; 617 618 case TextureFormat::SIGNED_INT8: 619 case TextureFormat::SIGNED_INT16: 620 case TextureFormat::SIGNED_INT32: 621 return isColor; 622 623 case TextureFormat::UNSIGNED_INT8: 624 case TextureFormat::UNSIGNED_INT16: 625 case TextureFormat::UNSIGNED_INT24: 626 case TextureFormat::UNSIGNED_INT32: 627 return isColor || format.order == TextureFormat::S; 628 629 case TextureFormat::HALF_FLOAT: 630 case TextureFormat::FLOAT: 631 case TextureFormat::FLOAT64: 632 return isColor || format.order == TextureFormat::D; 633 634 case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: 635 return format.order == TextureFormat::DS; 636 637 case TextureFormat::UNORM_SHORT_10: 638 case TextureFormat::UNORM_SHORT_12: 639 return isColor; 640 641 default: 642 DE_FATAL("Unknown format"); 643 return 0u; 644 } 645 646 DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 40); 647 } 648 649 int getNumUsedChannels (TextureFormat::ChannelOrder order) 650 { 651 // make sure this table is updated if type table is updated 652 DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 21); 653 654 switch (order) 655 { 656 case TextureFormat::R: return 1; 657 case TextureFormat::A: return 1; 658 case TextureFormat::I: return 1; 659 case TextureFormat::L: return 1; 660 case TextureFormat::LA: return 2; 661 case TextureFormat::RG: return 2; 662 case TextureFormat::RA: return 2; 663 case TextureFormat::RGB: return 3; 664 case TextureFormat::RGBA: return 4; 665 case TextureFormat::ARGB: return 4; 666 case TextureFormat::BGR: return 3; 667 case TextureFormat::BGRA: return 4; 668 case TextureFormat::sR: return 1; 669 case TextureFormat::sRG: return 2; 670 case TextureFormat::sRGB: return 3; 671 case TextureFormat::sRGBA: return 4; 672 case TextureFormat::sBGR: return 3; 673 case TextureFormat::sBGRA: return 4; 674 case TextureFormat::D: return 1; 675 case TextureFormat::S: return 1; 676 case TextureFormat::DS: return 2; 677 default: 678 DE_ASSERT(DE_FALSE); 679 return 0; 680 } 681 } 682 683 int getChannelSize (TextureFormat::ChannelType type) 684 { 685 // make sure this table is updated if format table is updated 686 DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 40); 687 688 switch (type) 689 { 690 case TextureFormat::SNORM_INT8: return 1; 691 case TextureFormat::SNORM_INT16: return 2; 692 case TextureFormat::SNORM_INT32: return 4; 693 case TextureFormat::UNORM_INT8: return 1; 694 case TextureFormat::UNORM_INT16: return 2; 695 case TextureFormat::UNORM_INT24: return 3; 696 case TextureFormat::UNORM_INT32: return 4; 697 case TextureFormat::SIGNED_INT8: return 1; 698 case TextureFormat::SIGNED_INT16: return 2; 699 case TextureFormat::SIGNED_INT32: return 4; 700 case TextureFormat::UNSIGNED_INT8: return 1; 701 case TextureFormat::UNSIGNED_INT16: return 2; 702 case TextureFormat::UNSIGNED_INT24: return 3; 703 case TextureFormat::UNSIGNED_INT32: return 4; 704 case TextureFormat::HALF_FLOAT: return 2; 705 case TextureFormat::FLOAT: return 4; 706 case TextureFormat::FLOAT64: return 8; 707 case TextureFormat::UNORM_SHORT_10: return 2; 708 case TextureFormat::UNORM_SHORT_12: return 2; 709 default: 710 DE_ASSERT(DE_FALSE); 711 return 0; 712 } 713 } 714 715 /** Get pixel size in bytes. */ 716 int getPixelSize (TextureFormat format) 717 { 718 const TextureFormat::ChannelOrder order = format.order; 719 const TextureFormat::ChannelType type = format.type; 720 721 DE_ASSERT(isValid(format)); 722 723 // make sure this table is updated if format table is updated 724 DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 40); 725 726 switch (type) 727 { 728 case TextureFormat::UNORM_BYTE_44: 729 case TextureFormat::UNSIGNED_BYTE_44: 730 return 1; 731 732 case TextureFormat::UNORM_SHORT_565: 733 case TextureFormat::UNORM_SHORT_555: 734 case TextureFormat::UNORM_SHORT_4444: 735 case TextureFormat::UNORM_SHORT_5551: 736 case TextureFormat::UNORM_SHORT_1555: 737 case TextureFormat::UNSIGNED_SHORT_565: 738 case TextureFormat::UNSIGNED_SHORT_4444: 739 case TextureFormat::UNSIGNED_SHORT_5551: 740 return 2; 741 742 case TextureFormat::UNORM_INT_101010: 743 case TextureFormat::UNSIGNED_INT_999_E5_REV: 744 case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: 745 case TextureFormat::SNORM_INT_1010102_REV: 746 case TextureFormat::UNORM_INT_1010102_REV: 747 case TextureFormat::SIGNED_INT_1010102_REV: 748 case TextureFormat::UNSIGNED_INT_1010102_REV: 749 case TextureFormat::UNSIGNED_INT_24_8: 750 case TextureFormat::UNSIGNED_INT_24_8_REV: 751 case TextureFormat::UNSIGNED_INT_16_8_8: 752 return 4; 753 754 case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: 755 return 8; 756 757 default: 758 return getNumUsedChannels(order) * getChannelSize(type); 759 } 760 } 761 762 int TextureFormat::getPixelSize (void) const 763 { 764 return ::tcu::getPixelSize(*this); 765 } 766 767 const TextureSwizzle& getChannelReadSwizzle (TextureFormat::ChannelOrder order) 768 { 769 // make sure to update these tables when channel orders are updated 770 DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 21); 771 772 static const TextureSwizzle INV = {{ TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; 773 static const TextureSwizzle R = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; 774 static const TextureSwizzle A = {{ TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_0 }}; 775 static const TextureSwizzle I = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0 }}; 776 static const TextureSwizzle L = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ONE }}; 777 static const TextureSwizzle LA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1 }}; 778 static const TextureSwizzle RG = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; 779 static const TextureSwizzle RA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_1 }}; 780 static const TextureSwizzle RGB = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_ONE }}; 781 static const TextureSwizzle RGBA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_3 }}; 782 static const TextureSwizzle BGR = {{ TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ONE }}; 783 static const TextureSwizzle BGRA = {{ TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3 }}; 784 static const TextureSwizzle ARGB = {{ TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_3, TextureSwizzle::CHANNEL_0 }}; 785 static const TextureSwizzle D = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; 786 static const TextureSwizzle S = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; 787 788 switch (order) 789 { 790 case TextureFormat::R: return R; 791 case TextureFormat::A: return A; 792 case TextureFormat::I: return I; 793 case TextureFormat::L: return L; 794 case TextureFormat::LA: return LA; 795 case TextureFormat::RG: return RG; 796 case TextureFormat::RA: return RA; 797 case TextureFormat::RGB: return RGB; 798 case TextureFormat::RGBA: return RGBA; 799 case TextureFormat::ARGB: return ARGB; 800 case TextureFormat::BGR: return BGR; 801 case TextureFormat::BGRA: return BGRA; 802 case TextureFormat::sR: return R; 803 case TextureFormat::sRG: return RG; 804 case TextureFormat::sRGB: return RGB; 805 case TextureFormat::sRGBA: return RGBA; 806 case TextureFormat::sBGR: return BGR; 807 case TextureFormat::sBGRA: return BGRA; 808 case TextureFormat::D: return D; 809 case TextureFormat::S: return S; 810 811 case TextureFormat::DS: 812 DE_ASSERT(false); // combined formats cannot be read from 813 return INV; 814 815 default: 816 DE_ASSERT(DE_FALSE); 817 return INV; 818 } 819 } 820 821 const TextureSwizzle& getChannelWriteSwizzle (TextureFormat::ChannelOrder order) 822 { 823 // make sure to update these tables when channel orders are updated 824 DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 21); 825 826 static const TextureSwizzle INV = {{ TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; 827 static const TextureSwizzle R = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; 828 static const TextureSwizzle A = {{ TextureSwizzle::CHANNEL_3, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; 829 static const TextureSwizzle I = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; 830 static const TextureSwizzle L = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; 831 static const TextureSwizzle LA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; 832 static const TextureSwizzle RG = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; 833 static const TextureSwizzle RA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; 834 static const TextureSwizzle RGB = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_LAST }}; 835 static const TextureSwizzle RGBA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_3 }}; 836 static const TextureSwizzle BGR = {{ TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_LAST }}; 837 static const TextureSwizzle BGRA = {{ TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3 }}; 838 static const TextureSwizzle ARGB = {{ TextureSwizzle::CHANNEL_3, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2 }}; 839 static const TextureSwizzle D = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; 840 static const TextureSwizzle S = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; 841 842 switch (order) 843 { 844 case TextureFormat::R: return R; 845 case TextureFormat::A: return A; 846 case TextureFormat::I: return I; 847 case TextureFormat::L: return L; 848 case TextureFormat::LA: return LA; 849 case TextureFormat::RG: return RG; 850 case TextureFormat::RA: return RA; 851 case TextureFormat::RGB: return RGB; 852 case TextureFormat::RGBA: return RGBA; 853 case TextureFormat::ARGB: return ARGB; 854 case TextureFormat::BGR: return BGR; 855 case TextureFormat::BGRA: return BGRA; 856 case TextureFormat::sR: return R; 857 case TextureFormat::sRG: return RG; 858 case TextureFormat::sRGB: return RGB; 859 case TextureFormat::sRGBA: return RGBA; 860 case TextureFormat::sBGR: return BGR; 861 case TextureFormat::sBGRA: return BGRA; 862 case TextureFormat::D: return D; 863 case TextureFormat::S: return S; 864 865 case TextureFormat::DS: 866 DE_ASSERT(false); // combined formats cannot be written to 867 return INV; 868 869 default: 870 DE_ASSERT(DE_FALSE); 871 return INV; 872 } 873 } 874 875 IVec3 calculatePackedPitch (const TextureFormat& format, const IVec3& size) 876 { 877 const int pixelSize = format.getPixelSize(); 878 const int rowPitch = pixelSize * size.x(); 879 const int slicePitch = rowPitch * size.y(); 880 881 return IVec3(pixelSize, rowPitch, slicePitch); 882 } 883 884 ConstPixelBufferAccess::ConstPixelBufferAccess (void) 885 : m_size (0) 886 , m_pitch (0) 887 , m_data (DE_NULL) 888 { 889 } 890 891 ConstPixelBufferAccess::ConstPixelBufferAccess (const TextureFormat& format, int width, int height, int depth, const void* data) 892 : m_format (format) 893 , m_size (width, height, depth) 894 , m_pitch (calculatePackedPitch(m_format, m_size)) 895 , m_data ((void*)data) 896 { 897 DE_ASSERT(isValid(format)); 898 } 899 900 ConstPixelBufferAccess::ConstPixelBufferAccess (const TextureFormat& format, const IVec3& size, const void* data) 901 : m_format (format) 902 , m_size (size) 903 , m_pitch (calculatePackedPitch(m_format, m_size)) 904 , m_data ((void*)data) 905 { 906 DE_ASSERT(isValid(format)); 907 } 908 909 ConstPixelBufferAccess::ConstPixelBufferAccess (const TextureFormat& format, int width, int height, int depth, int rowPitch, int slicePitch, const void* data) 910 : m_format (format) 911 , m_size (width, height, depth) 912 , m_pitch (format.getPixelSize(), rowPitch, slicePitch) 913 , m_data ((void*)data) 914 { 915 DE_ASSERT(isValid(format)); 916 } 917 918 ConstPixelBufferAccess::ConstPixelBufferAccess (const TextureFormat& format, const IVec3& size, const IVec3& pitch, const void* data) 919 : m_format (format) 920 , m_size (size) 921 , m_pitch (pitch) 922 , m_data ((void*)data) 923 { 924 DE_ASSERT(isValid(format)); 925 DE_ASSERT(m_format.getPixelSize() <= m_pitch.x()); 926 } 927 928 ConstPixelBufferAccess::ConstPixelBufferAccess (const TextureLevel& level) 929 : m_format (level.getFormat()) 930 , m_size (level.getSize()) 931 , m_pitch (calculatePackedPitch(m_format, m_size)) 932 , m_data ((void*)level.getPtr()) 933 { 934 } 935 936 PixelBufferAccess::PixelBufferAccess (const TextureFormat& format, int width, int height, int depth, void* data) 937 : ConstPixelBufferAccess(format, width, height, depth, data) 938 { 939 } 940 941 PixelBufferAccess::PixelBufferAccess (const TextureFormat& format, const IVec3& size, void* data) 942 : ConstPixelBufferAccess(format, size, data) 943 { 944 } 945 946 PixelBufferAccess::PixelBufferAccess (const TextureFormat& format, int width, int height, int depth, int rowPitch, int slicePitch, void* data) 947 : ConstPixelBufferAccess(format, width, height, depth, rowPitch, slicePitch, data) 948 { 949 } 950 951 PixelBufferAccess::PixelBufferAccess (const TextureFormat& format, const IVec3& size, const IVec3& pitch, void* data) 952 : ConstPixelBufferAccess(format, size, pitch, data) 953 { 954 } 955 956 PixelBufferAccess::PixelBufferAccess (TextureLevel& level) 957 : ConstPixelBufferAccess(level) 958 { 959 } 960 961 //! Swizzle RGB(A) <-> BGR(A) 962 template<typename T> 963 Vector<T, 4> swizzleRB (const Vector<T, 4>& v, TextureFormat::ChannelOrder src, TextureFormat::ChannelOrder dst) 964 { 965 if (src == dst) 966 return v; 967 else 968 { 969 DE_ASSERT((src == TextureFormat::RGB && dst == TextureFormat::BGR) || 970 (src == TextureFormat::BGR && dst == TextureFormat::RGB) || 971 (src == TextureFormat::RGBA && dst == TextureFormat::BGRA) || 972 (src == TextureFormat::BGRA && dst == TextureFormat::RGBA)); 973 return v.swizzle(2,1,0,3); 974 } 975 } 976 977 Vec4 ConstPixelBufferAccess::getPixel (int x, int y, int z) const 978 { 979 DE_ASSERT(de::inBounds(x, 0, m_size.x())); 980 DE_ASSERT(de::inBounds(y, 0, m_size.y())); 981 DE_ASSERT(de::inBounds(z, 0, m_size.z())); 982 DE_ASSERT(!isCombinedDepthStencilType(m_format.type)); // combined types cannot be accessed directly 983 DE_ASSERT(m_format.order != TextureFormat::DS); // combined formats cannot be accessed directly 984 985 const deUint8* pixelPtr = (const deUint8*)getPixelPtr(x, y, z); 986 987 // Optimized fomats. 988 if (m_format.type == TextureFormat::UNORM_INT8) 989 { 990 if (m_format.order == TextureFormat::RGBA || m_format.order == TextureFormat::sRGBA) 991 return readRGBA8888Float(pixelPtr); 992 else if (m_format.order == TextureFormat::RGB || m_format.order == TextureFormat::sRGB) 993 return readRGB888Float(pixelPtr); 994 } 995 996 #define UI8(OFFS, COUNT) ((*((const deUint8*)pixelPtr) >> (OFFS)) & ((1<<(COUNT))-1)) 997 #define UI16(OFFS, COUNT) ((*((const deUint16*)pixelPtr) >> (OFFS)) & ((1<<(COUNT))-1)) 998 #define UI32(OFFS, COUNT) ((*((const deUint32*)pixelPtr) >> (OFFS)) & ((1<<(COUNT))-1)) 999 #define SI32(OFFS, COUNT) signExtend(UI32(OFFS, COUNT), (COUNT)) 1000 #define UN8(OFFS, COUNT) channelToUnormFloat(UI8 (OFFS, COUNT), (COUNT)) 1001 #define UN16(OFFS, COUNT) channelToUnormFloat(UI16(OFFS, COUNT), (COUNT)) 1002 #define UN32(OFFS, COUNT) channelToUnormFloat(UI32(OFFS, COUNT), (COUNT)) 1003 #define SN32(OFFS, COUNT) channelToSnormFloat(UI32(OFFS, COUNT), (COUNT)) 1004 1005 // Packed formats. 1006 switch (m_format.type) 1007 { 1008 case TextureFormat::UNORM_BYTE_44: return Vec4(UN8 (4, 4), UN8 ( 0, 4), 0.0f, 1.0f); 1009 case TextureFormat::UNSIGNED_BYTE_44: return UVec4(UI8 (4, 4), UI8 ( 0, 4), 0u, 1u).cast<float>(); 1010 case TextureFormat::UNORM_SHORT_565: return swizzleRB( Vec4(UN16(11, 5), UN16( 5, 6), UN16( 0, 5), 1.0f), m_format.order, TextureFormat::RGB); 1011 case TextureFormat::UNSIGNED_SHORT_565: return swizzleRB(UVec4(UI16(11, 5), UI16( 5, 6), UI16( 0, 5), 1u), m_format.order, TextureFormat::RGB).cast<float>(); 1012 case TextureFormat::UNORM_SHORT_555: return swizzleRB( Vec4(UN16(10, 5), UN16( 5, 5), UN16( 0, 5), 1.0f), m_format.order, TextureFormat::RGB); 1013 case TextureFormat::UNORM_SHORT_4444: return swizzleRB( Vec4(UN16(12, 4), UN16( 8, 4), UN16( 4, 4), UN16( 0, 4)), m_format.order, TextureFormat::RGBA); 1014 case TextureFormat::UNSIGNED_SHORT_4444: return swizzleRB(UVec4(UI16(12, 4), UI16( 8, 4), UI16( 4, 4), UI16( 0, 4)), m_format.order, TextureFormat::RGBA).cast<float>(); 1015 case TextureFormat::UNORM_SHORT_5551: return swizzleRB( Vec4(UN16(11, 5), UN16( 6, 5), UN16( 1, 5), UN16( 0, 1)), m_format.order, TextureFormat::RGBA); 1016 case TextureFormat::UNSIGNED_SHORT_5551: return swizzleRB(UVec4(UI16(11, 5), UI16( 6, 5), UI16( 1, 5), UI16( 0, 1)), m_format.order, TextureFormat::RGBA).cast<float>(); 1017 case TextureFormat::UNORM_INT_101010: return Vec4(UN32(22, 10), UN32(12, 10), UN32( 2, 10), 1.0f); 1018 case TextureFormat::UNORM_INT_1010102_REV: return swizzleRB( Vec4(UN32( 0, 10), UN32(10, 10), UN32(20, 10), UN32(30, 2)), m_format.order, TextureFormat::RGBA); 1019 case TextureFormat::SNORM_INT_1010102_REV: return swizzleRB( Vec4(SN32( 0, 10), SN32(10, 10), SN32(20, 10), SN32(30, 2)), m_format.order, TextureFormat::RGBA); 1020 case TextureFormat::UNSIGNED_INT_1010102_REV: return swizzleRB( UVec4(UI32(0, 10), UI32(10, 10), UI32(20, 10), UI32(30, 2)), m_format.order, TextureFormat::RGBA).cast<float>(); 1021 case TextureFormat::SIGNED_INT_1010102_REV: return swizzleRB( UVec4(SI32(0, 10), SI32(10, 10), SI32(20, 10), SI32(30, 2)), m_format.order, TextureFormat::RGBA).cast<float>(); 1022 case TextureFormat::UNSIGNED_INT_999_E5_REV: return unpackRGB999E5(*((const deUint32*)pixelPtr)); 1023 1024 case TextureFormat::UNORM_SHORT_1555: 1025 DE_ASSERT(m_format.order == TextureFormat::ARGB); 1026 return Vec4(UN16(15, 1), UN16(10, 5), UN16(5, 5), UN16(0, 5)).swizzle(1,2,3,0); // ARGB -> RGBA 1027 1028 case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: 1029 return Vec4(Float11(UI32(0, 11)).asFloat(), Float11(UI32(11, 11)).asFloat(), Float10(UI32(22, 10)).asFloat(), 1.0f); 1030 1031 default: 1032 break; 1033 } 1034 1035 #undef UN8 1036 #undef UN16 1037 #undef UN32 1038 #undef SN32 1039 #undef SI32 1040 #undef UI8 1041 #undef UI16 1042 #undef UI32 1043 1044 // Generic path. 1045 Vec4 result; 1046 const TextureSwizzle::Channel* channelMap = getChannelReadSwizzle(m_format.order).components; 1047 int channelSize = getChannelSize(m_format.type); 1048 1049 for (int c = 0; c < 4; c++) 1050 { 1051 switch (channelMap[c]) 1052 { 1053 case TextureSwizzle::CHANNEL_0: 1054 case TextureSwizzle::CHANNEL_1: 1055 case TextureSwizzle::CHANNEL_2: 1056 case TextureSwizzle::CHANNEL_3: 1057 result[c] = channelToFloat(pixelPtr + channelSize*((int)channelMap[c]), m_format.type); 1058 break; 1059 1060 case TextureSwizzle::CHANNEL_ZERO: 1061 result[c] = 0.0f; 1062 break; 1063 1064 case TextureSwizzle::CHANNEL_ONE: 1065 result[c] = 1.0f; 1066 break; 1067 1068 default: 1069 DE_ASSERT(false); 1070 } 1071 } 1072 1073 return result; 1074 } 1075 1076 IVec4 ConstPixelBufferAccess::getPixelInt (int x, int y, int z) const 1077 { 1078 DE_ASSERT(de::inBounds(x, 0, m_size.x())); 1079 DE_ASSERT(de::inBounds(y, 0, m_size.y())); 1080 DE_ASSERT(de::inBounds(z, 0, m_size.z())); 1081 DE_ASSERT(!isCombinedDepthStencilType(m_format.type)); // combined types cannot be accessed directly 1082 DE_ASSERT(m_format.order != TextureFormat::DS); // combined formats cannot be accessed directly 1083 1084 const deUint8* const pixelPtr = (const deUint8*)getPixelPtr(x, y, z); 1085 IVec4 result; 1086 1087 // Optimized fomats. 1088 if (m_format.type == TextureFormat::UNORM_INT8) 1089 { 1090 if (m_format.order == TextureFormat::RGBA || m_format.order == TextureFormat::sRGBA) 1091 return readRGBA8888Int(pixelPtr); 1092 else if (m_format.order == TextureFormat::RGB || m_format.order == TextureFormat::sRGB) 1093 return readRGB888Int(pixelPtr); 1094 } 1095 1096 #define U8(OFFS, COUNT) ((*((const deUint8* )pixelPtr) >> (OFFS)) & ((1<<(COUNT))-1)) 1097 #define U16(OFFS, COUNT) ((*((const deUint16*)pixelPtr) >> (OFFS)) & ((1<<(COUNT))-1)) 1098 #define U32(OFFS, COUNT) ((*((const deUint32*)pixelPtr) >> (OFFS)) & ((1<<(COUNT))-1)) 1099 #define S32(OFFS, COUNT) signExtend(U32(OFFS, COUNT), (COUNT)) 1100 1101 switch (m_format.type) 1102 { 1103 case TextureFormat::UNSIGNED_BYTE_44: // Fall-through 1104 case TextureFormat::UNORM_BYTE_44: return UVec4(U8 ( 4, 4), U8 ( 0, 4), 0u, 1u).cast<int>(); 1105 case TextureFormat::UNSIGNED_SHORT_565: // Fall-through 1106 case TextureFormat::UNORM_SHORT_565: return swizzleRB(UVec4(U16(11, 5), U16( 5, 6), U16( 0, 5), 1).cast<int>(), m_format.order, TextureFormat::RGB); 1107 case TextureFormat::UNORM_SHORT_555: return swizzleRB(UVec4(U16(10, 5), U16( 5, 5), U16( 0, 5), 1).cast<int>(), m_format.order, TextureFormat::RGB); 1108 case TextureFormat::UNSIGNED_SHORT_4444: // Fall-through 1109 case TextureFormat::UNORM_SHORT_4444: return swizzleRB(UVec4(U16(12, 4), U16( 8, 4), U16( 4, 4), U16( 0, 4)).cast<int>(), m_format.order, TextureFormat::RGBA); 1110 case TextureFormat::UNSIGNED_SHORT_5551: // Fall-through 1111 case TextureFormat::UNORM_SHORT_5551: return swizzleRB(UVec4(U16(11, 5), U16( 6, 5), U16( 1, 5), U16( 0, 1)).cast<int>(), m_format.order, TextureFormat::RGBA); 1112 case TextureFormat::UNORM_INT_101010: return UVec4(U32(22, 10), U32(12, 10), U32( 2, 10), 1).cast<int>(); 1113 case TextureFormat::UNORM_INT_1010102_REV: // Fall-through 1114 case TextureFormat::UNSIGNED_INT_1010102_REV: return swizzleRB(UVec4(U32( 0, 10), U32(10, 10), U32(20, 10), U32(30, 2)), m_format.order, TextureFormat::RGBA).cast<int>(); 1115 case TextureFormat::SNORM_INT_1010102_REV: // Fall-through 1116 case TextureFormat::SIGNED_INT_1010102_REV: return swizzleRB(IVec4(S32( 0, 10), S32(10, 10), S32(20, 10), S32(30, 2)), m_format.order, TextureFormat::RGBA); 1117 1118 case TextureFormat::UNORM_SHORT_1555: 1119 DE_ASSERT(m_format.order == TextureFormat::ARGB); 1120 return UVec4(U16(15, 1), U16(10, 5), U16(5, 5), U16(0, 5)).cast<int>().swizzle(1,2,3,0); // ARGB -> RGBA 1121 1122 default: 1123 break; // To generic path. 1124 } 1125 1126 #undef U8 1127 #undef U16 1128 #undef U32 1129 #undef S32 1130 1131 // Generic path. 1132 const TextureSwizzle::Channel* channelMap = getChannelReadSwizzle(m_format.order).components; 1133 int channelSize = getChannelSize(m_format.type); 1134 1135 for (int c = 0; c < 4; c++) 1136 { 1137 switch (channelMap[c]) 1138 { 1139 case TextureSwizzle::CHANNEL_0: 1140 case TextureSwizzle::CHANNEL_1: 1141 case TextureSwizzle::CHANNEL_2: 1142 case TextureSwizzle::CHANNEL_3: 1143 result[c] = channelToInt(pixelPtr + channelSize*((int)channelMap[c]), m_format.type); 1144 break; 1145 1146 case TextureSwizzle::CHANNEL_ZERO: 1147 result[c] = 0; 1148 break; 1149 1150 case TextureSwizzle::CHANNEL_ONE: 1151 result[c] = 1; 1152 break; 1153 1154 default: 1155 DE_ASSERT(false); 1156 } 1157 } 1158 1159 return result; 1160 } 1161 1162 template<> 1163 Vec4 ConstPixelBufferAccess::getPixelT (int x, int y, int z) const 1164 { 1165 return getPixel(x, y, z); 1166 } 1167 1168 template<> 1169 IVec4 ConstPixelBufferAccess::getPixelT (int x, int y, int z) const 1170 { 1171 return getPixelInt(x, y, z); 1172 } 1173 1174 template<> 1175 UVec4 ConstPixelBufferAccess::getPixelT (int x, int y, int z) const 1176 { 1177 return getPixelUint(x, y, z); 1178 } 1179 1180 float ConstPixelBufferAccess::getPixDepth (int x, int y, int z) const 1181 { 1182 DE_ASSERT(de::inBounds(x, 0, getWidth())); 1183 DE_ASSERT(de::inBounds(y, 0, getHeight())); 1184 DE_ASSERT(de::inBounds(z, 0, getDepth())); 1185 1186 const deUint8* const pixelPtr = (const deUint8*)getPixelPtr(x, y, z); 1187 1188 switch (m_format.type) 1189 { 1190 case TextureFormat::UNSIGNED_INT_16_8_8: 1191 DE_ASSERT(m_format.order == TextureFormat::DS); 1192 return (float)readUint32High16(pixelPtr) / 65535.0f; 1193 1194 case TextureFormat::UNSIGNED_INT_24_8: 1195 DE_ASSERT(m_format.order == TextureFormat::D || m_format.order == TextureFormat::DS); 1196 return (float)readUint32High24(pixelPtr) / 16777215.0f; 1197 1198 case TextureFormat::UNSIGNED_INT_24_8_REV: 1199 DE_ASSERT(m_format.order == TextureFormat::D || m_format.order == TextureFormat::DS); 1200 return (float)readUint32Low24(pixelPtr) / 16777215.0f; 1201 1202 case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: 1203 DE_ASSERT(m_format.order == TextureFormat::DS); 1204 return *((const float*)pixelPtr); 1205 1206 default: 1207 DE_ASSERT(m_format.order == TextureFormat::D); // no other combined depth stencil types 1208 return channelToFloat(pixelPtr, m_format.type); 1209 } 1210 } 1211 1212 int ConstPixelBufferAccess::getPixStencil (int x, int y, int z) const 1213 { 1214 DE_ASSERT(de::inBounds(x, 0, getWidth())); 1215 DE_ASSERT(de::inBounds(y, 0, getHeight())); 1216 DE_ASSERT(de::inBounds(z, 0, getDepth())); 1217 1218 const deUint8* const pixelPtr = (const deUint8*)getPixelPtr(x, y, z); 1219 1220 switch (m_format.type) 1221 { 1222 case TextureFormat::UNSIGNED_INT_24_8_REV: 1223 DE_ASSERT(m_format.order == TextureFormat::DS); 1224 return (int)readUint32High8(pixelPtr); 1225 1226 case TextureFormat::UNSIGNED_INT_16_8_8: 1227 case TextureFormat::UNSIGNED_INT_24_8: 1228 DE_ASSERT(m_format.order == TextureFormat::DS); 1229 return (int)readUint32Low8(pixelPtr); 1230 1231 case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: 1232 DE_ASSERT(m_format.order == TextureFormat::DS); 1233 return (int)readUint32Low8(pixelPtr + 4); 1234 1235 default: 1236 { 1237 DE_ASSERT(m_format.order == TextureFormat::S); // no other combined depth stencil types 1238 return channelToInt(pixelPtr, m_format.type); 1239 } 1240 } 1241 } 1242 1243 void PixelBufferAccess::setPixel (const Vec4& color, int x, int y, int z) const 1244 { 1245 DE_ASSERT(de::inBounds(x, 0, getWidth())); 1246 DE_ASSERT(de::inBounds(y, 0, getHeight())); 1247 DE_ASSERT(de::inBounds(z, 0, getDepth())); 1248 DE_ASSERT(!isCombinedDepthStencilType(m_format.type)); // combined types cannot be accessed directly 1249 DE_ASSERT(m_format.order != TextureFormat::DS); // combined formats cannot be accessed directly 1250 1251 deUint8* const pixelPtr = (deUint8*)getPixelPtr(x, y, z); 1252 1253 // Optimized fomats. 1254 if (m_format.type == TextureFormat::UNORM_INT8) 1255 { 1256 if (m_format.order == TextureFormat::RGBA || m_format.order == TextureFormat::sRGBA) 1257 { 1258 writeRGBA8888Float(pixelPtr, color); 1259 return; 1260 } 1261 else if (m_format.order == TextureFormat::RGB || m_format.order == TextureFormat::sRGB) 1262 { 1263 writeRGB888Float(pixelPtr, color); 1264 return; 1265 } 1266 } 1267 1268 #define PN(VAL, OFFS, BITS) (unormFloatToChannel((VAL), (BITS)) << (OFFS)) 1269 #define PS(VAL, OFFS, BITS) (snormFloatToChannel((VAL), (BITS)) << (OFFS)) 1270 #define PU(VAL, OFFS, BITS) (uintToChannel((VAL), (BITS)) << (OFFS)) 1271 #define PI(VAL, OFFS, BITS) (intToChannel((VAL), (BITS)) << (OFFS)) 1272 1273 switch (m_format.type) 1274 { 1275 case TextureFormat::UNORM_BYTE_44: *((deUint8 *)pixelPtr) = (deUint8)(PN(color[0], 4, 4) | PN(color[1], 0, 4)); break; 1276 case TextureFormat::UNSIGNED_BYTE_44: *((deUint8 *)pixelPtr) = (deUint8)(PU((deUint32)color[0], 4, 4) | PU((deUint32)color[1], 0, 4)); break; 1277 case TextureFormat::UNORM_INT_101010: *((deUint32*)pixelPtr) = PN(color[0], 22, 10) | PN(color[1], 12, 10) | PN(color[2], 2, 10); break; 1278 1279 case TextureFormat::UNORM_SHORT_565: 1280 { 1281 const Vec4 swizzled = swizzleRB(color, TextureFormat::RGB, m_format.order); 1282 *((deUint16*)pixelPtr) = (deUint16)(PN(swizzled[0], 11, 5) | PN(swizzled[1], 5, 6) | PN(swizzled[2], 0, 5)); 1283 break; 1284 } 1285 1286 case TextureFormat::UNSIGNED_SHORT_565: 1287 { 1288 const UVec4 swizzled = swizzleRB(color.cast<deUint32>(), TextureFormat::RGB, m_format.order); 1289 *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 11, 5) | PU(swizzled[1], 5, 6) | PU(swizzled[2], 0, 5)); 1290 break; 1291 } 1292 1293 case TextureFormat::UNORM_SHORT_555: 1294 { 1295 const Vec4 swizzled = swizzleRB(color, TextureFormat::RGB, m_format.order); 1296 *((deUint16*)pixelPtr) = (deUint16)(PN(swizzled[0], 10, 5) | PN(swizzled[1], 5, 5) | PN(swizzled[2], 0, 5)); 1297 break; 1298 } 1299 1300 case TextureFormat::UNORM_SHORT_4444: 1301 { 1302 const Vec4 swizzled = swizzleRB(color, TextureFormat::RGBA, m_format.order); 1303 *((deUint16*)pixelPtr) = (deUint16)(PN(swizzled[0], 12, 4) | PN(swizzled[1], 8, 4) | PN(swizzled[2], 4, 4) | PN(swizzled[3], 0, 4)); 1304 break; 1305 } 1306 1307 case TextureFormat::UNSIGNED_SHORT_4444: 1308 { 1309 const UVec4 swizzled = swizzleRB(color.cast<deUint32>(), TextureFormat::RGBA, m_format.order); 1310 *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 12, 4) | PU(swizzled[1], 8, 4) | PU(swizzled[2], 4, 4) | PU(swizzled[3], 0, 4)); 1311 break; 1312 } 1313 1314 case TextureFormat::UNORM_SHORT_5551: 1315 { 1316 const Vec4 swizzled = swizzleRB(color, TextureFormat::RGBA, m_format.order); 1317 *((deUint16*)pixelPtr) = (deUint16)(PN(swizzled[0], 11, 5) | PN(swizzled[1], 6, 5) | PN(swizzled[2], 1, 5) | PN(swizzled[3], 0, 1)); 1318 break; 1319 } 1320 1321 case TextureFormat::UNORM_SHORT_1555: 1322 { 1323 const Vec4 swizzled = color.swizzle(3,0,1,2); // RGBA -> ARGB 1324 *((deUint16*)pixelPtr) = (deUint16)(PN(swizzled[0], 15, 1) | PN(swizzled[1], 10, 5) | PN(swizzled[2], 5, 5) | PN(swizzled[3], 0, 5)); 1325 break; 1326 } 1327 1328 case TextureFormat::UNSIGNED_SHORT_5551: 1329 { 1330 const UVec4 swizzled = swizzleRB(color.cast<deUint32>(), TextureFormat::RGBA, m_format.order); 1331 *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 11, 5) | PU(swizzled[1], 6, 5) | PU(swizzled[2], 1, 5) | PU(swizzled[3], 0, 1)); 1332 break; 1333 } 1334 1335 case TextureFormat::UNORM_INT_1010102_REV: 1336 { 1337 const Vec4 u = swizzleRB(color, TextureFormat::RGBA, m_format.order); 1338 *((deUint32*)pixelPtr) = PN(u[0], 0, 10) | PN(u[1], 10, 10) | PN(u[2], 20, 10) | PN(u[3], 30, 2); 1339 break; 1340 } 1341 1342 case TextureFormat::SNORM_INT_1010102_REV: 1343 { 1344 const Vec4 u = swizzleRB(color, TextureFormat::RGBA, m_format.order); 1345 *((deUint32*)pixelPtr) = PS(u[0], 0, 10) | PS(u[1], 10, 10) | PS(u[2], 20, 10) | PS(u[3], 30, 2); 1346 break; 1347 } 1348 1349 case TextureFormat::UNSIGNED_INT_1010102_REV: 1350 { 1351 const UVec4 u = swizzleRB(color.cast<deUint32>(), TextureFormat::RGBA, m_format.order); 1352 *((deUint32*)pixelPtr) = PU(u[0], 0, 10) | PU(u[1], 10, 10) | PU(u[2], 20, 10) | PU(u[3], 30, 2); 1353 break; 1354 } 1355 1356 case TextureFormat::SIGNED_INT_1010102_REV: 1357 { 1358 const IVec4 u = swizzleRB(color.cast<deInt32>(), TextureFormat::RGBA, m_format.order); 1359 *((deUint32*)pixelPtr) = PI(u[0], 0, 10) | PI(u[1], 10, 10) | PI(u[2], 20, 10) | PI(u[3], 30, 2); 1360 break; 1361 } 1362 1363 case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: 1364 *((deUint32*)pixelPtr) = Float11(color[0]).bits() | (Float11(color[1]).bits() << 11) | (Float10(color[2]).bits() << 22); 1365 break; 1366 1367 case TextureFormat::UNSIGNED_INT_999_E5_REV: 1368 *((deUint32*)pixelPtr) = packRGB999E5(color); 1369 break; 1370 1371 default: 1372 { 1373 // Generic path. 1374 int numChannels = getNumUsedChannels(m_format.order); 1375 const TextureSwizzle::Channel* map = getChannelWriteSwizzle(m_format.order).components; 1376 int channelSize = getChannelSize(m_format.type); 1377 1378 for (int c = 0; c < numChannels; c++) 1379 { 1380 DE_ASSERT(deInRange32(map[c], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3)); 1381 floatToChannel(pixelPtr + channelSize*c, color[map[c]], m_format.type); 1382 } 1383 break; 1384 } 1385 } 1386 1387 #undef PN 1388 #undef PS 1389 #undef PU 1390 #undef PI 1391 } 1392 1393 void PixelBufferAccess::setPixel (const IVec4& color, int x, int y, int z) const 1394 { 1395 DE_ASSERT(de::inBounds(x, 0, getWidth())); 1396 DE_ASSERT(de::inBounds(y, 0, getHeight())); 1397 DE_ASSERT(de::inBounds(z, 0, getDepth())); 1398 DE_ASSERT(!isCombinedDepthStencilType(m_format.type)); // combined types cannot be accessed directly 1399 DE_ASSERT(m_format.order != TextureFormat::DS); // combined formats cannot be accessed directly 1400 1401 deUint8* const pixelPtr = (deUint8*)getPixelPtr(x, y, z); 1402 1403 // Optimized fomats. 1404 if (m_format.type == TextureFormat::UNORM_INT8) 1405 { 1406 if (m_format.order == TextureFormat::RGBA || m_format.order == TextureFormat::sRGBA) 1407 { 1408 writeRGBA8888Int(pixelPtr, color); 1409 return; 1410 } 1411 else if (m_format.order == TextureFormat::RGB || m_format.order == TextureFormat::sRGB) 1412 { 1413 writeRGB888Int(pixelPtr, color); 1414 return; 1415 } 1416 } 1417 1418 #define PU(VAL, OFFS, BITS) (uintToChannel((deUint32)(VAL), (BITS)) << (OFFS)) 1419 #define PI(VAL, OFFS, BITS) (intToChannel((deUint32)(VAL), (BITS)) << (OFFS)) 1420 1421 switch (m_format.type) 1422 { 1423 case TextureFormat::UNSIGNED_BYTE_44: // Fall-through 1424 case TextureFormat::UNORM_BYTE_44: *((deUint8 *)pixelPtr) = (deUint8 )(PU(color[0], 4, 4) | PU(color[1], 0, 4)); break; 1425 case TextureFormat::UNORM_INT_101010: *((deUint32*)pixelPtr) = PU(color[0], 22, 10) | PU(color[1], 12, 10) | PU(color[2], 2, 10); break; 1426 1427 case TextureFormat::UNORM_SHORT_565: 1428 case TextureFormat::UNSIGNED_SHORT_565: 1429 { 1430 const IVec4 swizzled = swizzleRB(color, TextureFormat::RGB, m_format.order); 1431 *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 11, 5) | PU(swizzled[1], 5, 6) | PU(swizzled[2], 0, 5)); 1432 break; 1433 } 1434 1435 case TextureFormat::UNORM_SHORT_555: 1436 { 1437 const IVec4 swizzled = swizzleRB(color, TextureFormat::RGB, m_format.order); 1438 *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 10, 5) | PU(swizzled[1], 5, 5) | PU(swizzled[2], 0, 5)); 1439 break; 1440 } 1441 1442 case TextureFormat::UNORM_SHORT_4444: 1443 case TextureFormat::UNSIGNED_SHORT_4444: 1444 { 1445 const IVec4 swizzled = swizzleRB(color, TextureFormat::RGBA, m_format.order); 1446 *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 12, 4) | PU(swizzled[1], 8, 4) | PU(swizzled[2], 4, 4) | PU(swizzled[3], 0, 4)); 1447 break; 1448 } 1449 1450 case TextureFormat::UNORM_SHORT_5551: 1451 case TextureFormat::UNSIGNED_SHORT_5551: 1452 { 1453 const IVec4 swizzled = swizzleRB(color, TextureFormat::RGBA, m_format.order); 1454 *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 11, 5) | PU(swizzled[1], 6, 5) | PU(swizzled[2], 1, 5) | PU(swizzled[3], 0, 1)); 1455 break; 1456 } 1457 1458 case TextureFormat::UNORM_SHORT_1555: 1459 { 1460 const IVec4 swizzled = color.swizzle(3,0,1,2); // RGBA -> ARGB 1461 *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 15, 1) | PU(swizzled[1], 10, 5) | PU(swizzled[2], 5, 5) | PU(swizzled[3], 0, 5)); 1462 break; 1463 } 1464 1465 case TextureFormat::UNORM_INT_1010102_REV: 1466 case TextureFormat::UNSIGNED_INT_1010102_REV: 1467 { 1468 const IVec4 swizzled = swizzleRB(color, TextureFormat::RGBA, m_format.order); 1469 *((deUint32*)pixelPtr) = PU(swizzled[0], 0, 10) | PU(swizzled[1], 10, 10) | PU(swizzled[2], 20, 10) | PU(swizzled[3], 30, 2); 1470 break; 1471 } 1472 1473 case TextureFormat::SNORM_INT_1010102_REV: 1474 case TextureFormat::SIGNED_INT_1010102_REV: 1475 { 1476 const IVec4 swizzled = swizzleRB(color, TextureFormat::RGBA, m_format.order); 1477 *((deUint32*)pixelPtr) = PI(swizzled[0], 0, 10) | PI(swizzled[1], 10, 10) | PI(swizzled[2], 20, 10) | PI(swizzled[3], 30, 2); 1478 break; 1479 } 1480 1481 default: 1482 { 1483 // Generic path. 1484 int numChannels = getNumUsedChannels(m_format.order); 1485 const TextureSwizzle::Channel* map = getChannelWriteSwizzle(m_format.order).components; 1486 int channelSize = getChannelSize(m_format.type); 1487 1488 for (int c = 0; c < numChannels; c++) 1489 { 1490 DE_ASSERT(deInRange32(map[c], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3)); 1491 intToChannel(pixelPtr + channelSize*c, color[map[c]], m_format.type); 1492 } 1493 break; 1494 } 1495 } 1496 1497 #undef PU 1498 #undef PI 1499 } 1500 1501 void PixelBufferAccess::setPixDepth (float depth, int x, int y, int z) const 1502 { 1503 DE_ASSERT(de::inBounds(x, 0, getWidth())); 1504 DE_ASSERT(de::inBounds(y, 0, getHeight())); 1505 DE_ASSERT(de::inBounds(z, 0, getDepth())); 1506 1507 deUint8* const pixelPtr = (deUint8*)getPixelPtr(x, y, z); 1508 1509 switch (m_format.type) 1510 { 1511 case TextureFormat::UNSIGNED_INT_16_8_8: 1512 DE_ASSERT(m_format.order == TextureFormat::DS); 1513 writeUint32High16(pixelPtr, convertSatRte<deUint16>(depth * 65535.0f)); 1514 break; 1515 1516 case TextureFormat::UNSIGNED_INT_24_8: 1517 DE_ASSERT(m_format.order == TextureFormat::D || m_format.order == TextureFormat::DS); 1518 writeUint32High24(pixelPtr, convertSatRteUint24(depth * 16777215.0f)); 1519 break; 1520 1521 case TextureFormat::UNSIGNED_INT_24_8_REV: 1522 DE_ASSERT(m_format.order == TextureFormat::D || m_format.order == TextureFormat::DS); 1523 writeUint32Low24(pixelPtr, convertSatRteUint24(depth * 16777215.0f)); 1524 break; 1525 1526 case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: 1527 DE_ASSERT(m_format.order == TextureFormat::DS); 1528 *((float*)pixelPtr) = depth; 1529 break; 1530 1531 default: 1532 DE_ASSERT(m_format.order == TextureFormat::D); // no other combined depth stencil types 1533 floatToChannel(pixelPtr, depth, m_format.type); 1534 break; 1535 } 1536 } 1537 1538 void PixelBufferAccess::setPixStencil (int stencil, int x, int y, int z) const 1539 { 1540 DE_ASSERT(de::inBounds(x, 0, getWidth())); 1541 DE_ASSERT(de::inBounds(y, 0, getHeight())); 1542 DE_ASSERT(de::inBounds(z, 0, getDepth())); 1543 1544 deUint8* const pixelPtr = (deUint8*)getPixelPtr(x, y, z); 1545 1546 switch (m_format.type) 1547 { 1548 case TextureFormat::UNSIGNED_INT_16_8_8: 1549 case TextureFormat::UNSIGNED_INT_24_8: 1550 DE_ASSERT(m_format.order == TextureFormat::DS); 1551 writeUint32Low8(pixelPtr, convertSat<deUint8>((deUint32)stencil)); 1552 break; 1553 1554 case TextureFormat::UNSIGNED_INT_24_8_REV: 1555 DE_ASSERT(m_format.order == TextureFormat::DS); 1556 writeUint32High8(pixelPtr, convertSat<deUint8>((deUint32)stencil)); 1557 break; 1558 1559 case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: 1560 DE_ASSERT(m_format.order == TextureFormat::DS); 1561 writeUint32Low8(pixelPtr + 4, convertSat<deUint8>((deUint32)stencil)); 1562 break; 1563 1564 default: 1565 DE_ASSERT(m_format.order == TextureFormat::S); // no other combined depth stencil types 1566 intToChannel(pixelPtr, stencil, m_format.type); 1567 break; 1568 } 1569 } 1570 1571 static inline int imod (int a, int b) 1572 { 1573 int m = a % b; 1574 return m < 0 ? m + b : m; 1575 } 1576 1577 static inline int mirror (int a) 1578 { 1579 return a >= 0 ? a : -(1 + a); 1580 } 1581 1582 // Nearest-even rounding in case of tie (fractional part 0.5), otherwise ordinary rounding. 1583 static inline float rint (float a) 1584 { 1585 DE_STATIC_ASSERT((-3 % 2 != 0) && (-4 % 2 == 0)); 1586 1587 float fracVal = deFloatFrac(a); 1588 1589 if (fracVal != 0.5f) 1590 return deFloatRound(a); // Ordinary case. 1591 1592 float floorVal = a - fracVal; 1593 bool roundUp = (deInt64)floorVal % 2 != 0; 1594 1595 return floorVal + (roundUp ? 1.0f : 0.0f); 1596 } 1597 1598 static inline int wrap (Sampler::WrapMode mode, int c, int size) 1599 { 1600 switch (mode) 1601 { 1602 case tcu::Sampler::CLAMP_TO_BORDER: 1603 return deClamp32(c, -1, size); 1604 1605 case tcu::Sampler::CLAMP_TO_EDGE: 1606 return deClamp32(c, 0, size-1); 1607 1608 case tcu::Sampler::REPEAT_GL: 1609 return imod(c, size); 1610 1611 case tcu::Sampler::REPEAT_CL: 1612 return imod(c, size); 1613 1614 case tcu::Sampler::MIRRORED_ONCE: 1615 c = deClamp32(c, -size, size); 1616 // Fall-through 1617 1618 case tcu::Sampler::MIRRORED_REPEAT_GL: 1619 return (size - 1) - mirror(imod(c, 2*size) - size); 1620 1621 case tcu::Sampler::MIRRORED_REPEAT_CL: 1622 return deClamp32(c, 0, size-1); // \note Actual mirroring done already in unnormalization function. 1623 1624 default: 1625 DE_ASSERT(DE_FALSE); 1626 return 0; 1627 } 1628 } 1629 1630 // Special unnormalization for REPEAT_CL and MIRRORED_REPEAT_CL wrap modes; otherwise ordinary unnormalization. 1631 static inline float unnormalize (Sampler::WrapMode mode, float c, int size) 1632 { 1633 switch (mode) 1634 { 1635 case tcu::Sampler::CLAMP_TO_EDGE: 1636 case tcu::Sampler::CLAMP_TO_BORDER: 1637 case tcu::Sampler::REPEAT_GL: 1638 case tcu::Sampler::MIRRORED_REPEAT_GL: 1639 case tcu::Sampler::MIRRORED_ONCE: // Fall-through (ordinary case). 1640 return (float)size*c; 1641 1642 case tcu::Sampler::REPEAT_CL: 1643 return (float)size * (c - deFloatFloor(c)); 1644 1645 case tcu::Sampler::MIRRORED_REPEAT_CL: 1646 return (float)size * deFloatAbs(c - 2.0f * rint(0.5f * c)); 1647 1648 default: 1649 DE_ASSERT(DE_FALSE); 1650 return 0.0f; 1651 } 1652 } 1653 1654 static bool isFixedPointDepthTextureFormat (const tcu::TextureFormat& format) 1655 { 1656 DE_ASSERT(format.order == TextureFormat::D); 1657 1658 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(format.type); 1659 if (channelClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT) 1660 return false; 1661 else if (channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT) 1662 return true; 1663 else 1664 { 1665 DE_ASSERT(false); 1666 return false; 1667 } 1668 } 1669 1670 // Texel lookup with color conversion. 1671 static inline Vec4 lookup (const ConstPixelBufferAccess& access, int i, int j, int k) 1672 { 1673 const TextureFormat& format = access.getFormat(); 1674 1675 if (isSRGB(format)) 1676 { 1677 if (format.type == TextureFormat::UNORM_INT8 && format.order == TextureFormat::sRGB) 1678 return sRGB8ToLinear(access.getPixelUint(i, j, k)); 1679 else if (format.type == TextureFormat::UNORM_INT8 && format.order == TextureFormat::sRGBA) 1680 return sRGBA8ToLinear(access.getPixelUint(i, j, k)); 1681 else 1682 return sRGBToLinear(access.getPixel(i, j, k)); 1683 } 1684 else 1685 { 1686 return access.getPixel(i, j, k); 1687 } 1688 } 1689 1690 // Border texel lookup with color conversion. 1691 static inline Vec4 lookupBorder (const tcu::TextureFormat& format, const tcu::Sampler& sampler) 1692 { 1693 // "lookup" for a combined format does not make sense, disallow 1694 DE_ASSERT(!isCombinedDepthStencilType(format.type)); 1695 1696 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(format.type); 1697 const bool isFloat = channelClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT; 1698 const bool isFixed = channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT || 1699 channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 1700 const bool isPureInteger = channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER; 1701 const bool isPureUnsignedInteger = channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 1702 1703 if (isFloat || isFixed) 1704 return sampleTextureBorder<float>(format, sampler); 1705 else if (isPureInteger) 1706 return sampleTextureBorder<deInt32>(format, sampler).cast<float>(); 1707 else if (isPureUnsignedInteger) 1708 return sampleTextureBorder<deUint32>(format, sampler).cast<float>(); 1709 else 1710 { 1711 DE_ASSERT(false); 1712 return Vec4(-1.0); 1713 } 1714 } 1715 1716 static inline float execCompare (const tcu::Vec4& color, Sampler::CompareMode compare, int chanNdx, float ref_, bool isFixedPoint) 1717 { 1718 const bool clampValues = isFixedPoint; // if comparing against a floating point texture, ref (and value) is not clamped 1719 const float cmp = (clampValues) ? (de::clamp(color[chanNdx], 0.0f, 1.0f)) : (color[chanNdx]); 1720 const float ref = (clampValues) ? (de::clamp(ref_, 0.0f, 1.0f)) : (ref_); 1721 bool res = false; 1722 1723 switch (compare) 1724 { 1725 case Sampler::COMPAREMODE_LESS: res = ref < cmp; break; 1726 case Sampler::COMPAREMODE_LESS_OR_EQUAL: res = ref <= cmp; break; 1727 case Sampler::COMPAREMODE_GREATER: res = ref > cmp; break; 1728 case Sampler::COMPAREMODE_GREATER_OR_EQUAL: res = ref >= cmp; break; 1729 case Sampler::COMPAREMODE_EQUAL: res = ref == cmp; break; 1730 case Sampler::COMPAREMODE_NOT_EQUAL: res = ref != cmp; break; 1731 case Sampler::COMPAREMODE_ALWAYS: res = true; break; 1732 case Sampler::COMPAREMODE_NEVER: res = false; break; 1733 default: 1734 DE_ASSERT(false); 1735 } 1736 1737 return res ? 1.0f : 0.0f; 1738 } 1739 1740 static Vec4 sampleNearest1D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, const IVec2& offset) 1741 { 1742 int width = access.getWidth(); 1743 1744 int x = deFloorFloatToInt32(u)+offset.x(); 1745 1746 // Check for CLAMP_TO_BORDER. 1747 if (sampler.wrapS == Sampler::CLAMP_TO_BORDER && !deInBounds32(x, 0, width)) 1748 return lookupBorder(access.getFormat(), sampler); 1749 1750 int i = wrap(sampler.wrapS, x, width); 1751 1752 return lookup(access, i, offset.y(), 0); 1753 } 1754 1755 static Vec4 sampleNearest2D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, const IVec3& offset) 1756 { 1757 int width = access.getWidth(); 1758 int height = access.getHeight(); 1759 1760 int x = deFloorFloatToInt32(u)+offset.x(); 1761 int y = deFloorFloatToInt32(v)+offset.y(); 1762 1763 // Check for CLAMP_TO_BORDER. 1764 if ((sampler.wrapS == Sampler::CLAMP_TO_BORDER && !deInBounds32(x, 0, width)) || 1765 (sampler.wrapT == Sampler::CLAMP_TO_BORDER && !deInBounds32(y, 0, height))) 1766 return lookupBorder(access.getFormat(), sampler); 1767 1768 int i = wrap(sampler.wrapS, x, width); 1769 int j = wrap(sampler.wrapT, y, height); 1770 1771 return lookup(access, i, j, offset.z()); 1772 } 1773 1774 static Vec4 sampleNearest3D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, float w, const IVec3& offset) 1775 { 1776 int width = access.getWidth(); 1777 int height = access.getHeight(); 1778 int depth = access.getDepth(); 1779 1780 int x = deFloorFloatToInt32(u)+offset.x(); 1781 int y = deFloorFloatToInt32(v)+offset.y(); 1782 int z = deFloorFloatToInt32(w)+offset.z(); 1783 1784 // Check for CLAMP_TO_BORDER. 1785 if ((sampler.wrapS == Sampler::CLAMP_TO_BORDER && !deInBounds32(x, 0, width)) || 1786 (sampler.wrapT == Sampler::CLAMP_TO_BORDER && !deInBounds32(y, 0, height)) || 1787 (sampler.wrapR == Sampler::CLAMP_TO_BORDER && !deInBounds32(z, 0, depth))) 1788 return lookupBorder(access.getFormat(), sampler); 1789 1790 int i = wrap(sampler.wrapS, x, width); 1791 int j = wrap(sampler.wrapT, y, height); 1792 int k = wrap(sampler.wrapR, z, depth); 1793 1794 return lookup(access, i, j, k); 1795 } 1796 1797 static Vec4 sampleLinear1D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, const IVec2& offset) 1798 { 1799 int w = access.getWidth(); 1800 1801 int x0 = deFloorFloatToInt32(u-0.5f)+offset.x(); 1802 int x1 = x0+1; 1803 1804 int i0 = wrap(sampler.wrapS, x0, w); 1805 int i1 = wrap(sampler.wrapS, x1, w); 1806 1807 float a = deFloatFrac(u-0.5f); 1808 1809 bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, w); 1810 bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, w); 1811 1812 // Border color for out-of-range coordinates if using CLAMP_TO_BORDER, otherwise execute lookups. 1813 Vec4 p0 = i0UseBorder ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, offset.y(), 0); 1814 Vec4 p1 = i1UseBorder ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, offset.y(), 0); 1815 1816 // Interpolate. 1817 return p0 * (1.0f - a) + p1 * a; 1818 } 1819 1820 static Vec4 sampleLinear2D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, const IVec3& offset) 1821 { 1822 int w = access.getWidth(); 1823 int h = access.getHeight(); 1824 1825 int x0 = deFloorFloatToInt32(u-0.5f)+offset.x(); 1826 int x1 = x0+1; 1827 int y0 = deFloorFloatToInt32(v-0.5f)+offset.y(); 1828 int y1 = y0+1; 1829 1830 int i0 = wrap(sampler.wrapS, x0, w); 1831 int i1 = wrap(sampler.wrapS, x1, w); 1832 int j0 = wrap(sampler.wrapT, y0, h); 1833 int j1 = wrap(sampler.wrapT, y1, h); 1834 1835 float a = deFloatFrac(u-0.5f); 1836 float b = deFloatFrac(v-0.5f); 1837 1838 bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, w); 1839 bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, w); 1840 bool j0UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j0, 0, h); 1841 bool j1UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j1, 0, h); 1842 1843 // Border color for out-of-range coordinates if using CLAMP_TO_BORDER, otherwise execute lookups. 1844 Vec4 p00 = (i0UseBorder || j0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j0, offset.z()); 1845 Vec4 p10 = (i1UseBorder || j0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j0, offset.z()); 1846 Vec4 p01 = (i0UseBorder || j1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j1, offset.z()); 1847 Vec4 p11 = (i1UseBorder || j1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j1, offset.z()); 1848 1849 // Interpolate. 1850 return (p00*(1.0f-a)*(1.0f-b)) + 1851 (p10*( a)*(1.0f-b)) + 1852 (p01*(1.0f-a)*( b)) + 1853 (p11*( a)*( b)); 1854 } 1855 1856 static float sampleLinear1DCompare (const ConstPixelBufferAccess& access, const Sampler& sampler, float ref, float u, const IVec2& offset, bool isFixedPointDepthFormat) 1857 { 1858 int w = access.getWidth(); 1859 1860 int x0 = deFloorFloatToInt32(u-0.5f)+offset.x(); 1861 int x1 = x0+1; 1862 1863 int i0 = wrap(sampler.wrapS, x0, w); 1864 int i1 = wrap(sampler.wrapS, x1, w); 1865 1866 float a = deFloatFrac(u-0.5f); 1867 1868 bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, w); 1869 bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, w); 1870 1871 // Border color for out-of-range coordinates if using CLAMP_TO_BORDER, otherwise execute lookups. 1872 Vec4 p0Clr = i0UseBorder ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, offset.y(), 0); 1873 Vec4 p1Clr = i1UseBorder ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, offset.y(), 0); 1874 1875 // Execute comparisons. 1876 float p0 = execCompare(p0Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat); 1877 float p1 = execCompare(p1Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat); 1878 1879 // Interpolate. 1880 return (p0 * (1.0f - a)) + (p1 * a); 1881 } 1882 1883 static float sampleLinear2DCompare (const ConstPixelBufferAccess& access, const Sampler& sampler, float ref, float u, float v, const IVec3& offset, bool isFixedPointDepthFormat) 1884 { 1885 int w = access.getWidth(); 1886 int h = access.getHeight(); 1887 1888 int x0 = deFloorFloatToInt32(u-0.5f)+offset.x(); 1889 int x1 = x0+1; 1890 int y0 = deFloorFloatToInt32(v-0.5f)+offset.y(); 1891 int y1 = y0+1; 1892 1893 int i0 = wrap(sampler.wrapS, x0, w); 1894 int i1 = wrap(sampler.wrapS, x1, w); 1895 int j0 = wrap(sampler.wrapT, y0, h); 1896 int j1 = wrap(sampler.wrapT, y1, h); 1897 1898 float a = deFloatFrac(u-0.5f); 1899 float b = deFloatFrac(v-0.5f); 1900 1901 bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, w); 1902 bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, w); 1903 bool j0UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j0, 0, h); 1904 bool j1UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j1, 0, h); 1905 1906 // Border color for out-of-range coordinates if using CLAMP_TO_BORDER, otherwise execute lookups. 1907 Vec4 p00Clr = (i0UseBorder || j0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j0, offset.z()); 1908 Vec4 p10Clr = (i1UseBorder || j0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j0, offset.z()); 1909 Vec4 p01Clr = (i0UseBorder || j1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j1, offset.z()); 1910 Vec4 p11Clr = (i1UseBorder || j1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j1, offset.z()); 1911 1912 // Execute comparisons. 1913 float p00 = execCompare(p00Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat); 1914 float p10 = execCompare(p10Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat); 1915 float p01 = execCompare(p01Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat); 1916 float p11 = execCompare(p11Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat); 1917 1918 // Interpolate. 1919 return (p00*(1.0f-a)*(1.0f-b)) + 1920 (p10*( a)*(1.0f-b)) + 1921 (p01*(1.0f-a)*( b)) + 1922 (p11*( a)*( b)); 1923 } 1924 1925 static Vec4 sampleLinear3D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, float w, const IVec3& offset) 1926 { 1927 int width = access.getWidth(); 1928 int height = access.getHeight(); 1929 int depth = access.getDepth(); 1930 1931 int x0 = deFloorFloatToInt32(u-0.5f)+offset.x(); 1932 int x1 = x0+1; 1933 int y0 = deFloorFloatToInt32(v-0.5f)+offset.y(); 1934 int y1 = y0+1; 1935 int z0 = deFloorFloatToInt32(w-0.5f)+offset.z(); 1936 int z1 = z0+1; 1937 1938 int i0 = wrap(sampler.wrapS, x0, width); 1939 int i1 = wrap(sampler.wrapS, x1, width); 1940 int j0 = wrap(sampler.wrapT, y0, height); 1941 int j1 = wrap(sampler.wrapT, y1, height); 1942 int k0 = wrap(sampler.wrapR, z0, depth); 1943 int k1 = wrap(sampler.wrapR, z1, depth); 1944 1945 float a = deFloatFrac(u-0.5f); 1946 float b = deFloatFrac(v-0.5f); 1947 float c = deFloatFrac(w-0.5f); 1948 1949 bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, width); 1950 bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, width); 1951 bool j0UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j0, 0, height); 1952 bool j1UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j1, 0, height); 1953 bool k0UseBorder = sampler.wrapR == Sampler::CLAMP_TO_BORDER && !de::inBounds(k0, 0, depth); 1954 bool k1UseBorder = sampler.wrapR == Sampler::CLAMP_TO_BORDER && !de::inBounds(k1, 0, depth); 1955 1956 // Border color for out-of-range coordinates if using CLAMP_TO_BORDER, otherwise execute lookups. 1957 Vec4 p000 = (i0UseBorder || j0UseBorder || k0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j0, k0); 1958 Vec4 p100 = (i1UseBorder || j0UseBorder || k0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j0, k0); 1959 Vec4 p010 = (i0UseBorder || j1UseBorder || k0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j1, k0); 1960 Vec4 p110 = (i1UseBorder || j1UseBorder || k0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j1, k0); 1961 Vec4 p001 = (i0UseBorder || j0UseBorder || k1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j0, k1); 1962 Vec4 p101 = (i1UseBorder || j0UseBorder || k1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j0, k1); 1963 Vec4 p011 = (i0UseBorder || j1UseBorder || k1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j1, k1); 1964 Vec4 p111 = (i1UseBorder || j1UseBorder || k1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j1, k1); 1965 1966 // Interpolate. 1967 return (p000*(1.0f-a)*(1.0f-b)*(1.0f-c)) + 1968 (p100*( a)*(1.0f-b)*(1.0f-c)) + 1969 (p010*(1.0f-a)*( b)*(1.0f-c)) + 1970 (p110*( a)*( b)*(1.0f-c)) + 1971 (p001*(1.0f-a)*(1.0f-b)*( c)) + 1972 (p101*( a)*(1.0f-b)*( c)) + 1973 (p011*(1.0f-a)*( b)*( c)) + 1974 (p111*( a)*( b)*( c)); 1975 } 1976 1977 Vec4 ConstPixelBufferAccess::sample1D (const Sampler& sampler, Sampler::FilterMode filter, float s, int level) const 1978 { 1979 // check selected layer exists 1980 DE_ASSERT(de::inBounds(level, 0, m_size.y())); 1981 1982 return sample1DOffset(sampler, filter, s, tcu::IVec2(0, level)); 1983 } 1984 1985 Vec4 ConstPixelBufferAccess::sample2D (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, int depth) const 1986 { 1987 // check selected layer exists 1988 DE_ASSERT(de::inBounds(depth, 0, m_size.z())); 1989 1990 return sample2DOffset(sampler, filter, s, t, tcu::IVec3(0, 0, depth)); 1991 } 1992 1993 Vec4 ConstPixelBufferAccess::sample3D (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, float r) const 1994 { 1995 return sample3DOffset(sampler, filter, s, t, r, tcu::IVec3(0, 0, 0)); 1996 } 1997 1998 Vec4 ConstPixelBufferAccess::sample1DOffset (const Sampler& sampler, Sampler::FilterMode filter, float s, const IVec2& offset) const 1999 { 2000 // check selected layer exists 2001 // \note offset.x is X offset, offset.y is the selected layer 2002 DE_ASSERT(de::inBounds(offset.y(), 0, m_size.y())); 2003 2004 // Non-normalized coordinates. 2005 float u = s; 2006 2007 if (sampler.normalizedCoords) 2008 u = unnormalize(sampler.wrapS, s, m_size.x()); 2009 2010 switch (filter) 2011 { 2012 case Sampler::NEAREST: return sampleNearest1D (*this, sampler, u, offset); 2013 case Sampler::LINEAR: return sampleLinear1D (*this, sampler, u, offset); 2014 default: 2015 DE_ASSERT(DE_FALSE); 2016 return Vec4(0.0f); 2017 } 2018 } 2019 2020 Vec4 ConstPixelBufferAccess::sample2DOffset (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, const IVec3& offset) const 2021 { 2022 // check selected layer exists 2023 // \note offset.xy is the XY offset, offset.z is the selected layer 2024 DE_ASSERT(de::inBounds(offset.z(), 0, m_size.z())); 2025 2026 // Non-normalized coordinates. 2027 float u = s; 2028 float v = t; 2029 2030 if (sampler.normalizedCoords) 2031 { 2032 u = unnormalize(sampler.wrapS, s, m_size.x()); 2033 v = unnormalize(sampler.wrapT, t, m_size.y()); 2034 } 2035 2036 switch (filter) 2037 { 2038 case Sampler::NEAREST: return sampleNearest2D (*this, sampler, u, v, offset); 2039 case Sampler::LINEAR: return sampleLinear2D (*this, sampler, u, v, offset); 2040 default: 2041 DE_ASSERT(DE_FALSE); 2042 return Vec4(0.0f); 2043 } 2044 } 2045 2046 Vec4 ConstPixelBufferAccess::sample3DOffset (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, float r, const IVec3& offset) const 2047 { 2048 // Non-normalized coordinates. 2049 float u = s; 2050 float v = t; 2051 float w = r; 2052 2053 if (sampler.normalizedCoords) 2054 { 2055 u = unnormalize(sampler.wrapS, s, m_size.x()); 2056 v = unnormalize(sampler.wrapT, t, m_size.y()); 2057 w = unnormalize(sampler.wrapR, r, m_size.z()); 2058 } 2059 2060 switch (filter) 2061 { 2062 case Sampler::NEAREST: return sampleNearest3D (*this, sampler, u, v, w, offset); 2063 case Sampler::LINEAR: return sampleLinear3D (*this, sampler, u, v, w, offset); 2064 default: 2065 DE_ASSERT(DE_FALSE); 2066 return Vec4(0.0f); 2067 } 2068 } 2069 2070 float ConstPixelBufferAccess::sample1DCompare (const Sampler& sampler, Sampler::FilterMode filter, float ref, float s, const IVec2& offset) const 2071 { 2072 // check selected layer exists 2073 // \note offset.x is X offset, offset.y is the selected layer 2074 DE_ASSERT(de::inBounds(offset.y(), 0, m_size.y())); 2075 2076 // Format information for comparison function 2077 const bool isFixedPointDepth = isFixedPointDepthTextureFormat(m_format); 2078 2079 // Non-normalized coordinates. 2080 float u = s; 2081 2082 if (sampler.normalizedCoords) 2083 u = unnormalize(sampler.wrapS, s, m_size.x()); 2084 2085 switch (filter) 2086 { 2087 case Sampler::NEAREST: return execCompare(sampleNearest1D(*this, sampler, u, offset), sampler.compare, sampler.compareChannel, ref, isFixedPointDepth); 2088 case Sampler::LINEAR: return sampleLinear1DCompare(*this, sampler, ref, u, offset, isFixedPointDepth); 2089 default: 2090 DE_ASSERT(DE_FALSE); 2091 return 0.0f; 2092 } 2093 } 2094 2095 float ConstPixelBufferAccess::sample2DCompare (const Sampler& sampler, Sampler::FilterMode filter, float ref, float s, float t, const IVec3& offset) const 2096 { 2097 // check selected layer exists 2098 // \note offset.xy is XY offset, offset.z is the selected layer 2099 DE_ASSERT(de::inBounds(offset.z(), 0, m_size.z())); 2100 2101 // Format information for comparison function 2102 const bool isFixedPointDepth = isFixedPointDepthTextureFormat(m_format); 2103 2104 // Non-normalized coordinates. 2105 float u = s; 2106 float v = t; 2107 2108 if (sampler.normalizedCoords) 2109 { 2110 u = unnormalize(sampler.wrapS, s, m_size.x()); 2111 v = unnormalize(sampler.wrapT, t, m_size.y()); 2112 } 2113 2114 switch (filter) 2115 { 2116 case Sampler::NEAREST: return execCompare(sampleNearest2D(*this, sampler, u, v, offset), sampler.compare, sampler.compareChannel, ref, isFixedPointDepth); 2117 case Sampler::LINEAR: return sampleLinear2DCompare(*this, sampler, ref, u, v, offset, isFixedPointDepth); 2118 default: 2119 DE_ASSERT(DE_FALSE); 2120 return 0.0f; 2121 } 2122 } 2123 2124 TextureLevel::TextureLevel (void) 2125 : m_format () 2126 , m_size (0) 2127 { 2128 } 2129 2130 TextureLevel::TextureLevel (const TextureFormat& format) 2131 : m_format (format) 2132 , m_size (0) 2133 { 2134 } 2135 2136 TextureLevel::TextureLevel (const TextureFormat& format, int width, int height, int depth) 2137 : m_format (format) 2138 , m_size (0) 2139 { 2140 setSize(width, height, depth); 2141 } 2142 2143 TextureLevel::~TextureLevel (void) 2144 { 2145 } 2146 2147 void TextureLevel::setStorage (const TextureFormat& format, int width, int height, int depth) 2148 { 2149 m_format = format; 2150 setSize(width, height, depth); 2151 } 2152 2153 void TextureLevel::setSize (int width, int height, int depth) 2154 { 2155 int pixelSize = m_format.getPixelSize(); 2156 2157 m_size = IVec3(width, height, depth); 2158 2159 m_data.setStorage(m_size.x() * m_size.y() * m_size.z() * pixelSize); 2160 } 2161 2162 Vec4 sampleLevelArray1D (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, int depth, float lod) 2163 { 2164 return sampleLevelArray1DOffset(levels, numLevels, sampler, s, lod, IVec2(0, depth)); // y-offset in 1D textures is layer selector 2165 } 2166 2167 Vec4 sampleLevelArray2D (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, int depth, float lod) 2168 { 2169 return sampleLevelArray2DOffset(levels, numLevels, sampler, s, t, lod, IVec3(0, 0, depth)); // z-offset in 2D textures is layer selector 2170 } 2171 2172 Vec4 sampleLevelArray3D (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, float r, float lod) 2173 { 2174 return sampleLevelArray3DOffset(levels, numLevels, sampler, s, t, r, lod, IVec3(0, 0, 0)); 2175 } 2176 2177 Vec4 sampleLevelArray1DOffset (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float lod, const IVec2& offset) 2178 { 2179 bool magnified = lod <= sampler.lodThreshold; 2180 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; 2181 2182 switch (filterMode) 2183 { 2184 case Sampler::NEAREST: return levels[0].sample1DOffset(sampler, filterMode, s, offset); 2185 case Sampler::LINEAR: return levels[0].sample1DOffset(sampler, filterMode, s, offset); 2186 2187 case Sampler::NEAREST_MIPMAP_NEAREST: 2188 case Sampler::LINEAR_MIPMAP_NEAREST: 2189 { 2190 int maxLevel = (int)numLevels-1; 2191 int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); 2192 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; 2193 2194 return levels[level].sample1DOffset(sampler, levelFilter, s, offset); 2195 } 2196 2197 case Sampler::NEAREST_MIPMAP_LINEAR: 2198 case Sampler::LINEAR_MIPMAP_LINEAR: 2199 { 2200 int maxLevel = (int)numLevels-1; 2201 int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); 2202 int level1 = de::min(maxLevel, level0 + 1); 2203 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; 2204 float f = deFloatFrac(lod); 2205 tcu::Vec4 t0 = levels[level0].sample1DOffset(sampler, levelFilter, s, offset); 2206 tcu::Vec4 t1 = levels[level1].sample1DOffset(sampler, levelFilter, s, offset); 2207 2208 return t0*(1.0f - f) + t1*f; 2209 } 2210 2211 default: 2212 DE_ASSERT(DE_FALSE); 2213 return Vec4(0.0f); 2214 } 2215 } 2216 2217 Vec4 sampleLevelArray2DOffset (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, float lod, const IVec3& offset) 2218 { 2219 bool magnified = lod <= sampler.lodThreshold; 2220 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; 2221 2222 switch (filterMode) 2223 { 2224 case Sampler::NEAREST: return levels[0].sample2DOffset(sampler, filterMode, s, t, offset); 2225 case Sampler::LINEAR: return levels[0].sample2DOffset(sampler, filterMode, s, t, offset); 2226 2227 case Sampler::NEAREST_MIPMAP_NEAREST: 2228 case Sampler::LINEAR_MIPMAP_NEAREST: 2229 { 2230 int maxLevel = (int)numLevels-1; 2231 int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); 2232 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; 2233 2234 return levels[level].sample2DOffset(sampler, levelFilter, s, t, offset); 2235 } 2236 2237 case Sampler::NEAREST_MIPMAP_LINEAR: 2238 case Sampler::LINEAR_MIPMAP_LINEAR: 2239 { 2240 int maxLevel = (int)numLevels-1; 2241 int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); 2242 int level1 = de::min(maxLevel, level0 + 1); 2243 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; 2244 float f = deFloatFrac(lod); 2245 tcu::Vec4 t0 = levels[level0].sample2DOffset(sampler, levelFilter, s, t, offset); 2246 tcu::Vec4 t1 = levels[level1].sample2DOffset(sampler, levelFilter, s, t, offset); 2247 2248 return t0*(1.0f - f) + t1*f; 2249 } 2250 2251 default: 2252 DE_ASSERT(DE_FALSE); 2253 return Vec4(0.0f); 2254 } 2255 } 2256 2257 Vec4 sampleLevelArray3DOffset (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, float r, float lod, const IVec3& offset) 2258 { 2259 bool magnified = lod <= sampler.lodThreshold; 2260 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; 2261 2262 switch (filterMode) 2263 { 2264 case Sampler::NEAREST: return levels[0].sample3DOffset(sampler, filterMode, s, t, r, offset); 2265 case Sampler::LINEAR: return levels[0].sample3DOffset(sampler, filterMode, s, t, r, offset); 2266 2267 case Sampler::NEAREST_MIPMAP_NEAREST: 2268 case Sampler::LINEAR_MIPMAP_NEAREST: 2269 { 2270 int maxLevel = (int)numLevels-1; 2271 int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); 2272 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; 2273 2274 return levels[level].sample3DOffset(sampler, levelFilter, s, t, r, offset); 2275 } 2276 2277 case Sampler::NEAREST_MIPMAP_LINEAR: 2278 case Sampler::LINEAR_MIPMAP_LINEAR: 2279 { 2280 int maxLevel = (int)numLevels-1; 2281 int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); 2282 int level1 = de::min(maxLevel, level0 + 1); 2283 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; 2284 float f = deFloatFrac(lod); 2285 tcu::Vec4 t0 = levels[level0].sample3DOffset(sampler, levelFilter, s, t, r, offset); 2286 tcu::Vec4 t1 = levels[level1].sample3DOffset(sampler, levelFilter, s, t, r, offset); 2287 2288 return t0*(1.0f - f) + t1*f; 2289 } 2290 2291 default: 2292 DE_ASSERT(DE_FALSE); 2293 return Vec4(0.0f); 2294 } 2295 } 2296 2297 float sampleLevelArray1DCompare (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float ref, float s, float lod, const IVec2& offset) 2298 { 2299 bool magnified = lod <= sampler.lodThreshold; 2300 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; 2301 2302 switch (filterMode) 2303 { 2304 case Sampler::NEAREST: return levels[0].sample1DCompare(sampler, filterMode, ref, s, offset); 2305 case Sampler::LINEAR: return levels[0].sample1DCompare(sampler, filterMode, ref, s, offset); 2306 2307 case Sampler::NEAREST_MIPMAP_NEAREST: 2308 case Sampler::LINEAR_MIPMAP_NEAREST: 2309 { 2310 int maxLevel = (int)numLevels-1; 2311 int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); 2312 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; 2313 2314 return levels[level].sample1DCompare(sampler, levelFilter, ref, s, offset); 2315 } 2316 2317 case Sampler::NEAREST_MIPMAP_LINEAR: 2318 case Sampler::LINEAR_MIPMAP_LINEAR: 2319 { 2320 int maxLevel = (int)numLevels-1; 2321 int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); 2322 int level1 = de::min(maxLevel, level0 + 1); 2323 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; 2324 float f = deFloatFrac(lod); 2325 float t0 = levels[level0].sample1DCompare(sampler, levelFilter, ref, s, offset); 2326 float t1 = levels[level1].sample1DCompare(sampler, levelFilter, ref, s, offset); 2327 2328 return t0*(1.0f - f) + t1*f; 2329 } 2330 2331 default: 2332 DE_ASSERT(DE_FALSE); 2333 return 0.0f; 2334 } 2335 } 2336 2337 float sampleLevelArray2DCompare (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float ref, float s, float t, float lod, const IVec3& offset) 2338 { 2339 bool magnified = lod <= sampler.lodThreshold; 2340 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; 2341 2342 switch (filterMode) 2343 { 2344 case Sampler::NEAREST: return levels[0].sample2DCompare(sampler, filterMode, ref, s, t, offset); 2345 case Sampler::LINEAR: return levels[0].sample2DCompare(sampler, filterMode, ref, s, t, offset); 2346 2347 case Sampler::NEAREST_MIPMAP_NEAREST: 2348 case Sampler::LINEAR_MIPMAP_NEAREST: 2349 { 2350 int maxLevel = (int)numLevels-1; 2351 int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); 2352 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; 2353 2354 return levels[level].sample2DCompare(sampler, levelFilter, ref, s, t, offset); 2355 } 2356 2357 case Sampler::NEAREST_MIPMAP_LINEAR: 2358 case Sampler::LINEAR_MIPMAP_LINEAR: 2359 { 2360 int maxLevel = (int)numLevels-1; 2361 int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); 2362 int level1 = de::min(maxLevel, level0 + 1); 2363 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; 2364 float f = deFloatFrac(lod); 2365 float t0 = levels[level0].sample2DCompare(sampler, levelFilter, ref, s, t, offset); 2366 float t1 = levels[level1].sample2DCompare(sampler, levelFilter, ref, s, t, offset); 2367 2368 return t0*(1.0f - f) + t1*f; 2369 } 2370 2371 default: 2372 DE_ASSERT(DE_FALSE); 2373 return 0.0f; 2374 } 2375 } 2376 2377 static Vec4 fetchGatherArray2DOffsets (const ConstPixelBufferAccess& src, const Sampler& sampler, float s, float t, int depth, int componentNdx, const IVec2 (&offsets)[4]) 2378 { 2379 DE_ASSERT(de::inBounds(componentNdx, 0, 4)); 2380 2381 const int w = src.getWidth(); 2382 const int h = src.getHeight(); 2383 const float u = unnormalize(sampler.wrapS, s, w); 2384 const float v = unnormalize(sampler.wrapT, t, h); 2385 const int x0 = deFloorFloatToInt32(u-0.5f); 2386 const int y0 = deFloorFloatToInt32(v-0.5f); 2387 2388 Vec4 result; 2389 2390 for (int i = 0; i < 4; i++) 2391 { 2392 const int sampleX = wrap(sampler.wrapS, x0 + offsets[i].x(), w); 2393 const int sampleY = wrap(sampler.wrapT, y0 + offsets[i].y(), h); 2394 Vec4 pixel; 2395 2396 if (deInBounds32(sampleX, 0, w) && deInBounds32(sampleY, 0, h)) 2397 pixel = lookup(src, sampleX, sampleY, depth); 2398 else 2399 pixel = lookupBorder(src.getFormat(), sampler); 2400 2401 result[i] = pixel[componentNdx]; 2402 } 2403 2404 return result; 2405 } 2406 2407 Vec4 gatherArray2DOffsets (const ConstPixelBufferAccess& src, const Sampler& sampler, float s, float t, int depth, int componentNdx, const IVec2 (&offsets)[4]) 2408 { 2409 DE_ASSERT(sampler.compare == Sampler::COMPAREMODE_NONE); 2410 DE_ASSERT(de::inBounds(componentNdx, 0, 4)); 2411 2412 return fetchGatherArray2DOffsets(src, sampler, s, t, depth, componentNdx, offsets); 2413 } 2414 2415 Vec4 gatherArray2DOffsetsCompare (const ConstPixelBufferAccess& src, const Sampler& sampler, float ref, float s, float t, int depth, const IVec2 (&offsets)[4]) 2416 { 2417 DE_ASSERT(sampler.compare != Sampler::COMPAREMODE_NONE); 2418 DE_ASSERT(src.getFormat().order == TextureFormat::D || src.getFormat().order == TextureFormat::DS); 2419 DE_ASSERT(sampler.compareChannel == 0); 2420 2421 const bool isFixedPoint = isFixedPointDepthTextureFormat(src.getFormat()); 2422 const Vec4 gathered = fetchGatherArray2DOffsets(src, sampler, s, t, depth, 0 /* component 0: depth */, offsets); 2423 Vec4 result; 2424 2425 for (int i = 0; i < 4; i++) 2426 result[i] = execCompare(gathered, sampler.compare, i, ref, isFixedPoint); 2427 2428 return result; 2429 } 2430 2431 static Vec4 sampleCubeSeamlessNearest (const ConstPixelBufferAccess& faceAccess, const Sampler& sampler, float s, float t, int depth) 2432 { 2433 Sampler clampingSampler = sampler; 2434 clampingSampler.wrapS = Sampler::CLAMP_TO_EDGE; 2435 clampingSampler.wrapT = Sampler::CLAMP_TO_EDGE; 2436 return faceAccess.sample2D(clampingSampler, Sampler::NEAREST, s, t, depth); 2437 } 2438 2439 CubeFace selectCubeFace (const Vec3& coords) 2440 { 2441 const float x = coords.x(); 2442 const float y = coords.y(); 2443 const float z = coords.z(); 2444 const float ax = deFloatAbs(x); 2445 const float ay = deFloatAbs(y); 2446 const float az = deFloatAbs(z); 2447 2448 if (ay < ax && az < ax) 2449 return x >= 0.0f ? CUBEFACE_POSITIVE_X : CUBEFACE_NEGATIVE_X; 2450 else if (ax < ay && az < ay) 2451 return y >= 0.0f ? CUBEFACE_POSITIVE_Y : CUBEFACE_NEGATIVE_Y; 2452 else if (ax < az && ay < az) 2453 return z >= 0.0f ? CUBEFACE_POSITIVE_Z : CUBEFACE_NEGATIVE_Z; 2454 else 2455 { 2456 // Some of the components are equal. Use tie-breaking rule. 2457 if (ax == ay) 2458 { 2459 if (ax < az) 2460 return z >= 0.0f ? CUBEFACE_POSITIVE_Z : CUBEFACE_NEGATIVE_Z; 2461 else 2462 return x >= 0.0f ? CUBEFACE_POSITIVE_X : CUBEFACE_NEGATIVE_X; 2463 } 2464 else if (ax == az) 2465 { 2466 if (az < ay) 2467 return y >= 0.0f ? CUBEFACE_POSITIVE_Y : CUBEFACE_NEGATIVE_Y; 2468 else 2469 return z >= 0.0f ? CUBEFACE_POSITIVE_Z : CUBEFACE_NEGATIVE_Z; 2470 } 2471 else if (ay == az) 2472 { 2473 if (ay < ax) 2474 return x >= 0.0f ? CUBEFACE_POSITIVE_X : CUBEFACE_NEGATIVE_X; 2475 else 2476 return y >= 0.0f ? CUBEFACE_POSITIVE_Y : CUBEFACE_NEGATIVE_Y; 2477 } 2478 else 2479 return x >= 0.0f ? CUBEFACE_POSITIVE_X : CUBEFACE_NEGATIVE_X; 2480 } 2481 } 2482 2483 Vec2 projectToFace (CubeFace face, const Vec3& coord) 2484 { 2485 const float rx = coord.x(); 2486 const float ry = coord.y(); 2487 const float rz = coord.z(); 2488 float sc = 0.0f; 2489 float tc = 0.0f; 2490 float ma = 0.0f; 2491 float s; 2492 float t; 2493 2494 switch (face) 2495 { 2496 case CUBEFACE_NEGATIVE_X: sc = +rz; tc = -ry; ma = -rx; break; 2497 case CUBEFACE_POSITIVE_X: sc = -rz; tc = -ry; ma = +rx; break; 2498 case CUBEFACE_NEGATIVE_Y: sc = +rx; tc = -rz; ma = -ry; break; 2499 case CUBEFACE_POSITIVE_Y: sc = +rx; tc = +rz; ma = +ry; break; 2500 case CUBEFACE_NEGATIVE_Z: sc = -rx; tc = -ry; ma = -rz; break; 2501 case CUBEFACE_POSITIVE_Z: sc = +rx; tc = -ry; ma = +rz; break; 2502 default: 2503 DE_ASSERT(DE_FALSE); 2504 } 2505 2506 // Compute s, t 2507 s = ((sc / ma) + 1.0f) / 2.0f; 2508 t = ((tc / ma) + 1.0f) / 2.0f; 2509 2510 return Vec2(s, t); 2511 } 2512 2513 CubeFaceFloatCoords getCubeFaceCoords (const Vec3& coords) 2514 { 2515 const CubeFace face = selectCubeFace(coords); 2516 return CubeFaceFloatCoords(face, projectToFace(face, coords)); 2517 } 2518 2519 // Checks if origCoords.coords is in bounds defined by size; if not, return a CubeFaceIntCoords with face set to the appropriate neighboring face and coords transformed accordingly. 2520 // \note If both x and y in origCoords.coords are out of bounds, this returns with face CUBEFACE_LAST, signifying that there is no unique neighboring face. 2521 CubeFaceIntCoords remapCubeEdgeCoords (const CubeFaceIntCoords& origCoords, int size) 2522 { 2523 bool uInBounds = de::inBounds(origCoords.s, 0, size); 2524 bool vInBounds = de::inBounds(origCoords.t, 0, size); 2525 2526 if (uInBounds && vInBounds) 2527 return origCoords; 2528 2529 if (!uInBounds && !vInBounds) 2530 return CubeFaceIntCoords(CUBEFACE_LAST, -1, -1); 2531 2532 IVec2 coords(wrap(Sampler::CLAMP_TO_BORDER, origCoords.s, size), 2533 wrap(Sampler::CLAMP_TO_BORDER, origCoords.t, size)); 2534 IVec3 canonizedCoords; 2535 2536 // Map the uv coordinates to canonized 3d coordinates. 2537 2538 switch (origCoords.face) 2539 { 2540 case CUBEFACE_NEGATIVE_X: canonizedCoords = IVec3(0, size-1-coords.y(), coords.x()); break; 2541 case CUBEFACE_POSITIVE_X: canonizedCoords = IVec3(size-1, size-1-coords.y(), size-1-coords.x()); break; 2542 case CUBEFACE_NEGATIVE_Y: canonizedCoords = IVec3(coords.x(), 0, size-1-coords.y()); break; 2543 case CUBEFACE_POSITIVE_Y: canonizedCoords = IVec3(coords.x(), size-1, coords.y()); break; 2544 case CUBEFACE_NEGATIVE_Z: canonizedCoords = IVec3(size-1-coords.x(), size-1-coords.y(), 0); break; 2545 case CUBEFACE_POSITIVE_Z: canonizedCoords = IVec3(coords.x(), size-1-coords.y(), size-1); break; 2546 default: DE_ASSERT(false); 2547 } 2548 2549 // Find an appropriate face to re-map the coordinates to. 2550 2551 if (canonizedCoords.x() == -1) 2552 return CubeFaceIntCoords(CUBEFACE_NEGATIVE_X, IVec2(canonizedCoords.z(), size-1-canonizedCoords.y())); 2553 2554 if (canonizedCoords.x() == size) 2555 return CubeFaceIntCoords(CUBEFACE_POSITIVE_X, IVec2(size-1-canonizedCoords.z(), size-1-canonizedCoords.y())); 2556 2557 if (canonizedCoords.y() == -1) 2558 return CubeFaceIntCoords(CUBEFACE_NEGATIVE_Y, IVec2(canonizedCoords.x(), size-1-canonizedCoords.z())); 2559 2560 if (canonizedCoords.y() == size) 2561 return CubeFaceIntCoords(CUBEFACE_POSITIVE_Y, IVec2(canonizedCoords.x(), canonizedCoords.z())); 2562 2563 if (canonizedCoords.z() == -1) 2564 return CubeFaceIntCoords(CUBEFACE_NEGATIVE_Z, IVec2(size-1-canonizedCoords.x(), size-1-canonizedCoords.y())); 2565 2566 if (canonizedCoords.z() == size) 2567 return CubeFaceIntCoords(CUBEFACE_POSITIVE_Z, IVec2(canonizedCoords.x(), size-1-canonizedCoords.y())); 2568 2569 DE_ASSERT(false); 2570 return CubeFaceIntCoords(CUBEFACE_LAST, IVec2(-1)); 2571 } 2572 2573 static void getCubeLinearSamples (const ConstPixelBufferAccess (&faceAccesses)[CUBEFACE_LAST], CubeFace baseFace, float u, float v, int depth, Vec4 (&dst)[4]) 2574 { 2575 DE_ASSERT(faceAccesses[0].getWidth() == faceAccesses[0].getHeight()); 2576 int size = faceAccesses[0].getWidth(); 2577 int x0 = deFloorFloatToInt32(u-0.5f); 2578 int x1 = x0+1; 2579 int y0 = deFloorFloatToInt32(v-0.5f); 2580 int y1 = y0+1; 2581 IVec2 baseSampleCoords[4] = 2582 { 2583 IVec2(x0, y0), 2584 IVec2(x1, y0), 2585 IVec2(x0, y1), 2586 IVec2(x1, y1) 2587 }; 2588 Vec4 sampleColors[4]; 2589 bool hasBothCoordsOutOfBounds[4]; //!< Whether correctCubeFace() returns CUBEFACE_LAST, i.e. both u and v are out of bounds. 2590 2591 // Find correct faces and coordinates for out-of-bounds sample coordinates. 2592 2593 for (int i = 0; i < 4; i++) 2594 { 2595 CubeFaceIntCoords coords = remapCubeEdgeCoords(CubeFaceIntCoords(baseFace, baseSampleCoords[i]), size); 2596 hasBothCoordsOutOfBounds[i] = coords.face == CUBEFACE_LAST; 2597 if (!hasBothCoordsOutOfBounds[i]) 2598 sampleColors[i] = lookup(faceAccesses[coords.face], coords.s, coords.t, depth); 2599 } 2600 2601 // If a sample was out of bounds in both u and v, we get its color from the average of the three other samples. 2602 // \note This averaging behavior is not required by the GLES3 spec (though it is recommended). GLES3 spec only 2603 // requires that if the three other samples all have the same color, then the doubly-out-of-bounds sample 2604 // must have this color as well. 2605 2606 { 2607 int bothOutOfBoundsNdx = -1; 2608 for (int i = 0; i < 4; i++) 2609 { 2610 if (hasBothCoordsOutOfBounds[i]) 2611 { 2612 DE_ASSERT(bothOutOfBoundsNdx < 0); // Only one sample can be out of bounds in both u and v. 2613 bothOutOfBoundsNdx = i; 2614 } 2615 } 2616 if (bothOutOfBoundsNdx != -1) 2617 { 2618 sampleColors[bothOutOfBoundsNdx] = Vec4(0.0f); 2619 for (int i = 0; i < 4; i++) 2620 if (i != bothOutOfBoundsNdx) 2621 sampleColors[bothOutOfBoundsNdx] += sampleColors[i]; 2622 2623 sampleColors[bothOutOfBoundsNdx] = sampleColors[bothOutOfBoundsNdx] * (1.0f/3.0f); 2624 } 2625 } 2626 2627 for (int i = 0; i < DE_LENGTH_OF_ARRAY(sampleColors); i++) 2628 dst[i] = sampleColors[i]; 2629 } 2630 2631 // \todo [2014-02-19 pyry] Optimize faceAccesses 2632 static Vec4 sampleCubeSeamlessLinear (const ConstPixelBufferAccess (&faceAccesses)[CUBEFACE_LAST], CubeFace baseFace, const Sampler& sampler, float s, float t, int depth) 2633 { 2634 DE_ASSERT(faceAccesses[0].getWidth() == faceAccesses[0].getHeight()); 2635 2636 int size = faceAccesses[0].getWidth(); 2637 // Non-normalized coordinates. 2638 float u = s; 2639 float v = t; 2640 2641 if (sampler.normalizedCoords) 2642 { 2643 u = unnormalize(sampler.wrapS, s, size); 2644 v = unnormalize(sampler.wrapT, t, size); 2645 } 2646 2647 // Get sample colors. 2648 2649 Vec4 sampleColors[4]; 2650 getCubeLinearSamples(faceAccesses, baseFace, u, v, depth, sampleColors); 2651 2652 // Interpolate. 2653 2654 float a = deFloatFrac(u-0.5f); 2655 float b = deFloatFrac(v-0.5f); 2656 2657 return (sampleColors[0]*(1.0f-a)*(1.0f-b)) + 2658 (sampleColors[1]*( a)*(1.0f-b)) + 2659 (sampleColors[2]*(1.0f-a)*( b)) + 2660 (sampleColors[3]*( a)*( b)); 2661 } 2662 2663 static Vec4 sampleLevelArrayCubeSeamless (const ConstPixelBufferAccess* const (&faces)[CUBEFACE_LAST], int numLevels, CubeFace face, const Sampler& sampler, float s, float t, int depth, float lod) 2664 { 2665 bool magnified = lod <= sampler.lodThreshold; 2666 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; 2667 2668 switch (filterMode) 2669 { 2670 case Sampler::NEAREST: 2671 return sampleCubeSeamlessNearest(faces[face][0], sampler, s, t, depth); 2672 2673 case Sampler::LINEAR: 2674 { 2675 ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; 2676 for (int i = 0; i < (int)CUBEFACE_LAST; i++) 2677 faceAccesses[i] = faces[i][0]; 2678 2679 return sampleCubeSeamlessLinear(faceAccesses, face, sampler, s, t, depth); 2680 } 2681 2682 case Sampler::NEAREST_MIPMAP_NEAREST: 2683 case Sampler::LINEAR_MIPMAP_NEAREST: 2684 { 2685 int maxLevel = (int)numLevels-1; 2686 int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); 2687 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; 2688 2689 if (levelFilter == Sampler::NEAREST) 2690 return sampleCubeSeamlessNearest(faces[face][level], sampler, s, t, depth); 2691 else 2692 { 2693 DE_ASSERT(levelFilter == Sampler::LINEAR); 2694 2695 ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; 2696 for (int i = 0; i < (int)CUBEFACE_LAST; i++) 2697 faceAccesses[i] = faces[i][level]; 2698 2699 return sampleCubeSeamlessLinear(faceAccesses, face, sampler, s, t, depth); 2700 } 2701 } 2702 2703 case Sampler::NEAREST_MIPMAP_LINEAR: 2704 case Sampler::LINEAR_MIPMAP_LINEAR: 2705 { 2706 int maxLevel = (int)numLevels-1; 2707 int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); 2708 int level1 = de::min(maxLevel, level0 + 1); 2709 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; 2710 float f = deFloatFrac(lod); 2711 Vec4 t0; 2712 Vec4 t1; 2713 2714 if (levelFilter == Sampler::NEAREST) 2715 { 2716 t0 = sampleCubeSeamlessNearest(faces[face][level0], sampler, s, t, depth); 2717 t1 = sampleCubeSeamlessNearest(faces[face][level1], sampler, s, t, depth); 2718 } 2719 else 2720 { 2721 DE_ASSERT(levelFilter == Sampler::LINEAR); 2722 2723 ConstPixelBufferAccess faceAccesses0[CUBEFACE_LAST]; 2724 ConstPixelBufferAccess faceAccesses1[CUBEFACE_LAST]; 2725 for (int i = 0; i < (int)CUBEFACE_LAST; i++) 2726 { 2727 faceAccesses0[i] = faces[i][level0]; 2728 faceAccesses1[i] = faces[i][level1]; 2729 } 2730 2731 t0 = sampleCubeSeamlessLinear(faceAccesses0, face, sampler, s, t, depth); 2732 t1 = sampleCubeSeamlessLinear(faceAccesses1, face, sampler, s, t, depth); 2733 } 2734 2735 return t0*(1.0f - f) + t1*f; 2736 } 2737 2738 default: 2739 DE_ASSERT(DE_FALSE); 2740 return Vec4(0.0f); 2741 } 2742 } 2743 2744 static float sampleCubeSeamlessNearestCompare (const ConstPixelBufferAccess& faceAccess, const Sampler& sampler, float ref, float s, float t, int depth = 0) 2745 { 2746 Sampler clampingSampler = sampler; 2747 clampingSampler.wrapS = Sampler::CLAMP_TO_EDGE; 2748 clampingSampler.wrapT = Sampler::CLAMP_TO_EDGE; 2749 return faceAccess.sample2DCompare(clampingSampler, Sampler::NEAREST, ref, s, t, IVec3(0, 0, depth)); 2750 } 2751 2752 static float sampleCubeSeamlessLinearCompare (const ConstPixelBufferAccess (&faceAccesses)[CUBEFACE_LAST], CubeFace baseFace, const Sampler& sampler, float ref, float s, float t) 2753 { 2754 DE_ASSERT(faceAccesses[0].getWidth() == faceAccesses[0].getHeight()); 2755 2756 int size = faceAccesses[0].getWidth(); 2757 // Non-normalized coordinates. 2758 float u = s; 2759 float v = t; 2760 2761 if (sampler.normalizedCoords) 2762 { 2763 u = unnormalize(sampler.wrapS, s, size); 2764 v = unnormalize(sampler.wrapT, t, size); 2765 } 2766 2767 int x0 = deFloorFloatToInt32(u-0.5f); 2768 int x1 = x0+1; 2769 int y0 = deFloorFloatToInt32(v-0.5f); 2770 int y1 = y0+1; 2771 IVec2 baseSampleCoords[4] = 2772 { 2773 IVec2(x0, y0), 2774 IVec2(x1, y0), 2775 IVec2(x0, y1), 2776 IVec2(x1, y1) 2777 }; 2778 float sampleRes[4]; 2779 bool hasBothCoordsOutOfBounds[4]; //!< Whether correctCubeFace() returns CUBEFACE_LAST, i.e. both u and v are out of bounds. 2780 2781 // Find correct faces and coordinates for out-of-bounds sample coordinates. 2782 2783 for (int i = 0; i < 4; i++) 2784 { 2785 CubeFaceIntCoords coords = remapCubeEdgeCoords(CubeFaceIntCoords(baseFace, baseSampleCoords[i]), size); 2786 hasBothCoordsOutOfBounds[i] = coords.face == CUBEFACE_LAST; 2787 2788 if (!hasBothCoordsOutOfBounds[i]) 2789 { 2790 const bool isFixedPointDepth = isFixedPointDepthTextureFormat(faceAccesses[coords.face].getFormat()); 2791 2792 sampleRes[i] = execCompare(faceAccesses[coords.face].getPixel(coords.s, coords.t), sampler.compare, sampler.compareChannel, ref, isFixedPointDepth); 2793 } 2794 } 2795 2796 // If a sample was out of bounds in both u and v, we get its color from the average of the three other samples. 2797 // \note This averaging behavior is not required by the GLES3 spec (though it is recommended). GLES3 spec only 2798 // requires that if the three other samples all have the same color, then the doubly-out-of-bounds sample 2799 // must have this color as well. 2800 2801 { 2802 int bothOutOfBoundsNdx = -1; 2803 for (int i = 0; i < 4; i++) 2804 { 2805 if (hasBothCoordsOutOfBounds[i]) 2806 { 2807 DE_ASSERT(bothOutOfBoundsNdx < 0); // Only one sample can be out of bounds in both u and v. 2808 bothOutOfBoundsNdx = i; 2809 } 2810 } 2811 if (bothOutOfBoundsNdx != -1) 2812 { 2813 sampleRes[bothOutOfBoundsNdx] = 0.0f; 2814 for (int i = 0; i < 4; i++) 2815 if (i != bothOutOfBoundsNdx) 2816 sampleRes[bothOutOfBoundsNdx] += sampleRes[i]; 2817 2818 sampleRes[bothOutOfBoundsNdx] = sampleRes[bothOutOfBoundsNdx] * (1.0f/3.0f); 2819 } 2820 } 2821 2822 // Interpolate. 2823 2824 float a = deFloatFrac(u-0.5f); 2825 float b = deFloatFrac(v-0.5f); 2826 2827 return (sampleRes[0]*(1.0f-a)*(1.0f-b)) + 2828 (sampleRes[1]*( a)*(1.0f-b)) + 2829 (sampleRes[2]*(1.0f-a)*( b)) + 2830 (sampleRes[3]*( a)*( b)); 2831 } 2832 2833 static float sampleLevelArrayCubeSeamlessCompare (const ConstPixelBufferAccess* const (&faces)[CUBEFACE_LAST], int numLevels, CubeFace face, const Sampler& sampler, float ref, float s, float t, float lod) 2834 { 2835 bool magnified = lod <= sampler.lodThreshold; 2836 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; 2837 2838 switch (filterMode) 2839 { 2840 case Sampler::NEAREST: 2841 return sampleCubeSeamlessNearestCompare(faces[face][0], sampler, ref, s, t); 2842 2843 case Sampler::LINEAR: 2844 { 2845 ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; 2846 for (int i = 0; i < (int)CUBEFACE_LAST; i++) 2847 faceAccesses[i] = faces[i][0]; 2848 2849 return sampleCubeSeamlessLinearCompare(faceAccesses, face, sampler, ref, s, t); 2850 } 2851 2852 case Sampler::NEAREST_MIPMAP_NEAREST: 2853 case Sampler::LINEAR_MIPMAP_NEAREST: 2854 { 2855 int maxLevel = (int)numLevels-1; 2856 int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); 2857 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; 2858 2859 if (levelFilter == Sampler::NEAREST) 2860 return sampleCubeSeamlessNearestCompare(faces[face][level], sampler, ref, s, t); 2861 else 2862 { 2863 DE_ASSERT(levelFilter == Sampler::LINEAR); 2864 2865 ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; 2866 for (int i = 0; i < (int)CUBEFACE_LAST; i++) 2867 faceAccesses[i] = faces[i][level]; 2868 2869 return sampleCubeSeamlessLinearCompare(faceAccesses, face, sampler, ref, s, t); 2870 } 2871 } 2872 2873 case Sampler::NEAREST_MIPMAP_LINEAR: 2874 case Sampler::LINEAR_MIPMAP_LINEAR: 2875 { 2876 int maxLevel = (int)numLevels-1; 2877 int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); 2878 int level1 = de::min(maxLevel, level0 + 1); 2879 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; 2880 float f = deFloatFrac(lod); 2881 float t0; 2882 float t1; 2883 2884 if (levelFilter == Sampler::NEAREST) 2885 { 2886 t0 = sampleCubeSeamlessNearestCompare(faces[face][level0], sampler, ref, s, t); 2887 t1 = sampleCubeSeamlessNearestCompare(faces[face][level1], sampler, ref, s, t); 2888 } 2889 else 2890 { 2891 DE_ASSERT(levelFilter == Sampler::LINEAR); 2892 2893 ConstPixelBufferAccess faceAccesses0[CUBEFACE_LAST]; 2894 ConstPixelBufferAccess faceAccesses1[CUBEFACE_LAST]; 2895 for (int i = 0; i < (int)CUBEFACE_LAST; i++) 2896 { 2897 faceAccesses0[i] = faces[i][level0]; 2898 faceAccesses1[i] = faces[i][level1]; 2899 } 2900 2901 t0 = sampleCubeSeamlessLinearCompare(faceAccesses0, face, sampler, ref, s, t); 2902 t1 = sampleCubeSeamlessLinearCompare(faceAccesses1, face, sampler, ref, s, t); 2903 } 2904 2905 return t0*(1.0f - f) + t1*f; 2906 } 2907 2908 default: 2909 DE_ASSERT(DE_FALSE); 2910 return 0.0f; 2911 } 2912 } 2913 2914 // Cube map array sampling 2915 2916 static inline ConstPixelBufferAccess getCubeArrayFaceAccess (const ConstPixelBufferAccess* const levels, int levelNdx, int slice, CubeFace face) 2917 { 2918 const ConstPixelBufferAccess& level = levels[levelNdx]; 2919 const int depth = (slice * 6) + getCubeArrayFaceIndex(face); 2920 2921 return getSubregion(level, 0, 0, depth, level.getWidth(), level.getHeight(), 1); 2922 } 2923 2924 static Vec4 sampleCubeArraySeamless (const ConstPixelBufferAccess* const levels, int numLevels, int slice, CubeFace face, const Sampler& sampler, float s, float t, float lod) 2925 { 2926 const int faceDepth = (slice * 6) + getCubeArrayFaceIndex(face); 2927 const bool magnified = lod <= sampler.lodThreshold; 2928 const Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; 2929 2930 switch (filterMode) 2931 { 2932 case Sampler::NEAREST: 2933 return sampleCubeSeamlessNearest(levels[0], sampler, s, t, faceDepth); 2934 2935 case Sampler::LINEAR: 2936 { 2937 ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; 2938 for (int i = 0; i < (int)CUBEFACE_LAST; i++) 2939 faceAccesses[i] = getCubeArrayFaceAccess(levels, 0, slice, (CubeFace)i); 2940 2941 return sampleCubeSeamlessLinear(faceAccesses, face, sampler, s, t, 0); 2942 } 2943 2944 case Sampler::NEAREST_MIPMAP_NEAREST: 2945 case Sampler::LINEAR_MIPMAP_NEAREST: 2946 { 2947 int maxLevel = (int)numLevels-1; 2948 int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); 2949 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; 2950 2951 if (levelFilter == Sampler::NEAREST) 2952 return sampleCubeSeamlessNearest(levels[level], sampler, s, t, faceDepth); 2953 else 2954 { 2955 DE_ASSERT(levelFilter == Sampler::LINEAR); 2956 2957 ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; 2958 for (int i = 0; i < (int)CUBEFACE_LAST; i++) 2959 faceAccesses[i] = getCubeArrayFaceAccess(levels, level, slice, (CubeFace)i); 2960 2961 return sampleCubeSeamlessLinear(faceAccesses, face, sampler, s, t, 0); 2962 } 2963 } 2964 2965 case Sampler::NEAREST_MIPMAP_LINEAR: 2966 case Sampler::LINEAR_MIPMAP_LINEAR: 2967 { 2968 int maxLevel = (int)numLevels-1; 2969 int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); 2970 int level1 = de::min(maxLevel, level0 + 1); 2971 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; 2972 float f = deFloatFrac(lod); 2973 Vec4 t0; 2974 Vec4 t1; 2975 2976 if (levelFilter == Sampler::NEAREST) 2977 { 2978 t0 = sampleCubeSeamlessNearest(levels[level0], sampler, s, t, faceDepth); 2979 t1 = sampleCubeSeamlessNearest(levels[level1], sampler, s, t, faceDepth); 2980 } 2981 else 2982 { 2983 DE_ASSERT(levelFilter == Sampler::LINEAR); 2984 2985 ConstPixelBufferAccess faceAccesses0[CUBEFACE_LAST]; 2986 ConstPixelBufferAccess faceAccesses1[CUBEFACE_LAST]; 2987 for (int i = 0; i < (int)CUBEFACE_LAST; i++) 2988 { 2989 faceAccesses0[i] = getCubeArrayFaceAccess(levels, level0, slice, (CubeFace)i); 2990 faceAccesses1[i] = getCubeArrayFaceAccess(levels, level1, slice, (CubeFace)i); 2991 } 2992 2993 t0 = sampleCubeSeamlessLinear(faceAccesses0, face, sampler, s, t, 0); 2994 t1 = sampleCubeSeamlessLinear(faceAccesses1, face, sampler, s, t, 0); 2995 } 2996 2997 return t0*(1.0f - f) + t1*f; 2998 } 2999 3000 default: 3001 DE_ASSERT(DE_FALSE); 3002 return Vec4(0.0f); 3003 } 3004 } 3005 3006 static float sampleCubeArraySeamlessCompare (const ConstPixelBufferAccess* const levels, int numLevels, int slice, CubeFace face, const Sampler& sampler, float ref, float s, float t, float lod) 3007 { 3008 const int faceDepth = (slice * 6) + getCubeArrayFaceIndex(face); 3009 const bool magnified = lod <= sampler.lodThreshold; 3010 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; 3011 3012 switch (filterMode) 3013 { 3014 case Sampler::NEAREST: 3015 return sampleCubeSeamlessNearestCompare(levels[0], sampler, ref, s, t, faceDepth); 3016 3017 case Sampler::LINEAR: 3018 { 3019 ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; 3020 for (int i = 0; i < (int)CUBEFACE_LAST; i++) 3021 faceAccesses[i] = getCubeArrayFaceAccess(levels, 0, slice, (CubeFace)i); 3022 3023 return sampleCubeSeamlessLinearCompare(faceAccesses, face, sampler, ref, s, t); 3024 } 3025 3026 case Sampler::NEAREST_MIPMAP_NEAREST: 3027 case Sampler::LINEAR_MIPMAP_NEAREST: 3028 { 3029 int maxLevel = (int)numLevels-1; 3030 int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); 3031 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; 3032 3033 if (levelFilter == Sampler::NEAREST) 3034 return sampleCubeSeamlessNearestCompare(levels[level], sampler, ref, s, t, faceDepth); 3035 else 3036 { 3037 DE_ASSERT(levelFilter == Sampler::LINEAR); 3038 3039 ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; 3040 for (int i = 0; i < (int)CUBEFACE_LAST; i++) 3041 faceAccesses[i] = getCubeArrayFaceAccess(levels, level, slice, (CubeFace)i); 3042 3043 return sampleCubeSeamlessLinearCompare(faceAccesses, face, sampler, ref, s, t); 3044 } 3045 } 3046 3047 case Sampler::NEAREST_MIPMAP_LINEAR: 3048 case Sampler::LINEAR_MIPMAP_LINEAR: 3049 { 3050 int maxLevel = (int)numLevels-1; 3051 int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); 3052 int level1 = de::min(maxLevel, level0 + 1); 3053 Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; 3054 float f = deFloatFrac(lod); 3055 float t0; 3056 float t1; 3057 3058 if (levelFilter == Sampler::NEAREST) 3059 { 3060 t0 = sampleCubeSeamlessNearestCompare(levels[level0], sampler, ref, s, t, faceDepth); 3061 t1 = sampleCubeSeamlessNearestCompare(levels[level1], sampler, ref, s, t, faceDepth); 3062 } 3063 else 3064 { 3065 DE_ASSERT(levelFilter == Sampler::LINEAR); 3066 3067 ConstPixelBufferAccess faceAccesses0[CUBEFACE_LAST]; 3068 ConstPixelBufferAccess faceAccesses1[CUBEFACE_LAST]; 3069 for (int i = 0; i < (int)CUBEFACE_LAST; i++) 3070 { 3071 faceAccesses0[i] = getCubeArrayFaceAccess(levels, level0, slice, (CubeFace)i); 3072 faceAccesses1[i] = getCubeArrayFaceAccess(levels, level1, slice, (CubeFace)i); 3073 } 3074 3075 t0 = sampleCubeSeamlessLinearCompare(faceAccesses0, face, sampler, ref, s, t); 3076 t1 = sampleCubeSeamlessLinearCompare(faceAccesses1, face, sampler, ref, s, t); 3077 } 3078 3079 return t0*(1.0f - f) + t1*f; 3080 } 3081 3082 default: 3083 DE_ASSERT(DE_FALSE); 3084 return 0.0f; 3085 } 3086 } 3087 3088 inline int computeMipPyramidLevels (int size) 3089 { 3090 return deLog2Floor32(size)+1; 3091 } 3092 3093 inline int computeMipPyramidLevels (int width, int height) 3094 { 3095 return deLog2Floor32(de::max(width, height))+1; 3096 } 3097 3098 inline int computeMipPyramidLevels (int width, int height, int depth) 3099 { 3100 return deLog2Floor32(de::max(width, de::max(height, depth)))+1; 3101 } 3102 3103 inline int getMipPyramidLevelSize (int baseLevelSize, int levelNdx) 3104 { 3105 return de::max(baseLevelSize >> levelNdx, 1); 3106 } 3107 3108 // TextureLevelPyramid 3109 3110 TextureLevelPyramid::TextureLevelPyramid (const TextureFormat& format, int numLevels) 3111 : m_format (format) 3112 , m_data (numLevels) 3113 , m_access (numLevels) 3114 { 3115 } 3116 3117 TextureLevelPyramid::TextureLevelPyramid (const TextureLevelPyramid& other) 3118 : m_format (other.m_format) 3119 , m_data (other.getNumLevels()) 3120 , m_access (other.getNumLevels()) 3121 { 3122 for (int levelNdx = 0; levelNdx < other.getNumLevels(); levelNdx++) 3123 { 3124 if (!other.isLevelEmpty(levelNdx)) 3125 { 3126 const tcu::ConstPixelBufferAccess& srcLevel = other.getLevel(levelNdx); 3127 3128 m_data[levelNdx] = other.m_data[levelNdx]; 3129 m_access[levelNdx] = PixelBufferAccess(srcLevel.getFormat(), srcLevel.getWidth(), srcLevel.getHeight(), srcLevel.getDepth(), m_data[levelNdx].getPtr()); 3130 } 3131 } 3132 } 3133 3134 TextureLevelPyramid& TextureLevelPyramid::operator= (const TextureLevelPyramid& other) 3135 { 3136 if (this == &other) 3137 return *this; 3138 3139 m_format = other.m_format; 3140 m_data.resize(other.getNumLevels()); 3141 m_access.resize(other.getNumLevels()); 3142 3143 for (int levelNdx = 0; levelNdx < other.getNumLevels(); levelNdx++) 3144 { 3145 if (!other.isLevelEmpty(levelNdx)) 3146 { 3147 const tcu::ConstPixelBufferAccess& srcLevel = other.getLevel(levelNdx); 3148 3149 m_data[levelNdx] = other.m_data[levelNdx]; 3150 m_access[levelNdx] = PixelBufferAccess(srcLevel.getFormat(), srcLevel.getWidth(), srcLevel.getHeight(), srcLevel.getDepth(), m_data[levelNdx].getPtr()); 3151 } 3152 else if (!isLevelEmpty(levelNdx)) 3153 clearLevel(levelNdx); 3154 } 3155 3156 return *this; 3157 } 3158 3159 TextureLevelPyramid::~TextureLevelPyramid (void) 3160 { 3161 } 3162 3163 void TextureLevelPyramid::allocLevel (int levelNdx, int width, int height, int depth) 3164 { 3165 const int size = m_format.getPixelSize()*width*height*depth; 3166 3167 DE_ASSERT(isLevelEmpty(levelNdx)); 3168 3169 m_data[levelNdx].setStorage(size); 3170 m_access[levelNdx] = PixelBufferAccess(m_format, width, height, depth, m_data[levelNdx].getPtr()); 3171 } 3172 3173 void TextureLevelPyramid::clearLevel (int levelNdx) 3174 { 3175 DE_ASSERT(!isLevelEmpty(levelNdx)); 3176 3177 m_data[levelNdx].clear(); 3178 m_access[levelNdx] = PixelBufferAccess(); 3179 } 3180 3181 // Texture1D 3182 3183 Texture1D::Texture1D (const TextureFormat& format, int width) 3184 : TextureLevelPyramid (format, computeMipPyramidLevels(width)) 3185 , m_width (width) 3186 , m_view (getNumLevels(), getLevels()) 3187 { 3188 } 3189 3190 Texture1D::Texture1D (const Texture1D& other) 3191 : TextureLevelPyramid (other) 3192 , m_width (other.m_width) 3193 , m_view (getNumLevels(), getLevels()) 3194 { 3195 } 3196 3197 Texture1D& Texture1D::operator= (const Texture1D& other) 3198 { 3199 if (this == &other) 3200 return *this; 3201 3202 TextureLevelPyramid::operator=(other); 3203 3204 m_width = other.m_width; 3205 m_view = Texture1DView(getNumLevels(), getLevels()); 3206 3207 return *this; 3208 } 3209 3210 Texture1D::~Texture1D (void) 3211 { 3212 } 3213 3214 void Texture1D::allocLevel (int levelNdx) 3215 { 3216 DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); 3217 3218 const int width = getMipPyramidLevelSize(m_width, levelNdx); 3219 3220 TextureLevelPyramid::allocLevel(levelNdx, width, 1, 1); 3221 } 3222 3223 // Texture2D 3224 3225 Texture2D::Texture2D (const TextureFormat& format, int width, int height) 3226 : TextureLevelPyramid (format, computeMipPyramidLevels(width, height)) 3227 , m_width (width) 3228 , m_height (height) 3229 , m_view (getNumLevels(), getLevels()) 3230 { 3231 } 3232 3233 Texture2D::Texture2D (const Texture2D& other) 3234 : TextureLevelPyramid (other) 3235 , m_width (other.m_width) 3236 , m_height (other.m_height) 3237 , m_view (getNumLevels(), getLevels()) 3238 { 3239 } 3240 3241 Texture2D& Texture2D::operator= (const Texture2D& other) 3242 { 3243 if (this == &other) 3244 return *this; 3245 3246 TextureLevelPyramid::operator=(other); 3247 3248 m_width = other.m_width; 3249 m_height = other.m_height; 3250 m_view = Texture2DView(getNumLevels(), getLevels()); 3251 3252 return *this; 3253 } 3254 3255 Texture2D::~Texture2D (void) 3256 { 3257 } 3258 3259 void Texture2D::allocLevel (int levelNdx) 3260 { 3261 DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); 3262 3263 const int width = getMipPyramidLevelSize(m_width, levelNdx); 3264 const int height = getMipPyramidLevelSize(m_height, levelNdx); 3265 3266 TextureLevelPyramid::allocLevel(levelNdx, width, height, 1); 3267 } 3268 3269 // TextureCubeView 3270 3271 TextureCubeView::TextureCubeView (void) 3272 : m_numLevels(0) 3273 { 3274 for (int ndx = 0; ndx < CUBEFACE_LAST; ndx++) 3275 m_levels[ndx] = DE_NULL; 3276 } 3277 3278 TextureCubeView::TextureCubeView (int numLevels, const ConstPixelBufferAccess* const (&levels) [CUBEFACE_LAST]) 3279 : m_numLevels(numLevels) 3280 { 3281 for (int ndx = 0; ndx < CUBEFACE_LAST; ndx++) 3282 m_levels[ndx] = levels[ndx]; 3283 } 3284 3285 tcu::Vec4 TextureCubeView::sample (const Sampler& sampler, float s, float t, float r, float lod) const 3286 { 3287 DE_ASSERT(sampler.compare == Sampler::COMPAREMODE_NONE); 3288 3289 // Computes (face, s, t). 3290 const CubeFaceFloatCoords coords = getCubeFaceCoords(Vec3(s, t, r)); 3291 if (sampler.seamlessCubeMap) 3292 return sampleLevelArrayCubeSeamless(m_levels, m_numLevels, coords.face, sampler, coords.s, coords.t, 0 /* depth */, lod); 3293 else 3294 return sampleLevelArray2D(m_levels[coords.face], m_numLevels, sampler, coords.s, coords.t, 0 /* depth */, lod); 3295 } 3296 3297 float TextureCubeView::sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float lod) const 3298 { 3299 DE_ASSERT(sampler.compare != Sampler::COMPAREMODE_NONE); 3300 3301 // Computes (face, s, t). 3302 const CubeFaceFloatCoords coords = getCubeFaceCoords(Vec3(s, t, r)); 3303 if (sampler.seamlessCubeMap) 3304 return sampleLevelArrayCubeSeamlessCompare(m_levels, m_numLevels, coords.face, sampler, ref, coords.s, coords.t, lod); 3305 else 3306 return sampleLevelArray2DCompare(m_levels[coords.face], m_numLevels, sampler, ref, coords.s, coords.t, lod, IVec3(0, 0, 0)); 3307 } 3308 3309 Vec4 TextureCubeView::gather (const Sampler& sampler, float s, float t, float r, int componentNdx) const 3310 { 3311 DE_ASSERT(sampler.compare == Sampler::COMPAREMODE_NONE); 3312 3313 ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; 3314 for (int i = 0; i < (int)CUBEFACE_LAST; i++) 3315 faceAccesses[i] = m_levels[i][0]; 3316 3317 const CubeFaceFloatCoords coords = getCubeFaceCoords(Vec3(s, t, r)); 3318 const int size = faceAccesses[0].getWidth(); 3319 // Non-normalized coordinates. 3320 float u = coords.s; 3321 float v = coords.t; 3322 3323 if (sampler.normalizedCoords) 3324 { 3325 u = unnormalize(sampler.wrapS, coords.s, size); 3326 v = unnormalize(sampler.wrapT, coords.t, size); 3327 } 3328 3329 Vec4 sampleColors[4]; 3330 getCubeLinearSamples(faceAccesses, coords.face, u, v, 0, sampleColors); 3331 3332 const int sampleIndices[4] = { 2, 3, 1, 0 }; // \note Gather returns the samples in a non-obvious order. 3333 Vec4 result; 3334 for (int i = 0; i < 4; i++) 3335 result[i] = sampleColors[sampleIndices[i]][componentNdx]; 3336 3337 return result; 3338 } 3339 3340 Vec4 TextureCubeView::gatherCompare (const Sampler& sampler, float ref, float s, float t, float r) const 3341 { 3342 DE_ASSERT(sampler.compare != Sampler::COMPAREMODE_NONE); 3343 DE_ASSERT(m_levels[0][0].getFormat().order == TextureFormat::D || m_levels[0][0].getFormat().order == TextureFormat::DS); 3344 DE_ASSERT(sampler.compareChannel == 0); 3345 3346 Sampler noCompareSampler = sampler; 3347 noCompareSampler.compare = Sampler::COMPAREMODE_NONE; 3348 3349 const Vec4 gathered = gather(noCompareSampler, s, t, r, 0 /* component 0: depth */); 3350 const bool isFixedPoint = isFixedPointDepthTextureFormat(m_levels[0][0].getFormat()); 3351 Vec4 result; 3352 for (int i = 0; i < 4; i++) 3353 result[i] = execCompare(gathered, sampler.compare, i, ref, isFixedPoint); 3354 3355 return result; 3356 } 3357 3358 // TextureCube 3359 3360 TextureCube::TextureCube (const TextureFormat& format, int size) 3361 : m_format (format) 3362 , m_size (size) 3363 { 3364 const int numLevels = computeMipPyramidLevels(m_size); 3365 const ConstPixelBufferAccess* levels[CUBEFACE_LAST]; 3366 3367 for (int face = 0; face < CUBEFACE_LAST; face++) 3368 { 3369 m_data[face].resize(numLevels); 3370 m_access[face].resize(numLevels); 3371 levels[face] = &m_access[face][0]; 3372 } 3373 3374 m_view = TextureCubeView(numLevels, levels); 3375 } 3376 3377 TextureCube::TextureCube (const TextureCube& other) 3378 : m_format (other.m_format) 3379 , m_size (other.m_size) 3380 { 3381 const int numLevels = computeMipPyramidLevels(m_size); 3382 const ConstPixelBufferAccess* levels[CUBEFACE_LAST]; 3383 3384 for (int face = 0; face < CUBEFACE_LAST; face++) 3385 { 3386 m_data[face].resize(numLevels); 3387 m_access[face].resize(numLevels); 3388 levels[face] = &m_access[face][0]; 3389 } 3390 3391 m_view = TextureCubeView(numLevels, levels); 3392 3393 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 3394 { 3395 for (int face = 0; face < CUBEFACE_LAST; face++) 3396 { 3397 if (!other.isLevelEmpty((CubeFace)face, levelNdx)) 3398 { 3399 allocLevel((CubeFace)face, levelNdx); 3400 copy(getLevelFace(levelNdx, (CubeFace)face), 3401 other.getLevelFace(levelNdx, (CubeFace)face)); 3402 } 3403 } 3404 } 3405 } 3406 3407 TextureCube& TextureCube::operator= (const TextureCube& other) 3408 { 3409 if (this == &other) 3410 return *this; 3411 3412 const int numLevels = computeMipPyramidLevels(other.m_size); 3413 const ConstPixelBufferAccess* levels[CUBEFACE_LAST]; 3414 3415 for (int face = 0; face < CUBEFACE_LAST; face++) 3416 { 3417 m_data[face].resize(numLevels); 3418 m_access[face].resize(numLevels); 3419 levels[face] = &m_access[face][0]; 3420 } 3421 3422 m_format = other.m_format; 3423 m_size = other.m_size; 3424 m_view = TextureCubeView(numLevels, levels); 3425 3426 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 3427 { 3428 for (int face = 0; face < CUBEFACE_LAST; face++) 3429 { 3430 if (!isLevelEmpty((CubeFace)face, levelNdx)) 3431 clearLevel((CubeFace)face, levelNdx); 3432 3433 if (!other.isLevelEmpty((CubeFace)face, levelNdx)) 3434 { 3435 allocLevel((CubeFace)face, levelNdx); 3436 copy(getLevelFace(levelNdx, (CubeFace)face), 3437 other.getLevelFace(levelNdx, (CubeFace)face)); 3438 } 3439 } 3440 } 3441 3442 return *this; 3443 } 3444 3445 TextureCube::~TextureCube (void) 3446 { 3447 } 3448 3449 void TextureCube::allocLevel (tcu::CubeFace face, int levelNdx) 3450 { 3451 const int size = getMipPyramidLevelSize(m_size, levelNdx); 3452 const int dataSize = m_format.getPixelSize()*size*size; 3453 DE_ASSERT(isLevelEmpty(face, levelNdx)); 3454 3455 m_data[face][levelNdx].setStorage(dataSize); 3456 m_access[face][levelNdx] = PixelBufferAccess(m_format, size, size, 1, m_data[face][levelNdx].getPtr()); 3457 } 3458 3459 void TextureCube::clearLevel (tcu::CubeFace face, int levelNdx) 3460 { 3461 DE_ASSERT(!isLevelEmpty(face, levelNdx)); 3462 m_data[face][levelNdx].clear(); 3463 m_access[face][levelNdx] = PixelBufferAccess(); 3464 } 3465 3466 // Texture1DArrayView 3467 3468 Texture1DArrayView::Texture1DArrayView (int numLevels, const ConstPixelBufferAccess* levels) 3469 : m_numLevels (numLevels) 3470 , m_levels (levels) 3471 { 3472 } 3473 3474 inline int Texture1DArrayView::selectLayer (float r) const 3475 { 3476 DE_ASSERT(m_numLevels > 0 && m_levels); 3477 return de::clamp(deFloorFloatToInt32(r + 0.5f), 0, m_levels[0].getHeight()-1); 3478 } 3479 3480 Vec4 Texture1DArrayView::sample (const Sampler& sampler, float s, float t, float lod) const 3481 { 3482 return sampleLevelArray1D(m_levels, m_numLevels, sampler, s, selectLayer(t), lod); 3483 } 3484 3485 Vec4 Texture1DArrayView::sampleOffset (const Sampler& sampler, float s, float t, float lod, deInt32 offset) const 3486 { 3487 return sampleLevelArray1DOffset(m_levels, m_numLevels, sampler, s, lod, IVec2(offset, selectLayer(t))); 3488 } 3489 3490 float Texture1DArrayView::sampleCompare (const Sampler& sampler, float ref, float s, float t, float lod) const 3491 { 3492 return sampleLevelArray1DCompare(m_levels, m_numLevels, sampler, ref, s, lod, IVec2(0, selectLayer(t))); 3493 } 3494 3495 float Texture1DArrayView::sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float lod, deInt32 offset) const 3496 { 3497 return sampleLevelArray1DCompare(m_levels, m_numLevels, sampler, ref, s, lod, IVec2(offset, selectLayer(t))); 3498 } 3499 3500 // Texture2DArrayView 3501 3502 Texture2DArrayView::Texture2DArrayView (int numLevels, const ConstPixelBufferAccess* levels) 3503 : m_numLevels (numLevels) 3504 , m_levels (levels) 3505 { 3506 } 3507 3508 inline int Texture2DArrayView::selectLayer (float r) const 3509 { 3510 DE_ASSERT(m_numLevels > 0 && m_levels); 3511 return de::clamp(deFloorFloatToInt32(r + 0.5f), 0, m_levels[0].getDepth()-1); 3512 } 3513 3514 Vec4 Texture2DArrayView::sample (const Sampler& sampler, float s, float t, float r, float lod) const 3515 { 3516 return sampleLevelArray2D(m_levels, m_numLevels, sampler, s, t, selectLayer(r), lod); 3517 } 3518 3519 float Texture2DArrayView::sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float lod) const 3520 { 3521 return sampleLevelArray2DCompare(m_levels, m_numLevels, sampler, ref, s, t, lod, IVec3(0, 0, selectLayer(r))); 3522 } 3523 3524 Vec4 Texture2DArrayView::sampleOffset (const Sampler& sampler, float s, float t, float r, float lod, const IVec2& offset) const 3525 { 3526 return sampleLevelArray2DOffset(m_levels, m_numLevels, sampler, s, t, lod, IVec3(offset.x(), offset.y(), selectLayer(r))); 3527 } 3528 3529 float Texture2DArrayView::sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float r, float lod, const IVec2& offset) const 3530 { 3531 return sampleLevelArray2DCompare(m_levels, m_numLevels, sampler, ref, s, t, lod, IVec3(offset.x(), offset.y(), selectLayer(r))); 3532 } 3533 3534 Vec4 Texture2DArrayView::gatherOffsets (const Sampler& sampler, float s, float t, float r, int componentNdx, const IVec2 (&offsets)[4]) const 3535 { 3536 return gatherArray2DOffsets(m_levels[0], sampler, s, t, selectLayer(r), componentNdx, offsets); 3537 } 3538 3539 Vec4 Texture2DArrayView::gatherOffsetsCompare (const Sampler& sampler, float ref, float s, float t, float r, const IVec2 (&offsets)[4]) const 3540 { 3541 return gatherArray2DOffsetsCompare(m_levels[0], sampler, ref, s, t, selectLayer(r), offsets); 3542 } 3543 3544 // Texture1DArray 3545 3546 Texture1DArray::Texture1DArray (const TextureFormat& format, int width, int numLayers) 3547 : TextureLevelPyramid (format, computeMipPyramidLevels(width)) 3548 , m_width (width) 3549 , m_numLayers (numLayers) 3550 , m_view (getNumLevels(), getLevels()) 3551 { 3552 } 3553 3554 Texture1DArray::Texture1DArray (const Texture1DArray& other) 3555 : TextureLevelPyramid (other) 3556 , m_width (other.m_width) 3557 , m_numLayers (other.m_numLayers) 3558 , m_view (getNumLevels(), getLevels()) 3559 { 3560 } 3561 3562 Texture1DArray& Texture1DArray::operator= (const Texture1DArray& other) 3563 { 3564 if (this == &other) 3565 return *this; 3566 3567 TextureLevelPyramid::operator=(other); 3568 3569 m_width = other.m_width; 3570 m_numLayers = other.m_numLayers; 3571 m_view = Texture1DArrayView(getNumLevels(), getLevels()); 3572 3573 return *this; 3574 } 3575 3576 Texture1DArray::~Texture1DArray (void) 3577 { 3578 } 3579 3580 void Texture1DArray::allocLevel (int levelNdx) 3581 { 3582 DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); 3583 3584 const int width = getMipPyramidLevelSize(m_width, levelNdx); 3585 3586 TextureLevelPyramid::allocLevel(levelNdx, width, m_numLayers, 1); 3587 } 3588 3589 // Texture2DArray 3590 3591 Texture2DArray::Texture2DArray (const TextureFormat& format, int width, int height, int numLayers) 3592 : TextureLevelPyramid (format, computeMipPyramidLevels(width, height)) 3593 , m_width (width) 3594 , m_height (height) 3595 , m_numLayers (numLayers) 3596 , m_view (getNumLevels(), getLevels()) 3597 { 3598 } 3599 3600 Texture2DArray::Texture2DArray (const Texture2DArray& other) 3601 : TextureLevelPyramid (other) 3602 , m_width (other.m_width) 3603 , m_height (other.m_height) 3604 , m_numLayers (other.m_numLayers) 3605 , m_view (getNumLevels(), getLevels()) 3606 { 3607 } 3608 3609 Texture2DArray& Texture2DArray::operator= (const Texture2DArray& other) 3610 { 3611 if (this == &other) 3612 return *this; 3613 3614 TextureLevelPyramid::operator=(other); 3615 3616 m_width = other.m_width; 3617 m_height = other.m_height; 3618 m_numLayers = other.m_numLayers; 3619 m_view = Texture2DArrayView(getNumLevels(), getLevels()); 3620 3621 return *this; 3622 } 3623 3624 Texture2DArray::~Texture2DArray (void) 3625 { 3626 } 3627 3628 void Texture2DArray::allocLevel (int levelNdx) 3629 { 3630 DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); 3631 3632 const int width = getMipPyramidLevelSize(m_width, levelNdx); 3633 const int height = getMipPyramidLevelSize(m_height, levelNdx); 3634 3635 TextureLevelPyramid::allocLevel(levelNdx, width, height, m_numLayers); 3636 } 3637 3638 // Texture3DView 3639 3640 Texture3DView::Texture3DView (int numLevels, const ConstPixelBufferAccess* levels) 3641 : m_numLevels (numLevels) 3642 , m_levels (levels) 3643 { 3644 } 3645 3646 // Texture3D 3647 3648 Texture3D::Texture3D (const TextureFormat& format, int width, int height, int depth) 3649 : TextureLevelPyramid (format, computeMipPyramidLevels(width, height, depth)) 3650 , m_width (width) 3651 , m_height (height) 3652 , m_depth (depth) 3653 , m_view (getNumLevels(), getLevels()) 3654 { 3655 } 3656 3657 Texture3D::Texture3D (const Texture3D& other) 3658 : TextureLevelPyramid (other) 3659 , m_width (other.m_width) 3660 , m_height (other.m_height) 3661 , m_depth (other.m_depth) 3662 , m_view (getNumLevels(), getLevels()) 3663 { 3664 } 3665 3666 Texture3D& Texture3D::operator= (const Texture3D& other) 3667 { 3668 if (this == &other) 3669 return *this; 3670 3671 TextureLevelPyramid::operator=(other); 3672 3673 m_width = other.m_width; 3674 m_height = other.m_height; 3675 m_depth = other.m_depth; 3676 m_view = Texture3DView(getNumLevels(), getLevels()); 3677 3678 return *this; 3679 } 3680 3681 Texture3D::~Texture3D (void) 3682 { 3683 } 3684 3685 void Texture3D::allocLevel (int levelNdx) 3686 { 3687 DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); 3688 3689 const int width = getMipPyramidLevelSize(m_width, levelNdx); 3690 const int height = getMipPyramidLevelSize(m_height, levelNdx); 3691 const int depth = getMipPyramidLevelSize(m_depth, levelNdx); 3692 3693 TextureLevelPyramid::allocLevel(levelNdx, width, height, depth); 3694 } 3695 3696 // TextureCubeArrayView 3697 3698 TextureCubeArrayView::TextureCubeArrayView (int numLevels, const ConstPixelBufferAccess* levels) 3699 : m_numLevels (numLevels) 3700 , m_levels (levels) 3701 { 3702 } 3703 3704 inline int TextureCubeArrayView::selectLayer (float q) const 3705 { 3706 DE_ASSERT(m_numLevels > 0 && m_levels); 3707 DE_ASSERT((m_levels[0].getDepth() % 6) == 0); 3708 3709 return de::clamp(deFloorFloatToInt32(q + 0.5f), 0, (m_levels[0].getDepth() / 6)-1); 3710 } 3711 3712 tcu::Vec4 TextureCubeArrayView::sample (const Sampler& sampler, float s, float t, float r, float q, float lod) const 3713 { 3714 const CubeFaceFloatCoords coords = getCubeFaceCoords(Vec3(s, t, r)); 3715 const int layer = selectLayer(q); 3716 const int faceDepth = (layer * 6) + getCubeArrayFaceIndex(coords.face); 3717 3718 DE_ASSERT(sampler.compare == Sampler::COMPAREMODE_NONE); 3719 3720 if (sampler.seamlessCubeMap) 3721 return sampleCubeArraySeamless(m_levels, m_numLevels, layer, coords.face, sampler, coords.s, coords.t, lod); 3722 else 3723 return sampleLevelArray2D(m_levels, m_numLevels, sampler, coords.s, coords.t, faceDepth, lod); 3724 } 3725 3726 float TextureCubeArrayView::sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float q, float lod) const 3727 { 3728 const CubeFaceFloatCoords coords = getCubeFaceCoords(Vec3(s, t, r)); 3729 const int layer = selectLayer(q); 3730 const int faceDepth = (layer * 6) + getCubeArrayFaceIndex(coords.face); 3731 3732 DE_ASSERT(sampler.compare != Sampler::COMPAREMODE_NONE); 3733 3734 if (sampler.seamlessCubeMap) 3735 return sampleCubeArraySeamlessCompare(m_levels, m_numLevels, layer, coords.face, sampler, ref, coords.s, coords.t, lod); 3736 else 3737 return sampleLevelArray2DCompare(m_levels, m_numLevels, sampler, ref, coords.s, coords.t, lod, IVec3(0, 0, faceDepth)); 3738 } 3739 3740 // TextureCubeArray 3741 3742 TextureCubeArray::TextureCubeArray (const TextureFormat& format, int size, int depth) 3743 : TextureLevelPyramid (format, computeMipPyramidLevels(size)) 3744 , m_size (size) 3745 , m_depth (depth) 3746 , m_view (getNumLevels(), getLevels()) 3747 { 3748 DE_ASSERT(m_depth % 6 == 0); 3749 } 3750 3751 TextureCubeArray::TextureCubeArray (const TextureCubeArray& other) 3752 : TextureLevelPyramid (other) 3753 , m_size (other.m_size) 3754 , m_depth (other.m_depth) 3755 , m_view (getNumLevels(), getLevels()) 3756 { 3757 DE_ASSERT(m_depth % 6 == 0); 3758 } 3759 3760 TextureCubeArray& TextureCubeArray::operator= (const TextureCubeArray& other) 3761 { 3762 if (this == &other) 3763 return *this; 3764 3765 TextureLevelPyramid::operator=(other); 3766 3767 m_size = other.m_size; 3768 m_depth = other.m_depth; 3769 m_view = TextureCubeArrayView(getNumLevels(), getLevels()); 3770 3771 DE_ASSERT(m_depth % 6 == 0); 3772 3773 return *this; 3774 } 3775 3776 TextureCubeArray::~TextureCubeArray (void) 3777 { 3778 } 3779 3780 void TextureCubeArray::allocLevel (int levelNdx) 3781 { 3782 DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); 3783 3784 const int size = getMipPyramidLevelSize(m_size, levelNdx); 3785 3786 TextureLevelPyramid::allocLevel(levelNdx, size, size, m_depth); 3787 } 3788 3789 std::ostream& operator<< (std::ostream& str, TextureFormat::ChannelOrder order) 3790 { 3791 const char* const orderStrings[] = 3792 { 3793 "R", 3794 "A", 3795 "I", 3796 "L", 3797 "LA", 3798 "RG", 3799 "RA", 3800 "RGB", 3801 "RGBA", 3802 "ARGB", 3803 "BGR", 3804 "BGRA", 3805 3806 "sR", 3807 "sRG", 3808 "sRGB", 3809 "sRGBA", 3810 "sBGR", 3811 "sBGRA", 3812 3813 "D", 3814 "S", 3815 "DS" 3816 }; 3817 3818 return str << de::getSizedArrayElement<TextureFormat::CHANNELORDER_LAST>(orderStrings, order); 3819 } 3820 3821 std::ostream& operator<< (std::ostream& str, TextureFormat::ChannelType type) 3822 { 3823 const char* const typeStrings[] = 3824 { 3825 "SNORM_INT8", 3826 "SNORM_INT16", 3827 "SNORM_INT32", 3828 "UNORM_INT8", 3829 "UNORM_INT16", 3830 "UNORM_INT24", 3831 "UNORM_INT32", 3832 "UNORM_BYTE_44", 3833 "UNORM_SHORT_565", 3834 "UNORM_SHORT_555", 3835 "UNORM_SHORT_4444", 3836 "UNORM_SHORT_5551", 3837 "UNORM_SHORT_1555", 3838 "UNORM_INT_101010", 3839 "SNORM_INT_1010102_REV", 3840 "UNORM_INT_1010102_REV", 3841 "UNSIGNED_BYTE_44", 3842 "UNSIGNED_SHORT_565", 3843 "UNSIGNED_SHORT_4444", 3844 "UNSIGNED_SHORT_5551", 3845 "SIGNED_INT_1010102_REV", 3846 "UNSIGNED_INT_1010102_REV", 3847 "UNSIGNED_INT_11F_11F_10F_REV", 3848 "UNSIGNED_INT_999_E5_REV", 3849 "UNSIGNED_INT_16_8_8", 3850 "UNSIGNED_INT_24_8", 3851 "UNSIGNED_INT_24_8_REV", 3852 "SIGNED_INT8", 3853 "SIGNED_INT16", 3854 "SIGNED_INT32", 3855 "UNSIGNED_INT8", 3856 "UNSIGNED_INT16", 3857 "UNSIGNED_INT24", 3858 "UNSIGNED_INT32", 3859 "HALF_FLOAT", 3860 "FLOAT", 3861 "FLOAT64", 3862 "FLOAT_UNSIGNED_INT_24_8_REV", 3863 "UNORM_SHORT_10", 3864 "UNORM_SHORT_12" 3865 }; 3866 3867 return str << de::getSizedArrayElement<TextureFormat::CHANNELTYPE_LAST>(typeStrings, type); 3868 } 3869 3870 std::ostream& operator<< (std::ostream& str, CubeFace face) 3871 { 3872 switch (face) 3873 { 3874 case CUBEFACE_NEGATIVE_X: return str << "CUBEFACE_NEGATIVE_X"; 3875 case CUBEFACE_POSITIVE_X: return str << "CUBEFACE_POSITIVE_X"; 3876 case CUBEFACE_NEGATIVE_Y: return str << "CUBEFACE_NEGATIVE_Y"; 3877 case CUBEFACE_POSITIVE_Y: return str << "CUBEFACE_POSITIVE_Y"; 3878 case CUBEFACE_NEGATIVE_Z: return str << "CUBEFACE_NEGATIVE_Z"; 3879 case CUBEFACE_POSITIVE_Z: return str << "CUBEFACE_POSITIVE_Z"; 3880 case CUBEFACE_LAST: return str << "CUBEFACE_LAST"; 3881 default: return str << "UNKNOWN(" << (int)face << ")"; 3882 } 3883 } 3884 3885 std::ostream& operator<< (std::ostream& str, TextureFormat format) 3886 { 3887 return str << format.order << ", " << format.type << ""; 3888 } 3889 3890 std::ostream& operator<< (std::ostream& str, const ConstPixelBufferAccess& access) 3891 { 3892 return str << "format = (" << access.getFormat() << "), size = " 3893 << access.getWidth() << " x " << access.getHeight() << " x " << access.getDepth() 3894 << ", pitch = " << access.getRowPitch() << " / " << access.getSlicePitch(); 3895 } 3896 3897 } // tcu 3898
