Lines Matching defs:sampler
1976 static inline Vec4 lookupBorder (const tcu::TextureFormat& format, const tcu::Sampler& sampler)
1989 return sampleTextureBorder<float>(format, sampler);
1991 return sampleTextureBorder<deInt32>(format, sampler).cast<float>();
1993 return sampleTextureBorder<deUint32>(format, sampler).cast<float>();
2025 static Vec4 sampleNearest1D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, const IVec2& offset)
2032 if (sampler.wrapS == Sampler::CLAMP_TO_BORDER && !deInBounds32(x, 0, width))
2033 return lookupBorder(access.getFormat(), sampler);
2035 int i = wrap(sampler.wrapS, x, width);
2040 static Vec4 sampleNearest2D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, const IVec3& offset)
2049 if ((sampler.wrapS == Sampler::CLAMP_TO_BORDER && !deInBounds32(x, 0, width)) ||
2050 (sampler.wrapT == Sampler::CLAMP_TO_BORDER && !deInBounds32(y, 0, height)))
2051 return lookupBorder(access.getFormat(), sampler);
2053 int i = wrap(sampler.wrapS, x, width);
2054 int j = wrap(sampler.wrapT, y, height);
2059 static Vec4 sampleNearest3D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, float w, const IVec3& offset)
2070 if ((sampler.wrapS == Sampler::CLAMP_TO_BORDER && !deInBounds32(x, 0, width)) ||
2071 (sampler.wrapT == Sampler::CLAMP_TO_BORDER && !deInBounds32(y, 0, height)) ||
2072 (sampler.wrapR == Sampler::CLAMP_TO_BORDER && !deInBounds32(z, 0, depth)))
2073 return lookupBorder(access.getFormat(), sampler);
2075 int i = wrap(sampler.wrapS, x, width);
2076 int j = wrap(sampler.wrapT, y, height);
2077 int k = wrap(sampler.wrapR, z, depth);
2082 static Vec4 sampleLinear1D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, const IVec2& offset)
2089 int i0 = wrap(sampler.wrapS, x0, w);
2090 int i1 = wrap(sampler.wrapS, x1, w);
2094 bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, w);
2095 bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, w);
2098 Vec4 p0 = i0UseBorder ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, offset.y(), 0);
2099 Vec4 p1 = i1UseBorder ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, offset.y(), 0);
2105 static Vec4 sampleCubic1D(const ConstPixelBufferAccess& access, const Sampler& sampler, float u, const IVec2& offset)
2117 i[m] = wrap(sampler.wrapS, x[m], width);
2121 iUseBorder[m] = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i[m], 0, width);
2137 tcu::Vec4 p = (iUseBorder[m]) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i[m], offset.y(), 0);
2143 static Vec4 sampleLinear2D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, const IVec3& offset)
2153 int i0 = wrap(sampler.wrapS, x0, w);
2154 int i1 = wrap(sampler.wrapS, x1, w);
2155 int j0 = wrap(sampler.wrapT, y0, h);
2156 int j1 = wrap(sampler.wrapT, y1, h);
2161 bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, w);
2162 bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, w);
2163 bool j0UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j0, 0, h);
2164 bool j1UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j1, 0, h);
2167 Vec4 p00 = (i0UseBorder || j0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j0, offset.z());
2168 Vec4 p10 = (i1UseBorder || j0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j0, offset.z());
2169 Vec4 p01 = (i0UseBorder || j1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j1, offset.z());
2170 Vec4 p11 = (i1UseBorder || j1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j1, offset.z());
2179 static Vec4 sampleCubic2D(const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, const IVec3& offset)
2196 i[m] = wrap(sampler.wrapS, x[m], width);
2198 j[n] = wrap(sampler.wrapT, y[n], height);
2202 iUseBorder[m] = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i[m], 0, width);
2204 jUseBorder[n] = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j[n], 0, height);
2224 tcu::Vec4 p = (iUseBorder[m] || jUseBorder[n]) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i[m], j[n], offset.z());
2230 static float sampleLinear1DCompare (const ConstPixelBufferAccess& access, const Sampler& sampler, float ref, float u, const IVec2& offset, bool isFixedPointDepthFormat)
2237 int i0 = wrap(sampler.wrapS, x0, w);
2238 int i1 = wrap(sampler.wrapS, x1, w);
2242 bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, w);
2243 bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, w);
2246 Vec4 p0Clr = i0UseBorder ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, offset.y(), 0);
2247 Vec4 p1Clr = i1UseBorder ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, offset.y(), 0);
2250 float p0 = execCompare(p0Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat);
2251 float p1 = execCompare(p1Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat);
2257 static float sampleLinear2DCompare (const ConstPixelBufferAccess& access, const Sampler& sampler, float ref, float u, float v, const IVec3& offset, bool isFixedPointDepthFormat)
2267 int i0 = wrap(sampler.wrapS, x0, w);
2268 int i1 = wrap(sampler.wrapS, x1, w);
2269 int j0 = wrap(sampler.wrapT, y0, h);
2270 int j1 = wrap(sampler.wrapT, y1, h);
2275 bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, w);
2276 bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, w);
2277 bool j0UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j0, 0, h);
2278 bool j1UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j1, 0, h);
2281 Vec4 p00Clr = (i0UseBorder || j0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j0, offset.z());
2282 Vec4 p10Clr = (i1UseBorder || j0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j0, offset.z());
2283 Vec4 p01Clr = (i0UseBorder || j1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j1, offset.z());
2284 Vec4 p11Clr = (i1UseBorder || j1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j1, offset.z());
2287 float p00 = execCompare(p00Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat);
2288 float p10 = execCompare(p10Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat);
2289 float p01 = execCompare(p01Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat);
2290 float p11 = execCompare(p11Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat);
2299 static Vec4 sampleLinear3D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, float w, const IVec3& offset)
2312 int i0 = wrap(sampler.wrapS, x0, width);
2313 int i1 = wrap(sampler.wrapS, x1, width);
2314 int j0 = wrap(sampler.wrapT, y0, height);
2315 int j1 = wrap(sampler.wrapT, y1, height);
2316 int k0 = wrap(sampler.wrapR, z0, depth);
2317 int k1 = wrap(sampler.wrapR, z1, depth);
2323 bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, width);
2324 bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, width);
2325 bool j0UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j0, 0, height);
2326 bool j1UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j1, 0, height);
2327 bool k0UseBorder = sampler.wrapR == Sampler::CLAMP_TO_BORDER && !de::inBounds(k0, 0, depth);
2328 bool k1UseBorder = sampler.wrapR == Sampler::CLAMP_TO_BORDER && !de::inBounds(k1, 0, depth);
2331 Vec4 p000 = (i0UseBorder || j0UseBorder || k0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j0, k0);
2332 Vec4 p100 = (i1UseBorder || j0UseBorder || k0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j0, k0);
2333 Vec4 p010 = (i0UseBorder || j1UseBorder || k0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j1, k0);
2334 Vec4 p110 = (i1UseBorder || j1UseBorder || k0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j1, k0);
2335 Vec4 p001 = (i0UseBorder || j0UseBorder || k1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j0, k1);
2336 Vec4 p101 = (i1UseBorder || j0UseBorder || k1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j0, k1);
2337 Vec4 p011 = (i0UseBorder || j1UseBorder || k1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j1, k1);
2338 Vec4 p111 = (i1UseBorder || j1UseBorder || k1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j1, k1);
2351 static Vec4 sampleCubic3D(const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, float w, const IVec3& offset)
2373 i[m] = wrap(sampler.wrapS, x[m], width);
2375 j[n] = wrap(sampler.wrapT, y[n], height);
2377 k[o] = wrap(sampler.wrapR, k[o], depth);
2381 iUseBorder[m] = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i[m], 0, width);
2383 jUseBorder[n] = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j[n], 0, height);
2385 kUseBorder[o] = sampler.wrapR == Sampler::CLAMP_TO_BORDER && !de::inBounds(k[o], 0, depth);
2409 tcu::Vec4 p = (iUseBorder[m] || jUseBorder[n] || kUseBorder[o]) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i[m], j[n], k[o]);
2415 Vec4 ConstPixelBufferAccess::sample1D (const Sampler& sampler, Sampler::FilterMode filter, float s, int level) const
2420 return sample1DOffset(sampler, filter, s, tcu::IVec2(0, level));
2423 Vec4 ConstPixelBufferAccess::sample2D (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, int depth) const
2428 return sample2DOffset(sampler, filter, s, t, tcu::IVec3(0, 0, depth));
2431 Vec4 ConstPixelBufferAccess::sample3D (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, float r) const
2433 return sample3DOffset(sampler, filter, s, t, r, tcu::IVec3(0, 0, 0));
2436 Vec4 ConstPixelBufferAccess::sample1DOffset (const Sampler& sampler, Sampler::FilterMode filter, float s, const IVec2& offset) const
2445 if (sampler.normalizedCoords)
2446 u = unnormalize(sampler.wrapS, s, m_size.x());
2450 case Sampler::NEAREST: return sampleNearest1D (*this, sampler, u, offset);
2451 case Sampler::LINEAR: return sampleLinear1D (*this, sampler, u, offset);
2452 case Sampler::CUBIC: return sampleCubic1D (*this, sampler, u, offset);
2459 Vec4 ConstPixelBufferAccess::sample2DOffset (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, const IVec3& offset) const
2469 if (sampler.normalizedCoords)
2471 u = unnormalize(sampler.wrapS, s, m_size.x());
2472 v = unnormalize(sampler.wrapT, t, m_size.y());
2477 case Sampler::NEAREST: return sampleNearest2D (*this, sampler, u, v, offset);
2478 case Sampler::LINEAR: return sampleLinear2D (*this, sampler, u, v, offset);
2479 case Sampler::CUBIC: return sampleCubic2D (*this, sampler, u, v, offset);
2486 Vec4 ConstPixelBufferAccess::sample3DOffset (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, float r, const IVec3& offset) const
2493 if (sampler.normalizedCoords)
2495 u = unnormalize(sampler.wrapS, s, m_size.x());
2496 v = unnormalize(sampler.wrapT, t, m_size.y());
2497 w = unnormalize(sampler.wrapR, r, m_size.z());
2502 case Sampler::NEAREST: return sampleNearest3D (*this, sampler, u, v, w, offset);
2503 case Sampler::LINEAR: return sampleLinear3D (*this, sampler, u, v, w, offset);
2504 case Sampler::CUBIC: return sampleCubic3D (*this, sampler, u, v, w, offset);
2511 float ConstPixelBufferAccess::sample1DCompare (const Sampler& sampler, Sampler::FilterMode filter, float ref, float s, const IVec2& offset) const
2523 if (sampler.normalizedCoords)
2524 u = unnormalize(sampler.wrapS, s, m_size.x());
2528 case Sampler::NEAREST: return execCompare(sampleNearest1D(*this, sampler, u, offset), sampler.compare, sampler.compareChannel, ref, isFixedPointDepth);
2529 case Sampler::LINEAR: return sampleLinear1DCompare(*this, sampler, ref, u, offset, isFixedPointDepth);
2536 float ConstPixelBufferAccess::sample2DCompare (const Sampler& sampler, Sampler::FilterMode filter, float ref, float s, float t, const IVec3& offset) const
2549 if (sampler.normalizedCoords)
2551 u = unnormalize(sampler.wrapS, s, m_size.x());
2552 v = unnormalize(sampler.wrapT, t, m_size.y());
2557 case Sampler::NEAREST: return execCompare(sampleNearest2D(*this, sampler, u, v, offset), sampler.compare, sampler.compareChannel, ref, isFixedPointDepth);
2558 case Sampler::LINEAR: return sampleLinear2DCompare(*this, sampler, ref, u, v, offset, isFixedPointDepth);
2603 Vec4 sampleLevelArray1D (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, int depth, float lod)
2605 return sampleLevelArray1DOffset(levels, numLevels, sampler, s, lod, IVec2(0, depth)); // y-offset in 1D textures is layer selector
2608 Vec4 sampleLevelArray2D (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, int depth, float lod, bool es2, ImageViewMinLodParams* minLodParams)
2610 return sampleLevelArray2DOffset(levels, numLevels, sampler, s, t, lod, IVec3(0, 0, depth), es2, minLodParams); // z-offset in 2D textures is layer selector
2613 Vec4 sampleLevelArray3D (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, float r, float lod, ImageViewMinLodParams* minLodParams)
2615 return sampleLevelArray3DOffset(levels, numLevels, sampler, s, t, r, lod, IVec3(0, 0, 0), minLodParams);
2618 Vec4 sampleLevelArray1DOffset (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float lod, const IVec2& offset)
2620 bool magnified = lod <= sampler.lodThreshold;
2621 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter;
2625 case Sampler::NEAREST: return levels[0].sample1DOffset(sampler, filterMode, s, offset);
2626 case Sampler::LINEAR: return levels[0].sample1DOffset(sampler, filterMode, s, offset);
2635 return levels[level].sample1DOffset(sampler, levelFilter, s, offset);
2646 tcu::Vec4 t0 = levels[level0].sample1DOffset(sampler, levelFilter, s, offset);
2647 tcu::Vec4 t1 = levels[level1].sample1DOffset(sampler, levelFilter, s, offset);
2658 Vec4 sampleLevelArray2DOffset (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, float lod, const IVec3& offset, bool es2, ImageViewMinLodParams* minLodParams)
2665 if (es2 && sampler.magFilter == Sampler::LINEAR &&
2666 (sampler.minFilter == Sampler::NEAREST_MIPMAP_NEAREST || sampler.minFilter == Sampler::NEAREST_MIPMAP_LINEAR))
2669 magnified = lod <= sampler.lodThreshold;
2681 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter;
2688 bool isLinearMipmapMode = magnified && tcu::isSamplerMipmapModeLinear(sampler.minFilter);
2691 tcu::Vec4 t0 = levels[level0].sample2DOffset(sampler, filterMode, s, t, offset);
2698 tcu::Vec4 t1 = levels[level1].sample2DOffset(sampler, filterMode, s, t, offset);
2722 return levels[level].sample2DOffset(sampler, levelFilter, s, t, offset);
2746 tcu::Vec4 t0 = levels[level0].sample2DOffset(sampler, levelFilter, s, t, offset);
2747 tcu::Vec4 t1 = levels[level1].sample2DOffset(sampler, levelFilter, s, t, offset);
2758 Vec4 sampleLevelArray3DOffset (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, float r, float lod, const IVec3& offset, ImageViewMinLodParams* minLodParams)
2763 bool magnified = lod <= sampler.lodThreshold;
2764 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter;
2781 bool isLinearMipmapMode = magnified && tcu::isSamplerMipmapModeLinear(sampler.minFilter);
2784 tcu::Vec4 t0 = levels[level0].sample3DOffset(sampler, filterMode, s, t, r, offset);
2791 tcu::Vec4 t1 = levels[level1].sample3DOffset(sampler, filterMode, s, t, r, offset);
2805 return levels[level].sample3DOffset(sampler, levelFilter, s, t, r, offset);
2819 tcu::Vec4 t0 = levels[level0].sample3DOffset(sampler, levelFilter, s, t, r, offset);
2820 tcu::Vec4 t1 = levels[level1].sample3DOffset(sampler, levelFilter, s, t, r, offset);
2831 float sampleLevelArray1DCompare (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float ref, float s, float lod, const IVec2& offset)
2833 bool magnified = lod <= sampler.lodThreshold;
2834 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter;
2838 case Sampler::NEAREST: return levels[0].sample1DCompare(sampler, filterMode, ref, s, offset);
2839 case Sampler::LINEAR: return levels[0].sample1DCompare(sampler, filterMode, ref, s, offset);
2848 return levels[level].sample1DCompare(sampler, levelFilter, ref, s, offset);
2859 float t0 = levels[level0].sample1DCompare(sampler, levelFilter, ref, s, offset);
2860 float t1 = levels[level1].sample1DCompare(sampler, levelFilter, ref, s, offset);
2871 float sampleLevelArray2DCompare (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float ref, float s, float t, float lod, const IVec3& offset)
2873 bool magnified = lod <= sampler.lodThreshold;
2874 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter;
2878 case Sampler::NEAREST: return levels[0].sample2DCompare(sampler, filterMode, ref, s, t, offset);
2879 case Sampler::LINEAR: return levels[0].sample2DCompare(sampler, filterMode, ref, s, t, offset);
2888 return levels[level].sample2DCompare(sampler, levelFilter, ref, s, t, offset);
2899 float t0 = levels[level0].sample2DCompare(sampler, levelFilter, ref, s, t, offset);
2900 float t1 = levels[level1].sample2DCompare(sampler, levelFilter, ref, s, t, offset);
2911 static Vec4 fetchGatherArray2DOffsets (const ConstPixelBufferAccess& src, const Sampler& sampler, float s, float t, int depth, int componentNdx, const IVec2 (&offsets)[4])
2917 const float u = unnormalize(sampler.wrapS, s, w);
2918 const float v = unnormalize(sampler.wrapT, t, h);
2926 const int sampleX = wrap(sampler.wrapS, x0 + offsets[i].x(), w);
2927 const int sampleY = wrap(sampler.wrapT, y0 + offsets[i].y(), h);
2933 pixel = lookupBorder(src.getFormat(), sampler);
2941 Vec4 gatherArray2DOffsets (const ConstPixelBufferAccess& src, const Sampler& sampler, float s, float t, int depth, int componentNdx, const IVec2 (&offsets)[4])
2943 DE_ASSERT(sampler.compare == Sampler::COMPAREMODE_NONE);
2946 return fetchGatherArray2DOffsets(src, sampler, s, t, depth, componentNdx, offsets);
2949 Vec4 gatherArray2DOffsetsCompare (const ConstPixelBufferAccess& src, const Sampler& sampler, float ref, float s, float t, int depth, const IVec2 (&offsets)[4])
2951 DE_ASSERT(sampler.compare != Sampler::COMPAREMODE_NONE);
2953 DE_ASSERT(sampler.compareChannel == 0);
2956 const Vec4 gathered = fetchGatherArray2DOffsets(src, sampler, s, t, depth, 0 /* component 0: depth */, offsets);
2960 result[i] = execCompare(gathered, sampler.compare, i, ref, isFixedPoint);
2965 static Vec4 sampleCubeSeamlessNearest (const ConstPixelBufferAccess& faceAccess, const Sampler& sampler, float s, float t, int depth)
2967 Sampler clampingSampler = sampler;
3171 static Vec4 sampleCubeSeamlessLinear (const ConstPixelBufferAccess (&faceAccesses)[CUBEFACE_LAST], CubeFace baseFace, const Sampler& sampler, float s, float t, int depth)
3180 if (sampler.normalizedCoords)
3182 u = unnormalize(sampler.wrapS, s, size);
3183 v = unnormalize(sampler.wrapT, t, size);
3202 static Vec4 sampleLevelArrayCubeSeamless (const ConstPixelBufferAccess* const (&faces)[CUBEFACE_LAST], int numLevels, CubeFace face, const Sampler& sampler, float s, float t, int depth, float lod, ImageViewMinLodParams* minLodParams)
3207 bool magnified = lod <= sampler.lodThreshold;
3208 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter;
3224 bool isLinearMipmapMode = magnified && tcu::isSamplerMipmapModeLinear(sampler.minFilter);
3227 tcu::Vec4 t0 = sampleCubeSeamlessNearest(faces[face][level0], sampler, s, t, depth);
3234 tcu::Vec4 t1 = sampleCubeSeamlessNearest(faces[face][level1], sampler, s, t, depth);
3240 bool cond = sampler.minFilter == Sampler::NEAREST_MIPMAP_LINEAR || sampler.minFilter == Sampler::LINEAR_MIPMAP_LINEAR;
3246 Vec4 result = sampleCubeSeamlessLinear(faceAccesses, face, sampler, s, t, depth);
3258 result += sampleCubeSeamlessLinear(faceAccesses, face, sampler, s, t, depth) * deFloatFrac(minLodRelative);
3274 return sampleCubeSeamlessNearest(faces[face][level], sampler, s, t, depth);
3283 return sampleCubeSeamlessLinear(faceAccesses, face, sampler, s, t, depth);
3303 t0 = sampleCubeSeamlessNearest(faces[face][level0], sampler, s, t, depth);
3304 t1 = sampleCubeSeamlessNearest(faces[face][level1], sampler, s, t, depth);
3318 t0 = sampleCubeSeamlessLinear(faceAccesses0, face, sampler, s, t, depth);
3319 t1 = sampleCubeSeamlessLinear(faceAccesses1, face, sampler, s, t, depth);
3331 static float sampleCubeSeamlessNearestCompare (const ConstPixelBufferAccess& faceAccess, const Sampler& sampler, float ref, float s, float t, int depth = 0)
3333 Sampler clampingSampler = sampler;
3339 static float sampleCubeSeamlessLinearCompare (const ConstPixelBufferAccess (&faceAccesses)[CUBEFACE_LAST], CubeFace baseFace, const Sampler& sampler, float ref, float s, float t)
3348 if (sampler.normalizedCoords)
3350 u = unnormalize(sampler.wrapS, s, size);
3351 v = unnormalize(sampler.wrapT, t, size);
3379 sampleRes[i] = execCompare(faceAccesses[coords.face].getPixel(coords.s, coords.t), sampler.compare, sampler.compareChannel, ref, isFixedPointDepth);
3420 static float sampleLevelArrayCubeSeamlessCompare (const ConstPixelBufferAccess* const (&faces)[CUBEFACE_LAST], int numLevels, CubeFace face, const Sampler& sampler, float ref, float s, float t, float lod)
3422 bool magnified = lod <= sampler.lodThreshold;
3423 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter;
3428 return sampleCubeSeamlessNearestCompare(faces[face][0], sampler, ref, s, t);
3436 return sampleCubeSeamlessLinearCompare(faceAccesses, face, sampler, ref, s, t);
3447 return sampleCubeSeamlessNearestCompare(faces[face][level], sampler, ref, s, t);
3456 return sampleCubeSeamlessLinearCompare(faceAccesses, face, sampler, ref, s, t);
3473 t0 = sampleCubeSeamlessNearestCompare(faces[face][level0], sampler, ref, s, t);
3474 t1 = sampleCubeSeamlessNearestCompare(faces[face][level1], sampler, ref, s, t);
3488 t0 = sampleCubeSeamlessLinearCompare(faceAccesses0, face, sampler, ref, s, t);
3489 t1 = sampleCubeSeamlessLinearCompare(faceAccesses1, face, sampler, ref, s, t);
3511 static Vec4 sampleCubeArraySeamless (const ConstPixelBufferAccess* const levels, int numLevels, int slice, CubeFace face, const Sampler& sampler, float s, float t, float lod)
3514 const bool magnified = lod <= sampler.lodThreshold;
3515 const Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter;
3520 return sampleCubeSeamlessNearest(levels[0], sampler, s, t, faceDepth);
3528 return sampleCubeSeamlessLinear(faceAccesses, face, sampler, s, t, 0);
3539 return sampleCubeSeamlessNearest(levels[level], sampler, s, t, faceDepth);
3548 return sampleCubeSeamlessLinear(faceAccesses, face, sampler, s, t, 0);
3565 t0 = sampleCubeSeamlessNearest(levels[level0], sampler, s, t, faceDepth);
3566 t1 = sampleCubeSeamlessNearest(levels[level1], sampler, s, t, faceDepth);
3580 t0 = sampleCubeSeamlessLinear(faceAccesses0, face, sampler, s, t, 0);
3581 t1 = sampleCubeSeamlessLinear(faceAccesses1, face, sampler, s, t, 0);
3593 static float sampleCubeArraySeamlessCompare (const ConstPixelBufferAccess* const levels, int numLevels, int slice, CubeFace face, const Sampler& sampler, float ref, float s, float t, float lod)
3596 const bool magnified = lod <= sampler.lodThreshold;
3597 Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter;
3602 return sampleCubeSeamlessNearestCompare(levels[0], sampler, ref, s, t, faceDepth);
3610 return sampleCubeSeamlessLinearCompare(faceAccesses, face, sampler, ref, s, t);
3621 return sampleCubeSeamlessNearestCompare(levels[level], sampler, ref, s, t, faceDepth);
3630 return sampleCubeSeamlessLinearCompare(faceAccesses, face, sampler, ref, s, t);
3647 t0 = sampleCubeSeamlessNearestCompare(levels[level0], sampler, ref, s, t, faceDepth);
3648 t1 = sampleCubeSeamlessNearestCompare(levels[level1], sampler, ref, s, t, faceDepth);
3662 t0 = sampleCubeSeamlessLinearCompare(faceAccesses0, face, sampler, ref, s, t);
3663 t1 = sampleCubeSeamlessLinearCompare(faceAccesses1, face, sampler, ref, s, t);
3887 tcu::Vec4 TextureCubeView::sample (const Sampler& sampler, float s, float t, float r, float lod) const
3889 DE_ASSERT(sampler.compare == Sampler::COMPAREMODE_NONE);
3893 if (sampler.seamlessCubeMap)
3894 return sampleLevelArrayCubeSeamless(m_levels, m_numLevels, coords.face, sampler, coords.s, coords.t, 0 /* depth */, lod, m_minLodParams);
3896 return sampleLevelArray2D(m_levels[coords.face], m_numLevels, sampler, coords.s, coords.t, 0 /* depth */, lod, m_es2, m_minLodParams);
3899 float TextureCubeView::sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float lod) const
3901 DE_ASSERT(sampler.compare != Sampler::COMPAREMODE_NONE);
3905 if (sampler.seamlessCubeMap)
3906 return sampleLevelArrayCubeSeamlessCompare(m_levels, m_numLevels, coords.face, sampler, ref, coords.s, coords.t, lod);
3908 return sampleLevelArray2DCompare(m_levels[coords.face], m_numLevels, sampler, ref, coords.s, coords.t, lod, IVec3(0, 0, 0));
3911 Vec4 TextureCubeView::gather (const Sampler& sampler, float s, float t, float r, int componentNdx) const
3913 DE_ASSERT(sampler.compare == Sampler::COMPAREMODE_NONE);
3925 if (sampler.normalizedCoords)
3927 u = unnormalize(sampler.wrapS, coords.s, size);
3928 v = unnormalize(sampler.wrapT, coords.t, size);
3942 Vec4 TextureCubeView::gatherCompare (const Sampler& sampler, float ref, float s, float t, float r) const
3944 DE_ASSERT(sampler.compare != Sampler::COMPAREMODE_NONE);
3946 DE_ASSERT(sampler.compareChannel == 0);
3948 Sampler noCompareSampler = sampler;
3955 result[i] = execCompare(gathered, sampler.compare, i, ref, isFixedPoint);
4082 Vec4 Texture1DArrayView::sample (const Sampler& sampler, float s, float t, float lod) const
4084 return sampleLevelArray1D(m_levels, m_numLevels, sampler, s, selectLayer(t), lod);
4087 Vec4 Texture1DArrayView::sampleOffset (const Sampler& sampler, float s, float t, float lod, deInt32 offset) const
4089 return sampleLevelArray1DOffset(m_levels, m_numLevels, sampler, s, lod, IVec2(offset, selectLayer(t)));
4092 float Texture1DArrayView::sampleCompare (const Sampler& sampler, float ref, float s, float t, float lod) const
4094 return sampleLevelArray1DCompare(m_levels, m_numLevels, sampler, ref, s, lod, IVec2(0, selectLayer(t)));
4097 float Texture1DArrayView::sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float lod, deInt32 offset) const
4099 return sampleLevelArray1DCompare(m_levels, m_numLevels, sampler, ref, s, lod, IVec2(offset, selectLayer(t)));
4116 Vec4 Texture2DArrayView::sample (const Sampler& sampler, float s, float t, float r, float lod) const
4118 return sampleLevelArray2D(m_levels, m_numLevels, sampler, s, t, selectLayer(r), lod);
4121 float Texture2DArrayView::sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float lod) const
4123 return sampleLevelArray2DCompare(m_levels, m_numLevels, sampler, ref, s, t, lod, IVec3(0, 0, selectLayer(r)));
4126 Vec4 Texture2DArrayView::sampleOffset (const Sampler& sampler, float s, float t, float r, float lod, const IVec2& offset) const
4128 return sampleLevelArray2DOffset(m_levels, m_numLevels, sampler, s, t, lod, IVec3(offset.x(), offset.y(), selectLayer(r)));
4131 float Texture2DArrayView::sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float r, float lod, const IVec2& offset) const
4133 return sampleLevelArray2DCompare(m_levels, m_numLevels, sampler, ref, s, t, lod, IVec3(offset.x(), offset.y(), selectLayer(r)));
4136 Vec4 Texture2DArrayView::gatherOffsets (const Sampler& sampler, float s, float t, float r, int componentNdx, const IVec2 (&offsets)[4]) const
4138 return gatherArray2DOffsets(m_levels[0], sampler, s, t, selectLayer(r), componentNdx, offsets);
4141 Vec4 Texture2DArrayView::gatherOffsetsCompare (const Sampler& sampler, float ref, float s, float t, float r, const IVec2 (&offsets)[4]) const
4143 return gatherArray2DOffsetsCompare(m_levels[0], sampler, ref, s, t, selectLayer(r), offsets);
4316 tcu::Vec4 TextureCubeArrayView::sample (const Sampler& sampler, float s, float t, float r, float q, float lod) const
4322 DE_ASSERT(sampler.compare == Sampler::COMPAREMODE_NONE);
4324 if (sampler.seamlessCubeMap)
4325 return sampleCubeArraySeamless(m_levels, m_numLevels, layer, coords.face, sampler, coords.s, coords.t, lod);
4327 return sampleLevelArray2D(m_levels, m_numLevels, sampler, coords.s, coords.t, faceDepth, lod);
4330 float TextureCubeArrayView::sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float q, float lod) const
4336 DE_ASSERT(sampler.compare != Sampler::COMPAREMODE_NONE);
4338 if (sampler.seamlessCubeMap)
4339 return sampleCubeArraySeamlessCompare(m_levels, m_numLevels, layer, coords.face, sampler, ref, coords.s, coords.t, lod);
4341 return sampleLevelArray2DCompare(m_levels, m_numLevels, sampler, ref, coords.s, coords.t, lod, IVec3(0, 0, faceDepth));