framework/opengl/simplereference/sglrReferenceContext.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES Utilities
   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 Rendering Context.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "sglrReferenceContext.hpp"
  25 #include "sglrReferenceUtils.hpp"
  26 #include "sglrShaderProgram.hpp"
  27 #include "tcuTextureUtil.hpp"
  28 #include "tcuMatrix.hpp"
  29 #include "tcuMatrixUtil.hpp"
  30 #include "tcuVectorUtil.hpp"
  31 #include "gluDefs.hpp"
  32 #include "gluTextureUtil.hpp"
  33 #include "glwFunctions.hpp"
  34 #include "glwEnums.hpp"
  35 #include "deMemory.h"
  36 #include "rrFragmentOperations.hpp"
  37 #include "rrRenderer.hpp"
  38
  39 namespace sglr
  40 {
  41
  42 using std::vector;
  43 using std::map;
  44
  45 using tcu::Vec2;
  46 using tcu::Vec3;
  47 using tcu::Vec4;
  48 using tcu::IVec2;
  49 using tcu::IVec4;
  50 using tcu::RGBA;
  51
  52 // Reference context implementation
  53 using namespace rc;
  54
  55 using tcu::TextureFormat;
  56 using tcu::PixelBufferAccess;
  57 using tcu::ConstPixelBufferAccess;
  58
  59 // Utilities for ReferenceContext
  60 #define RC_RET_VOID
  61
  62 #define RC_ERROR_RET(ERR, RET)                  \
  63 do {                                                                    \
  64         setError(ERR);                                          \
  65         return RET;                                                     \
  66 } while (deGetFalse())
  67
  68 #define RC_IF_ERROR(COND, ERR, RET)             \
  69 do {                                                                    \
  70         if (COND)                                                       \
  71                 RC_ERROR_RET(ERR, RET);                 \
  72 } while (deGetFalse())
  73
  74 static inline tcu::PixelBufferAccess nullAccess (void)
  75 {
  76         return tcu::PixelBufferAccess(TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT8), 0, 0, 0, DE_NULL);
  77 }
  78
  79 static inline bool isEmpty (const tcu::ConstPixelBufferAccess& access)
  80 {
  81         return access.getWidth() == 0 || access.getHeight() == 0 || access.getDepth() == 0;
  82 }
  83
  84 static inline bool isEmpty (const rr::MultisampleConstPixelBufferAccess& access)
  85 {
  86         return access.raw().getWidth() == 0 || access.raw().getHeight() == 0 || access.raw().getDepth() == 0;
  87 }
  88
  89 static inline bool isEmpty (const IVec4& rect)
  90 {
  91         return rect.z() == 0 || rect.w() == 0;
  92 }
  93
  94 inline int getNumMipLevels1D (int size)
  95 {
  96         return deLog2Floor32(size)+1;
  97 }
  98
  99 inline int getNumMipLevels2D (int width, int height)
 100 {
 101         return deLog2Floor32(de::max(width, height))+1;
 102 }
 103
 104 inline int getNumMipLevels3D (int width, int height, int depth)
 105 {
 106         return deLog2Floor32(de::max(width, de::max(height, depth)))+1;
 107 }
 108
 109 inline int getMipLevelSize (int baseLevelSize, int levelNdx)
 110 {
 111         return de::max(baseLevelSize >> levelNdx, 1);
 112 }
 113
 114 inline bool isMipmapFilter (const tcu::Sampler::FilterMode mode)
 115 {
 116         return mode != tcu::Sampler::NEAREST && mode != tcu::Sampler::LINEAR;
 117 }
 118
 119 static tcu::CubeFace texTargetToFace (Framebuffer::TexTarget target)
 120 {
 121         switch (target)
 122         {
 123                 case Framebuffer::TEXTARGET_CUBE_MAP_NEGATIVE_X:        return tcu::CUBEFACE_NEGATIVE_X;
 124                 case Framebuffer::TEXTARGET_CUBE_MAP_POSITIVE_X:        return tcu::CUBEFACE_POSITIVE_X;
 125                 case Framebuffer::TEXTARGET_CUBE_MAP_NEGATIVE_Y:        return tcu::CUBEFACE_NEGATIVE_Y;
 126                 case Framebuffer::TEXTARGET_CUBE_MAP_POSITIVE_Y:        return tcu::CUBEFACE_POSITIVE_Y;
 127                 case Framebuffer::TEXTARGET_CUBE_MAP_NEGATIVE_Z:        return tcu::CUBEFACE_NEGATIVE_Z;
 128                 case Framebuffer::TEXTARGET_CUBE_MAP_POSITIVE_Z:        return tcu::CUBEFACE_POSITIVE_Z;
 129                 default:                                                                                        return tcu::CUBEFACE_LAST;
 130         }
 131 }
 132
 133 static Framebuffer::TexTarget texLayeredTypeToTarget (Texture::Type type)
 134 {
 135         switch (type)
 136         {
 137                 case Texture::TYPE_2D_ARRAY:            return Framebuffer::TEXTARGET_2D_ARRAY;
 138                 case Texture::TYPE_3D:                          return Framebuffer::TEXTARGET_3D;
 139                 case Texture::TYPE_CUBE_MAP_ARRAY:      return Framebuffer::TEXTARGET_CUBE_MAP_ARRAY;
 140                 default:                                                        return Framebuffer::TEXTARGET_LAST;
 141         }
 142 }
 143
 144 static tcu::CubeFace mapGLCubeFace (deUint32 face)
 145 {
 146         switch (face)
 147         {
 148                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:    return tcu::CUBEFACE_NEGATIVE_X;
 149                 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:    return tcu::CUBEFACE_POSITIVE_X;
 150                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:    return tcu::CUBEFACE_NEGATIVE_Y;
 151                 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:    return tcu::CUBEFACE_POSITIVE_Y;
 152                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:    return tcu::CUBEFACE_NEGATIVE_Z;
 153                 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:    return tcu::CUBEFACE_POSITIVE_Z;
 154                 default:                                                                return tcu::CUBEFACE_LAST;
 155         }
 156 }
 157
 158 tcu::TextureFormat toTextureFormat (const tcu::PixelFormat& pixelFmt)
 159 {
 160         static const struct
 161         {
 162                 tcu::PixelFormat        pixelFmt;
 163                 tcu::TextureFormat      texFmt;
 164         } pixelFormatMap[] =
 165         {
 166                 { tcu::PixelFormat(8,8,8,8),    tcu::TextureFormat(tcu::TextureFormat::RGBA,    tcu::TextureFormat::UNORM_INT8)                 },
 167                 { tcu::PixelFormat(8,8,8,0),    tcu::TextureFormat(tcu::TextureFormat::RGB,             tcu::TextureFormat::UNORM_INT8)                 },
 168                 { tcu::PixelFormat(4,4,4,4),    tcu::TextureFormat(tcu::TextureFormat::RGBA,    tcu::TextureFormat::UNORM_SHORT_4444)   },
 169                 { tcu::PixelFormat(5,5,5,1),    tcu::TextureFormat(tcu::TextureFormat::RGBA,    tcu::TextureFormat::UNORM_SHORT_5551)   },
 170                 { tcu::PixelFormat(5,6,5,0),    tcu::TextureFormat(tcu::TextureFormat::RGB,             tcu::TextureFormat::UNORM_SHORT_565)    }
 171         };
 172
 173         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(pixelFormatMap); ndx++)
 174         {
 175                 if (pixelFormatMap[ndx].pixelFmt == pixelFmt)
 176                         return pixelFormatMap[ndx].texFmt;
 177         }
 178
 179         TCU_FAIL("Can't map pixel format to texture format");
 180 }
 181
 182 tcu::TextureFormat toNonSRGBFormat (const tcu::TextureFormat& fmt)
 183 {
 184         switch (fmt.order)
 185         {
 186                 case tcu::TextureFormat::sRGB:
 187                         return tcu::TextureFormat(tcu::TextureFormat::RGB,      fmt.type);
 188                 case tcu::TextureFormat::sRGBA:
 189                         return tcu::TextureFormat(tcu::TextureFormat::RGBA,     fmt.type);
 190                 default:
 191                         return fmt;
 192         }
 193 }
 194
 195 tcu::TextureFormat getDepthFormat (int depthBits)
 196 {
 197         switch (depthBits)
 198         {
 199                 case 8:         return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT8);
 200                 case 16:        return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT16);
 201                 case 24:        return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNSIGNED_INT_24_8);
 202                 case 32:        return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::FLOAT);
 203                 default:
 204                         TCU_FAIL("Can't map depth buffer format");
 205         }
 206 }
 207
 208 tcu::TextureFormat getStencilFormat (int stencilBits)
 209 {
 210         switch (stencilBits)
 211         {
 212                 case 8:         return tcu::TextureFormat(tcu::TextureFormat::S, tcu::TextureFormat::UNSIGNED_INT8);
 213                 case 16:        return tcu::TextureFormat(tcu::TextureFormat::S, tcu::TextureFormat::UNSIGNED_INT16);
 214                 case 24:        return tcu::TextureFormat(tcu::TextureFormat::S, tcu::TextureFormat::UNSIGNED_INT_24_8);
 215                 case 32:        return tcu::TextureFormat(tcu::TextureFormat::S, tcu::TextureFormat::UNSIGNED_INT32);
 216                 default:
 217                         TCU_FAIL("Can't map depth buffer format");
 218         }
 219 }
 220
 221 static inline tcu::IVec4 intersect (const tcu::IVec4& a, const tcu::IVec4& b)
 222 {
 223         int             x0      = de::max(a.x(), b.x());
 224         int             y0      = de::max(a.y(), b.y());
 225         int             x1      = de::min(a.x()+a.z(), b.x()+b.z());
 226         int             y1      = de::min(a.y()+a.w(), b.y()+b.w());
 227         int             w       = de::max(0, x1-x0);
 228         int             h       = de::max(0, y1-y0);
 229
 230         return tcu::IVec4(x0, y0, w, h);
 231 }
 232
 233 static inline tcu::IVec4 getBufferRect (const rr::MultisampleConstPixelBufferAccess& access)
 234 {
 235         return tcu::IVec4(0, 0, access.raw().getHeight(), access.raw().getDepth());
 236 }
 237
 238 ReferenceContextLimits::ReferenceContextLimits (const glu::RenderContext& renderCtx)
 239         : contextType                           (renderCtx.getType())
 240         , maxTextureImageUnits          (0)
 241         , maxTexture2DSize                      (0)
 242         , maxTextureCubeSize            (0)
 243         , maxTexture2DArrayLayers       (0)
 244         , maxTexture3DSize                      (0)
 245         , maxRenderbufferSize           (0)
 246         , maxVertexAttribs                      (0)
 247 {
 248         const glw::Functions& gl = renderCtx.getFunctions();
 249
 250         gl.getIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,              &maxTextureImageUnits);
 251         gl.getIntegerv(GL_MAX_TEXTURE_SIZE,                             &maxTexture2DSize);
 252         gl.getIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE,    &maxTextureCubeSize);
 253         gl.getIntegerv(GL_MAX_RENDERBUFFER_SIZE,                &maxRenderbufferSize);
 254         gl.getIntegerv(GL_MAX_VERTEX_ATTRIBS,                   &maxVertexAttribs);
 255
 256         if (contextSupports(contextType, glu::ApiType::es(3,0)) || glu::isContextTypeGLCore(contextType))
 257         {
 258                 gl.getIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS,     &maxTexture2DArrayLayers);
 259                 gl.getIntegerv(GL_MAX_3D_TEXTURE_SIZE,          &maxTexture3DSize);
 260         }
 261
 262         // Limit texture sizes to supported values
 263         maxTexture2DSize        = de::min(maxTexture2DSize,             (int)MAX_TEXTURE_SIZE);
 264         maxTextureCubeSize      = de::min(maxTextureCubeSize,   (int)MAX_TEXTURE_SIZE);
 265         maxTexture3DSize        = de::min(maxTexture3DSize,             (int)MAX_TEXTURE_SIZE);
 266
 267         GLU_EXPECT_NO_ERROR(gl.getError(), GL_NO_ERROR);
 268
 269         // \todo [pyry] Figure out following things:
 270         // + supported fbo configurations
 271         // ...
 272
 273         // \todo [2013-08-01 pyry] Do we want to make these conditional based on renderCtx?
 274         addExtension("GL_EXT_color_buffer_half_float");
 275         addExtension("GL_EXT_color_buffer_float");
 276
 277         if (contextSupports(contextType, glu::ApiType::es(3,1)))
 278                 addExtension("GL_EXT_texture_cube_map_array");
 279 }
 280
 281 void ReferenceContextLimits::addExtension (const char* extension)
 282 {
 283         extensionList.push_back(extension);
 284
 285         if (!extensionStr.empty())
 286                 extensionStr += " ";
 287         extensionStr += extension;
 288 }
 289
 290 ReferenceContextBuffers::ReferenceContextBuffers (const tcu::PixelFormat& colorBits, int depthBits, int stencilBits, int width, int height, int samples)
 291 {
 292         m_colorbuffer.setStorage(toTextureFormat(colorBits), samples, width, height);
 293
 294         if (depthBits > 0)
 295                 m_depthbuffer.setStorage(getDepthFormat(depthBits), samples, width, height);
 296
 297         if (stencilBits > 0)
 298                 m_stencilbuffer.setStorage(getStencilFormat(stencilBits), samples, width, height);
 299 }
 300
 301 ReferenceContext::StencilState::StencilState (void)
 302         : func                          (GL_ALWAYS)
 303         , ref                           (0)
 304         , opMask                        (~0u)
 305         , opStencilFail         (GL_KEEP)
 306         , opDepthFail           (GL_KEEP)
 307         , opDepthPass           (GL_KEEP)
 308         , writeMask                     (~0u)
 309 {
 310 }
 311
 312 ReferenceContext::ReferenceContext (const ReferenceContextLimits& limits, const rr::MultisamplePixelBufferAccess& colorbuffer, const rr::MultisamplePixelBufferAccess& depthbuffer, const rr::MultisamplePixelBufferAccess& stencilbuffer)
 313         : Context                                                       (limits.contextType)
 314         , m_limits                                                      (limits)
 315         , m_defaultColorbuffer                          (colorbuffer)
 316         , m_defaultDepthbuffer                          (depthbuffer)
 317         , m_defaultStencilbuffer                        (stencilbuffer)
 318         , m_clientVertexArray                           (0, m_limits.maxVertexAttribs)
 319
 320         , m_viewport                                            (0, 0, colorbuffer.raw().getHeight(), colorbuffer.raw().getDepth())
 321
 322         , m_activeTexture                                       (0)
 323         , m_textureUnits                                        (m_limits.maxTextureImageUnits)
 324         , m_emptyTex1D                                          ()
 325         , m_emptyTex2D                                          ()
 326         , m_emptyTexCube                                        ()
 327         , m_emptyTex2DArray                                     ()
 328         , m_emptyTex3D                                          ()
 329         , m_emptyTexCubeArray                           ()
 330
 331         , m_pixelUnpackRowLength                        (0)
 332         , m_pixelUnpackSkipRows                         (0)
 333         , m_pixelUnpackSkipPixels                       (0)
 334         , m_pixelUnpackImageHeight                      (0)
 335         , m_pixelUnpackSkipImages                       (0)
 336         , m_pixelUnpackAlignment                        (4)
 337         , m_pixelPackAlignment                          (4)
 338
 339         , m_readFramebufferBinding                      (DE_NULL)
 340         , m_drawFramebufferBinding                      (DE_NULL)
 341         , m_renderbufferBinding                         (DE_NULL)
 342         , m_vertexArrayBinding                          (DE_NULL)
 343         , m_currentProgram                                      (DE_NULL)
 344
 345         , m_arrayBufferBinding                          (DE_NULL)
 346         , m_pixelPackBufferBinding                      (DE_NULL)
 347         , m_pixelUnpackBufferBinding            (DE_NULL)
 348         , m_transformFeedbackBufferBinding      (DE_NULL)
 349         , m_uniformBufferBinding                        (DE_NULL)
 350         , m_copyReadBufferBinding                       (DE_NULL)
 351         , m_copyWriteBufferBinding                      (DE_NULL)
 352         , m_drawIndirectBufferBinding           (DE_NULL)
 353
 354         , m_clearColor                                          (0.0f, 0.0f, 0.0f, 0.0f)
 355         , m_clearDepth                                          (1.0f)
 356         , m_clearStencil                                        (0)
 357         , m_scissorEnabled                                      (false)
 358         , m_scissorBox                                          (m_viewport)
 359         , m_stencilTestEnabled                          (false)
 360         , m_depthTestEnabled                            (false)
 361         , m_depthFunc                                           (GL_LESS)
 362         , m_depthRangeNear                                      (0.0f)
 363         , m_depthRangeFar                                       (1.0f)
 364         , m_polygonOffsetFactor                         (0.0f)
 365         , m_polygonOffsetUnits                          (0.0f)
 366         , m_polygonOffsetFillEnabled            (false)
 367         , m_provokingFirstVertexConvention      (false)
 368         , m_blendEnabled                                        (false)
 369         , m_blendModeRGB                                        (GL_FUNC_ADD)
 370         , m_blendModeAlpha                                      (GL_FUNC_ADD)
 371         , m_blendFactorSrcRGB                           (GL_ONE)
 372         , m_blendFactorDstRGB                           (GL_ZERO)
 373         , m_blendFactorSrcAlpha                         (GL_ONE)
 374         , m_blendFactorDstAlpha                         (GL_ZERO)
 375         , m_blendColor                                          (0.0f, 0.0f, 0.0f, 0.0f)
 376         , m_sRGBUpdateEnabled                           (true)
 377         , m_depthClampEnabled                           (false)
 378         , m_colorMask                                           (true, true, true, true)
 379         , m_depthMask                                           (true)
 380         , m_currentAttribs                                      (m_limits.maxVertexAttribs, rr::GenericVec4(tcu::Vec4(0, 0, 0, 1)))
 381         , m_lineWidth                                           (1.0f)
 382         , m_primitiveRestartFixedIndex          (false)
 383         , m_primitiveRestartSettableIndex       (false)
 384         , m_primitiveRestartIndex                       (0)
 385
 386         , m_lastError                                           (GL_NO_ERROR)
 387 {
 388         // Create empty textures to be used when texture objects are incomplete.
 389         m_emptyTex1D.getSampler().wrapS         = tcu::Sampler::CLAMP_TO_EDGE;
 390         m_emptyTex1D.getSampler().wrapT         = tcu::Sampler::CLAMP_TO_EDGE;
 391         m_emptyTex1D.getSampler().minFilter     = tcu::Sampler::NEAREST;
 392         m_emptyTex1D.getSampler().magFilter     = tcu::Sampler::NEAREST;
 393         m_emptyTex1D.allocLevel(0, tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), 1);
 394         m_emptyTex1D.getLevel(0).setPixel(Vec4(0.0f, 0.0f, 0.0f, 1.0f), 0, 0);
 395         m_emptyTex1D.updateView(tcu::Sampler::MODE_LAST);
 396
 397         m_emptyTex2D.getSampler().wrapS         = tcu::Sampler::CLAMP_TO_EDGE;
 398         m_emptyTex2D.getSampler().wrapT         = tcu::Sampler::CLAMP_TO_EDGE;
 399         m_emptyTex2D.getSampler().minFilter     = tcu::Sampler::NEAREST;
 400         m_emptyTex2D.getSampler().magFilter     = tcu::Sampler::NEAREST;
 401         m_emptyTex2D.allocLevel(0, tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), 1, 1);
 402         m_emptyTex2D.getLevel(0).setPixel(Vec4(0.0f, 0.0f, 0.0f, 1.0f), 0, 0);
 403         m_emptyTex2D.updateView(tcu::Sampler::MODE_LAST);
 404
 405         m_emptyTexCube.getSampler().wrapS               = tcu::Sampler::CLAMP_TO_EDGE;
 406         m_emptyTexCube.getSampler().wrapT               = tcu::Sampler::CLAMP_TO_EDGE;
 407         m_emptyTexCube.getSampler().minFilter   = tcu::Sampler::NEAREST;
 408         m_emptyTexCube.getSampler().magFilter   = tcu::Sampler::NEAREST;
 409         for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
 410         {
 411                 m_emptyTexCube.allocFace(0, (tcu::CubeFace)face, tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), 1, 1);
 412                 m_emptyTexCube.getFace(0, (tcu::CubeFace)face).setPixel(Vec4(0.0f, 0.0f, 0.0f, 1.0f), 0, 0);
 413         }
 414         m_emptyTexCube.updateView(tcu::Sampler::MODE_LAST);
 415
 416         m_emptyTex2DArray.getSampler().wrapS            = tcu::Sampler::CLAMP_TO_EDGE;
 417         m_emptyTex2DArray.getSampler().wrapT            = tcu::Sampler::CLAMP_TO_EDGE;
 418         m_emptyTex2DArray.getSampler().minFilter        = tcu::Sampler::NEAREST;
 419         m_emptyTex2DArray.getSampler().magFilter        = tcu::Sampler::NEAREST;
 420         m_emptyTex2DArray.allocLevel(0, tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), 1, 1, 1);
 421         m_emptyTex2DArray.getLevel(0).setPixel(Vec4(0.0f, 0.0f, 0.0f, 1.0f), 0, 0);
 422         m_emptyTex2DArray.updateView(tcu::Sampler::MODE_LAST);
 423
 424         m_emptyTex3D.getSampler().wrapS         = tcu::Sampler::CLAMP_TO_EDGE;
 425         m_emptyTex3D.getSampler().wrapT         = tcu::Sampler::CLAMP_TO_EDGE;
 426         m_emptyTex3D.getSampler().wrapR         = tcu::Sampler::CLAMP_TO_EDGE;
 427         m_emptyTex3D.getSampler().minFilter     = tcu::Sampler::NEAREST;
 428         m_emptyTex3D.getSampler().magFilter     = tcu::Sampler::NEAREST;
 429         m_emptyTex3D.allocLevel(0, tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), 1, 1, 1);
 430         m_emptyTex3D.getLevel(0).setPixel(Vec4(0.0f, 0.0f, 0.0f, 1.0f), 0, 0);
 431         m_emptyTex3D.updateView(tcu::Sampler::MODE_LAST);
 432
 433         m_emptyTexCubeArray.getSampler().wrapS          = tcu::Sampler::CLAMP_TO_EDGE;
 434         m_emptyTexCubeArray.getSampler().wrapT          = tcu::Sampler::CLAMP_TO_EDGE;
 435         m_emptyTexCubeArray.getSampler().minFilter      = tcu::Sampler::NEAREST;
 436         m_emptyTexCubeArray.getSampler().magFilter      = tcu::Sampler::NEAREST;
 437         m_emptyTexCubeArray.allocLevel(0, tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), 1, 1, 6);
 438         for (int faceNdx = 0; faceNdx < 6; faceNdx++)
 439                 m_emptyTexCubeArray.getLevel(0).setPixel(Vec4(0.0f, 0.0f, 0.0f, 1.0f), 0, 0, faceNdx);
 440         m_emptyTexCubeArray.updateView(tcu::Sampler::MODE_LAST);
 441
 442         if (glu::isContextTypeGLCore(getType()))
 443                 m_sRGBUpdateEnabled = false;
 444 }
 445
 446 ReferenceContext::~ReferenceContext (void)
 447 {
 448         // Destroy all objects -- verifies that ref counting works
 449         {
 450                 vector<VertexArray*> vertexArrays;
 451                 m_vertexArrays.getAll(vertexArrays);
 452                 for (vector<VertexArray*>::iterator i = vertexArrays.begin(); i != vertexArrays.end(); i++)
 453                         deleteVertexArray(*i);
 454
 455                 DE_ASSERT(m_clientVertexArray.getRefCount() == 1);
 456         }
 457
 458         {
 459                 vector<Texture*> textures;
 460                 m_textures.getAll(textures);
 461                 for (vector<Texture*>::iterator i = textures.begin(); i != textures.end(); i++)
 462                         deleteTexture(*i);
 463         }
 464
 465         {
 466                 vector<Framebuffer*> framebuffers;
 467                 m_framebuffers.getAll(framebuffers);
 468                 for (vector<Framebuffer*>::iterator i = framebuffers.begin(); i != framebuffers.end(); i++)
 469                         deleteFramebuffer(*i);
 470         }
 471
 472         {
 473                 vector<Renderbuffer*> renderbuffers;
 474                 m_renderbuffers.getAll(renderbuffers);
 475                 for (vector<Renderbuffer*>::iterator i = renderbuffers.begin(); i != renderbuffers.end(); i++)
 476                         deleteRenderbuffer(*i);
 477         }
 478
 479         {
 480                 vector<DataBuffer*> buffers;
 481                 m_buffers.getAll(buffers);
 482                 for (vector<DataBuffer*>::iterator i = buffers.begin(); i != buffers.end(); i++)
 483                         deleteBuffer(*i);
 484         }
 485
 486         {
 487                 vector<ShaderProgramObjectContainer*> programs;
 488                 m_programs.getAll(programs);
 489                 for (vector<ShaderProgramObjectContainer*>::iterator i = programs.begin(); i != programs.end(); i++)
 490                         deleteProgramObject(*i);
 491         }
 492 }
 493
 494 void ReferenceContext::activeTexture (deUint32 texture)
 495 {
 496         if (deInBounds32(texture, GL_TEXTURE0, GL_TEXTURE0 + (deUint32)m_textureUnits.size()))
 497                 m_activeTexture = texture - GL_TEXTURE0;
 498         else
 499                 setError(GL_INVALID_ENUM);
 500 }
 501
 502 void ReferenceContext::setTex1DBinding (int unitNdx, Texture1D* texture)
 503 {
 504         if (m_textureUnits[unitNdx].tex1DBinding)
 505         {
 506                 m_textures.releaseReference(m_textureUnits[unitNdx].tex1DBinding);
 507                 m_textureUnits[unitNdx].tex1DBinding = DE_NULL;
 508         }
 509
 510         if (texture)
 511         {
 512                 m_textures.acquireReference(texture);
 513                 m_textureUnits[unitNdx].tex1DBinding = texture;
 514         }
 515 }
 516
 517 void ReferenceContext::setTex2DBinding (int unitNdx, Texture2D* texture)
 518 {
 519         if (m_textureUnits[unitNdx].tex2DBinding)
 520         {
 521                 m_textures.releaseReference(m_textureUnits[unitNdx].tex2DBinding);
 522                 m_textureUnits[unitNdx].tex2DBinding = DE_NULL;
 523         }
 524
 525         if (texture)
 526         {
 527                 m_textures.acquireReference(texture);
 528                 m_textureUnits[unitNdx].tex2DBinding = texture;
 529         }
 530 }
 531
 532 void ReferenceContext::setTexCubeBinding (int unitNdx, TextureCube* texture)
 533 {
 534         if (m_textureUnits[unitNdx].texCubeBinding)
 535         {
 536                 m_textures.releaseReference(m_textureUnits[unitNdx].texCubeBinding);
 537                 m_textureUnits[unitNdx].texCubeBinding = DE_NULL;
 538         }
 539
 540         if (texture)
 541         {
 542                 m_textures.acquireReference(texture);
 543                 m_textureUnits[unitNdx].texCubeBinding = texture;
 544         }
 545 }
 546
 547 void ReferenceContext::setTex2DArrayBinding (int unitNdx, Texture2DArray* texture)
 548 {
 549         if (m_textureUnits[unitNdx].tex2DArrayBinding)
 550         {
 551                 m_textures.releaseReference(m_textureUnits[unitNdx].tex2DArrayBinding);
 552                 m_textureUnits[unitNdx].tex2DArrayBinding = DE_NULL;
 553         }
 554
 555         if (texture)
 556         {
 557                 m_textures.acquireReference(texture);
 558                 m_textureUnits[unitNdx].tex2DArrayBinding = texture;
 559         }
 560 }
 561
 562 void ReferenceContext::setTex3DBinding (int unitNdx, Texture3D* texture)
 563 {
 564         if (m_textureUnits[unitNdx].tex3DBinding)
 565         {
 566                 m_textures.releaseReference(m_textureUnits[unitNdx].tex3DBinding);
 567                 m_textureUnits[unitNdx].tex3DBinding = DE_NULL;
 568         }
 569
 570         if (texture)
 571         {
 572                 m_textures.acquireReference(texture);
 573                 m_textureUnits[unitNdx].tex3DBinding = texture;
 574         }
 575 }
 576
 577 void ReferenceContext::setTexCubeArrayBinding (int unitNdx, TextureCubeArray* texture)
 578 {
 579         if (m_textureUnits[unitNdx].texCubeArrayBinding)
 580         {
 581                 m_textures.releaseReference(m_textureUnits[unitNdx].texCubeArrayBinding);
 582                 m_textureUnits[unitNdx].texCubeArrayBinding = DE_NULL;
 583         }
 584
 585         if (texture)
 586         {
 587                 m_textures.acquireReference(texture);
 588                 m_textureUnits[unitNdx].texCubeArrayBinding = texture;
 589         }
 590 }
 591
 592 void ReferenceContext::bindTexture (deUint32 target, deUint32 texture)
 593 {
 594         int unitNdx = m_activeTexture;
 595
 596         RC_IF_ERROR(target != GL_TEXTURE_1D                             &&
 597                                 target != GL_TEXTURE_2D                         &&
 598                                 target != GL_TEXTURE_CUBE_MAP           &&
 599                                 target != GL_TEXTURE_2D_ARRAY           &&
 600                                 target != GL_TEXTURE_3D                         &&
 601                                 target != GL_TEXTURE_CUBE_MAP_ARRAY,
 602                                 GL_INVALID_ENUM, RC_RET_VOID);
 603
 604         RC_IF_ERROR(glu::isContextTypeES(m_limits.contextType) && (target == GL_TEXTURE_1D), GL_INVALID_ENUM, RC_RET_VOID);
 605
 606         if (texture == 0)
 607         {
 608                 // Clear binding.
 609                 switch (target)
 610                 {
 611                         case GL_TEXTURE_1D:                             setTex1DBinding                 (unitNdx, DE_NULL);     break;
 612                         case GL_TEXTURE_2D:                             setTex2DBinding                 (unitNdx, DE_NULL);     break;
 613                         case GL_TEXTURE_CUBE_MAP:               setTexCubeBinding               (unitNdx, DE_NULL);     break;
 614                         case GL_TEXTURE_2D_ARRAY:               setTex2DArrayBinding    (unitNdx, DE_NULL);     break;
 615                         case GL_TEXTURE_3D:                             setTex3DBinding                 (unitNdx, DE_NULL);     break;
 616                         case GL_TEXTURE_CUBE_MAP_ARRAY: setTexCubeArrayBinding  (unitNdx, DE_NULL);     break;
 617                         default:
 618                                 DE_ASSERT(false);
 619                 }
 620         }
 621         else
 622         {
 623                 Texture* texObj = m_textures.find(texture);
 624
 625                 if (texObj)
 626                 {
 627                         // Validate type.
 628                         Texture::Type expectedType = Texture::TYPE_LAST;
 629                         switch (target)
 630                         {
 631                                 case GL_TEXTURE_1D:                             expectedType = Texture::TYPE_1D;                                break;
 632                                 case GL_TEXTURE_2D:                             expectedType = Texture::TYPE_2D;                                break;
 633                                 case GL_TEXTURE_CUBE_MAP:               expectedType = Texture::TYPE_CUBE_MAP;                  break;
 634                                 case GL_TEXTURE_2D_ARRAY:               expectedType = Texture::TYPE_2D_ARRAY;                  break;
 635                                 case GL_TEXTURE_3D:                             expectedType = Texture::TYPE_3D;                                break;
 636                                 case GL_TEXTURE_CUBE_MAP_ARRAY: expectedType = Texture::TYPE_CUBE_MAP_ARRAY;    break;
 637                                 default:
 638                                         DE_ASSERT(false);
 639                         }
 640                         RC_IF_ERROR(texObj->getType() != expectedType, GL_INVALID_OPERATION, RC_RET_VOID);
 641                 }
 642                 else
 643                 {
 644                         // New texture object.
 645                         switch (target)
 646                         {
 647                                 case GL_TEXTURE_1D:                             texObj = new Texture1D                  (texture);      break;
 648                                 case GL_TEXTURE_2D:                             texObj = new Texture2D                  (texture);      break;
 649                                 case GL_TEXTURE_CUBE_MAP:               texObj = new TextureCube                (texture);      break;
 650                                 case GL_TEXTURE_2D_ARRAY:               texObj = new Texture2DArray             (texture);      break;
 651                                 case GL_TEXTURE_3D:                             texObj = new Texture3D                  (texture);      break;
 652                                 case GL_TEXTURE_CUBE_MAP_ARRAY: texObj = new TextureCubeArray   (texture);      break;
 653                                 default:
 654                                         DE_ASSERT(false);
 655                         }
 656
 657                         m_textures.insert(texObj);
 658                 }
 659
 660                 switch (target)
 661                 {
 662                         case GL_TEXTURE_1D:                             setTex1DBinding                 (unitNdx, static_cast<Texture1D*>                       (texObj));      break;
 663                         case GL_TEXTURE_2D:                             setTex2DBinding                 (unitNdx, static_cast<Texture2D*>                       (texObj));      break;
 664                         case GL_TEXTURE_CUBE_MAP:               setTexCubeBinding               (unitNdx, static_cast<TextureCube*>                     (texObj));      break;
 665                         case GL_TEXTURE_2D_ARRAY:               setTex2DArrayBinding    (unitNdx, static_cast<Texture2DArray*>          (texObj));      break;
 666                         case GL_TEXTURE_3D:                             setTex3DBinding                 (unitNdx, static_cast<Texture3D*>                       (texObj));      break;
 667                         case GL_TEXTURE_CUBE_MAP_ARRAY: setTexCubeArrayBinding  (unitNdx, static_cast<TextureCubeArray*>        (texObj));      break;
 668                         default:
 669                                 DE_ASSERT(false);
 670                 }
 671         }
 672 }
 673
 674 void ReferenceContext::genTextures (int numTextures, deUint32* textures)
 675 {
 676         while (numTextures--)
 677                 *textures++ = m_textures.allocateName();
 678 }
 679
 680 void ReferenceContext::deleteTextures (int numTextures, const deUint32* textures)
 681 {
 682         for (int i = 0; i < numTextures; i++)
 683         {
 684                 deUint32        name            = textures[i];
 685                 Texture*        texture         = name ? m_textures.find(name) : DE_NULL;
 686
 687                 if (texture)
 688                         deleteTexture(texture);
 689         }
 690 }
 691
 692 void ReferenceContext::deleteTexture (Texture* texture)
 693 {
 694         // Unbind from context
 695         for (int unitNdx = 0; unitNdx < (int)m_textureUnits.size(); unitNdx++)
 696         {
 697                 if (m_textureUnits[unitNdx].tex1DBinding                                == texture)     setTex1DBinding                 (unitNdx, DE_NULL);
 698                 else if (m_textureUnits[unitNdx].tex2DBinding                   == texture)     setTex2DBinding                 (unitNdx, DE_NULL);
 699                 else if (m_textureUnits[unitNdx].texCubeBinding                 == texture)     setTexCubeBinding               (unitNdx, DE_NULL);
 700                 else if (m_textureUnits[unitNdx].tex2DArrayBinding              == texture)     setTex2DArrayBinding    (unitNdx, DE_NULL);
 701                 else if (m_textureUnits[unitNdx].tex3DBinding                   == texture)     setTex3DBinding                 (unitNdx, DE_NULL);
 702                 else if (m_textureUnits[unitNdx].texCubeArrayBinding    == texture)     setTexCubeArrayBinding  (unitNdx, DE_NULL);
 703         }
 704
 705         // Unbind from currently bound framebuffers
 706         for (int ndx = 0; ndx < 2; ndx++)
 707         {
 708                 rc::Framebuffer* framebufferBinding = ndx ? m_drawFramebufferBinding : m_readFramebufferBinding;
 709                 if (framebufferBinding)
 710                 {
 711                         int releaseRefCount = (framebufferBinding == m_drawFramebufferBinding ? 1 : 0)
 712                                                                 + (framebufferBinding == m_readFramebufferBinding ? 1 : 0);
 713
 714                         for (int point = 0; point < Framebuffer::ATTACHMENTPOINT_LAST; point++)
 715                         {
 716                                 Framebuffer::Attachment& attachment = framebufferBinding->getAttachment((Framebuffer::AttachmentPoint)point);
 717                                 if (attachment.name == texture->getName())
 718                                 {
 719                                         for (int refNdx = 0; refNdx < releaseRefCount; refNdx++)
 720                                                 releaseFboAttachmentReference(attachment);
 721                                         attachment = Framebuffer::Attachment();
 722                                 }
 723                         }
 724                 }
 725         }
 726
 727         DE_ASSERT(texture->getRefCount() == 1);
 728         m_textures.releaseReference(texture);
 729 }
 730
 731 void ReferenceContext::bindFramebuffer (deUint32 target, deUint32 name)
 732 {
 733         Framebuffer* fbo = DE_NULL;
 734
 735         RC_IF_ERROR(target != GL_FRAMEBUFFER            &&
 736                                 target != GL_DRAW_FRAMEBUFFER   &&
 737                                 target != GL_READ_FRAMEBUFFER, GL_INVALID_ENUM, RC_RET_VOID);
 738
 739         if (name != 0)
 740         {
 741                 // Find or create framebuffer object.
 742                 fbo = m_framebuffers.find(name);
 743                 if (!fbo)
 744                 {
 745                         fbo = new Framebuffer(name);
 746                         m_framebuffers.insert(fbo);
 747                 }
 748         }
 749
 750         for (int ndx = 0; ndx < 2; ndx++)
 751         {
 752                 deUint32                        bindingTarget   = ndx ? GL_DRAW_FRAMEBUFFER                     : GL_READ_FRAMEBUFFER;
 753                 rc::Framebuffer*&       binding                 = ndx ? m_drawFramebufferBinding        : m_readFramebufferBinding;
 754
 755                 if (target != GL_FRAMEBUFFER && target != bindingTarget)
 756                         continue; // Doesn't match this target.
 757
 758                 // Remove old references
 759                 if (binding)
 760                 {
 761                         // Clear all attachment point references
 762                         for (int point = 0; point < Framebuffer::ATTACHMENTPOINT_LAST; point++)
 763                                 releaseFboAttachmentReference(binding->getAttachment((Framebuffer::AttachmentPoint)point));
 764
 765                         m_framebuffers.releaseReference(binding);
 766                 }
 767
 768                 // Create new references
 769                 if (fbo)
 770                 {
 771                         m_framebuffers.acquireReference(fbo);
 772
 773                         for (int point = 0; point < Framebuffer::ATTACHMENTPOINT_LAST; point++)
 774                                 acquireFboAttachmentReference(fbo->getAttachment((Framebuffer::AttachmentPoint)point));
 775                 }
 776
 777                 binding = fbo;
 778         }
 779 }
 780
 781 void ReferenceContext::genFramebuffers (int numFramebuffers, deUint32* framebuffers)
 782 {
 783         while (numFramebuffers--)
 784                 *framebuffers++ = m_framebuffers.allocateName();
 785 }
 786
 787 void ReferenceContext::deleteFramebuffer (Framebuffer* framebuffer)
 788 {
 789         // Remove bindings.
 790         if (m_drawFramebufferBinding == framebuffer) bindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
 791         if (m_readFramebufferBinding == framebuffer) bindFramebuffer(GL_READ_FRAMEBUFFER, 0);
 792
 793         DE_ASSERT(framebuffer->getRefCount() == 1);
 794         m_framebuffers.releaseReference(framebuffer);
 795 }
 796
 797 void ReferenceContext::deleteFramebuffers (int numFramebuffers, const deUint32* framebuffers)
 798 {
 799         for (int i = 0; i < numFramebuffers; i++)
 800         {
 801                 deUint32                name            = framebuffers[i];
 802                 Framebuffer*    framebuffer     = name ? m_framebuffers.find(name) : DE_NULL;
 803
 804                 if (framebuffer)
 805                         deleteFramebuffer(framebuffer);
 806         }
 807 }
 808
 809 void ReferenceContext::bindRenderbuffer (deUint32 target, deUint32 name)
 810 {
 811         Renderbuffer* rbo = DE_NULL;
 812
 813         RC_IF_ERROR(target != GL_RENDERBUFFER, GL_INVALID_ENUM, RC_RET_VOID);
 814
 815         if (name != 0)
 816         {
 817                 rbo = m_renderbuffers.find(name);
 818                 if (!rbo)
 819                 {
 820                         rbo = new Renderbuffer(name);
 821                         m_renderbuffers.insert(rbo);
 822                 }
 823         }
 824
 825         // Remove old reference
 826         if (m_renderbufferBinding)
 827                 m_renderbuffers.releaseReference(m_renderbufferBinding);
 828
 829         // Create new reference
 830         if (rbo)
 831                 m_renderbuffers.acquireReference(rbo);
 832
 833         m_renderbufferBinding = rbo;
 834 }
 835
 836 void ReferenceContext::genRenderbuffers (int numRenderbuffers, deUint32* renderbuffers)
 837 {
 838         while (numRenderbuffers--)
 839                 *renderbuffers++ = m_renderbuffers.allocateName();
 840 }
 841
 842 void ReferenceContext::deleteRenderbuffer (Renderbuffer* renderbuffer)
 843 {
 844         if (m_renderbufferBinding == renderbuffer)
 845                 bindRenderbuffer(GL_RENDERBUFFER, 0);
 846
 847         // Unbind from currently bound framebuffers
 848         for (int ndx = 0; ndx < 2; ndx++)
 849         {
 850                 rc::Framebuffer* framebufferBinding = ndx ? m_drawFramebufferBinding : m_readFramebufferBinding;
 851                 if (framebufferBinding)
 852                 {
 853                         int releaseRefCount = (framebufferBinding == m_drawFramebufferBinding ? 1 : 0)
 854                                                                 + (framebufferBinding == m_readFramebufferBinding ? 1 : 0);
 855
 856                         for (int point = 0; point < Framebuffer::ATTACHMENTPOINT_LAST; point++)
 857                         {
 858                                 Framebuffer::Attachment& attachment = framebufferBinding->getAttachment((Framebuffer::AttachmentPoint)point);
 859                                 if (attachment.name == renderbuffer->getName())
 860                                 {
 861                                         for (int refNdx = 0; refNdx < releaseRefCount; refNdx++)
 862                                                 releaseFboAttachmentReference(attachment);
 863                                         attachment = Framebuffer::Attachment();
 864                                 }
 865                         }
 866                 }
 867         }
 868
 869         DE_ASSERT(renderbuffer->getRefCount() == 1);
 870         m_renderbuffers.releaseReference(renderbuffer);
 871 }
 872
 873 void ReferenceContext::deleteRenderbuffers (int numRenderbuffers, const deUint32* renderbuffers)
 874 {
 875         for (int i = 0; i < numRenderbuffers; i++)
 876         {
 877                 deUint32                name                    = renderbuffers[i];
 878                 Renderbuffer*   renderbuffer    = name ? m_renderbuffers.find(name) : DE_NULL;
 879
 880                 if (renderbuffer)
 881                         deleteRenderbuffer(renderbuffer);
 882         }
 883 }
 884
 885 void ReferenceContext::pixelStorei (deUint32 pname, int param)
 886 {
 887         switch (pname)
 888         {
 889                 case GL_UNPACK_ALIGNMENT:
 890                         RC_IF_ERROR(param != 1 && param != 2 && param != 4 && param != 8, GL_INVALID_VALUE, RC_RET_VOID);
 891                         m_pixelUnpackAlignment = param;
 892                         break;
 893
 894                 case GL_PACK_ALIGNMENT:
 895                         RC_IF_ERROR(param != 1 && param != 2 && param != 4 && param != 8, GL_INVALID_VALUE, RC_RET_VOID);
 896                         m_pixelPackAlignment = param;
 897                         break;
 898
 899                 case GL_UNPACK_ROW_LENGTH:
 900                         RC_IF_ERROR(param < 0, GL_INVALID_VALUE, RC_RET_VOID);
 901                         m_pixelUnpackRowLength = param;
 902                         break;
 903
 904                 case GL_UNPACK_SKIP_ROWS:
 905                         RC_IF_ERROR(param < 0, GL_INVALID_VALUE, RC_RET_VOID);
 906                         m_pixelUnpackSkipRows = param;
 907                         break;
 908
 909                 case GL_UNPACK_SKIP_PIXELS:
 910                         RC_IF_ERROR(param < 0, GL_INVALID_VALUE, RC_RET_VOID);
 911                         m_pixelUnpackSkipPixels = param;
 912                         break;
 913
 914                 case GL_UNPACK_IMAGE_HEIGHT:
 915                         RC_IF_ERROR(param < 0, GL_INVALID_VALUE, RC_RET_VOID);
 916                         m_pixelUnpackImageHeight = param;
 917                         break;
 918
 919                 case GL_UNPACK_SKIP_IMAGES:
 920                         RC_IF_ERROR(param < 0, GL_INVALID_VALUE, RC_RET_VOID);
 921                         m_pixelUnpackSkipImages = param;
 922                         break;
 923
 924                 default:
 925                         setError(GL_INVALID_ENUM);
 926         }
 927 }
 928
 929 tcu::ConstPixelBufferAccess ReferenceContext::getUnpack2DAccess (const tcu::TextureFormat& format, int width, int height, const void* data)
 930 {
 931         int                             pixelSize       = format.getPixelSize();
 932         int                             rowLen          = m_pixelUnpackRowLength > 0 ? m_pixelUnpackRowLength : width;
 933         int                             rowPitch        = deAlign32(rowLen*pixelSize, m_pixelUnpackAlignment);
 934         const deUint8*  ptr                     = (const deUint8*)data + m_pixelUnpackSkipRows*rowPitch + m_pixelUnpackSkipPixels*pixelSize;
 935
 936         return tcu::ConstPixelBufferAccess(format, width, height, 1, rowPitch, 0, ptr);
 937 }
 938
 939 tcu::ConstPixelBufferAccess ReferenceContext::getUnpack3DAccess (const tcu::TextureFormat& format, int width, int height, int depth, const void* data)
 940 {
 941         int                             pixelSize       = format.getPixelSize();
 942         int                             rowLen          = m_pixelUnpackRowLength        > 0 ? m_pixelUnpackRowLength    : width;
 943         int                             imageHeight     = m_pixelUnpackImageHeight      > 0 ? m_pixelUnpackImageHeight  : height;
 944         int                             rowPitch        = deAlign32(rowLen*pixelSize, m_pixelUnpackAlignment);
 945         int                             slicePitch      = imageHeight*rowPitch;
 946         const deUint8*  ptr                     = (const deUint8*)data + m_pixelUnpackSkipImages*slicePitch + m_pixelUnpackSkipRows*rowPitch + m_pixelUnpackSkipPixels*pixelSize;
 947
 948         return tcu::ConstPixelBufferAccess(format, width, height, depth, rowPitch, slicePitch, ptr);
 949 }
 950
 951 static tcu::TextureFormat mapInternalFormat (deUint32 internalFormat)
 952 {
 953         switch (internalFormat)
 954         {
 955                 case GL_ALPHA:                          return TextureFormat(TextureFormat::A,          TextureFormat::UNORM_INT8);
 956                 case GL_LUMINANCE:                      return TextureFormat(TextureFormat::L,          TextureFormat::UNORM_INT8);
 957                 case GL_LUMINANCE_ALPHA:        return TextureFormat(TextureFormat::LA,         TextureFormat::UNORM_INT8);
 958                 case GL_RGB:                            return TextureFormat(TextureFormat::RGB,        TextureFormat::UNORM_INT8);
 959                 case GL_RGBA:                           return TextureFormat(TextureFormat::RGBA,       TextureFormat::UNORM_INT8);
 960
 961                 default:
 962                         return glu::mapGLInternalFormat(internalFormat);
 963         }
 964 }
 965
 966 static void depthValueFloatClampCopy (const PixelBufferAccess& dst, const ConstPixelBufferAccess& src)
 967 {
 968         int width       = dst.getWidth();
 969         int height      = dst.getHeight();
 970         int depth       = dst.getDepth();
 971
 972         DE_ASSERT(src.getWidth() == width && src.getHeight() == height && src.getDepth() == depth);
 973
 974         // clamping copy
 975
 976         if (src.getFormat().order == tcu::TextureFormat::DS && dst.getFormat().order == tcu::TextureFormat::DS)
 977         {
 978                 // copy only depth and stencil
 979                 for (int z = 0; z < depth; z++)
 980                 for (int y = 0; y < height; y++)
 981                 for (int x = 0; x < width; x++)
 982                 {
 983                         dst.setPixDepth(de::clamp(src.getPixDepth(x, y, z), 0.0f, 1.0f), x, y, z);
 984                         dst.setPixStencil(src.getPixStencil(x, y, z), x, y, z);
 985                 }
 986         }
 987         else
 988         {
 989                 // copy only depth
 990                 for (int z = 0; z < depth; z++)
 991                 for (int y = 0; y < height; y++)
 992                 for (int x = 0; x < width; x++)
 993                         dst.setPixDepth(de::clamp(src.getPixDepth(x, y, z), 0.0f, 1.0f), x, y, z);
 994         }
 995 }
 996
 997 void ReferenceContext::texImage1D (deUint32 target, int level, deUint32 internalFormat, int width, int border, deUint32 format, deUint32 type, const void* data)
 998 {
 999         texImage2D(target, level, internalFormat, width, 1, border, format, type, data);
1000 }
1001
1002 void ReferenceContext::texImage2D (deUint32 target, int level, deUint32 internalFormat, int width, int height, int border, deUint32 format, deUint32 type, const void* data)
1003 {
1004         texImage3D(target, level, internalFormat, width, height, 1, border, format, type, data);
1005 }
1006
1007 static void clearToTextureInitialValue (PixelBufferAccess access)
1008 {
1009         const bool hasDepth             = access.getFormat().order == tcu::TextureFormat::D || access.getFormat().order == tcu::TextureFormat::DS;
1010         const bool hasStencil   = access.getFormat().order == tcu::TextureFormat::S || access.getFormat().order == tcu::TextureFormat::DS;
1011         const bool hasColor             = !hasDepth && !hasStencil;
1012
1013         if (hasDepth)
1014                 tcu::clearDepth(access, 0.0f);
1015         if (hasStencil)
1016                 tcu::clearStencil(access, 0u);
1017         if (hasColor)
1018                 tcu::clear(access, Vec4(0.0f, 0.0f, 0.0f, 1.0f));
1019 }
1020
1021 void ReferenceContext::texImage3D (deUint32 target, int level, deUint32 internalFormat, int width, int height, int depth, int border, deUint32 format, deUint32 type, const void* data)
1022 {
1023         TextureUnit&            unit                                    = m_textureUnits[m_activeTexture];
1024         const void*                     unpackPtr                               = getPixelUnpackPtr(data);
1025         const bool                      isDstFloatDepthFormat   = (internalFormat == GL_DEPTH_COMPONENT32F || internalFormat == GL_DEPTH32F_STENCIL8); // depth components are limited to [0,1] range
1026         TextureFormat           storageFmt;
1027         TextureFormat           transferFmt;
1028
1029         RC_IF_ERROR(border != 0, GL_INVALID_VALUE, RC_RET_VOID);
1030         RC_IF_ERROR(width < 0 || height < 0 || depth < 0 || level < 0, GL_INVALID_VALUE, RC_RET_VOID);
1031
1032         // Map storage format.
1033         storageFmt = mapInternalFormat(internalFormat);
1034         RC_IF_ERROR(storageFmt.order    == TextureFormat::CHANNELORDER_LAST ||
1035                                 storageFmt.type         == TextureFormat::CHANNELTYPE_LAST, GL_INVALID_ENUM, RC_RET_VOID);
1036
1037         // Map transfer format.
1038         transferFmt = glu::mapGLTransferFormat(format, type);
1039         RC_IF_ERROR(transferFmt.order   == TextureFormat::CHANNELORDER_LAST ||
1040                                 transferFmt.type        == TextureFormat::CHANNELTYPE_LAST, GL_INVALID_ENUM, RC_RET_VOID);
1041
1042         if (target == GL_TEXTURE_1D && glu::isContextTypeGLCore(m_limits.contextType))
1043         {
1044                 // Validate size and level.
1045                 RC_IF_ERROR(width > m_limits.maxTexture2DSize || height != 1 || depth != 1, GL_INVALID_VALUE, RC_RET_VOID);
1046                 RC_IF_ERROR(level > deLog2Floor32(m_limits.maxTexture2DSize), GL_INVALID_VALUE, RC_RET_VOID);
1047
1048                 Texture1D* texture = unit.tex1DBinding ? unit.tex1DBinding : &unit.default1DTex;
1049
1050                 if (texture->isImmutable())
1051                 {
1052                         RC_IF_ERROR(!texture->hasLevel(level), GL_INVALID_OPERATION, RC_RET_VOID);
1053
1054                         ConstPixelBufferAccess dst(texture->getLevel(level));
1055                         RC_IF_ERROR(storageFmt  != dst.getFormat()      ||
1056                                                 width           != dst.getWidth(), GL_INVALID_OPERATION, RC_RET_VOID);
1057                 }
1058                 else
1059                         texture->allocLevel(level, storageFmt, width);
1060
1061                 if (unpackPtr)
1062                 {
1063                         ConstPixelBufferAccess  src             = getUnpack2DAccess(transferFmt, width, 1, unpackPtr);
1064                         PixelBufferAccess               dst             (texture->getLevel(level));
1065
1066                         if (isDstFloatDepthFormat)
1067                                 depthValueFloatClampCopy(dst, src);
1068                         else
1069                                 tcu::copy(dst, src);
1070                 }
1071                 else
1072                 {
1073                         // No data supplied, clear to initial
1074                         clearToTextureInitialValue(texture->getLevel(level));
1075                 }
1076         }
1077         else if (target == GL_TEXTURE_2D)
1078         {
1079                 // Validate size and level.
1080                 RC_IF_ERROR(width > m_limits.maxTexture2DSize || height > m_limits.maxTexture2DSize || depth != 1, GL_INVALID_VALUE, RC_RET_VOID);
1081                 RC_IF_ERROR(level > deLog2Floor32(m_limits.maxTexture2DSize), GL_INVALID_VALUE, RC_RET_VOID);
1082
1083                 Texture2D* texture = unit.tex2DBinding ? unit.tex2DBinding : &unit.default2DTex;
1084
1085                 if (texture->isImmutable())
1086                 {
1087                         RC_IF_ERROR(!texture->hasLevel(level), GL_INVALID_OPERATION, RC_RET_VOID);
1088
1089                         ConstPixelBufferAccess dst(texture->getLevel(level));
1090                         RC_IF_ERROR(storageFmt  != dst.getFormat()      ||
1091                                                 width           != dst.getWidth()       ||
1092                                                 height          != dst.getHeight(), GL_INVALID_OPERATION, RC_RET_VOID);
1093                 }
1094                 else
1095                         texture->allocLevel(level, storageFmt, width, height);
1096
1097                 if (unpackPtr)
1098                 {
1099                         ConstPixelBufferAccess  src             = getUnpack2DAccess(transferFmt, width, height, unpackPtr);
1100                         PixelBufferAccess               dst             (texture->getLevel(level));
1101
1102                         if (isDstFloatDepthFormat)
1103                                 depthValueFloatClampCopy(dst, src);
1104                         else
1105                                 tcu::copy(dst, src);
1106                 }
1107                 else
1108                 {
1109                         // No data supplied, clear to initial
1110                         clearToTextureInitialValue(texture->getLevel(level));
1111                 }
1112         }
1113         else if (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_X ||
1114                          target == GL_TEXTURE_CUBE_MAP_POSITIVE_X ||
1115                          target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y ||
1116                          target == GL_TEXTURE_CUBE_MAP_POSITIVE_Y ||
1117                          target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Z ||
1118                          target == GL_TEXTURE_CUBE_MAP_POSITIVE_Z)
1119         {
1120                 // Validate size and level.
1121                 RC_IF_ERROR(width != height || width > m_limits.maxTextureCubeSize || depth != 1, GL_INVALID_VALUE, RC_RET_VOID);
1122                 RC_IF_ERROR(level > deLog2Floor32(m_limits.maxTextureCubeSize), GL_INVALID_VALUE, RC_RET_VOID);
1123
1124                 TextureCube*    texture = unit.texCubeBinding ? unit.texCubeBinding : &unit.defaultCubeTex;
1125                 tcu::CubeFace   face    = mapGLCubeFace(target);
1126
1127                 if (texture->isImmutable())
1128                 {
1129                         RC_IF_ERROR(!texture->hasFace(level, face), GL_INVALID_OPERATION, RC_RET_VOID);
1130
1131                         ConstPixelBufferAccess dst(texture->getFace(level, face));
1132                         RC_IF_ERROR(storageFmt  != dst.getFormat()      ||
1133                                                 width           != dst.getWidth()       ||
1134                                                 height          != dst.getHeight(), GL_INVALID_OPERATION, RC_RET_VOID);
1135                 }
1136                 else
1137                         texture->allocFace(level, face, storageFmt, width, height);
1138
1139                 if (unpackPtr)
1140                 {
1141                         ConstPixelBufferAccess  src             = getUnpack2DAccess(transferFmt, width, height, unpackPtr);
1142                         PixelBufferAccess               dst             (texture->getFace(level, face));
1143
1144                         if (isDstFloatDepthFormat)
1145                                 depthValueFloatClampCopy(dst, src);
1146                         else
1147                                 tcu::copy(dst, src);
1148                 }
1149                 else
1150                 {
1151                         // No data supplied, clear to initial
1152                         clearToTextureInitialValue(texture->getFace(level, face));
1153                 }
1154         }
1155         else if (target == GL_TEXTURE_2D_ARRAY)
1156         {
1157                 // Validate size and level.
1158                 RC_IF_ERROR(width       > m_limits.maxTexture2DSize ||
1159                                         height  > m_limits.maxTexture2DSize ||
1160                                         depth   > m_limits.maxTexture2DArrayLayers, GL_INVALID_VALUE, RC_RET_VOID);
1161                 RC_IF_ERROR(level > deLog2Floor32(m_limits.maxTexture2DSize), GL_INVALID_VALUE, RC_RET_VOID);
1162
1163                 Texture2DArray* texture = unit.tex2DArrayBinding ? unit.tex2DArrayBinding : &unit.default2DArrayTex;
1164
1165                 if (texture->isImmutable())
1166                 {
1167                         RC_IF_ERROR(!texture->hasLevel(level), GL_INVALID_OPERATION, RC_RET_VOID);
1168
1169                         ConstPixelBufferAccess dst(texture->getLevel(level));
1170                         RC_IF_ERROR(storageFmt  != dst.getFormat()      ||
1171                                                 width           != dst.getWidth()       ||
1172                                                 height          != dst.getHeight()      ||
1173                                                 depth           != dst.getDepth(), GL_INVALID_OPERATION, RC_RET_VOID);
1174                 }
1175                 else
1176                         texture->allocLevel(level, storageFmt, width, height, depth);
1177
1178                 if (unpackPtr)
1179                 {
1180                         ConstPixelBufferAccess  src             = getUnpack3DAccess(transferFmt, width, height, depth, unpackPtr);
1181                         PixelBufferAccess               dst             (texture->getLevel(level));
1182
1183                         if (isDstFloatDepthFormat)
1184                                 depthValueFloatClampCopy(dst, src);
1185                         else
1186                                 tcu::copy(dst, src);
1187                 }
1188                 else
1189                 {
1190                         // No data supplied, clear to initial
1191                         clearToTextureInitialValue(texture->getLevel(level));
1192                 }
1193         }
1194         else if (target == GL_TEXTURE_3D)
1195         {
1196                 // Validate size and level.
1197                 RC_IF_ERROR(width       > m_limits.maxTexture3DSize ||
1198                                         height  > m_limits.maxTexture3DSize ||
1199                                         depth   > m_limits.maxTexture3DSize, GL_INVALID_VALUE, RC_RET_VOID);
1200                 RC_IF_ERROR(level > deLog2Floor32(m_limits.maxTexture3DSize), GL_INVALID_VALUE, RC_RET_VOID);
1201
1202                 Texture3D* texture = unit.tex3DBinding ? unit.tex3DBinding : &unit.default3DTex;
1203
1204                 if (texture->isImmutable())
1205                 {
1206                         RC_IF_ERROR(!texture->hasLevel(level), GL_INVALID_OPERATION, RC_RET_VOID);
1207
1208                         ConstPixelBufferAccess dst(texture->getLevel(level));
1209                         RC_IF_ERROR(storageFmt  != dst.getFormat()      ||
1210                                                 width           != dst.getWidth()       ||
1211                                                 height          != dst.getHeight()      ||
1212                                                 depth           != dst.getDepth(), GL_INVALID_OPERATION, RC_RET_VOID);
1213                 }
1214                 else
1215                         texture->allocLevel(level, storageFmt, width, height, depth);
1216
1217                 if (unpackPtr)
1218                 {
1219                         ConstPixelBufferAccess  src             = getUnpack3DAccess(transferFmt, width, height, depth, unpackPtr);
1220                         PixelBufferAccess               dst             (texture->getLevel(level));
1221
1222                         if (isDstFloatDepthFormat)
1223                                 depthValueFloatClampCopy(dst, src);
1224                         else
1225                                 tcu::copy(dst, src);
1226                 }
1227                 else
1228                 {
1229                         // No data supplied, clear to initial
1230                         clearToTextureInitialValue(texture->getLevel(level));
1231                 }
1232         }
1233         else if (target == GL_TEXTURE_CUBE_MAP_ARRAY)
1234         {
1235                 // Validate size and level.
1236                 RC_IF_ERROR(width               != height                                               ||
1237                                         width            > m_limits.maxTexture2DSize    ||
1238                                         depth % 6       != 0                                                    ||
1239                                         depth            > m_limits.maxTexture2DArrayLayers, GL_INVALID_VALUE, RC_RET_VOID);
1240                 RC_IF_ERROR(level > deLog2Floor32(m_limits.maxTexture2DSize), GL_INVALID_VALUE, RC_RET_VOID);
1241
1242                 TextureCubeArray* texture = unit.texCubeArrayBinding ? unit.texCubeArrayBinding : &unit.defaultCubeArrayTex;
1243
1244                 if (texture->isImmutable())
1245                 {
1246                         RC_IF_ERROR(!texture->hasLevel(level), GL_INVALID_OPERATION, RC_RET_VOID);
1247
1248                         ConstPixelBufferAccess dst(texture->getLevel(level));
1249                         RC_IF_ERROR(storageFmt  != dst.getFormat()      ||
1250                                                 width           != dst.getWidth()       ||
1251                                                 height          != dst.getHeight()      ||
1252                                                 depth           != dst.getDepth(), GL_INVALID_OPERATION, RC_RET_VOID);
1253                 }
1254                 else
1255                         texture->allocLevel(level, storageFmt, width, height, depth);
1256
1257                 if (unpackPtr)
1258                 {
1259                         ConstPixelBufferAccess  src             = getUnpack3DAccess(transferFmt, width, height, depth, unpackPtr);
1260                         PixelBufferAccess               dst             (texture->getLevel(level));
1261
1262                         if (isDstFloatDepthFormat)
1263                                 depthValueFloatClampCopy(dst, src);
1264                         else
1265                                 tcu::copy(dst, src);
1266                 }
1267                 else
1268                 {
1269                         // No data supplied, clear to initial
1270                         clearToTextureInitialValue(texture->getLevel(level));
1271                 }
1272         }
1273         else
1274                 RC_ERROR_RET(GL_INVALID_ENUM, RC_RET_VOID);
1275 }
1276
1277 void ReferenceContext::texSubImage1D (deUint32 target, int level, int xoffset, int width, deUint32 format, deUint32 type, const void* data)
1278 {
1279         texSubImage2D(target, level, xoffset, 0, width, 1, format, type, data);
1280 }
1281
1282 void ReferenceContext::texSubImage2D (deUint32 target, int level, int xoffset, int yoffset, int width, int height, deUint32 format, deUint32 type, const void* data)
1283 {
1284         texSubImage3D(target, level, xoffset, yoffset, 0, width, height, 1, format, type, data);
1285 }
1286
1287 void ReferenceContext::texSubImage3D (deUint32 target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, deUint32 format, deUint32 type, const void* data)
1288 {
1289         TextureUnit& unit = m_textureUnits[m_activeTexture];
1290
1291         RC_IF_ERROR(xoffset < 0 || yoffset < 0 || zoffset < 0,  GL_INVALID_VALUE, RC_RET_VOID);
1292         RC_IF_ERROR(width < 0 || height < 0 || depth < 0,               GL_INVALID_VALUE, RC_RET_VOID);
1293
1294         TextureFormat transferFmt = glu::mapGLTransferFormat(format, type);
1295         RC_IF_ERROR(transferFmt.order   == TextureFormat::CHANNELORDER_LAST ||
1296                                 transferFmt.type        == TextureFormat::CHANNELTYPE_LAST, GL_INVALID_ENUM, RC_RET_VOID);
1297
1298         ConstPixelBufferAccess src = getUnpack3DAccess(transferFmt, width, height, depth, getPixelUnpackPtr(data));
1299
1300         if (target == GL_TEXTURE_1D && glu::isContextTypeGLCore(m_limits.contextType))
1301         {
1302                 Texture1D& texture = unit.tex1DBinding ? *unit.tex1DBinding : unit.default1DTex;
1303
1304                 RC_IF_ERROR(!texture.hasLevel(level), GL_INVALID_VALUE, RC_RET_VOID);
1305
1306                 PixelBufferAccess dst = texture.getLevel(level);
1307
1308                 RC_IF_ERROR(xoffset + width             > dst.getWidth()        ||
1309                                         yoffset + height        > dst.getHeight()       ||
1310                                         zoffset + depth         > dst.getDepth(),
1311                                         GL_INVALID_VALUE, RC_RET_VOID);
1312
1313                 // depth components are limited to [0,1] range
1314                 if (dst.getFormat().order == tcu::TextureFormat::D || dst.getFormat().order == tcu::TextureFormat::DS)
1315                         depthValueFloatClampCopy(tcu::getSubregion(dst, xoffset, yoffset, zoffset, width, height, depth), src);
1316                 else
1317                         tcu::copy(tcu::getSubregion(dst, xoffset, yoffset, zoffset, width, height, depth), src);
1318         }
1319         else if (target == GL_TEXTURE_2D)
1320         {
1321                 Texture2D& texture = unit.tex2DBinding ? *unit.tex2DBinding : unit.default2DTex;
1322
1323                 RC_IF_ERROR(!texture.hasLevel(level), GL_INVALID_VALUE, RC_RET_VOID);
1324
1325                 PixelBufferAccess dst = texture.getLevel(level);
1326
1327                 RC_IF_ERROR(xoffset + width             > dst.getWidth()        ||
1328                                         yoffset + height        > dst.getHeight()       ||
1329                                         zoffset + depth         > dst.getDepth(),
1330                                         GL_INVALID_VALUE, RC_RET_VOID);
1331
1332                 // depth components are limited to [0,1] range
1333                 if (dst.getFormat().order == tcu::TextureFormat::D || dst.getFormat().order == tcu::TextureFormat::DS)
1334                         depthValueFloatClampCopy(tcu::getSubregion(dst, xoffset, yoffset, zoffset, width, height, depth), src);
1335                 else
1336                         tcu::copy(tcu::getSubregion(dst, xoffset, yoffset, zoffset, width, height, depth), src);
1337         }
1338         else if (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_X ||
1339                          target == GL_TEXTURE_CUBE_MAP_POSITIVE_X ||
1340                          target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y ||
1341                          target == GL_TEXTURE_CUBE_MAP_POSITIVE_Y ||
1342                          target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Z ||
1343                          target == GL_TEXTURE_CUBE_MAP_POSITIVE_Z)
1344         {
1345                 TextureCube&    texture         = unit.texCubeBinding ? *unit.texCubeBinding : unit.defaultCubeTex;
1346                 tcu::CubeFace   face            = mapGLCubeFace(target);
1347
1348                 RC_IF_ERROR(!texture.hasFace(level, face), GL_INVALID_VALUE, RC_RET_VOID);
1349
1350                 PixelBufferAccess dst = texture.getFace(level, face);
1351
1352                 RC_IF_ERROR(xoffset + width             > dst.getWidth()        ||
1353                                         yoffset + height        > dst.getHeight()       ||
1354                                         zoffset + depth         > dst.getDepth(),
1355                                         GL_INVALID_VALUE, RC_RET_VOID);
1356
1357                 // depth components are limited to [0,1] range
1358                 if (dst.getFormat().order == tcu::TextureFormat::D || dst.getFormat().order == tcu::TextureFormat::DS)
1359                         depthValueFloatClampCopy(tcu::getSubregion(dst, xoffset, yoffset, zoffset, width, height, depth), src);
1360                 else
1361                         tcu::copy(tcu::getSubregion(dst, xoffset, yoffset, zoffset, width, height, depth), src);
1362         }
1363         else if (target == GL_TEXTURE_3D)
1364         {
1365                 Texture3D& texture = unit.tex3DBinding ? *unit.tex3DBinding : unit.default3DTex;
1366
1367                 RC_IF_ERROR(!texture.hasLevel(level), GL_INVALID_VALUE, RC_RET_VOID);
1368
1369                 PixelBufferAccess dst = texture.getLevel(level);
1370
1371                 RC_IF_ERROR(xoffset + width             > dst.getWidth()        ||
1372                                         yoffset + height        > dst.getHeight()       ||
1373                                         zoffset + depth         > dst.getDepth(),
1374                                         GL_INVALID_VALUE, RC_RET_VOID);
1375
1376                 // depth components are limited to [0,1] range
1377                 if (dst.getFormat().order == tcu::TextureFormat::D || dst.getFormat().order == tcu::TextureFormat::DS)
1378                         depthValueFloatClampCopy(tcu::getSubregion(dst, xoffset, yoffset, zoffset, width, height, depth), src);
1379                 else
1380                         tcu::copy(tcu::getSubregion(dst, xoffset, yoffset, zoffset, width, height, depth), src);
1381         }
1382         else if (target == GL_TEXTURE_2D_ARRAY)
1383         {
1384                 Texture2DArray& texture = unit.tex2DArrayBinding ? *unit.tex2DArrayBinding : unit.default2DArrayTex;
1385
1386                 RC_IF_ERROR(!texture.hasLevel(level), GL_INVALID_VALUE, RC_RET_VOID);
1387
1388                 PixelBufferAccess dst = texture.getLevel(level);
1389
1390                 RC_IF_ERROR(xoffset + width             > dst.getWidth()        ||
1391                                         yoffset + height        > dst.getHeight()       ||
1392                                         zoffset + depth         > dst.getDepth(),
1393                                         GL_INVALID_VALUE, RC_RET_VOID);
1394
1395                 // depth components are limited to [0,1] range
1396                 if (dst.getFormat().order == tcu::TextureFormat::D || dst.getFormat().order == tcu::TextureFormat::DS)
1397                         depthValueFloatClampCopy(tcu::getSubregion(dst, xoffset, yoffset, zoffset, width, height, depth), src);
1398                 else
1399                         tcu::copy(tcu::getSubregion(dst, xoffset, yoffset, zoffset, width, height, depth), src);
1400         }
1401         else if (target == GL_TEXTURE_CUBE_MAP_ARRAY)
1402         {
1403                 TextureCubeArray& texture = unit.texCubeArrayBinding ? *unit.texCubeArrayBinding : unit.defaultCubeArrayTex;
1404
1405                 RC_IF_ERROR(!texture.hasLevel(level), GL_INVALID_VALUE, RC_RET_VOID);
1406
1407                 PixelBufferAccess dst = texture.getLevel(level);
1408
1409                 RC_IF_ERROR(xoffset + width             > dst.getWidth()        ||
1410                                         yoffset + height        > dst.getHeight()       ||
1411                                         zoffset + depth         > dst.getDepth(),
1412                                         GL_INVALID_VALUE, RC_RET_VOID);
1413
1414                 // depth components are limited to [0,1] range
1415                 if (dst.getFormat().order == tcu::TextureFormat::D || dst.getFormat().order == tcu::TextureFormat::DS)
1416                         depthValueFloatClampCopy(tcu::getSubregion(dst, xoffset, yoffset, zoffset, width, height, depth), src);
1417                 else
1418                         tcu::copy(tcu::getSubregion(dst, xoffset, yoffset, zoffset, width, height, depth), src);
1419         }
1420         else
1421                 RC_ERROR_RET(GL_INVALID_ENUM, RC_RET_VOID);
1422 }
1423
1424 void ReferenceContext::copyTexImage1D (deUint32 target, int level, deUint32 internalFormat, int x, int y, int width, int border)
1425 {
1426         TextureUnit&                                                    unit            = m_textureUnits[m_activeTexture];
1427         TextureFormat                                                   storageFmt;
1428         rr::MultisampleConstPixelBufferAccess   src                     = getReadColorbuffer();
1429
1430         RC_IF_ERROR(border != 0, GL_INVALID_VALUE, RC_RET_VOID);
1431         RC_IF_ERROR(width < 0 || level < 0, GL_INVALID_VALUE, RC_RET_VOID);
1432         RC_IF_ERROR(isEmpty(src), GL_INVALID_OPERATION, RC_RET_VOID);
1433
1434         // Map storage format.
1435         storageFmt = mapInternalFormat(internalFormat);
1436         RC_IF_ERROR(storageFmt.order    == TextureFormat::CHANNELORDER_LAST ||
1437                                 storageFmt.type         == TextureFormat::CHANNELTYPE_LAST, GL_INVALID_ENUM, RC_RET_VOID);
1438
1439         if (target == GL_TEXTURE_1D)
1440         {
1441                 // Validate size and level.
1442                 RC_IF_ERROR(width > m_limits.maxTexture2DSize, GL_INVALID_VALUE, RC_RET_VOID);
1443                 RC_IF_ERROR(level > deLog2Floor32(m_limits.maxTexture2DSize), GL_INVALID_VALUE, RC_RET_VOID);
1444
1445                 Texture1D* texture = unit.tex1DBinding ? unit.tex1DBinding : &unit.default1DTex;
1446
1447                 if (texture->isImmutable())
1448                 {
1449                         RC_IF_ERROR(!texture->hasLevel(level), GL_INVALID_OPERATION, RC_RET_VOID);
1450
1451                         ConstPixelBufferAccess dst(texture->getLevel(level));
1452                         RC_IF_ERROR(storageFmt  != dst.getFormat()      ||
1453                                                 width           != dst.getWidth(), GL_INVALID_OPERATION, RC_RET_VOID);
1454                 }
1455                 else
1456                         texture->allocLevel(level, storageFmt, width);
1457
1458                 // Copy from current framebuffer.
1459                 PixelBufferAccess dst = texture->getLevel(level);
1460                 for (int xo = 0; xo < width; xo++)
1461                 {
1462                         if (!de::inBounds(x+xo, 0, src.raw().getHeight()))
1463                                 continue; // Undefined pixel.
1464
1465                         dst.setPixel(rr::resolveMultisamplePixel(src, x+xo, y), xo, 0);
1466                 }
1467         }
1468         else
1469                 RC_ERROR_RET(GL_INVALID_ENUM, RC_RET_VOID);
1470 }
1471
1472 void ReferenceContext::copyTexImage2D (deUint32 target, int level, deUint32 internalFormat, int x, int y, int width, int height, int border)
1473 {
1474         TextureUnit&                                                    unit            = m_textureUnits[m_activeTexture];
1475         TextureFormat                                                   storageFmt;
1476         rr::MultisampleConstPixelBufferAccess   src                     = getReadColorbuffer();
1477
1478         RC_IF_ERROR(border != 0, GL_INVALID_VALUE, RC_RET_VOID);
1479         RC_IF_ERROR(width < 0 || height < 0 || level < 0, GL_INVALID_VALUE, RC_RET_VOID);
1480         RC_IF_ERROR(isEmpty(src), GL_INVALID_OPERATION, RC_RET_VOID);
1481
1482         // Map storage format.
1483         storageFmt = mapInternalFormat(internalFormat);
1484         RC_IF_ERROR(storageFmt.order    == TextureFormat::CHANNELORDER_LAST ||
1485                                 storageFmt.type         == TextureFormat::CHANNELTYPE_LAST, GL_INVALID_ENUM, RC_RET_VOID);
1486
1487         if (target == GL_TEXTURE_2D)
1488         {
1489                 // Validate size and level.
1490                 RC_IF_ERROR(width > m_limits.maxTexture2DSize || height > m_limits.maxTexture2DSize, GL_INVALID_VALUE, RC_RET_VOID);
1491                 RC_IF_ERROR(level > deLog2Floor32(m_limits.maxTexture2DSize), GL_INVALID_VALUE, RC_RET_VOID);
1492
1493                 Texture2D* texture = unit.tex2DBinding ? unit.tex2DBinding : &unit.default2DTex;
1494
1495                 if (texture->isImmutable())
1496                 {
1497                         RC_IF_ERROR(!texture->hasLevel(level), GL_INVALID_OPERATION, RC_RET_VOID);
1498
1499                         ConstPixelBufferAccess dst(texture->getLevel(level));
1500                         RC_IF_ERROR(storageFmt  != dst.getFormat()      ||
1501                                                 width           != dst.getWidth()       ||
1502                                                 height          != dst.getHeight(), GL_INVALID_OPERATION, RC_RET_VOID);
1503                 }
1504                 else
1505                         texture->allocLevel(level, storageFmt, width, height);
1506
1507                 // Copy from current framebuffer.
1508                 PixelBufferAccess dst = texture->getLevel(level);
1509                 for (int yo = 0; yo < height; yo++)
1510                 for (int xo = 0; xo < width; xo++)
1511                 {
1512                         if (!de::inBounds(x+xo, 0, src.raw().getHeight()) || !de::inBounds(y+yo, 0, src.raw().getDepth()))
1513                                 continue; // Undefined pixel.
1514
1515                         dst.setPixel(rr::resolveMultisamplePixel(src, x+xo, y+yo), xo, yo);
1516                 }
1517         }
1518         else if (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_X ||
1519                          target == GL_TEXTURE_CUBE_MAP_POSITIVE_X ||
1520                          target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y ||
1521                          target == GL_TEXTURE_CUBE_MAP_POSITIVE_Y ||
1522                          target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Z ||
1523                          target == GL_TEXTURE_CUBE_MAP_POSITIVE_Z)
1524         {
1525                 // Validate size and level.
1526                 RC_IF_ERROR(width != height || width > m_limits.maxTextureCubeSize, GL_INVALID_VALUE, RC_RET_VOID);
1527                 RC_IF_ERROR(level > deLog2Floor32(m_limits.maxTextureCubeSize), GL_INVALID_VALUE, RC_RET_VOID);
1528
1529                 TextureCube*    texture = unit.texCubeBinding ? unit.texCubeBinding : &unit.defaultCubeTex;
1530                 tcu::CubeFace   face    = mapGLCubeFace(target);
1531
1532                 if (texture->isImmutable())
1533                 {
1534                         RC_IF_ERROR(!texture->hasFace(level, face), GL_INVALID_OPERATION, RC_RET_VOID);
1535
1536                         ConstPixelBufferAccess dst(texture->getFace(level, face));
1537                         RC_IF_ERROR(storageFmt  != dst.getFormat()      ||
1538                                                 width           != dst.getWidth()       ||
1539                                                 height          != dst.getHeight(), GL_INVALID_OPERATION, RC_RET_VOID);
1540                 }
1541                 else
1542                         texture->allocFace(level, face, storageFmt, width, height);
1543
1544                 // Copy from current framebuffer.
1545                 PixelBufferAccess dst = texture->getFace(level, face);
1546                 for (int yo = 0; yo < height; yo++)
1547                 for (int xo = 0; xo < width; xo++)
1548                 {
1549                         if (!de::inBounds(x+xo, 0, src.raw().getHeight()) || !de::inBounds(y+yo, 0, src.raw().getDepth()))
1550                                 continue; // Undefined pixel.
1551
1552                         dst.setPixel(rr::resolveMultisamplePixel(src, x+xo, y+yo), xo, yo);
1553                 }
1554         }
1555         else
1556                 RC_ERROR_RET(GL_INVALID_ENUM, RC_RET_VOID);
1557 }
1558
1559 void ReferenceContext::copyTexSubImage1D (deUint32 target, int level, int xoffset, int x, int y, int width)
1560 {
1561         TextureUnit&                                                    unit    = m_textureUnits[m_activeTexture];
1562         rr::MultisampleConstPixelBufferAccess   src             = getReadColorbuffer();
1563
1564         RC_IF_ERROR(xoffset < 0,        GL_INVALID_VALUE,               RC_RET_VOID);
1565         RC_IF_ERROR(width < 0,          GL_INVALID_VALUE,               RC_RET_VOID);
1566         RC_IF_ERROR(isEmpty(src),       GL_INVALID_OPERATION,   RC_RET_VOID);
1567
1568         if (target == GL_TEXTURE_1D)
1569         {
1570                 Texture1D& texture = unit.tex1DBinding ? *unit.tex1DBinding : unit.default1DTex;
1571
1572                 RC_IF_ERROR(!texture.hasLevel(level), GL_INVALID_VALUE, RC_RET_VOID);
1573
1574                 PixelBufferAccess dst = texture.getLevel(level);
1575
1576                 RC_IF_ERROR(xoffset + width > dst.getWidth(), GL_INVALID_VALUE, RC_RET_VOID);
1577
1578                 for (int xo = 0; xo < width; xo++)
1579                 {
1580                         if (!de::inBounds(x+xo, 0, src.raw().getHeight()))
1581                                 continue;
1582
1583                         dst.setPixel(rr::resolveMultisamplePixel(src, x+xo, y), xo+xoffset, 0);
1584                 }
1585         }
1586         else
1587                 RC_ERROR_RET(GL_INVALID_ENUM, RC_RET_VOID);
1588 }
1589
1590 void ReferenceContext::copyTexSubImage2D (deUint32 target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
1591 {
1592         TextureUnit&                                                    unit    = m_textureUnits[m_activeTexture];
1593         rr::MultisampleConstPixelBufferAccess   src             = getReadColorbuffer();
1594
1595         RC_IF_ERROR(xoffset < 0 || yoffset < 0,                                 GL_INVALID_VALUE, RC_RET_VOID);
1596         RC_IF_ERROR(width < 0 || height < 0,                                    GL_INVALID_VALUE, RC_RET_VOID);
1597         RC_IF_ERROR(isEmpty(src),                                                               GL_INVALID_OPERATION, RC_RET_VOID);
1598
1599         if (target == GL_TEXTURE_2D)
1600         {
1601                 Texture2D& texture = unit.tex2DBinding ? *unit.tex2DBinding : unit.default2DTex;
1602
1603                 RC_IF_ERROR(!texture.hasLevel(level), GL_INVALID_VALUE, RC_RET_VOID);
1604
1605                 PixelBufferAccess dst = texture.getLevel(level);
1606
1607                 RC_IF_ERROR(xoffset + width             > dst.getWidth() ||
1608                                         yoffset + height        > dst.getHeight(),
1609                                         GL_INVALID_VALUE, RC_RET_VOID);
1610
1611                 for (int yo = 0; yo < height; yo++)
1612                 for (int xo = 0; xo < width; xo++)
1613                 {
1614                         if (!de::inBounds(x+xo, 0, src.raw().getHeight()) || !de::inBounds(y+yo, 0, src.raw().getDepth()))
1615                                 continue;
1616
1617                         dst.setPixel(rr::resolveMultisamplePixel(src, x+xo, y+yo), xo+xoffset, yo+yoffset);
1618                 }
1619         }
1620         else if (target == GL_TEXTURE_CUBE_MAP_NEGATIVE_X ||
1621                          target == GL_TEXTURE_CUBE_MAP_POSITIVE_X ||
1622                          target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y ||
1623                          target == GL_TEXTURE_CUBE_MAP_POSITIVE_Y ||
1624                          target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Z ||
1625                          target == GL_TEXTURE_CUBE_MAP_POSITIVE_Z)
1626         {
1627                 TextureCube&    texture         = unit.texCubeBinding ? *unit.texCubeBinding : unit.defaultCubeTex;
1628                 tcu::CubeFace   face            = mapGLCubeFace(target);
1629
1630                 RC_IF_ERROR(!texture.hasFace(level, face), GL_INVALID_VALUE, RC_RET_VOID);
1631
1632                 PixelBufferAccess dst = texture.getFace(level, face);
1633
1634                 RC_IF_ERROR(xoffset + width             > dst.getWidth() ||
1635                                         yoffset + height        > dst.getHeight(),
1636                                         GL_INVALID_VALUE, RC_RET_VOID);
1637
1638                 for (int yo = 0; yo < height; yo++)
1639                 for (int xo = 0; xo < width; xo++)
1640                 {
1641                         if (!de::inBounds(x+xo, 0, src.raw().getHeight()) || !de::inBounds(y+yo, 0, src.raw().getDepth()))
1642                                 continue;
1643
1644                         dst.setPixel(rr::resolveMultisamplePixel(src, x+xo, y+yo), xo+xoffset, yo+yoffset);
1645                 }
1646         }
1647         else
1648                 RC_ERROR_RET(GL_INVALID_ENUM, RC_RET_VOID);
1649 }
1650
1651 void ReferenceContext::copyTexSubImage3D (deUint32 target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
1652 {
1653         DE_UNREF(target && level && xoffset && yoffset && zoffset && x && y && width && height);
1654         DE_ASSERT(false);
1655 }
1656
1657 void ReferenceContext::texStorage2D (deUint32 target, int levels, deUint32 internalFormat, int width, int height)
1658 {
1659         TextureUnit&            unit            = m_textureUnits[m_activeTexture];
1660         TextureFormat           storageFmt;
1661
1662         RC_IF_ERROR(width <= 0 || height <= 0, GL_INVALID_VALUE, RC_RET_VOID);
1663         RC_IF_ERROR(!de::inRange(levels, 1, (int)deLog2Floor32(de::max(width, height))+1), GL_INVALID_VALUE, RC_RET_VOID);
1664
1665         // Map storage format.
1666         storageFmt = mapInternalFormat(internalFormat);
1667         RC_IF_ERROR(storageFmt.order    == TextureFormat::CHANNELORDER_LAST ||
1668                                 storageFmt.type         == TextureFormat::CHANNELTYPE_LAST, GL_INVALID_ENUM, RC_RET_VOID);
1669
1670         if (target == GL_TEXTURE_2D)
1671         {
1672                 Texture2D& texture = unit.tex2DBinding ? *unit.tex2DBinding : unit.default2DTex;
1673
1674                 RC_IF_ERROR(width > m_limits.maxTexture2DSize || height >= m_limits.maxTexture2DSize, GL_INVALID_VALUE, RC_RET_VOID);
1675                 RC_IF_ERROR(texture.isImmutable(), GL_INVALID_OPERATION, RC_RET_VOID);
1676
1677                 texture.clearLevels();
1678                 texture.setImmutable();
1679
1680                 for (int level = 0; level < levels; level++)
1681                 {
1682                         int levelW = de::max(1, width >> level);
1683                         int levelH = de::max(1, height >> level);
1684
1685                         texture.allocLevel(level, storageFmt, levelW, levelH);
1686                 }
1687         }
1688         else if (target == GL_TEXTURE_CUBE_MAP)
1689         {
1690                 TextureCube& texture = unit.texCubeBinding ? *unit.texCubeBinding : unit.defaultCubeTex;
1691
1692                 RC_IF_ERROR(width > m_limits.maxTextureCubeSize || height > m_limits.maxTextureCubeSize, GL_INVALID_VALUE, RC_RET_VOID);
1693                 RC_IF_ERROR(texture.isImmutable(), GL_INVALID_OPERATION, RC_RET_VOID);
1694
1695                 texture.clearLevels();
1696                 texture.setImmutable();
1697
1698                 for (int level = 0; level < levels; level++)
1699                 {
1700                         int levelW = de::max(1, width >> level);
1701                         int levelH = de::max(1, height >> level);
1702
1703                         for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
1704                                 texture.allocFace(level, (tcu::CubeFace)face, storageFmt, levelW, levelH);
1705                 }
1706         }
1707         else
1708                 RC_ERROR_RET(GL_INVALID_ENUM, RC_RET_VOID);
1709 }
1710
1711 void ReferenceContext::texStorage3D (deUint32 target, int levels, deUint32 internalFormat, int width, int height, int depth)
1712 {
1713         TextureUnit&            unit            = m_textureUnits[m_activeTexture];
1714         TextureFormat           storageFmt;
1715
1716         RC_IF_ERROR(width <= 0 || height <= 0, GL_INVALID_VALUE, RC_RET_VOID);
1717         RC_IF_ERROR(!de::inRange(levels, 1, (int)deLog2Floor32(de::max(width, height))+1), GL_INVALID_VALUE, RC_RET_VOID);
1718
1719         // Map storage format.
1720         storageFmt = mapInternalFormat(internalFormat);
1721         RC_IF_ERROR(storageFmt.order    == TextureFormat::CHANNELORDER_LAST ||
1722                                 storageFmt.type         == TextureFormat::CHANNELTYPE_LAST, GL_INVALID_ENUM, RC_RET_VOID);
1723
1724         if (target == GL_TEXTURE_2D_ARRAY)
1725         {
1726                 Texture2DArray& texture = unit.tex2DArrayBinding ? *unit.tex2DArrayBinding : unit.default2DArrayTex;
1727
1728                 RC_IF_ERROR(width       >       m_limits.maxTexture2DSize       ||
1729                                         height  >=      m_limits.maxTexture2DSize       ||
1730                                         depth   >=      m_limits.maxTexture2DArrayLayers, GL_INVALID_VALUE, RC_RET_VOID);
1731                 RC_IF_ERROR(texture.isImmutable(), GL_INVALID_OPERATION, RC_RET_VOID);
1732
1733                 texture.clearLevels();
1734                 texture.setImmutable();
1735
1736                 for (int level = 0; level < levels; level++)
1737                 {
1738                         int levelW = de::max(1, width >> level);
1739                         int levelH = de::max(1, height >> level);
1740
1741                         texture.allocLevel(level, storageFmt, levelW, levelH, depth);
1742                 }
1743         }
1744         else if (target == GL_TEXTURE_3D)
1745         {
1746                 Texture3D& texture = unit.tex3DBinding ? *unit.tex3DBinding : unit.default3DTex;
1747
1748                 RC_IF_ERROR(width       > m_limits.maxTexture3DSize     ||
1749                                         height  > m_limits.maxTexture3DSize     ||
1750                                         depth   > m_limits.maxTexture3DSize, GL_INVALID_VALUE, RC_RET_VOID);
1751                 RC_IF_ERROR(texture.isImmutable(), GL_INVALID_OPERATION, RC_RET_VOID);
1752
1753                 texture.clearLevels();
1754                 texture.setImmutable();
1755
1756                 for (int level = 0; level < levels; level++)
1757                 {
1758                         int levelW = de::max(1, width           >> level);
1759                         int levelH = de::max(1, height  >> level);
1760                         int levelD = de::max(1, depth           >> level);
1761
1762                         texture.allocLevel(level, storageFmt, levelW, levelH, levelD);
1763                 }
1764         }
1765         else if (target == GL_TEXTURE_CUBE_MAP_ARRAY)
1766         {
1767                 TextureCubeArray& texture = unit.texCubeArrayBinding ? *unit.texCubeArrayBinding : unit.defaultCubeArrayTex;
1768
1769                 RC_IF_ERROR(width               !=      height                                                          ||
1770                                         depth % 6       != 0                                                                    ||
1771                                         width           >       m_limits.maxTexture2DSize                       ||
1772                                         depth           >=      m_limits.maxTexture2DArrayLayers, GL_INVALID_VALUE, RC_RET_VOID);
1773                 RC_IF_ERROR(texture.isImmutable(), GL_INVALID_OPERATION, RC_RET_VOID);
1774
1775                 texture.clearLevels();
1776                 texture.setImmutable();
1777
1778                 for (int level = 0; level < levels; level++)
1779                 {
1780                         int levelW = de::max(1, width >> level);
1781                         int levelH = de::max(1, height >> level);
1782
1783                         texture.allocLevel(level, storageFmt, levelW, levelH, depth);
1784                 }
1785         }
1786         else
1787                 RC_ERROR_RET(GL_INVALID_ENUM, RC_RET_VOID);
1788 }
1789
1790 // \todo [2014-02-19 pyry] Duplicated with code in gluTextureUtil.hpp
1791
1792 static inline tcu::Sampler::WrapMode mapGLWrapMode (int value)
1793 {
1794         switch (value)
1795         {
1796                 case GL_CLAMP_TO_EDGE:          return tcu::Sampler::CLAMP_TO_EDGE;
1797                 case GL_REPEAT:                         return tcu::Sampler::REPEAT_GL;
1798                 case GL_MIRRORED_REPEAT:        return tcu::Sampler::MIRRORED_REPEAT_GL;
1799                 default:                                        return tcu::Sampler::WRAPMODE_LAST;
1800         }
1801 }
1802
1803 static inline tcu::Sampler::FilterMode mapGLFilterMode (int value)
1804 {
1805         switch (value)
1806         {
1807                 case GL_NEAREST:                                return tcu::Sampler::NEAREST;
1808                 case GL_LINEAR:                                 return tcu::Sampler::LINEAR;
1809                 case GL_NEAREST_MIPMAP_NEAREST: return tcu::Sampler::NEAREST_MIPMAP_NEAREST;
1810                 case GL_NEAREST_MIPMAP_LINEAR:  return tcu::Sampler::NEAREST_MIPMAP_LINEAR;
1811                 case GL_LINEAR_MIPMAP_NEAREST:  return tcu::Sampler::LINEAR_MIPMAP_NEAREST;
1812                 case GL_LINEAR_MIPMAP_LINEAR:   return tcu::Sampler::LINEAR_MIPMAP_LINEAR;
1813                 default:                                                return tcu::Sampler::FILTERMODE_LAST;
1814         }
1815 }
1816
1817 void ReferenceContext::texParameteri (deUint32 target, deUint32 pname, int value)
1818 {
1819         TextureUnit&    unit            = m_textureUnits[m_activeTexture];
1820         Texture*                texture         = DE_NULL;
1821
1822         switch (target)
1823         {
1824                 case GL_TEXTURE_1D:                             texture = unit.tex1DBinding                     ? unit.tex1DBinding                     : &unit.default1DTex;                   break;
1825                 case GL_TEXTURE_2D:                             texture = unit.tex2DBinding                     ? unit.tex2DBinding                     : &unit.default2DTex;                   break;
1826                 case GL_TEXTURE_CUBE_MAP:               texture = unit.texCubeBinding           ? unit.texCubeBinding           : &unit.defaultCubeTex;                 break;
1827                 case GL_TEXTURE_2D_ARRAY:               texture = unit.tex2DArrayBinding        ? unit.tex2DArrayBinding        : &unit.default2DArrayTex;              break;
1828                 case GL_TEXTURE_3D:                             texture = unit.tex3DBinding                     ? unit.tex3DBinding                     : &unit.default3DTex;                   break;
1829                 case GL_TEXTURE_CUBE_MAP_ARRAY: texture = unit.texCubeArrayBinding      ? unit.texCubeArrayBinding      : &unit.defaultCubeArrayTex;    break;
1830
1831                 default:                                        RC_ERROR_RET(GL_INVALID_ENUM, RC_RET_VOID);
1832         }
1833
1834         switch (pname)
1835         {
1836                 case GL_TEXTURE_WRAP_S:
1837                 {
1838                         tcu::Sampler::WrapMode wrapS = mapGLWrapMode(value);
1839                         RC_IF_ERROR(wrapS == tcu::Sampler::WRAPMODE_LAST, GL_INVALID_VALUE, RC_RET_VOID);
1840                         texture->getSampler().wrapS = wrapS;
1841                         break;
1842                 }
1843
1844                 case GL_TEXTURE_WRAP_T:
1845                 {
1846                         tcu::Sampler::WrapMode wrapT = mapGLWrapMode(value);
1847                         RC_IF_ERROR(wrapT == tcu::Sampler::WRAPMODE_LAST, GL_INVALID_VALUE, RC_RET_VOID);
1848                         texture->getSampler().wrapT = wrapT;
1849                         break;
1850                 }
1851
1852                 case GL_TEXTURE_WRAP_R:
1853                 {
1854                         tcu::Sampler::WrapMode wrapR = mapGLWrapMode(value);
1855                         RC_IF_ERROR(wrapR == tcu::Sampler::WRAPMODE_LAST, GL_INVALID_VALUE, RC_RET_VOID);
1856                         texture->getSampler().wrapR = wrapR;
1857                         break;
1858                 }
1859
1860                 case GL_TEXTURE_MIN_FILTER:
1861                 {
1862                         tcu::Sampler::FilterMode minMode = mapGLFilterMode(value);
1863                         RC_IF_ERROR(minMode == tcu::Sampler::FILTERMODE_LAST, GL_INVALID_VALUE, RC_RET_VOID);
1864                         texture->getSampler().minFilter = minMode;
1865                         break;
1866                 }
1867
1868                 case GL_TEXTURE_MAG_FILTER:
1869                 {
1870                         tcu::Sampler::FilterMode magMode = mapGLFilterMode(value);
1871                         RC_IF_ERROR(magMode != tcu::Sampler::LINEAR && magMode != tcu::Sampler::NEAREST,
1872                                                 GL_INVALID_VALUE, RC_RET_VOID);
1873                         texture->getSampler().magFilter = magMode;
1874                         break;
1875                 }
1876
1877                 case GL_TEXTURE_MAX_LEVEL:
1878                 {
1879                         RC_IF_ERROR(value < 0, GL_INVALID_VALUE, RC_RET_VOID);
1880                         texture->setMaxLevel(value);
1881                         break;
1882                 }
1883
1884                 default:
1885                         RC_ERROR_RET(GL_INVALID_ENUM, RC_RET_VOID);
1886         }
1887 }
1888
1889 static inline Framebuffer::AttachmentPoint mapGLAttachmentPoint (deUint32 attachment)
1890 {
1891         switch (attachment)
1892         {
1893                 case GL_COLOR_ATTACHMENT0:      return Framebuffer::ATTACHMENTPOINT_COLOR0;
1894                 case GL_DEPTH_ATTACHMENT:       return Framebuffer::ATTACHMENTPOINT_DEPTH;
1895                 case GL_STENCIL_ATTACHMENT:     return Framebuffer::ATTACHMENTPOINT_STENCIL;
1896                 default:                                        return Framebuffer::ATTACHMENTPOINT_LAST;
1897         }
1898 }
1899
1900 static inline Framebuffer::TexTarget mapGLFboTexTarget (deUint32 target)
1901 {
1902         switch (target)
1903         {
1904                 case GL_TEXTURE_2D:                                             return Framebuffer::TEXTARGET_2D;
1905                 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:    return Framebuffer::TEXTARGET_CUBE_MAP_POSITIVE_X;
1906                 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:    return Framebuffer::TEXTARGET_CUBE_MAP_POSITIVE_Y;
1907                 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:    return Framebuffer::TEXTARGET_CUBE_MAP_POSITIVE_Z;
1908                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:    return Framebuffer::TEXTARGET_CUBE_MAP_NEGATIVE_X;
1909                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:    return Framebuffer::TEXTARGET_CUBE_MAP_NEGATIVE_Y;
1910                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:    return Framebuffer::TEXTARGET_CUBE_MAP_NEGATIVE_Z;
1911                 default:                                                                return Framebuffer::TEXTARGET_LAST;
1912         }
1913 }
1914
1915 void ReferenceContext::acquireFboAttachmentReference (const Framebuffer::Attachment& attachment)
1916 {
1917         switch (attachment.type)
1918         {
1919                 case Framebuffer::ATTACHMENTTYPE_TEXTURE:
1920                 {
1921                         TCU_CHECK(attachment.name != 0);
1922                         Texture* texture = m_textures.find(attachment.name);
1923                         TCU_CHECK(texture);
1924                         m_textures.acquireReference(texture);
1925                         break;
1926                 }
1927
1928                 case Framebuffer::ATTACHMENTTYPE_RENDERBUFFER:
1929                 {
1930                         TCU_CHECK(attachment.name != 0);
1931                         Renderbuffer* rbo = m_renderbuffers.find(attachment.name);
1932                         TCU_CHECK(rbo);
1933                         m_renderbuffers.acquireReference(rbo);
1934                         break;
1935                 }
1936
1937                 default:
1938                         break; // Silently ignore
1939         }
1940 }
1941
1942 void ReferenceContext::releaseFboAttachmentReference (const Framebuffer::Attachment& attachment)
1943 {
1944         switch (attachment.type)
1945         {
1946                 case Framebuffer::ATTACHMENTTYPE_TEXTURE:
1947                 {
1948                         TCU_CHECK(attachment.name != 0);
1949                         Texture* texture = m_textures.find(attachment.name);
1950                         TCU_CHECK(texture);
1951                         m_textures.releaseReference(texture);
1952                         break;
1953                 }
1954
1955                 case Framebuffer::ATTACHMENTTYPE_RENDERBUFFER:
1956                 {
1957                         TCU_CHECK(attachment.name != 0);
1958                         Renderbuffer* rbo = m_renderbuffers.find(attachment.name);
1959                         TCU_CHECK(rbo);
1960                         m_renderbuffers.releaseReference(rbo);
1961                         break;
1962                 }
1963
1964                 default:
1965                         break; // Silently ignore
1966         }
1967 }
1968
1969 void ReferenceContext::framebufferTexture2D (deUint32 target, deUint32 attachment, deUint32 textarget, deUint32 texture, int level)
1970 {
1971         if (attachment == GL_DEPTH_STENCIL_ATTACHMENT)
1972         {
1973                 // Attach to both depth and stencil.
1974                 framebufferTexture2D(target, GL_DEPTH_ATTACHMENT,       textarget, texture, level);
1975                 framebufferTexture2D(target, GL_STENCIL_ATTACHMENT,     textarget, texture, level);
1976         }
1977         else
1978         {
1979                 Framebuffer::AttachmentPoint    point                   = mapGLAttachmentPoint(attachment);
1980                 Texture*                                                texObj                  = DE_NULL;
1981                 Framebuffer::TexTarget                  fboTexTarget    = mapGLFboTexTarget(textarget);
1982
1983                 RC_IF_ERROR(target != GL_FRAMEBUFFER            &&
1984                                         target != GL_DRAW_FRAMEBUFFER   &&
1985                                         target != GL_READ_FRAMEBUFFER,                          GL_INVALID_ENUM,                RC_RET_VOID);
1986                 RC_IF_ERROR(point == Framebuffer::ATTACHMENTPOINT_LAST, GL_INVALID_ENUM,                RC_RET_VOID);
1987
1988                 // Select binding point.
1989                 rc::Framebuffer* framebufferBinding = (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER) ? m_drawFramebufferBinding : m_readFramebufferBinding;
1990                 RC_IF_ERROR(!framebufferBinding, GL_INVALID_OPERATION, RC_RET_VOID);
1991
1992                 // If framebuffer object is bound for both reading and writing then we need to acquire/release multiple references.
1993                 int bindingRefCount = (framebufferBinding == m_drawFramebufferBinding ? 1 : 0)
1994                                                         + (framebufferBinding == m_readFramebufferBinding ? 1 : 0);
1995
1996                 if (texture != 0)
1997                 {
1998                         texObj = m_textures.find(texture);
1999
2000                         RC_IF_ERROR(!texObj,            GL_INVALID_OPERATION,   RC_RET_VOID);
2001                         RC_IF_ERROR(level != 0,         GL_INVALID_VALUE,               RC_RET_VOID); // \todo [2012-03-19 pyry] We should allow other levels as well.
2002
2003                         if (texObj->getType() == Texture::TYPE_2D)
2004                                 RC_IF_ERROR(fboTexTarget != Framebuffer::TEXTARGET_2D, GL_INVALID_OPERATION, RC_RET_VOID);
2005                         else
2006                         {
2007                                 TCU_CHECK(texObj->getType() == Texture::TYPE_CUBE_MAP);
2008                                 if (!deInRange32(fboTexTarget, Framebuffer::TEXTARGET_CUBE_MAP_POSITIVE_X, Framebuffer::TEXTARGET_CUBE_MAP_NEGATIVE_Z))
2009                                         RC_ERROR_RET(GL_INVALID_OPERATION, RC_RET_VOID);
2010                         }
2011                 }
2012
2013                 Framebuffer::Attachment& fboAttachment = framebufferBinding->getAttachment(point);
2014                 for (int ndx = 0; ndx < bindingRefCount; ndx++)
2015                         releaseFboAttachmentReference(fboAttachment);
2016                 fboAttachment = Framebuffer::Attachment();
2017
2018                 if (texObj)
2019                 {
2020                         fboAttachment.type                      = Framebuffer::ATTACHMENTTYPE_TEXTURE;
2021                         fboAttachment.name                      = texObj->getName();
2022                         fboAttachment.texTarget         = fboTexTarget;
2023                         fboAttachment.level                     = level;
2024
2025                         for (int ndx = 0; ndx < bindingRefCount; ndx++)
2026                                 acquireFboAttachmentReference(fboAttachment);
2027                 }
2028         }
2029 }
2030
2031 void ReferenceContext::framebufferTextureLayer (deUint32 target, deUint32 attachment, deUint32 texture, int level, int layer)
2032 {
2033         if (attachment == GL_DEPTH_STENCIL_ATTACHMENT)
2034         {
2035                 // Attach to both depth and stencil.
2036                 framebufferTextureLayer(target, GL_DEPTH_ATTACHMENT,    texture, level, layer);
2037                 framebufferTextureLayer(target, GL_STENCIL_ATTACHMENT,  texture, level, layer);
2038         }
2039         else
2040         {
2041                 Framebuffer::AttachmentPoint    point                   = mapGLAttachmentPoint(attachment);
2042                 Texture*                                                texObj                  = DE_NULL;
2043
2044                 RC_IF_ERROR(target != GL_FRAMEBUFFER            &&
2045                                         target != GL_DRAW_FRAMEBUFFER   &&
2046                                         target != GL_READ_FRAMEBUFFER,                          GL_INVALID_ENUM,                RC_RET_VOID);
2047                 RC_IF_ERROR(point == Framebuffer::ATTACHMENTPOINT_LAST, GL_INVALID_ENUM,                RC_RET_VOID);
2048
2049                 // Select binding point.
2050                 rc::Framebuffer* framebufferBinding = (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER) ? m_drawFramebufferBinding : m_readFramebufferBinding;
2051                 RC_IF_ERROR(!framebufferBinding, GL_INVALID_OPERATION, RC_RET_VOID);
2052
2053                 // If framebuffer object is bound for both reading and writing then we need to acquire/release multiple references.
2054                 int bindingRefCount = (framebufferBinding == m_drawFramebufferBinding ? 1 : 0)
2055                                                         + (framebufferBinding == m_readFramebufferBinding ? 1 : 0);
2056
2057                 if (texture != 0)
2058                 {
2059                         texObj = m_textures.find(texture);
2060
2061                         RC_IF_ERROR(!texObj,            GL_INVALID_OPERATION,   RC_RET_VOID);
2062                         RC_IF_ERROR(level != 0,         GL_INVALID_VALUE,               RC_RET_VOID); // \todo [2012-03-19 pyry] We should allow other levels as well.
2063
2064                         RC_IF_ERROR(texObj->getType() != Texture::TYPE_2D_ARRAY                 &&
2065                                                 texObj->getType() != Texture::TYPE_3D                           &&
2066                                                 texObj->getType() != Texture::TYPE_CUBE_MAP_ARRAY,                              GL_INVALID_OPERATION,   RC_RET_VOID);
2067
2068                         if (texObj->getType() == Texture::TYPE_2D_ARRAY || texObj->getType() == Texture::TYPE_CUBE_MAP_ARRAY)
2069                         {
2070                                 RC_IF_ERROR((layer < 0) || (layer >= GL_MAX_ARRAY_TEXTURE_LAYERS),              GL_INVALID_VALUE,               RC_RET_VOID);
2071                                 RC_IF_ERROR((level < 0) || (level > deLog2Floor32(GL_MAX_TEXTURE_SIZE)),GL_INVALID_VALUE,               RC_RET_VOID);
2072                         }
2073                         else if (texObj->getType() == Texture::TYPE_3D)
2074                         {
2075                                 RC_IF_ERROR((layer < 0) || (layer >= GL_MAX_3D_TEXTURE_SIZE),                           GL_INVALID_VALUE,               RC_RET_VOID);
2076                                 RC_IF_ERROR((level < 0) || (level > deLog2Floor32(GL_MAX_3D_TEXTURE_SIZE)),     GL_INVALID_VALUE,               RC_RET_VOID);
2077                         }
2078                 }
2079
2080                 Framebuffer::Attachment& fboAttachment = framebufferBinding->getAttachment(point);
2081                 for (int ndx = 0; ndx < bindingRefCount; ndx++)
2082                         releaseFboAttachmentReference(fboAttachment);
2083                 fboAttachment = Framebuffer::Attachment();
2084
2085                 if (texObj)
2086                 {
2087                         fboAttachment.type                      = Framebuffer::ATTACHMENTTYPE_TEXTURE;
2088                         fboAttachment.name                      = texObj->getName();
2089                         fboAttachment.texTarget         = texLayeredTypeToTarget(texObj->getType());
2090                         fboAttachment.level                     = level;
2091                         fboAttachment.layer                     = layer;
2092
2093                         DE_ASSERT(fboAttachment.texTarget != Framebuffer::TEXTARGET_LAST);
2094
2095                         for (int ndx = 0; ndx < bindingRefCount; ndx++)
2096                                 acquireFboAttachmentReference(fboAttachment);
2097                 }
2098         }
2099 }
2100
2101 void ReferenceContext::framebufferRenderbuffer (deUint32 target, deUint32 attachment, deUint32 renderbuffertarget, deUint32 renderbuffer)
2102 {
2103         if (attachment == GL_DEPTH_STENCIL_ATTACHMENT)
2104         {
2105                 // Attach both to depth and stencil.
2106                 framebufferRenderbuffer(target, GL_DEPTH_ATTACHMENT,    renderbuffertarget, renderbuffer);
2107                 framebufferRenderbuffer(target, GL_STENCIL_ATTACHMENT,  renderbuffertarget, renderbuffer);
2108         }
2109         else
2110         {
2111                 Framebuffer::AttachmentPoint    point                   = mapGLAttachmentPoint(attachment);
2112                 Renderbuffer*                                   rbo                             = DE_NULL;
2113
2114                 RC_IF_ERROR(target != GL_FRAMEBUFFER            &&
2115                                         target != GL_DRAW_FRAMEBUFFER   &&
2116                                         target != GL_READ_FRAMEBUFFER,                          GL_INVALID_ENUM,                RC_RET_VOID);
2117                 RC_IF_ERROR(point == Framebuffer::ATTACHMENTPOINT_LAST, GL_INVALID_ENUM,                RC_RET_VOID);
2118
2119                 // Select binding point.
2120                 rc::Framebuffer* framebufferBinding = (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER) ? m_drawFramebufferBinding : m_readFramebufferBinding;
2121                 RC_IF_ERROR(!framebufferBinding, GL_INVALID_OPERATION, RC_RET_VOID);
2122
2123                 // If framebuffer object is bound for both reading and writing then we need to acquire/release multiple references.
2124                 int bindingRefCount = (framebufferBinding == m_drawFramebufferBinding ? 1 : 0)
2125                                                         + (framebufferBinding == m_readFramebufferBinding ? 1 : 0);
2126
2127                 if (renderbuffer != 0)
2128                 {
2129                         rbo = m_renderbuffers.find(renderbuffer);
2130
2131                         RC_IF_ERROR(renderbuffertarget != GL_RENDERBUFFER,      GL_INVALID_ENUM,                RC_RET_VOID);
2132                         RC_IF_ERROR(!rbo,                                                                       GL_INVALID_OPERATION,   RC_RET_VOID);
2133                 }
2134
2135                 Framebuffer::Attachment& fboAttachment = framebufferBinding->getAttachment(point);
2136                 for (int ndx = 0; ndx < bindingRefCount; ndx++)
2137                         releaseFboAttachmentReference(fboAttachment);
2138                 fboAttachment = Framebuffer::Attachment();
2139
2140                 if (rbo)
2141                 {
2142                         fboAttachment.type      = Framebuffer::ATTACHMENTTYPE_RENDERBUFFER;
2143                         fboAttachment.name      = rbo->getName();
2144
2145                         for (int ndx = 0; ndx < bindingRefCount; ndx++)
2146                                 acquireFboAttachmentReference(fboAttachment);
2147                 }
2148         }
2149 }
2150
2151 deUint32 ReferenceContext::checkFramebufferStatus (deUint32 target)
2152 {
2153         RC_IF_ERROR(target != GL_FRAMEBUFFER            &&
2154                                 target != GL_DRAW_FRAMEBUFFER   &&
2155                                 target != GL_READ_FRAMEBUFFER, GL_INVALID_ENUM, 0);
2156
2157         // Select binding point.
2158         rc::Framebuffer* framebufferBinding = (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER) ? m_drawFramebufferBinding : m_readFramebufferBinding;
2159
2160         // Default framebuffer is always complete.
2161         if (!framebufferBinding)
2162                 return GL_FRAMEBUFFER_COMPLETE;
2163
2164         int             width                           = -1;
2165         int             height                          = -1;
2166         bool    hasAttachment           = false;
2167         bool    attachmentComplete      = true;
2168         bool    dimensionsOk            = true;
2169
2170         for (int point = 0; point < Framebuffer::ATTACHMENTPOINT_LAST; point++)
2171         {
2172                 const Framebuffer::Attachment&  attachment                      = framebufferBinding->getAttachment((Framebuffer::AttachmentPoint)point);
2173                 int                                                             attachmentWidth         = 0;
2174                 int                                                             attachmentHeight        = 0;
2175                 tcu::TextureFormat                              attachmentFormat;
2176
2177                 if (attachment.type == Framebuffer::ATTACHMENTTYPE_TEXTURE)
2178                 {
2179                         const Texture*                                  texture = m_textures.find(attachment.name);
2180                         tcu::ConstPixelBufferAccess             level;
2181                         TCU_CHECK(texture);
2182
2183                         if (attachment.texTarget == Framebuffer::TEXTARGET_2D)
2184                         {
2185                                 DE_ASSERT(texture->getType() == Texture::TYPE_2D);
2186                                 const Texture2D* tex2D = static_cast<const Texture2D*>(texture);
2187
2188                                 if (tex2D->hasLevel(attachment.level))
2189                                         level = tex2D->getLevel(attachment.level);
2190                         }
2191                         else if (deInRange32(attachment.texTarget, Framebuffer::TEXTARGET_CUBE_MAP_POSITIVE_X,
2192                                                                                                            Framebuffer::TEXTARGET_CUBE_MAP_NEGATIVE_Z))
2193                         {
2194                                 DE_ASSERT(texture->getType() == Texture::TYPE_CUBE_MAP);
2195
2196                                 const TextureCube*      texCube = static_cast<const TextureCube*>(texture);
2197                                 const tcu::CubeFace     face    = texTargetToFace(attachment.texTarget);
2198                                 TCU_CHECK(de::inBounds<int>(face, 0, tcu::CUBEFACE_LAST));
2199
2200                                 if (texCube->hasFace(attachment.level, face))
2201                                         level = texCube->getFace(attachment.level, face);
2202                         }
2203                         else if (attachment.texTarget == Framebuffer::TEXTARGET_2D_ARRAY)
2204                         {
2205                                 DE_ASSERT(texture->getType() == Texture::TYPE_2D_ARRAY);
2206                                 const Texture2DArray* tex2DArr = static_cast<const Texture2DArray*>(texture);
2207
2208                                 if (tex2DArr->hasLevel(attachment.level))
2209                                         level = tex2DArr->getLevel(attachment.level); // \note Slice doesn't matter here.
2210                         }
2211                         else if (attachment.texTarget == Framebuffer::TEXTARGET_3D)
2212                         {
2213                                 DE_ASSERT(texture->getType() == Texture::TYPE_3D);
2214                                 const Texture3D* tex3D = static_cast<const Texture3D*>(texture);
2215
2216                                 if (tex3D->hasLevel(attachment.level))
2217                                         level = tex3D->getLevel(attachment.level); // \note Slice doesn't matter here.
2218                         }
2219                         else if (attachment.texTarget == Framebuffer::TEXTARGET_CUBE_MAP_ARRAY)
2220                         {
2221                                 DE_ASSERT(texture->getType() == Texture::TYPE_CUBE_MAP_ARRAY);
2222                                 const TextureCubeArray* texCubeArr = static_cast<const TextureCubeArray*>(texture);
2223
2224                                 if (texCubeArr->hasLevel(attachment.level))
2225                                         level = texCubeArr->getLevel(attachment.level); // \note Slice doesn't matter here.
2226                         }
2227                         else
2228                                 TCU_FAIL("Framebuffer attached to a texture but no valid target specified");
2229
2230                         attachmentWidth         = level.getWidth();
2231                         attachmentHeight        = level.getHeight();
2232                         attachmentFormat        = level.getFormat();
2233                 }
2234                 else if (attachment.type == Framebuffer::ATTACHMENTTYPE_RENDERBUFFER)
2235                 {
2236                         const Renderbuffer* renderbuffer = m_renderbuffers.find(attachment.name);
2237                         TCU_CHECK(renderbuffer);
2238
2239                         attachmentWidth         = renderbuffer->getWidth();
2240                         attachmentHeight        = renderbuffer->getHeight();
2241                         attachmentFormat        = renderbuffer->getFormat();
2242                 }
2243                 else
2244                 {
2245                         TCU_CHECK(attachment.type == Framebuffer::ATTACHMENTTYPE_LAST);
2246                         continue; // Skip rest of checks.
2247                 }
2248
2249                 if (!hasAttachment && attachmentWidth > 0 && attachmentHeight > 0)
2250                 {
2251                         width                   = attachmentWidth;
2252                         height                  = attachmentHeight;
2253                         hasAttachment   = true;
2254                 }
2255                 else if (attachmentWidth != width || attachmentHeight != height)
2256                         dimensionsOk = false;
2257
2258                 // Validate attachment point compatibility.
2259                 switch (attachmentFormat.order)
2260                 {
2261                         case TextureFormat::R:
2262                         case TextureFormat::RG:
2263                         case TextureFormat::RGB:
2264                         case TextureFormat::RGBA:
2265                         case TextureFormat::sRGB:
2266                         case TextureFormat::sRGBA:
2267                                 if (point != Framebuffer::ATTACHMENTPOINT_COLOR0)
2268                                         attachmentComplete = false;
2269                                 break;
2270
2271                         case TextureFormat::D:
2272                                 if (point != Framebuffer::ATTACHMENTPOINT_DEPTH)
2273                                         attachmentComplete = false;
2274                                 break;
2275
2276                         case TextureFormat::S:
2277                                 if (point != Framebuffer::ATTACHMENTPOINT_STENCIL)
2278                                         attachmentComplete = false;
2279                                 break;
2280
2281                         case TextureFormat::DS:
2282                                 if (point != Framebuffer::ATTACHMENTPOINT_DEPTH &&
2283                                         point != Framebuffer::ATTACHMENTPOINT_STENCIL)
2284                                         attachmentComplete = false;
2285                                 break;
2286
2287                         default:
2288                                 TCU_FAIL("Unsupported attachment channel order");
2289                 }
2290         }
2291
2292         if (!attachmentComplete)
2293                 return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
2294         else if (!hasAttachment)
2295                 return GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
2296         else if (!dimensionsOk)
2297                 return GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS;
2298         else
2299                 return GL_FRAMEBUFFER_COMPLETE;
2300 }
2301
2302 void ReferenceContext::getFramebufferAttachmentParameteriv (deUint32 target, deUint32 attachment, deUint32 pname, int* params)
2303 {
2304         DE_UNREF(target && attachment && pname && params);
2305         TCU_CHECK(false); // \todo [pyry] Implement
2306 }
2307
2308 void ReferenceContext::renderbufferStorage (deUint32 target, deUint32 internalformat, int width, int height)
2309 {
2310         TextureFormat format = glu::mapGLInternalFormat(internalformat);
2311
2312         RC_IF_ERROR(target != GL_RENDERBUFFER, GL_INVALID_ENUM, RC_RET_VOID);
2313         RC_IF_ERROR(!m_renderbufferBinding, GL_INVALID_OPERATION, RC_RET_VOID);
2314         RC_IF_ERROR(!deInRange32(width, 0, m_limits.maxRenderbufferSize) ||
2315                                 !deInRange32(height, 0, m_limits.maxRenderbufferSize),
2316                                 GL_INVALID_OPERATION, RC_RET_VOID);
2317         RC_IF_ERROR(format.order == TextureFormat::CHANNELORDER_LAST ||
2318                                 format.type == TextureFormat::CHANNELTYPE_LAST, GL_INVALID_ENUM, RC_RET_VOID);
2319
2320         m_renderbufferBinding->setStorage(format, (int)width, (int)height);
2321 }
2322
2323 void ReferenceContext::renderbufferStorageMultisample (deUint32 target, int samples, deUint32 internalFormat, int width, int height)
2324 {
2325         // \todo [2012-04-07 pyry] Implement MSAA support.
2326         DE_UNREF(samples);
2327         renderbufferStorage(target, internalFormat, width, height);
2328 }
2329
2330 tcu::PixelBufferAccess ReferenceContext::getFboAttachment (const rc::Framebuffer& framebuffer, rc::Framebuffer::AttachmentPoint point)
2331 {
2332         const Framebuffer::Attachment& attachment = framebuffer.getAttachment(point);
2333
2334         switch (attachment.type)
2335         {
2336                 case Framebuffer::ATTACHMENTTYPE_TEXTURE:
2337                 {
2338                         Texture* texture = m_textures.find(attachment.name);
2339                         TCU_CHECK(texture);
2340
2341                         if (texture->getType() == Texture::TYPE_2D)
2342                                 return dynamic_cast<Texture2D*>(texture)->getLevel(attachment.level);
2343                         else if (texture->getType() == Texture::TYPE_CUBE_MAP)
2344                                 return dynamic_cast<TextureCube*>(texture)->getFace(attachment.level, texTargetToFace(attachment.texTarget));
2345                         else if (texture->getType() == Texture::TYPE_2D_ARRAY   ||
2346                                          texture->getType() == Texture::TYPE_3D                 ||
2347                                          texture->getType() == Texture::TYPE_CUBE_MAP_ARRAY)
2348                         {
2349                                 tcu::PixelBufferAccess level;
2350
2351                                 if (texture->getType() == Texture::TYPE_2D_ARRAY)
2352                                         level = dynamic_cast<Texture2DArray*>(texture)->getLevel(attachment.level);
2353                                 else if (texture->getType() == Texture::TYPE_3D)
2354                                         level = dynamic_cast<Texture3D*>(texture)->getLevel(attachment.level);
2355                                 else if (texture->getType() == Texture::TYPE_CUBE_MAP_ARRAY)
2356                                         level = dynamic_cast<TextureCubeArray*>(texture)->getLevel(attachment.level);
2357
2358                                 void* layerData = static_cast<deUint8*>(level.getDataPtr()) + level.getSlicePitch() * attachment.layer;
2359
2360                                 return tcu::PixelBufferAccess(level.getFormat(), level.getWidth(), level.getHeight(), 1, level.getRowPitch(), 0, layerData);
2361                         }
2362                         else
2363                                 return nullAccess();
2364                 }
2365
2366                 case Framebuffer::ATTACHMENTTYPE_RENDERBUFFER:
2367                 {
2368                         Renderbuffer* rbo = m_renderbuffers.find(attachment.name);
2369                         TCU_CHECK(rbo);
2370
2371                         return rbo->getAccess();
2372                 }
2373
2374                 default:
2375                         return nullAccess();
2376         }
2377 }
2378
2379 const Texture2D& ReferenceContext::getTexture2D (int unitNdx) const
2380 {
2381         const TextureUnit& unit = m_textureUnits[unitNdx];
2382         return unit.tex2DBinding ? *unit.tex2DBinding : unit.default2DTex;
2383 }
2384
2385 const TextureCube& ReferenceContext::getTextureCube (int unitNdx) const
2386 {
2387         const TextureUnit& unit = m_textureUnits[unitNdx];
2388         return unit.texCubeBinding ? *unit.texCubeBinding : unit.defaultCubeTex;
2389 }
2390
2391 static bool isValidBufferTarget (deUint32 target)
2392 {
2393         switch (target)
2394         {
2395                 case GL_ARRAY_BUFFER:
2396                 case GL_COPY_READ_BUFFER:
2397                 case GL_COPY_WRITE_BUFFER:
2398                 case GL_DRAW_INDIRECT_BUFFER:
2399                 case GL_ELEMENT_ARRAY_BUFFER:
2400                 case GL_PIXEL_PACK_BUFFER:
2401                 case GL_PIXEL_UNPACK_BUFFER:
2402                 case GL_TRANSFORM_FEEDBACK_BUFFER:
2403                 case GL_UNIFORM_BUFFER:
2404                         return true;
2405
2406                 default:
2407                         return false;
2408         }
2409 }
2410
2411 void ReferenceContext::setBufferBinding (deUint32 target, DataBuffer* buffer)
2412 {
2413         DataBuffer** bindingPoint = DE_NULL;
2414         VertexArray* vertexArrayObject = (m_vertexArrayBinding) ? (m_vertexArrayBinding) : (&m_clientVertexArray);
2415
2416         switch (target)
2417         {
2418                 case GL_ARRAY_BUFFER:                           bindingPoint = &m_arrayBufferBinding;                                                           break;
2419                 case GL_COPY_READ_BUFFER:                       bindingPoint = &m_copyReadBufferBinding;                                                        break;
2420                 case GL_COPY_WRITE_BUFFER:                      bindingPoint = &m_copyWriteBufferBinding;                                                       break;
2421                 case GL_DRAW_INDIRECT_BUFFER:           bindingPoint = &m_drawIndirectBufferBinding;                                            break;
2422                 case GL_ELEMENT_ARRAY_BUFFER:           bindingPoint = &vertexArrayObject->m_elementArrayBufferBinding;         break;
2423                 case GL_PIXEL_PACK_BUFFER:                      bindingPoint = &m_pixelPackBufferBinding;                                                       break;
2424                 case GL_PIXEL_UNPACK_BUFFER:            bindingPoint = &m_pixelUnpackBufferBinding;                                                     break;
2425                 case GL_TRANSFORM_FEEDBACK_BUFFER:      bindingPoint = &m_transformFeedbackBufferBinding;                                       break;
2426                 case GL_UNIFORM_BUFFER:                         bindingPoint = &m_uniformBufferBinding;                                                         break;
2427                 default:
2428                         DE_ASSERT(false);
2429                         return;
2430         }
2431
2432         if (*bindingPoint)
2433         {
2434                 m_buffers.releaseReference(*bindingPoint);
2435                 *bindingPoint = DE_NULL;
2436         }
2437
2438         if (buffer)
2439                 m_buffers.acquireReference(buffer);
2440
2441         *bindingPoint = buffer;
2442 }
2443
2444 DataBuffer* ReferenceContext::getBufferBinding (deUint32 target) const
2445 {
2446         const VertexArray* vertexArrayObject = (m_vertexArrayBinding) ? (m_vertexArrayBinding) : (&m_clientVertexArray);
2447
2448         switch (target)
2449         {
2450                 case GL_ARRAY_BUFFER:                           return m_arrayBufferBinding;
2451                 case GL_COPY_READ_BUFFER:                       return m_copyReadBufferBinding;
2452                 case GL_COPY_WRITE_BUFFER:                      return m_copyWriteBufferBinding;
2453                 case GL_DRAW_INDIRECT_BUFFER:           return m_drawIndirectBufferBinding;
2454                 case GL_ELEMENT_ARRAY_BUFFER:           return vertexArrayObject->m_elementArrayBufferBinding;
2455                 case GL_PIXEL_PACK_BUFFER:                      return m_pixelPackBufferBinding;
2456                 case GL_PIXEL_UNPACK_BUFFER:            return m_pixelUnpackBufferBinding;
2457                 case GL_TRANSFORM_FEEDBACK_BUFFER:      return m_transformFeedbackBufferBinding;
2458                 case GL_UNIFORM_BUFFER:                         return m_uniformBufferBinding;
2459                 default:
2460                         DE_ASSERT(false);
2461                         return DE_NULL;
2462         }
2463 }
2464
2465 void ReferenceContext::bindBuffer (deUint32 target, deUint32 buffer)
2466 {
2467         RC_IF_ERROR(!isValidBufferTarget(target), GL_INVALID_ENUM, RC_RET_VOID);
2468
2469         rc::DataBuffer* bufObj  = DE_NULL;
2470
2471         if (buffer != 0)
2472         {
2473                 bufObj = m_buffers.find(buffer);
2474                 if (!bufObj)
2475                 {
2476                         bufObj = new DataBuffer(buffer);
2477                         m_buffers.insert(bufObj);
2478                 }
2479         }
2480
2481         setBufferBinding(target, bufObj);
2482 }
2483
2484 void ReferenceContext::genBuffers (int numBuffers, deUint32* buffers)
2485 {
2486         RC_IF_ERROR(!buffers, GL_INVALID_VALUE, RC_RET_VOID);
2487
2488         for (int ndx = 0; ndx < numBuffers; ndx++)
2489                 buffers[ndx] = m_buffers.allocateName();
2490 }
2491
2492 void ReferenceContext::deleteBuffers (int numBuffers, const deUint32* buffers)
2493 {
2494         RC_IF_ERROR(numBuffers < 0, GL_INVALID_VALUE, RC_RET_VOID);
2495
2496         for (int ndx = 0; ndx < numBuffers; ndx++)
2497         {
2498                 deUint32        buffer  = buffers[ndx];
2499                 DataBuffer*     bufObj  = DE_NULL;
2500
2501                 if (buffer == 0)
2502                         continue;
2503
2504                 bufObj = m_buffers.find(buffer);
2505
2506                 if (bufObj)
2507                         deleteBuffer(bufObj);
2508         }
2509 }
2510
2511 void ReferenceContext::deleteBuffer (DataBuffer* buffer)
2512 {
2513         static const deUint32 bindingPoints[] =
2514         {
2515                 GL_ARRAY_BUFFER,
2516                 GL_COPY_READ_BUFFER,
2517                 GL_COPY_WRITE_BUFFER,
2518                 GL_DRAW_INDIRECT_BUFFER,
2519                 GL_ELEMENT_ARRAY_BUFFER,
2520                 GL_PIXEL_PACK_BUFFER,
2521                 GL_PIXEL_UNPACK_BUFFER,
2522                 GL_TRANSFORM_FEEDBACK_BUFFER,
2523                 GL_UNIFORM_BUFFER
2524         };
2525
2526         for (int bindingNdx = 0; bindingNdx < DE_LENGTH_OF_ARRAY(bindingPoints); bindingNdx++)
2527         {
2528                 if (getBufferBinding(bindingPoints[bindingNdx]) == buffer)
2529                         setBufferBinding(bindingPoints[bindingNdx], DE_NULL);
2530         }
2531
2532         {
2533                 vector<VertexArray*> vertexArrays;
2534                 m_vertexArrays.getAll(vertexArrays);
2535                 vertexArrays.push_back(&m_clientVertexArray);
2536
2537                 for (vector<VertexArray*>::iterator i = vertexArrays.begin(); i != vertexArrays.end(); i++)
2538                 {
2539                         if ((*i)->m_elementArrayBufferBinding == buffer)
2540                         {
2541                                 m_buffers.releaseReference(buffer);
2542                                 (*i)->m_elementArrayBufferBinding = DE_NULL;
2543                         }
2544
2545                         for (size_t vertexAttribNdx = 0; vertexAttribNdx < (*i)->m_arrays.size(); ++vertexAttribNdx)
2546                         {
2547                                 if ((*i)->m_arrays[vertexAttribNdx].bufferBinding == buffer)
2548                                 {
2549                                         m_buffers.releaseReference(buffer);
2550                                         (*i)->m_arrays[vertexAttribNdx].bufferDeleted = true;
2551                                         (*i)->m_arrays[vertexAttribNdx].bufferBinding = DE_NULL;
2552                                 }
2553                         }
2554                 }
2555         }
2556
2557         DE_ASSERT(buffer->getRefCount() == 1);
2558         m_buffers.releaseReference(buffer);
2559 }
2560
2561 void ReferenceContext::bufferData (deUint32 target, deIntptr size, const void* data, deUint32 usage)
2562 {
2563         RC_IF_ERROR(!isValidBufferTarget(target), GL_INVALID_ENUM, RC_RET_VOID);
2564         RC_IF_ERROR(size < 0, GL_INVALID_VALUE, RC_RET_VOID);
2565
2566         DE_UNREF(usage);
2567
2568         DataBuffer* buffer = getBufferBinding(target);
2569         RC_IF_ERROR(!buffer, GL_INVALID_OPERATION, RC_RET_VOID);
2570
2571         DE_ASSERT((deIntptr)(int)size == size);
2572         buffer->setStorage((int)size);
2573         if (data)
2574                 deMemcpy(buffer->getData(), data, (int)size);
2575 }
2576
2577 void ReferenceContext::bufferSubData (deUint32 target, deIntptr offset, deIntptr size, const void* data)
2578 {
2579         RC_IF_ERROR(!isValidBufferTarget(target), GL_INVALID_ENUM, RC_RET_VOID);
2580         RC_IF_ERROR(offset < 0 || size < 0, GL_INVALID_VALUE, RC_RET_VOID);
2581
2582         DataBuffer* buffer = getBufferBinding(target);
2583
2584         RC_IF_ERROR(!buffer, GL_INVALID_OPERATION, RC_RET_VOID);
2585         RC_IF_ERROR((int)(offset+size) > buffer->getSize(), GL_INVALID_VALUE, RC_RET_VOID);
2586
2587         deMemcpy(buffer->getData()+offset, data, (int)size);
2588 }
2589
2590 void ReferenceContext::clearColor (float red, float green, float blue, float alpha)
2591 {
2592         m_clearColor = Vec4(de::clamp(red,      0.0f, 1.0f),
2593                                                 de::clamp(green,        0.0f, 1.0f),
2594                                                 de::clamp(blue, 0.0f, 1.0f),
2595                                                 de::clamp(alpha,        0.0f, 1.0f));
2596 }
2597
2598 void ReferenceContext::clearDepthf (float depth)
2599 {
2600         m_clearDepth = de::clamp(depth, 0.0f, 1.0f);
2601 }
2602
2603 void ReferenceContext::clearStencil (int stencil)
2604 {
2605         m_clearStencil = stencil;
2606 }
2607
2608 void ReferenceContext::scissor (int x, int y, int width, int height)
2609 {
2610         RC_IF_ERROR(width < 0 || height < 0, GL_INVALID_VALUE, RC_RET_VOID);
2611         m_scissorBox = IVec4(x, y, width, height);
2612 }
2613
2614 void ReferenceContext::enable (deUint32 cap)
2615 {
2616         switch (cap)
2617         {
2618                 case GL_BLEND:                                  m_blendEnabled                          = true; break;
2619                 case GL_SCISSOR_TEST:                   m_scissorEnabled                        = true; break;
2620                 case GL_DEPTH_TEST:                             m_depthTestEnabled                      = true; break;
2621                 case GL_STENCIL_TEST:                   m_stencilTestEnabled            = true; break;
2622                 case GL_POLYGON_OFFSET_FILL:    m_polygonOffsetFillEnabled      = true; break;
2623
2624                 case GL_FRAMEBUFFER_SRGB:
2625                         if (glu::isContextTypeGLCore(getType()))
2626                         {
2627                                 m_sRGBUpdateEnabled = true;
2628                                 break;
2629                         }
2630                         setError(GL_INVALID_ENUM);
2631                         break;
2632
2633                 case GL_DEPTH_CLAMP:
2634                         if (glu::isContextTypeGLCore(getType()))
2635                         {
2636                                 m_depthClampEnabled = true;
2637                                 break;
2638                         }
2639                         setError(GL_INVALID_ENUM);
2640                         break;
2641
2642                 case GL_DITHER:
2643                         // Not implemented - just ignored.
2644                         break;
2645
2646                 case GL_PRIMITIVE_RESTART_FIXED_INDEX:
2647                         if (!glu::isContextTypeGLCore(getType()))
2648                         {
2649                                 m_primitiveRestartFixedIndex = true;
2650                                 break;
2651                         }
2652                         setError(GL_INVALID_ENUM);
2653                         break;
2654
2655                 case GL_PRIMITIVE_RESTART:
2656                         if (glu::isContextTypeGLCore(getType()))
2657                         {
2658                                 m_primitiveRestartSettableIndex = true;
2659                                 break;
2660                         }
2661                         setError(GL_INVALID_ENUM);
2662                         break;
2663
2664                 default:
2665                         setError(GL_INVALID_ENUM);
2666                         break;
2667         }
2668 }
2669
2670 void ReferenceContext::disable (deUint32 cap)
2671 {
2672         switch (cap)
2673         {
2674                 case GL_BLEND:                                  m_blendEnabled                          = false;        break;
2675                 case GL_SCISSOR_TEST:                   m_scissorEnabled                        = false;        break;
2676                 case GL_DEPTH_TEST:                             m_depthTestEnabled                      = false;        break;
2677                 case GL_STENCIL_TEST:                   m_stencilTestEnabled            = false;        break;
2678                 case GL_POLYGON_OFFSET_FILL:    m_polygonOffsetFillEnabled      = false;        break;
2679
2680                 case GL_FRAMEBUFFER_SRGB:
2681                         if (glu::isContextTypeGLCore(getType()))
2682                         {
2683                                 m_sRGBUpdateEnabled = false;
2684                                 break;
2685                         }
2686                         setError(GL_INVALID_ENUM);
2687                         break;
2688
2689                 case GL_DEPTH_CLAMP:
2690                         if (glu::isContextTypeGLCore(getType()))
2691                         {
2692                                 m_depthClampEnabled = false;
2693                                 break;
2694                         }
2695                         setError(GL_INVALID_ENUM);
2696                         break;
2697
2698                 case GL_DITHER:
2699                         break;
2700
2701                 case GL_PRIMITIVE_RESTART_FIXED_INDEX:
2702                         if (!glu::isContextTypeGLCore(getType()))
2703                         {
2704                                 m_primitiveRestartFixedIndex = false;
2705                                 break;
2706                         }
2707                         setError(GL_INVALID_ENUM);
2708                         break;
2709
2710                 case GL_PRIMITIVE_RESTART:
2711                         if (glu::isContextTypeGLCore(getType()))
2712                         {
2713                                 m_primitiveRestartSettableIndex = false;
2714                                 break;
2715                         }
2716                         setError(GL_INVALID_ENUM);
2717                         break;
2718
2719                 default:
2720                         setError(GL_INVALID_ENUM);
2721                         break;
2722         }
2723 }
2724
2725 static bool isValidCompareFunc (deUint32 func)
2726 {
2727         switch (func)
2728         {
2729                 case GL_NEVER:
2730                 case GL_LESS:
2731                 case GL_LEQUAL:
2732                 case GL_GREATER:
2733                 case GL_GEQUAL:
2734                 case GL_EQUAL:
2735                 case GL_NOTEQUAL:
2736                 case GL_ALWAYS:
2737                         return true;
2738
2739                 default:
2740                         return false;
2741         }
2742 }
2743
2744 static bool isValidStencilOp (deUint32 op)
2745 {
2746         switch (op)
2747         {
2748                 case GL_KEEP:
2749                 case GL_ZERO:
2750                 case GL_REPLACE:
2751                 case GL_INCR:
2752                 case GL_INCR_WRAP:
2753                 case GL_DECR:
2754                 case GL_DECR_WRAP:
2755                 case GL_INVERT:
2756                         return true;
2757
2758                 default:
2759                         return false;
2760         }
2761 }
2762
2763 void ReferenceContext::stencilFunc (deUint32 func, int ref, deUint32 mask)
2764 {
2765         stencilFuncSeparate(GL_FRONT_AND_BACK, func, ref, mask);
2766 }
2767
2768 void ReferenceContext::stencilFuncSeparate (deUint32 face, deUint32 func, int ref, deUint32 mask)
2769 {
2770         const bool      setFront        = face == GL_FRONT || face == GL_FRONT_AND_BACK;
2771         const bool      setBack         = face == GL_BACK || face == GL_FRONT_AND_BACK;
2772
2773         RC_IF_ERROR(!isValidCompareFunc(func), GL_INVALID_ENUM, RC_RET_VOID);
2774         RC_IF_ERROR(!setFront && !setBack, GL_INVALID_ENUM, RC_RET_VOID);
2775
2776         for (int type = 0; type < rr::FACETYPE_LAST; ++type)
2777         {
2778                 if ((type == rr::FACETYPE_FRONT && setFront) ||
2779                         (type == rr::FACETYPE_BACK && setBack))
2780                 {
2781                         m_stencil[type].func    = func;
2782                         m_stencil[type].ref             = ref;
2783                         m_stencil[type].opMask  = mask;
2784                 }
2785         }
2786 }
2787
2788 void ReferenceContext::stencilOp (deUint32 sfail, deUint32 dpfail, deUint32 dppass)
2789 {
2790         stencilOpSeparate(GL_FRONT_AND_BACK, sfail, dpfail, dppass);
2791 }
2792
2793 void ReferenceContext::stencilOpSeparate (deUint32 face, deUint32 sfail, deUint32 dpfail, deUint32 dppass)
2794 {
2795         const bool      setFront        = face == GL_FRONT || face == GL_FRONT_AND_BACK;
2796         const bool      setBack         = face == GL_BACK || face == GL_FRONT_AND_BACK;
2797
2798         RC_IF_ERROR(!isValidStencilOp(sfail)    ||
2799                                 !isValidStencilOp(dpfail)       ||
2800                                 !isValidStencilOp(dppass),
2801                                 GL_INVALID_ENUM, RC_RET_VOID);
2802         RC_IF_ERROR(!setFront && !setBack, GL_INVALID_ENUM, RC_RET_VOID);
2803
2804         for (int type = 0; type < rr::FACETYPE_LAST; ++type)
2805         {
2806                 if ((type == rr::FACETYPE_FRONT && setFront) ||
2807                         (type == rr::FACETYPE_BACK && setBack))
2808                 {
2809                         m_stencil[type].opStencilFail   = sfail;
2810                         m_stencil[type].opDepthFail             = dpfail;
2811                         m_stencil[type].opDepthPass             = dppass;
2812                 }
2813         }
2814 }
2815
2816 void ReferenceContext::depthFunc (deUint32 func)
2817 {
2818         RC_IF_ERROR(!isValidCompareFunc(func), GL_INVALID_ENUM, RC_RET_VOID);
2819         m_depthFunc = func;
2820 }
2821
2822 void ReferenceContext::depthRangef (float n, float f)
2823 {
2824         m_depthRangeNear = de::clamp(n, 0.0f, 1.0f);
2825         m_depthRangeFar = de::clamp(f, 0.0f, 1.0f);
2826 }
2827
2828 void ReferenceContext::depthRange (double n, double f)
2829 {
2830         depthRangef((float)n, (float)f);
2831 }
2832
2833 void ReferenceContext::polygonOffset (float factor, float units)
2834 {
2835         m_polygonOffsetFactor = factor;
2836         m_polygonOffsetUnits = units;
2837 }
2838
2839 void ReferenceContext::provokingVertex (deUint32 convention)
2840 {
2841         // only in core
2842         DE_ASSERT(glu::isContextTypeGLCore(getType()));
2843
2844         switch (convention)
2845         {
2846                 case GL_FIRST_VERTEX_CONVENTION:        m_provokingFirstVertexConvention = true; break;
2847                 case GL_LAST_VERTEX_CONVENTION:         m_provokingFirstVertexConvention = false; break;
2848
2849                 default:
2850                         RC_ERROR_RET(GL_INVALID_ENUM, RC_RET_VOID);
2851         }
2852 }
2853
2854 void ReferenceContext::primitiveRestartIndex (deUint32 index)
2855 {
2856         // only in core
2857         DE_ASSERT(glu::isContextTypeGLCore(getType()));
2858         m_primitiveRestartIndex = index;
2859 }
2860
2861 static inline bool isValidBlendEquation (deUint32 mode)
2862 {
2863         return mode == GL_FUNC_ADD                              ||
2864                    mode == GL_FUNC_SUBTRACT                     ||
2865                    mode == GL_FUNC_REVERSE_SUBTRACT     ||
2866                    mode == GL_MIN                                       ||
2867                    mode == GL_MAX;
2868 }
2869
2870 static bool isValidBlendFactor (deUint32 factor)
2871 {
2872         switch (factor)
2873         {
2874                 case GL_ZERO:
2875                 case GL_ONE:
2876                 case GL_SRC_COLOR:
2877                 case GL_ONE_MINUS_SRC_COLOR:
2878                 case GL_DST_COLOR:
2879                 case GL_ONE_MINUS_DST_COLOR:
2880                 case GL_SRC_ALPHA:
2881                 case GL_ONE_MINUS_SRC_ALPHA:
2882                 case GL_DST_ALPHA:
2883                 case GL_ONE_MINUS_DST_ALPHA:
2884                 case GL_CONSTANT_COLOR:
2885                 case GL_ONE_MINUS_CONSTANT_COLOR:
2886                 case GL_CONSTANT_ALPHA:
2887                 case GL_ONE_MINUS_CONSTANT_ALPHA:
2888                 case GL_SRC_ALPHA_SATURATE:
2889                         return true;
2890
2891                 default:
2892                         return false;
2893         }
2894 }
2895
2896 void ReferenceContext::blendEquation (deUint32 mode)
2897 {
2898         RC_IF_ERROR(!isValidBlendEquation(mode), GL_INVALID_ENUM, RC_RET_VOID);
2899
2900         m_blendModeRGB          = mode;
2901         m_blendModeAlpha        = mode;
2902 }
2903
2904 void ReferenceContext::blendEquationSeparate (deUint32 modeRGB, deUint32 modeAlpha)
2905 {
2906         RC_IF_ERROR(!isValidBlendEquation(modeRGB) ||
2907                                 !isValidBlendEquation(modeAlpha),
2908                                 GL_INVALID_ENUM, RC_RET_VOID);
2909
2910         m_blendModeRGB          = modeRGB;
2911         m_blendModeAlpha        = modeAlpha;
2912 }
2913
2914 void ReferenceContext::blendFunc (deUint32 src, deUint32 dst)
2915 {
2916         RC_IF_ERROR(!isValidBlendFactor(src) ||
2917                                 !isValidBlendFactor(dst),
2918                                 GL_INVALID_ENUM, RC_RET_VOID);
2919
2920         m_blendFactorSrcRGB             = src;
2921         m_blendFactorSrcAlpha   = src;
2922         m_blendFactorDstRGB             = dst;
2923         m_blendFactorDstAlpha   = dst;
2924 }
2925
2926 void ReferenceContext::blendFuncSeparate (deUint32 srcRGB, deUint32 dstRGB, deUint32 srcAlpha, deUint32 dstAlpha)
2927 {
2928         RC_IF_ERROR(!isValidBlendFactor(srcRGB)         ||
2929                                 !isValidBlendFactor(dstRGB)             ||
2930                                 !isValidBlendFactor(srcAlpha)   ||
2931                                 !isValidBlendFactor(dstAlpha),
2932                                 GL_INVALID_ENUM, RC_RET_VOID);
2933
2934         m_blendFactorSrcRGB             = srcRGB;
2935         m_blendFactorSrcAlpha   = srcAlpha;
2936         m_blendFactorDstRGB             = dstRGB;
2937         m_blendFactorDstAlpha   = dstAlpha;
2938 }
2939
2940 void ReferenceContext::blendColor (float red, float green, float blue, float alpha)
2941 {
2942         m_blendColor = Vec4(de::clamp(red,      0.0f, 1.0f),
2943                                                 de::clamp(green,        0.0f, 1.0f),
2944                                                 de::clamp(blue, 0.0f, 1.0f),
2945                                                 de::clamp(alpha,        0.0f, 1.0f));
2946 }
2947
2948 void ReferenceContext::colorMask (deBool r, deBool g, deBool b, deBool a)
2949 {
2950         m_colorMask = tcu::BVec4(!!r, !!g, !!b, !!a);
2951 }
2952
2953 void ReferenceContext::depthMask (deBool mask)
2954 {
2955         m_depthMask = !!mask;
2956 }
2957
2958 void ReferenceContext::stencilMask (deUint32 mask)
2959 {
2960         stencilMaskSeparate(GL_FRONT_AND_BACK, mask);
2961 }
2962
2963 void ReferenceContext::stencilMaskSeparate (deUint32 face, deUint32 mask)
2964 {
2965         const bool      setFront        = face == GL_FRONT || face == GL_FRONT_AND_BACK;
2966         const bool      setBack         = face == GL_BACK || face == GL_FRONT_AND_BACK;
2967
2968         RC_IF_ERROR(!setFront && !setBack, GL_INVALID_ENUM, RC_RET_VOID);
2969
2970         if (setFront)   m_stencil[rr::FACETYPE_FRONT].writeMask = mask;
2971         if (setBack)    m_stencil[rr::FACETYPE_BACK].writeMask  = mask;
2972 }
2973
2974 static int getNumStencilBits (const tcu::TextureFormat& format)
2975 {
2976         switch (format.order)
2977         {
2978                 case tcu::TextureFormat::S:
2979                         switch (format.type)
2980                         {
2981                                 case tcu::TextureFormat::UNSIGNED_INT8:         return 8;
2982                                 case tcu::TextureFormat::UNSIGNED_INT16:        return 16;
2983                                 case tcu::TextureFormat::UNSIGNED_INT32:        return 32;
2984                                 default:
2985                                         DE_ASSERT(false);
2986                                         return 0;
2987                         }
2988
2989                 case tcu::TextureFormat::DS:
2990                         switch (format.type)
2991                         {
2992                                 case tcu::TextureFormat::UNSIGNED_INT_24_8:                             return 8;
2993                                 case tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV:   return 8;
2994                                 default:
2995                                         DE_ASSERT(false);
2996                                         return 0;
2997                         }
2998
2999                 default:
3000                         DE_ASSERT(false);
3001                         return 0;
3002         }
3003 }
3004
3005 static inline deUint32 maskStencil (int numBits, deUint32 s)
3006 {
3007         return s & deBitMask32(0, numBits);
3008 }
3009
3010 static inline void writeMaskedStencil (const rr::MultisamplePixelBufferAccess& access, int s, int x, int y, deUint32 stencil, deUint32 writeMask)
3011 {
3012         DE_ASSERT(access.raw().getFormat().order == tcu::TextureFormat::S);
3013
3014         const deUint32 oldVal = access.raw().getPixelUint(s, x, y).x();
3015         const deUint32 newVal = (oldVal & ~writeMask) | (stencil & writeMask);
3016         access.raw().setPixel(tcu::UVec4(newVal, 0u, 0u, 0u), s, x, y);
3017 }
3018
3019 static inline void writeDepthOnly (const rr::MultisamplePixelBufferAccess& access, int s, int x, int y, float depth)
3020 {
3021         access.raw().setPixDepth(depth, s, x, y);
3022 }
3023
3024 static rr::MultisamplePixelBufferAccess getDepthMultisampleAccess (const rr::MultisamplePixelBufferAccess& combinedDSaccess)
3025 {
3026         return rr::MultisamplePixelBufferAccess::fromMultisampleAccess(tcu::getEffectiveDepthStencilAccess(combinedDSaccess.raw(), tcu::Sampler::MODE_DEPTH));
3027 }
3028
3029 static rr::MultisamplePixelBufferAccess getStencilMultisampleAccess (const rr::MultisamplePixelBufferAccess& combinedDSaccess)
3030 {
3031         return rr::MultisamplePixelBufferAccess::fromMultisampleAccess(tcu::getEffectiveDepthStencilAccess(combinedDSaccess.raw(), tcu::Sampler::MODE_STENCIL));
3032 }
3033
3034 deUint32 ReferenceContext::blitResolveMultisampleFramebuffer (deUint32 mask, const IVec4& srcRect, const IVec4& dstRect, bool flipX, bool flipY)
3035 {
3036         if (mask & GL_COLOR_BUFFER_BIT)
3037         {
3038                 rr::MultisampleConstPixelBufferAccess   src                     = rr::getSubregion(getReadColorbuffer(), srcRect.x(), srcRect.y(), srcRect.z(), srcRect.w());
3039                 tcu::PixelBufferAccess                                  dst                     = tcu::getSubregion(getDrawColorbuffer().toSinglesampleAccess(), dstRect.x(), dstRect.y(), dstRect.z(), dstRect.w());
3040                 tcu::TextureChannelClass                                dstClass        = tcu::getTextureChannelClass(dst.getFormat().type);
3041                 bool                                                                    dstIsFloat      = dstClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT           ||
3042                                                                                                                           dstClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT     ||
3043                                                                                                                           dstClass == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT;
3044                 bool                                                                    srcIsSRGB       = tcu::isSRGB(src.raw().getFormat());
3045                 bool                                                                    dstIsSRGB       = tcu::isSRGB(dst.getFormat());
3046                 const bool                                                              convertSRGB     = m_sRGBUpdateEnabled && glu::isContextTypeES(getType());
3047
3048                 if (!convertSRGB)
3049                 {
3050                         tcu::ConstPixelBufferAccess     srcRaw  = src.raw();
3051                         tcu::TextureFormat                      srcFmt  = toNonSRGBFormat(srcRaw.getFormat());
3052
3053                         srcRaw  = tcu::ConstPixelBufferAccess(srcFmt, srcRaw.getWidth(), srcRaw.getHeight(), srcRaw.getDepth(), srcRaw.getRowPitch(), srcRaw.getSlicePitch(), srcRaw.getDataPtr());
3054                         src             = rr::MultisampleConstPixelBufferAccess::fromMultisampleAccess(srcRaw);
3055
3056                         dst             = tcu::PixelBufferAccess(toNonSRGBFormat(dst.getFormat()), dst.getWidth(), dst.getHeight(), dst.getDepth(), dst.getRowPitch(), dst.getSlicePitch(), dst.getDataPtr());
3057                 }
3058
3059                 for (int x = 0; x < dstRect.z(); ++x)
3060                 for (int y = 0; y < dstRect.w(); ++y)
3061                 {
3062                         int srcX = (flipX) ? (srcRect.z() - x - 1) : (x);
3063                         int srcY = (flipY) ? (srcRect.z() - y - 1) : (y);
3064
3065                         if (dstIsFloat || srcIsSRGB)
3066                         {
3067                                 Vec4 p = src.raw().getPixel(0, srcX,srcY);
3068                                 dst.setPixel((dstIsSRGB && convertSRGB) ? tcu::linearToSRGB(p) : p, x, y);
3069                         }
3070                         else
3071                                 dst.setPixel(src.raw().getPixelInt(0, srcX, srcY), x, y);
3072                 }
3073         }
3074
3075         if (mask & GL_DEPTH_BUFFER_BIT)
3076         {
3077                 rr::MultisampleConstPixelBufferAccess   src     = rr::getSubregion(getReadDepthbuffer(), srcRect.x(), srcRect.y(), srcRect.z(), srcRect.w());
3078                 rr::MultisamplePixelBufferAccess                dst     = rr::getSubregion(getDrawDepthbuffer(), dstRect.x(), dstRect.y(), dstRect.z(), dstRect.w());
3079
3080                 for (int x = 0; x < dstRect.z(); ++x)
3081                 for (int y = 0; y < dstRect.w(); ++y)
3082                 {
3083                         int srcX = (flipX) ? (srcRect.z() - x - 1) : (x);
3084                         int srcY = (flipY) ? (srcRect.z() - y - 1) : (y);
3085
3086                         writeDepthOnly(dst, 0, x, y, src.raw().getPixel(0, srcX, srcY).x());
3087                 }
3088         }
3089
3090         if (mask & GL_STENCIL_BUFFER_BIT)
3091         {
3092                 rr::MultisampleConstPixelBufferAccess   src     = getStencilMultisampleAccess(rr::getSubregion(getReadStencilbuffer(), srcRect.x(), srcRect.y(), srcRect.z(), srcRect.w()));
3093                 rr::MultisamplePixelBufferAccess                dst     = getStencilMultisampleAccess(rr::getSubregion(getDrawStencilbuffer(), dstRect.x(), dstRect.y(), dstRect.z(), dstRect.w()));
3094
3095                 for (int x = 0; x < dstRect.z(); ++x)
3096                 for (int y = 0; y < dstRect.w(); ++y)
3097                 {
3098                         int                     srcX            = (flipX) ? (srcRect.z() - x - 1) : (x);
3099                         int                     srcY            = (flipY) ? (srcRect.z() - y - 1) : (y);
3100                         deUint32        srcStencil      = src.raw().getPixelUint(0, srcX, srcY).x();
3101
3102                         writeMaskedStencil(dst, 0, x, y, srcStencil, m_stencil[rr::FACETYPE_FRONT].writeMask);
3103                 }
3104         }
3105
3106         return GL_NO_ERROR;
3107 }
3108
3109 void ReferenceContext::blitFramebuffer (int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, deUint32 mask, deUint32 filter)
3110 {
3111         // p0 in inclusive, p1 exclusive.
3112         // Negative width/height means swap.
3113         bool    swapSrcX        = srcX1 < srcX0;
3114         bool    swapSrcY        = srcY1 < srcY0;
3115         bool    swapDstX        = dstX1 < dstX0;
3116         bool    swapDstY        = dstY1 < dstY0;
3117         int             srcW            = de::abs(srcX1-srcX0);
3118         int             srcH            = de::abs(srcY1-srcY0);
3119         int             dstW            = de::abs(dstX1-dstX0);
3120         int             dstH            = de::abs(dstY1-dstY0);
3121         bool    scale           = srcW != dstW || srcH != dstH;
3122         int             srcOriginX      = swapSrcX ? srcX1 : srcX0;
3123         int             srcOriginY      = swapSrcY ? srcY1 : srcY0;
3124         int             dstOriginX      = swapDstX ? dstX1 : dstX0;
3125         int             dstOriginY      = swapDstY ? dstY1 : dstY0;
3126         IVec4   srcRect         = IVec4(srcOriginX, srcOriginY, srcW, srcH);
3127         IVec4   dstRect         = IVec4(dstOriginX, dstOriginY, dstW, dstH);
3128
3129         RC_IF_ERROR(filter != GL_NEAREST && filter != GL_LINEAR, GL_INVALID_ENUM, RC_RET_VOID);
3130         RC_IF_ERROR((mask & (GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT)) != 0 && filter != GL_NEAREST, GL_INVALID_OPERATION, RC_RET_VOID);
3131
3132         // Validate that both targets are complete.
3133         RC_IF_ERROR(checkFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE ||
3134                                 checkFramebufferStatus(GL_READ_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE, GL_INVALID_OPERATION, RC_RET_VOID);
3135
3136         // Check samples count is valid
3137         RC_IF_ERROR(getDrawColorbuffer().getNumSamples() != 1, GL_INVALID_OPERATION, RC_RET_VOID);
3138
3139         // Check size restrictions of multisampled case
3140         if (getReadColorbuffer().getNumSamples() != 1)
3141         {
3142                 // Src and Dst rect dimensions must be the same
3143                 RC_IF_ERROR(srcW != dstW || srcH != dstH, GL_INVALID_OPERATION, RC_RET_VOID);
3144
3145                 // Framebuffer formats must match
3146                 if (mask & GL_COLOR_BUFFER_BIT)         RC_IF_ERROR(getReadColorbuffer().raw().getFormat()   != getDrawColorbuffer().raw().getFormat(),   GL_INVALID_OPERATION, RC_RET_VOID);
3147                 if (mask & GL_DEPTH_BUFFER_BIT)         RC_IF_ERROR(getReadDepthbuffer().raw().getFormat()   != getDrawDepthbuffer().raw().getFormat(),   GL_INVALID_OPERATION, RC_RET_VOID);
3148                 if (mask & GL_STENCIL_BUFFER_BIT)       RC_IF_ERROR(getReadStencilbuffer().raw().getFormat() != getDrawStencilbuffer().raw().getFormat(), GL_INVALID_OPERATION, RC_RET_VOID);
3149         }
3150
3151         // Compute actual source rect.
3152         srcRect = (mask & GL_COLOR_BUFFER_BIT)          ? intersect(srcRect, getBufferRect(getReadColorbuffer()))       : srcRect;
3153         srcRect = (mask & GL_DEPTH_BUFFER_BIT)          ? intersect(srcRect, getBufferRect(getReadDepthbuffer()))       : srcRect;
3154         srcRect = (mask & GL_STENCIL_BUFFER_BIT)        ? intersect(srcRect, getBufferRect(getReadStencilbuffer()))     : srcRect;
3155
3156         // Compute destination rect.
3157         dstRect = (mask & GL_COLOR_BUFFER_BIT)          ? intersect(dstRect, getBufferRect(getDrawColorbuffer()))       : dstRect;
3158         dstRect = (mask & GL_DEPTH_BUFFER_BIT)          ? intersect(dstRect, getBufferRect(getDrawDepthbuffer()))       : dstRect;
3159         dstRect = (mask & GL_STENCIL_BUFFER_BIT)        ? intersect(dstRect, getBufferRect(getDrawStencilbuffer()))     : dstRect;
3160         dstRect = m_scissorEnabled                                      ? intersect(dstRect, m_scissorBox)                                                      : dstRect;
3161
3162         if (isEmpty(srcRect) || isEmpty(dstRect))
3163                 return; // Don't attempt copy.
3164
3165         // Multisampled read buffer is a special case
3166         if (getReadColorbuffer().getNumSamples() != 1)
3167         {
3168                 deUint32 error = blitResolveMultisampleFramebuffer(mask, srcRect, dstRect, swapSrcX ^ swapDstX, swapSrcY ^ swapDstY);
3169
3170                 if (error != GL_NO_ERROR)
3171                         setError(error);
3172
3173                 return;
3174         }
3175
3176         // \note Multisample pixel buffers can now be accessed like non-multisampled because multisample read buffer case is already handled. => sample count must be 1
3177
3178         // Coordinate transformation:
3179         // Dst offset space -> dst rectangle space -> src rectangle space -> src offset space.
3180         tcu::Mat3 transform = tcu::translationMatrix(Vec2((float)(srcX0 - srcRect.x()), (float)(srcY0 - srcRect.y())))
3181                                                 * tcu::Mat3(Vec3((float)(srcX1-srcX0) / (float)(dstX1-dstX0),
3182                                                                                  (float)(srcY1-srcY0) / (float)(dstY1-dstY0),
3183                                                                                  1.0f))
3184                                                 * tcu::translationMatrix(Vec2((float)(dstRect.x() - dstX0), (float)(dstRect.y() - dstY0)));
3185
3186         if (mask & GL_COLOR_BUFFER_BIT)
3187         {
3188                 tcu::ConstPixelBufferAccess             src                     = tcu::getSubregion(getReadColorbuffer().toSinglesampleAccess(), srcRect.x(), srcRect.y(), srcRect.z(), srcRect.w());
3189                 tcu::PixelBufferAccess                  dst                     = tcu::getSubregion(getDrawColorbuffer().toSinglesampleAccess(), dstRect.x(), dstRect.y(), dstRect.z(), dstRect.w());
3190                 tcu::TextureChannelClass                dstClass        = tcu::getTextureChannelClass(dst.getFormat().type);
3191                 bool                                                    dstIsFloat      = dstClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT           ||
3192                                                                                                           dstClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT     ||
3193                                                                                                           dstClass == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT;
3194                 tcu::Sampler::FilterMode                sFilter         = (scale && filter == GL_LINEAR) ? tcu::Sampler::LINEAR : tcu::Sampler::NEAREST;
3195                 tcu::Sampler                                    sampler         (tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE,
3196                                                                                                          sFilter, sFilter, 0.0f /* lod threshold */, false /* non-normalized coords */);
3197                 bool                                                    srcIsSRGB       = tcu::isSRGB(src.getFormat());
3198                 bool                                                    dstIsSRGB       = tcu::isSRGB(dst.getFormat());
3199                 const bool                                              convertSRGB     = m_sRGBUpdateEnabled && glu::isContextTypeES(getType());
3200
3201                 if (!convertSRGB)
3202                 {
3203                         src     = tcu::ConstPixelBufferAccess   (toNonSRGBFormat(src.getFormat()), src.getWidth(), src.getHeight(), src.getDepth(), src.getRowPitch(), src.getSlicePitch(), src.getDataPtr());
3204                         dst     = tcu::PixelBufferAccess                (toNonSRGBFormat(dst.getFormat()), dst.getWidth(), dst.getHeight(), dst.getDepth(), dst.getRowPitch(), dst.getSlicePitch(), dst.getDataPtr());
3205                 }
3206
3207                 // \note We don't check for unsupported conversions, unlike spec requires.
3208
3209                 for (int yo = 0; yo < dstRect.w(); yo++)
3210                 {
3211                         for (int xo = 0; xo < dstRect.z(); xo++)
3212                         {
3213                                 float   dX      = (float)xo + 0.5f;
3214                                 float   dY      = (float)yo + 0.5f;
3215
3216                                 // \note Only affine part is used.
3217                                 float   sX      = transform(0, 0)*dX + transform(0, 1)*dY + transform(0, 2);
3218                                 float   sY      = transform(1, 0)*dX + transform(1, 1)*dY + transform(1, 2);
3219
3220                                 // do not copy pixels outside the modified source region (modified by buffer intersection)
3221                                 if (sX < 0.0f || sX >= (float)srcRect.z() ||
3222                                         sY < 0.0f || sY >= (float)srcRect.w())
3223                                         continue;
3224
3225                                 if (dstIsFloat || srcIsSRGB || filter == tcu::Sampler::LINEAR)
3226                                 {
3227                                         Vec4 p = src.sample2D(sampler, sampler.minFilter, sX, sY, 0);
3228                                         dst.setPixel((dstIsSRGB && convertSRGB) ? tcu::linearToSRGB(p) : p, xo, yo);
3229                                 }
3230                                 else
3231                                         dst.setPixel(src.getPixelInt(deFloorFloatToInt32(sX), deFloorFloatToInt32(sY)), xo, yo);
3232                         }
3233                 }
3234         }
3235
3236         if ((mask & GL_DEPTH_BUFFER_BIT) && m_depthMask)
3237         {
3238                 rr::MultisampleConstPixelBufferAccess   src             = getDepthMultisampleAccess(rr::getSubregion(getReadDepthbuffer(), srcRect.x(), srcRect.y(), srcRect.z(), srcRect.w()));
3239                 rr::MultisamplePixelBufferAccess                dst             = getDepthMultisampleAccess(rr::getSubregion(getDrawDepthbuffer(), dstRect.x(), dstRect.y(), dstRect.z(), dstRect.w()));
3240
3241                 for (int yo = 0; yo < dstRect.w(); yo++)
3242                 {
3243                         for (int xo = 0; xo < dstRect.z(); xo++)
3244                         {
3245                                 const int sampleNdx = 0; // multisample read buffer case is already handled
3246
3247                                 float   dX      = (float)xo + 0.5f;
3248                                 float   dY      = (float)yo + 0.5f;
3249                                 float   sX      = transform(0, 0)*dX + transform(0, 1)*dY + transform(0, 2);
3250                                 float   sY      = transform(1, 0)*dX + transform(1, 1)*dY + transform(1, 2);
3251
3252                                 writeDepthOnly(dst, sampleNdx, xo, yo, src.raw().getPixDepth(sampleNdx, deFloorFloatToInt32(sX), deFloorFloatToInt32(sY)));
3253                         }
3254                 }
3255         }
3256
3257         if (mask & GL_STENCIL_BUFFER_BIT)
3258         {
3259                 rr::MultisampleConstPixelBufferAccess   src     = getStencilMultisampleAccess(rr::getSubregion(getReadStencilbuffer(), srcRect.x(), srcRect.y(), srcRect.z(), srcRect.w()));
3260                 rr::MultisamplePixelBufferAccess                dst     = getStencilMultisampleAccess(rr::getSubregion(getDrawStencilbuffer(), dstRect.x(), dstRect.y(), dstRect.z(), dstRect.w()));
3261
3262                 for (int yo = 0; yo < dstRect.w(); yo++)
3263                 {
3264                         for (int xo = 0; xo < dstRect.z(); xo++)
3265                         {
3266                                 const int       sampleNdx = 0; // multisample read buffer case is already handled
3267
3268                                 float           dX                      = (float)xo + 0.5f;
3269                                 float           dY                      = (float)yo + 0.5f;
3270                                 float           sX                      = transform(0, 0)*dX + transform(0, 1)*dY + transform(0, 2);
3271                                 float           sY                      = transform(1, 0)*dX + transform(1, 1)*dY + transform(1, 2);
3272                                 deUint32        srcStencil      = src.raw().getPixelUint(sampleNdx, deFloorFloatToInt32(sX), deFloorFloatToInt32(sY)).x();
3273
3274                                 writeMaskedStencil(dst, sampleNdx, xo, yo, srcStencil, m_stencil[rr::FACETYPE_FRONT].writeMask);
3275                         }
3276                 }
3277         }
3278 }
3279
3280 void ReferenceContext::invalidateSubFramebuffer (deUint32 target, int numAttachments, const deUint32* attachments, int x, int y, int width, int height)
3281 {
3282         RC_IF_ERROR(target != GL_FRAMEBUFFER, GL_INVALID_ENUM, RC_RET_VOID);
3283         RC_IF_ERROR((numAttachments < 0) || (numAttachments > 1 && attachments == DE_NULL), GL_INVALID_VALUE, RC_RET_VOID);
3284         RC_IF_ERROR(width < 0 || height < 0, GL_INVALID_VALUE, RC_RET_VOID);
3285
3286         // \todo [2012-07-17 pyry] Support multiple color attachments.
3287
3288         const Vec4              colorClearValue         (0.0f);
3289         const float             depthClearValue         = 1.0f;
3290         const int               stencilClearValue       = 0;
3291
3292         bool                    isFboBound                      = m_drawFramebufferBinding != DE_NULL;
3293         bool                    discardBuffers[3]       = { false, false, false }; // Color, depth, stencil
3294
3295         for (int attNdx = 0; attNdx < numAttachments; attNdx++)
3296         {
3297                 bool    isColor                 = attachments[attNdx] == (isFboBound ? GL_COLOR_ATTACHMENT0             : GL_COLOR);
3298                 bool    isDepth                 = attachments[attNdx] == (isFboBound ? GL_DEPTH_ATTACHMENT              : GL_DEPTH);
3299                 bool    isStencil               = attachments[attNdx] == (isFboBound ? GL_STENCIL_ATTACHMENT    : GL_STENCIL);
3300                 bool    isDepthStencil  = isFboBound && attachments[attNdx] == GL_DEPTH_STENCIL_ATTACHMENT;
3301
3302                 RC_IF_ERROR(!isColor && !isDepth && !isStencil && !isDepthStencil, GL_INVALID_VALUE, RC_RET_VOID);
3303
3304                 if (isColor)                                            discardBuffers[0] = true;
3305                 if (isDepth || isDepthStencil)          discardBuffers[1] = true;
3306                 if (isStencil || isDepthStencil)        discardBuffers[2] = true;
3307         }
3308
3309         for (int ndx = 0; ndx < 3; ndx++)
3310         {
3311                 if (!discardBuffers[ndx])
3312                         continue;
3313
3314                 bool                                                            isColor                                 = ndx == 0;
3315                 bool                                                            isDepth                                 = ndx == 1;
3316                 bool                                                            isStencil                               = ndx == 2;
3317                 rr::MultisamplePixelBufferAccess        buf                                             = isColor ? getDrawColorbuffer()                                                                :
3318                                                                                                                                           isDepth ? getDepthMultisampleAccess(getDrawDepthbuffer())             :
3319                                                                                                                                                                 getStencilMultisampleAccess(getDrawStencilbuffer());
3320
3321                 if (isEmpty(buf))
3322                         continue;
3323
3324                 tcu::IVec4                                                      area                                    = intersect(tcu::IVec4(0, 0, buf.raw().getHeight(), buf.raw().getDepth()), tcu::IVec4(x, y, width, height));
3325                 rr::MultisamplePixelBufferAccess        access                                  = rr::getSubregion(buf, area.x(), area.y(), area.z(), area.w());
3326
3327                 if (isColor)
3328                         rr::clear(access, colorClearValue);
3329                 else if (isDepth)
3330                         rr::clear(access, tcu::Vec4(depthClearValue));
3331                 else if (isStencil)
3332                         rr::clear(access, tcu::IVec4(stencilClearValue));
3333         }
3334 }
3335
3336 void ReferenceContext::invalidateFramebuffer (deUint32 target, int numAttachments, const deUint32* attachments)
3337 {
3338         // \todo [2012-07-17 pyry] Support multiple color attachments.
3339         rr::MultisampleConstPixelBufferAccess   colorBuf0       = getDrawColorbuffer();
3340         rr::MultisampleConstPixelBufferAccess   depthBuf        = getDrawDepthbuffer();
3341         rr::MultisampleConstPixelBufferAccess   stencilBuf      = getDrawStencilbuffer();
3342         int                                                                             width           = 0;
3343         int                                                                             height          = 0;
3344
3345         width = de::max(width, colorBuf0.raw().getHeight());
3346         width = de::max(width, depthBuf.raw().getHeight());
3347         width = de::max(width, stencilBuf.raw().getHeight());
3348
3349         height = de::max(height, colorBuf0.raw().getDepth());
3350         height = de::max(height, depthBuf.raw().getDepth());
3351         height = de::max(height, stencilBuf.raw().getDepth());
3352
3353         invalidateSubFramebuffer(target, numAttachments, attachments, 0, 0, width, height);
3354 }
3355
3356 void ReferenceContext::clear (deUint32 buffers)
3357 {
3358         RC_IF_ERROR((buffers & ~(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT)) != 0, GL_INVALID_VALUE, RC_RET_VOID);
3359
3360         rr::MultisamplePixelBufferAccess        colorBuf0       = getDrawColorbuffer();
3361         rr::MultisamplePixelBufferAccess        depthBuf        = getDrawDepthbuffer();
3362         rr::MultisamplePixelBufferAccess        stencilBuf      = getDrawStencilbuffer();
3363         IVec4                                                           baseArea        = m_scissorEnabled ? m_scissorBox : IVec4(0, 0, 0x7fffffff, 0x7fffffff);
3364         IVec4                                                           colorArea       = intersect(baseArea, getBufferRect(colorBuf0));
3365         IVec4                                                           depthArea       = intersect(baseArea, getBufferRect(depthBuf));
3366         IVec4                                                           stencilArea     = intersect(baseArea, getBufferRect(stencilBuf));
3367         bool                                                            hasColor0       = !isEmpty(colorArea);
3368         bool                                                            hasDepth        = !isEmpty(depthArea);
3369         bool                                                            hasStencil      = !isEmpty(stencilArea);
3370
3371         if (hasColor0 && (buffers & GL_COLOR_BUFFER_BIT) != 0)
3372         {
3373                 rr::MultisamplePixelBufferAccess        access          = rr::getSubregion(colorBuf0, colorArea.x(), colorArea.y(), colorArea.z(), colorArea.w());
3374                 bool                                                            isSRGB          = tcu::isSRGB(colorBuf0.raw().getFormat());
3375                 Vec4                                                            c                       = (isSRGB && m_sRGBUpdateEnabled) ? tcu::linearToSRGB(m_clearColor) : m_clearColor;
3376                 bool                                                            maskUsed        = !m_colorMask[0] || !m_colorMask[1] || !m_colorMask[2] || !m_colorMask[3];
3377                 bool                                                            maskZero        = !m_colorMask[0] && !m_colorMask[1] && !m_colorMask[2] && !m_colorMask[3];
3378
3379                 if (!maskUsed)
3380                         rr::clear(access, c);
3381                 else if (!maskZero)
3382                 {
3383                         for (int y = 0; y < access.raw().getDepth(); y++)
3384                                 for (int x = 0; x < access.raw().getHeight(); x++)
3385                                         for (int s = 0; s < access.getNumSamples(); s++)
3386                                                 access.raw().setPixel(tcu::select(c, access.raw().getPixel(s, x, y), m_colorMask), s, x, y);
3387                 }
3388                 // else all channels masked out
3389         }
3390
3391         if (hasDepth && (buffers & GL_DEPTH_BUFFER_BIT) != 0 && m_depthMask)
3392         {
3393                 rr::MultisamplePixelBufferAccess access = getDepthMultisampleAccess(rr::getSubregion(depthBuf, depthArea.x(), depthArea.y(), depthArea.z(), depthArea.w()));
3394                 rr::clearDepth(access, m_clearDepth);
3395         }
3396
3397         if (hasStencil && (buffers & GL_STENCIL_BUFFER_BIT) != 0)
3398         {
3399                 rr::MultisamplePixelBufferAccess        access                                  = getStencilMultisampleAccess(rr::getSubregion(stencilBuf, stencilArea.x(), stencilArea.y(), stencilArea.z(), stencilArea.w()));
3400                 int                                                                     stencilBits                             = getNumStencilBits(stencilBuf.raw().getFormat());
3401                 int                                                                     stencil                                 = maskStencil(stencilBits, m_clearStencil);
3402
3403                 if ((m_stencil[rr::FACETYPE_FRONT].writeMask & ((1u<<stencilBits)-1u)) != ((1u<<stencilBits)-1u))
3404                 {
3405                         // Slow path where depth or stencil is masked out in write.
3406                         for (int y = 0; y < access.raw().getDepth(); y++)
3407                                 for (int x = 0; x < access.raw().getHeight(); x++)
3408                                         for (int s = 0; s < access.getNumSamples(); s++)
3409                                                 writeMaskedStencil(access, s, x, y, stencil, m_stencil[rr::FACETYPE_FRONT].writeMask);
3410                 }
3411                 else
3412                         rr::clearStencil(access, stencil);
3413         }
3414 }
3415
3416 void ReferenceContext::clearBufferiv (deUint32 buffer, int drawbuffer, const int* value)
3417 {
3418         RC_IF_ERROR(buffer != GL_COLOR && buffer != GL_STENCIL, GL_INVALID_ENUM, RC_RET_VOID);
3419         RC_IF_ERROR(drawbuffer != 0, GL_INVALID_VALUE, RC_RET_VOID); // \todo [2012-04-06 pyry] MRT support.
3420
3421         IVec4 baseArea = m_scissorEnabled ? m_scissorBox : IVec4(0, 0, 0x7fffffff, 0x7fffffff);
3422
3423         if (buffer == GL_COLOR)
3424         {
3425                 rr::MultisamplePixelBufferAccess        colorBuf        = getDrawColorbuffer();
3426                 bool                                                            maskUsed        = !m_colorMask[0] || !m_colorMask[1] || !m_colorMask[2] || !m_colorMask[3];
3427                 bool                                                            maskZero        = !m_colorMask[0] && !m_colorMask[1] && !m_colorMask[2] && !m_colorMask[3];
3428                 IVec4                                                           area            = intersect(baseArea, getBufferRect(colorBuf));
3429
3430                 if (!isEmpty(area) && !maskZero)
3431                 {
3432                         rr::MultisamplePixelBufferAccess        access          = rr::getSubregion(colorBuf, area.x(), area.y(), area.z(), area.w());
3433                         IVec4                                                           color           (value[0], value[1], value[2], value[3]);
3434
3435                         if (!maskUsed)
3436                                 rr::clear(access, color);
3437                         else
3438                         {
3439                                 for (int y = 0; y < access.raw().getDepth(); y++)
3440                                         for (int x = 0; x < access.raw().getHeight(); x++)
3441                                                 for (int s = 0; s < access.getNumSamples(); s++)
3442                                                         access.raw().setPixel(tcu::select(color, access.raw().getPixelInt(s, x, y), m_colorMask), s, x, y);
3443                         }
3444                 }
3445         }
3446         else
3447         {
3448                 TCU_CHECK_INTERNAL(buffer == GL_STENCIL);
3449
3450                 rr::MultisamplePixelBufferAccess        stencilBuf      = getDrawStencilbuffer();
3451                 IVec4                                                           area            = intersect(baseArea, getBufferRect(stencilBuf));
3452
3453                 if (!isEmpty(area) && m_stencil[rr::FACETYPE_FRONT].writeMask != 0)
3454                 {
3455                         rr::MultisamplePixelBufferAccess        access          = getStencilMultisampleAccess(rr::getSubregion(stencilBuf, area.x(), area.y(), area.z(), area.w()));
3456                         int                                                                     stencil         = value[0];
3457
3458                         for (int y = 0; y < access.raw().getDepth(); y++)
3459                                 for (int x = 0; x < access.raw().getHeight(); x++)
3460                                         for (int s = 0; s < access.getNumSamples(); s++)
3461                                                 writeMaskedStencil(access, s, x, y, stencil, m_stencil[rr::FACETYPE_FRONT].writeMask);
3462                 }
3463         }
3464 }
3465
3466 void ReferenceContext::clearBufferfv (deUint32 buffer, int drawbuffer, const float* value)
3467 {
3468         RC_IF_ERROR(buffer != GL_COLOR && buffer != GL_DEPTH, GL_INVALID_ENUM, RC_RET_VOID);
3469         RC_IF_ERROR(drawbuffer != 0, GL_INVALID_VALUE, RC_RET_VOID); // \todo [2012-04-06 pyry] MRT support.
3470
3471         IVec4 baseArea = m_scissorEnabled ? m_scissorBox : IVec4(0, 0, 0x7fffffff, 0x7fffffff);
3472
3473         if (buffer == GL_COLOR)
3474         {
3475                 rr::MultisamplePixelBufferAccess        colorBuf        = getDrawColorbuffer();
3476                 bool                                                            maskUsed        = !m_colorMask[0] || !m_colorMask[1] || !m_colorMask[2] || !m_colorMask[3];
3477                 bool                                                            maskZero        = !m_colorMask[0] && !m_colorMask[1] && !m_colorMask[2] && !m_colorMask[3];
3478                 IVec4                                                           area            = intersect(baseArea, getBufferRect(colorBuf));
3479
3480                 if (!isEmpty(area) && !maskZero)
3481                 {
3482                         rr::MultisamplePixelBufferAccess        access          = rr::getSubregion(colorBuf, area.x(), area.y(), area.z(), area.w());
3483                         Vec4                                                            color           (value[0], value[1], value[2], value[3]);
3484
3485                         if (m_sRGBUpdateEnabled && tcu::isSRGB(access.raw().getFormat()))
3486                                 color = tcu::linearToSRGB(color);
3487
3488                         if (!maskUsed)
3489                                 rr::clear(access, color);
3490                         else
3491                         {
3492                                 for (int y = 0; y < access.raw().getDepth(); y++)
3493                                         for (int x = 0; x < access.raw().getHeight(); x++)
3494                                                 for (int s = 0; s < access.getNumSamples(); s++)
3495                                                         access.raw().setPixel(tcu::select(color, access.raw().getPixel(s, x, y), m_colorMask), s, x, y);
3496                         }
3497                 }
3498         }
3499         else
3500         {
3501                 TCU_CHECK_INTERNAL(buffer == GL_DEPTH);
3502
3503                 rr::MultisamplePixelBufferAccess        depthBuf        = getDrawDepthbuffer();
3504                 IVec4                                                           area            = intersect(baseArea, getBufferRect(depthBuf));
3505
3506                 if (!isEmpty(area) && m_depthMask)
3507                 {
3508                         rr::MultisamplePixelBufferAccess        access          = rr::getSubregion(depthBuf, area.x(), area.y(), area.z(), area.w());
3509                         float                                                           depth           = value[0];
3510
3511                         rr::clearDepth(access, depth);
3512                 }
3513         }
3514 }
3515
3516 void ReferenceContext::clearBufferuiv (deUint32 buffer, int drawbuffer, const deUint32* value)
3517 {
3518         RC_IF_ERROR(buffer != GL_COLOR, GL_INVALID_ENUM, RC_RET_VOID);
3519         RC_IF_ERROR(drawbuffer != 0, GL_INVALID_VALUE, RC_RET_VOID); // \todo [2012-04-06 pyry] MRT support.
3520
3521         IVec4 baseArea = m_scissorEnabled ? m_scissorBox : IVec4(0, 0, 0x7fffffff, 0x7fffffff);
3522
3523         TCU_CHECK_INTERNAL(buffer == GL_COLOR);
3524         {
3525                 rr::MultisamplePixelBufferAccess        colorBuf        = getDrawColorbuffer();
3526                 bool                                                            maskUsed        = !m_colorMask[0] || !m_colorMask[1] || !m_colorMask[2] || !m_colorMask[3];
3527                 bool                                                            maskZero        = !m_colorMask[0] && !m_colorMask[1] && !m_colorMask[2] && !m_colorMask[3];
3528                 IVec4                                                           area            = intersect(baseArea, getBufferRect(colorBuf));
3529
3530                 if (!isEmpty(area) && !maskZero)
3531                 {
3532                         rr::MultisamplePixelBufferAccess        access          = rr::getSubregion(colorBuf, area.x(), area.y(), area.z(), area.w());
3533                         tcu::UVec4                                                      color           (value[0], value[1], value[2], value[3]);
3534
3535                         if (!maskUsed)
3536                                 rr::clear(access, color.asInt());
3537                         else
3538                         {
3539                                 for (int y = 0; y < access.raw().getDepth(); y++)
3540                                         for (int x = 0; x < access.raw().getHeight(); x++)
3541                                                 for (int s = 0; s < access.getNumSamples(); s++)
3542                                                         access.raw().setPixel(tcu::select(color, access.raw().getPixelUint(s, x, y), m_colorMask), s, x, y);
3543                         }
3544                 }
3545         }
3546 }
3547
3548 void ReferenceContext::clearBufferfi (deUint32 buffer, int drawbuffer, float depth, int stencil)
3549 {
3550         RC_IF_ERROR(buffer != GL_DEPTH_STENCIL, GL_INVALID_ENUM, RC_RET_VOID);
3551         clearBufferfv(GL_DEPTH, drawbuffer, &depth);
3552         clearBufferiv(GL_STENCIL, drawbuffer, &stencil);
3553 }
3554
3555 void ReferenceContext::bindVertexArray (deUint32 array)
3556 {
3557         rc::VertexArray* vertexArrayObject = DE_NULL;
3558
3559         if (array != 0)
3560         {
3561                 vertexArrayObject = m_vertexArrays.find(array);
3562                 if (!vertexArrayObject)
3563                 {
3564                         vertexArrayObject = new rc::VertexArray(array, m_limits.maxVertexAttribs);
3565                         m_vertexArrays.insert(vertexArrayObject);
3566                 }
3567         }
3568
3569         // Create new references
3570         if (vertexArrayObject)
3571                 m_vertexArrays.acquireReference(vertexArrayObject);
3572
3573         // Remove old references
3574         if (m_vertexArrayBinding)
3575                 m_vertexArrays.releaseReference(m_vertexArrayBinding);
3576
3577         m_vertexArrayBinding = vertexArrayObject;
3578 }
3579
3580 void ReferenceContext::genVertexArrays (int numArrays, deUint32* vertexArrays)
3581 {
3582         RC_IF_ERROR(!vertexArrays, GL_INVALID_VALUE, RC_RET_VOID);
3583
3584         for (int ndx = 0; ndx < numArrays; ndx++)
3585                 vertexArrays[ndx] = m_vertexArrays.allocateName();
3586 }
3587
3588 void ReferenceContext::deleteVertexArrays (int numArrays, const deUint32* vertexArrays)
3589 {
3590         for (int i = 0; i < numArrays; i++)
3591         {
3592                 deUint32                name            = vertexArrays[i];
3593                 VertexArray*    vertexArray     = name ? m_vertexArrays.find(name) : DE_NULL;
3594
3595                 if (vertexArray)
3596                         deleteVertexArray(vertexArray);
3597         }
3598 }
3599
3600 void ReferenceContext::vertexAttribPointer (deUint32 index, int rawSize, deUint32 type, deBool normalized, int stride, const void *pointer)
3601 {
3602         const bool allowBGRA    = !glu::isContextTypeES(getType());
3603         const int effectiveSize = (allowBGRA && rawSize == GL_BGRA) ? (4) : (rawSize);
3604
3605         RC_IF_ERROR(index >= (deUint32)m_limits.maxVertexAttribs, GL_INVALID_VALUE, RC_RET_VOID);
3606         RC_IF_ERROR(effectiveSize <= 0 || effectiveSize > 4, GL_INVALID_VALUE, RC_RET_VOID);
3607         RC_IF_ERROR(type != GL_BYTE                                     &&      type != GL_UNSIGNED_BYTE        &&
3608                                 type != GL_SHORT                                &&      type != GL_UNSIGNED_SHORT       &&
3609                                 type != GL_INT                                  &&      type != GL_UNSIGNED_INT         &&
3610                                 type != GL_FIXED                                &&      type != GL_DOUBLE                       &&
3611                                 type != GL_FLOAT                                &&      type != GL_HALF_FLOAT           &&
3612                                 type != GL_INT_2_10_10_10_REV   &&      type != GL_UNSIGNED_INT_2_10_10_10_REV, GL_INVALID_ENUM, RC_RET_VOID);
3613         RC_IF_ERROR(normalized != GL_TRUE && normalized != GL_FALSE, GL_INVALID_ENUM, RC_RET_VOID);
3614         RC_IF_ERROR(stride < 0, GL_INVALID_VALUE, RC_RET_VOID);
3615         RC_IF_ERROR((type == GL_INT_2_10_10_10_REV || type == GL_UNSIGNED_INT_2_10_10_10_REV) && effectiveSize != 4, GL_INVALID_OPERATION, RC_RET_VOID);
3616         RC_IF_ERROR(m_vertexArrayBinding != DE_NULL && m_arrayBufferBinding == DE_NULL && pointer != DE_NULL, GL_INVALID_OPERATION, RC_RET_VOID);
3617         RC_IF_ERROR(allowBGRA && rawSize == GL_BGRA && type != GL_INT_2_10_10_10_REV && type != GL_UNSIGNED_INT_2_10_10_10_REV && type != GL_UNSIGNED_BYTE, GL_INVALID_OPERATION, RC_RET_VOID);
3618         RC_IF_ERROR(allowBGRA && rawSize == GL_BGRA && normalized == GL_FALSE, GL_INVALID_OPERATION, RC_RET_VOID);
3619
3620         rc::VertexArray& vao = (m_vertexArrayBinding) ? (*m_vertexArrayBinding) : (m_clientVertexArray);
3621
3622         vao.m_arrays[index].size                        = rawSize;
3623         vao.m_arrays[index].stride                      = stride;
3624         vao.m_arrays[index].type                        = type;
3625         vao.m_arrays[index].normalized          = normalized == GL_TRUE;
3626         vao.m_arrays[index].integer                     = false;
3627         vao.m_arrays[index].pointer                     = pointer;
3628
3629         // acquire new reference
3630         if (m_arrayBufferBinding)
3631                 m_buffers.acquireReference(m_arrayBufferBinding);
3632
3633         // release old reference
3634         if (vao.m_arrays[index].bufferBinding)
3635                 m_buffers.releaseReference(vao.m_arrays[index].bufferBinding);
3636
3637         vao.m_arrays[index].bufferDeleted       = false;
3638         vao.m_arrays[index].bufferBinding       = m_arrayBufferBinding;
3639 }
3640
3641 void ReferenceContext::vertexAttribIPointer (deUint32 index, int size, deUint32 type, int stride, const void *pointer)
3642 {
3643         RC_IF_ERROR(index >= (deUint32)m_limits.maxVertexAttribs, GL_INVALID_VALUE, RC_RET_VOID);
3644         RC_IF_ERROR(size <= 0 || size > 4, GL_INVALID_VALUE, RC_RET_VOID);
3645         RC_IF_ERROR(type != GL_BYTE                                     &&      type != GL_UNSIGNED_BYTE        &&
3646                                 type != GL_SHORT                                &&      type != GL_UNSIGNED_SHORT       &&
3647                                 type != GL_INT                                  &&      type != GL_UNSIGNED_INT, GL_INVALID_ENUM, RC_RET_VOID);
3648         RC_IF_ERROR(stride < 0, GL_INVALID_VALUE, RC_RET_VOID);
3649         RC_IF_ERROR(m_vertexArrayBinding != DE_NULL && m_arrayBufferBinding == DE_NULL && pointer != DE_NULL, GL_INVALID_OPERATION, RC_RET_VOID);
3650
3651         rc::VertexArray& vao = (m_vertexArrayBinding) ? (*m_vertexArrayBinding) : (m_clientVertexArray);
3652
3653         vao.m_arrays[index].size                        = size;
3654         vao.m_arrays[index].stride                      = stride;
3655         vao.m_arrays[index].type                        = type;
3656         vao.m_arrays[index].normalized          = false;
3657         vao.m_arrays[index].integer                     = true;
3658         vao.m_arrays[index].pointer                     = pointer;
3659
3660         // acquire new reference
3661         if (m_arrayBufferBinding)
3662                 m_buffers.acquireReference(m_arrayBufferBinding);
3663
3664         // release old reference
3665         if (vao.m_arrays[index].bufferBinding)
3666                 m_buffers.releaseReference(vao.m_arrays[index].bufferBinding);
3667
3668         vao.m_arrays[index].bufferDeleted       = false;
3669         vao.m_arrays[index].bufferBinding       = m_arrayBufferBinding;
3670 }
3671
3672 void ReferenceContext::enableVertexAttribArray (deUint32 index)
3673 {
3674         RC_IF_ERROR(index >= (deUint32)m_limits.maxVertexAttribs, GL_INVALID_VALUE, RC_RET_VOID);
3675
3676         rc::VertexArray& vao = (m_vertexArrayBinding) ? (*m_vertexArrayBinding) : (m_clientVertexArray);
3677         vao.m_arrays[index].enabled = true;
3678 }
3679
3680 void ReferenceContext::disableVertexAttribArray (deUint32 index)
3681 {
3682         RC_IF_ERROR(index >= (deUint32)m_limits.maxVertexAttribs, GL_INVALID_VALUE, RC_RET_VOID);
3683
3684         rc::VertexArray& vao = (m_vertexArrayBinding) ? (*m_vertexArrayBinding) : (m_clientVertexArray);
3685         vao.m_arrays[index].enabled = false;
3686 }
3687
3688 void ReferenceContext::vertexAttribDivisor (deUint32 index, deUint32 divisor)
3689 {
3690         RC_IF_ERROR(index >= (deUint32)m_limits.maxVertexAttribs, GL_INVALID_VALUE, RC_RET_VOID);
3691
3692         rc::VertexArray& vao = (m_vertexArrayBinding) ? (*m_vertexArrayBinding) : (m_clientVertexArray);
3693         vao.m_arrays[index].divisor = divisor;
3694 }
3695
3696 void ReferenceContext::vertexAttrib1f (deUint32 index, float x)
3697 {
3698         RC_IF_ERROR(index >= (deUint32)m_limits.maxVertexAttribs, GL_INVALID_VALUE, RC_RET_VOID);
3699
3700         m_currentAttribs[index] = rr::GenericVec4(tcu::Vec4(x, 0, 0, 1));
3701 }
3702
3703 void ReferenceContext::vertexAttrib2f (deUint32 index, float x, float y)
3704 {
3705         RC_IF_ERROR(index >= (deUint32)m_limits.maxVertexAttribs, GL_INVALID_VALUE, RC_RET_VOID);
3706
3707         m_currentAttribs[index] = rr::GenericVec4(tcu::Vec4(x, y, 0, 1));
3708 }
3709
3710 void ReferenceContext::vertexAttrib3f (deUint32 index, float x, float y, float z)
3711 {
3712         RC_IF_ERROR(index >= (deUint32)m_limits.maxVertexAttribs, GL_INVALID_VALUE, RC_RET_VOID);
3713
3714         m_currentAttribs[index] = rr::GenericVec4(tcu::Vec4(x, y, z, 1));
3715 }
3716
3717 void ReferenceContext::vertexAttrib4f (deUint32 index, float x, float y, float z, float w)
3718 {
3719         RC_IF_ERROR(index >= (deUint32)m_limits.maxVertexAttribs, GL_INVALID_VALUE, RC_RET_VOID);
3720
3721         m_currentAttribs[index] = rr::GenericVec4(tcu::Vec4(x, y, z, w));
3722 }
3723
3724 void ReferenceContext::vertexAttribI4i (deUint32 index, deInt32 x, deInt32 y, deInt32 z, deInt32 w)
3725 {
3726         RC_IF_ERROR(index >= (deUint32)m_limits.maxVertexAttribs, GL_INVALID_VALUE, RC_RET_VOID);
3727
3728         m_currentAttribs[index] = rr::GenericVec4(tcu::IVec4(x, y, z, w));
3729 }
3730
3731 void ReferenceContext::vertexAttribI4ui (deUint32 index, deUint32 x, deUint32 y, deUint32 z, deUint32 w)
3732 {
3733         RC_IF_ERROR(index >= (deUint32)m_limits.maxVertexAttribs, GL_INVALID_VALUE, RC_RET_VOID);
3734
3735         m_currentAttribs[index] = rr::GenericVec4(tcu::UVec4(x, y, z, w));
3736 }
3737
3738 deInt32 ReferenceContext::getAttribLocation (deUint32 program, const char *name)
3739 {
3740         ShaderProgramObjectContainer* shaderProg = m_programs.find(program);
3741
3742         RC_IF_ERROR(shaderProg == DE_NULL, GL_INVALID_OPERATION, -1);
3743
3744         if (name)
3745         {
3746                 std::string nameString(name);
3747
3748                 for (size_t ndx = 0; ndx < shaderProg->m_program->m_attributeNames.size(); ++ndx)
3749                         if (shaderProg->m_program->m_attributeNames[ndx] == nameString)
3750                                 return (int)ndx;
3751         }
3752
3753         return -1;
3754 }
3755
3756 void ReferenceContext::uniformv (deInt32 location, glu::DataType type, deInt32 count, const void* v)
3757 {
3758         RC_IF_ERROR(m_currentProgram == DE_NULL, GL_INVALID_OPERATION, RC_RET_VOID);
3759
3760         std::vector<sglr::UniformSlot>& uniforms = m_currentProgram->m_program->m_uniforms;
3761
3762         if (location == -1)
3763                 return;
3764
3765         RC_IF_ERROR(location < 0 || (size_t)location >= uniforms.size(), GL_INVALID_OPERATION, RC_RET_VOID);
3766         RC_IF_ERROR(uniforms[location].type != type, GL_INVALID_OPERATION, RC_RET_VOID);
3767         RC_IF_ERROR(count != 1, GL_INVALID_OPERATION, RC_RET_VOID); // \todo [2013-12-13 pyry] Array uniforms.
3768
3769         {
3770                 const int scalarSize = glu::getDataTypeScalarSize(type);
3771                 DE_ASSERT(scalarSize*sizeof(deUint32) <= sizeof(uniforms[location].value));
3772                 deMemcpy(&uniforms[location].value, v, scalarSize*(int)sizeof(deUint32));
3773         }
3774 }
3775
3776 void ReferenceContext::uniform1iv (deInt32 location, deInt32 count, const deInt32* v)
3777 {
3778         RC_IF_ERROR(m_currentProgram == DE_NULL, GL_INVALID_OPERATION, RC_RET_VOID);
3779
3780         std::vector<sglr::UniformSlot>& uniforms = m_currentProgram->m_program->m_uniforms;
3781
3782         if (location == -1)
3783                 return;
3784
3785         RC_IF_ERROR(location < 0 || (size_t)location >= uniforms.size(), GL_INVALID_OPERATION, RC_RET_VOID);
3786         RC_IF_ERROR(count != 1, GL_INVALID_OPERATION, RC_RET_VOID); // \todo [2013-12-13 pyry] Array uniforms.
3787
3788         switch (uniforms[location].type)
3789         {
3790                 case glu::TYPE_INT:             uniforms[location].value.i = *v;        return;
3791
3792                 // \note texture unit is stored to value
3793                 case glu::TYPE_SAMPLER_2D:
3794                 case glu::TYPE_UINT_SAMPLER_2D:
3795                 case glu::TYPE_INT_SAMPLER_2D:
3796                 case glu::TYPE_SAMPLER_CUBE:
3797                 case glu::TYPE_UINT_SAMPLER_CUBE:
3798                 case glu::TYPE_INT_SAMPLER_CUBE:
3799                 case glu::TYPE_SAMPLER_2D_ARRAY:
3800                 case glu::TYPE_UINT_SAMPLER_2D_ARRAY:
3801                 case glu::TYPE_INT_SAMPLER_2D_ARRAY:
3802                 case glu::TYPE_SAMPLER_3D:
3803                 case glu::TYPE_UINT_SAMPLER_3D:
3804                 case glu::TYPE_INT_SAMPLER_3D:
3805                 case glu::TYPE_SAMPLER_CUBE_ARRAY:
3806                 case glu::TYPE_UINT_SAMPLER_CUBE_ARRAY:
3807                 case glu::TYPE_INT_SAMPLER_CUBE_ARRAY:
3808                         uniforms[location].value.i = *v;
3809                         return;
3810
3811                 default:
3812                         setError(GL_INVALID_OPERATION);
3813                         return;
3814         }
3815 }
3816
3817 void ReferenceContext::uniform1f (deInt32 location, const float v0)
3818 {
3819         uniform1fv(location, 1, &v0);
3820 }
3821
3822 void ReferenceContext::uniform1i (deInt32 location, deInt32 v0)
3823 {
3824         uniform1iv(location, 1, &v0);
3825 }
3826
3827 void ReferenceContext::uniform1fv (deInt32 location, deInt32 count, const float* v)
3828 {
3829         uniformv(location, glu::TYPE_FLOAT, count, v);
3830 }
3831
3832 void ReferenceContext::uniform2fv (deInt32 location, deInt32 count, const float* v)
3833 {
3834         uniformv(location, glu::TYPE_FLOAT_VEC2, count, v);
3835 }
3836
3837 void ReferenceContext::uniform3fv (deInt32 location, deInt32 count, const float* v)
3838 {
3839         uniformv(location, glu::TYPE_FLOAT_VEC3, count, v);
3840 }
3841
3842 void ReferenceContext::uniform4fv (deInt32 location, deInt32 count, const float* v)
3843 {
3844         uniformv(location, glu::TYPE_FLOAT_VEC4, count, v);
3845 }
3846
3847 void ReferenceContext::uniform2iv (deInt32 location, deInt32 count, const deInt32* v)
3848 {
3849         uniformv(location, glu::TYPE_INT_VEC2, count, v);
3850 }
3851
3852 void ReferenceContext::uniform3iv (deInt32 location, deInt32 count, const deInt32* v)
3853 {
3854         uniformv(location, glu::TYPE_INT_VEC3, count, v);
3855 }
3856
3857 void ReferenceContext::uniform4iv (deInt32 location, deInt32 count, const deInt32* v)
3858 {
3859         uniformv(location, glu::TYPE_INT_VEC4, count, v);
3860 }
3861
3862 void ReferenceContext::uniformMatrix3fv (deInt32 location, deInt32 count, deBool transpose, const float *value)
3863 {
3864         RC_IF_ERROR(m_currentProgram == DE_NULL, GL_INVALID_OPERATION, RC_RET_VOID);
3865
3866         std::vector<sglr::UniformSlot>& uniforms = m_currentProgram->m_program->m_uniforms;
3867
3868         if (location == -1)
3869                 return;
3870
3871         RC_IF_ERROR(location < 0 || (size_t)location >= uniforms.size(), GL_INVALID_OPERATION, RC_RET_VOID);
3872
3873         if (count == 0)
3874                 return;
3875
3876         RC_IF_ERROR(transpose != GL_TRUE && transpose != GL_FALSE, GL_INVALID_ENUM, RC_RET_VOID);
3877
3878         switch (uniforms[location].type)
3879         {
3880                 case glu::TYPE_FLOAT_MAT3:
3881                         RC_IF_ERROR(count > 1, GL_INVALID_OPERATION, RC_RET_VOID);
3882
3883                         if (transpose == GL_FALSE) // input is column major => transpose from column major to internal row major
3884                                 for (int row = 0; row < 3; ++row)
3885                                 for (int col = 0; col < 3; ++col)
3886                                         uniforms[location].value.m3[row*3+col] = value[col*3+row];
3887                         else // input is row major
3888                                 for (int row = 0; row < 3; ++row)
3889                                 for (int col = 0; col < 3; ++col)
3890                                         uniforms[location].value.m3[row*3+col] = value[row*3+col];
3891
3892                         break;
3893
3894                 default:
3895                         setError(GL_INVALID_OPERATION);
3896                         return;
3897         }
3898 }
3899
3900 void ReferenceContext::uniformMatrix4fv (deInt32 location, deInt32 count, deBool transpose, const float *value)
3901 {
3902         RC_IF_ERROR(m_currentProgram == DE_NULL, GL_INVALID_OPERATION, RC_RET_VOID);
3903
3904         std::vector<sglr::UniformSlot>& uniforms = m_currentProgram->m_program->m_uniforms;
3905
3906         if (location == -1)
3907                 return;
3908
3909         RC_IF_ERROR(location < 0 || (size_t)location >= uniforms.size(), GL_INVALID_OPERATION, RC_RET_VOID);
3910
3911         if (count == 0)
3912                 return;
3913
3914         RC_IF_ERROR(transpose != GL_TRUE && transpose != GL_FALSE, GL_INVALID_ENUM, RC_RET_VOID);
3915
3916         switch (uniforms[location].type)
3917         {
3918                 case glu::TYPE_FLOAT_MAT4:
3919                         RC_IF_ERROR(count > 1, GL_INVALID_OPERATION, RC_RET_VOID);
3920
3921                         if (transpose == GL_FALSE) // input is column major => transpose from column major to internal row major
3922                                 for (int row = 0; row < 4; ++row)
3923                                 for (int col = 0; col < 4; ++col)
3924                                         uniforms[location].value.m4[row*3+col] = value[col*3+row];
3925                         else // input is row major
3926                                 for (int row = 0; row < 4; ++row)
3927                                 for (int col = 0; col < 4; ++col)
3928                                         uniforms[location].value.m4[row*3+col] = value[row*3+col];
3929
3930                         break;
3931
3932                 default:
3933                         setError(GL_INVALID_OPERATION);
3934                         return;
3935         }
3936 }
3937
3938 deInt32 ReferenceContext::getUniformLocation (deUint32 program, const char *name)
3939 {
3940         ShaderProgramObjectContainer* shaderProg = m_programs.find(program);
3941         RC_IF_ERROR(shaderProg == DE_NULL, GL_INVALID_OPERATION, -1);
3942
3943         std::vector<sglr::UniformSlot>& uniforms = shaderProg->m_program->m_uniforms;
3944
3945         for (size_t i = 0; i < uniforms.size(); ++i)
3946                 if (name && deStringEqual(uniforms[i].name.c_str(), name))
3947                         return (int)i;
3948
3949         return -1;
3950 }
3951
3952 void ReferenceContext::lineWidth (float w)
3953 {
3954         RC_IF_ERROR(w < 0.0f, GL_INVALID_VALUE, RC_RET_VOID);
3955         m_lineWidth = w;
3956 }
3957
3958 void ReferenceContext::deleteVertexArray (rc::VertexArray* vertexArray)
3959 {
3960         if (m_vertexArrayBinding == vertexArray)
3961                 bindVertexArray(0);
3962
3963         if (vertexArray->m_elementArrayBufferBinding)
3964                 m_buffers.releaseReference(vertexArray->m_elementArrayBufferBinding);
3965
3966         for (size_t ndx = 0; ndx < vertexArray->m_arrays.size(); ++ndx)
3967                 if (vertexArray->m_arrays[ndx].bufferBinding)
3968                         m_buffers.releaseReference(vertexArray->m_arrays[ndx].bufferBinding);
3969
3970         DE_ASSERT(vertexArray->getRefCount() == 1);
3971         m_vertexArrays.releaseReference(vertexArray);
3972 }
3973
3974 void ReferenceContext::deleteProgramObject (rc::ShaderProgramObjectContainer* sp)
3975 {
3976         // Unbinding program will delete it
3977         if (m_currentProgram == sp && sp->m_deleteFlag)
3978         {
3979                 useProgram(0);
3980                 return;
3981         }
3982
3983         // Unbinding program will NOT delete it
3984         if (m_currentProgram == sp)
3985                 useProgram(0);
3986
3987         DE_ASSERT(sp->getRefCount() == 1);
3988         m_programs.releaseReference(sp);
3989 }
3990
3991 void ReferenceContext::drawArrays (deUint32 mode, int first, int count)
3992 {
3993         drawArraysInstanced(mode, first, count, 1);
3994 }
3995
3996 void ReferenceContext::drawArraysInstanced (deUint32 mode, int first, int count, int instanceCount)
3997 {
3998         // Error conditions
3999         {
4000                 RC_IF_ERROR(first < 0 || count < 0 || instanceCount < 0, GL_INVALID_VALUE, RC_RET_VOID);
4001
4002                 if (!predrawErrorChecks(mode))
4003                         return;
4004         }
4005
4006         // All is ok
4007         {
4008                 const rr::PrimitiveType primitiveType = sglr::rr_util::mapGLPrimitiveType(mode);
4009
4010                 drawWithReference(rr::PrimitiveList(primitiveType, count, first), instanceCount);
4011         }
4012 }
4013
4014 void ReferenceContext::drawElements (deUint32 mode, int count, deUint32 type, const void *indices)
4015 {
4016         drawElementsInstanced(mode, count, type, indices, 1);
4017 }
4018
4019 void ReferenceContext::drawElementsBaseVertex (deUint32 mode, int count, deUint32 type, const void *indices, int baseVertex)
4020 {
4021         drawElementsInstancedBaseVertex(mode, count, type, indices, 1, baseVertex);
4022 }
4023
4024 void ReferenceContext::drawElementsInstanced (deUint32 mode, int count, deUint32 type, const void *indices, int instanceCount)
4025 {
4026         drawElementsInstancedBaseVertex(mode, count, type, indices, instanceCount, 0);
4027 }
4028
4029 void ReferenceContext::drawElementsInstancedBaseVertex (deUint32 mode, int count, deUint32 type, const void *indices, int instanceCount, int baseVertex)
4030 {
4031         rc::VertexArray& vao = (m_vertexArrayBinding) ? (*m_vertexArrayBinding) : (m_clientVertexArray);
4032
4033         // Error conditions
4034         {
4035                 RC_IF_ERROR(type != GL_UNSIGNED_BYTE &&
4036                                         type != GL_UNSIGNED_SHORT &&
4037                                         type != GL_UNSIGNED_INT, GL_INVALID_ENUM, RC_RET_VOID);
4038                 RC_IF_ERROR(count < 0 || instanceCount < 0, GL_INVALID_VALUE, RC_RET_VOID);
4039
4040                 if (!predrawErrorChecks(mode))
4041                         return;
4042         }
4043
4044         // All is ok
4045         {
4046                 const rr::PrimitiveType primitiveType   = sglr::rr_util::mapGLPrimitiveType(mode);
4047                 const void*                             indicesPtr              = (vao.m_elementArrayBufferBinding) ? (vao.m_elementArrayBufferBinding->getData() + ((const deUint8*)indices - (const deUint8*)DE_NULL)) : (indices);
4048
4049                 drawWithReference(rr::PrimitiveList(primitiveType, count, rr::DrawIndices(indicesPtr, sglr::rr_util::mapGLIndexType(type), baseVertex)), instanceCount);
4050         }
4051 }
4052
4053 void ReferenceContext::drawRangeElements (deUint32 mode, deUint32 start, deUint32 end, int count, deUint32 type, const void *indices)
4054 {
4055         RC_IF_ERROR(end < start, GL_INVALID_VALUE, RC_RET_VOID);
4056
4057         drawElements(mode, count, type, indices);
4058 }
4059
4060 void ReferenceContext::drawRangeElementsBaseVertex (deUint32 mode, deUint32 start, deUint32 end, int count, deUint32 type, const void *indices, int baseVertex)
4061 {
4062         RC_IF_ERROR(end < start, GL_INVALID_VALUE, RC_RET_VOID);
4063
4064         drawElementsBaseVertex(mode, count, type, indices, baseVertex);
4065 }
4066
4067 void ReferenceContext::drawArraysIndirect (deUint32 mode, const void *indirect)
4068 {
4069         struct DrawArraysIndirectCommand
4070         {
4071                 deUint32 count;
4072                 deUint32 primCount;
4073                 deUint32 first;
4074                 deUint32 reservedMustBeZero;
4075         };
4076
4077         const DrawArraysIndirectCommand* command;
4078
4079         // Check errors
4080
4081         if (!predrawErrorChecks(mode))
4082                 return;
4083
4084         // Check pointer validity
4085
4086         RC_IF_ERROR(m_drawIndirectBufferBinding == DE_NULL, GL_INVALID_OPERATION, RC_RET_VOID);
4087         RC_IF_ERROR(!deIsAlignedPtr(indirect, 4), GL_INVALID_OPERATION, RC_RET_VOID);
4088
4089         // \note watch for overflows, indirect might be close to 0xFFFFFFFF and indirect+something might overflow
4090         RC_IF_ERROR((size_t)((const char*)indirect - (const char*)DE_NULL)                                     > (size_t)m_drawIndirectBufferBinding->getSize(), GL_INVALID_OPERATION, RC_RET_VOID);
4091         RC_IF_ERROR((size_t)((const char*)indirect - (const char*)DE_NULL) + sizeof(DrawArraysIndirectCommand) > (size_t)m_drawIndirectBufferBinding->getSize(), GL_INVALID_OPERATION, RC_RET_VOID);
4092
4093         // Check values
4094
4095         command = (const DrawArraysIndirectCommand*)(m_drawIndirectBufferBinding->getData() + ((const char*)indirect - (const char*)DE_NULL));
4096         RC_IF_ERROR(command->reservedMustBeZero != 0, GL_INVALID_OPERATION, RC_RET_VOID);
4097
4098         // draw
4099         drawArraysInstanced(mode, command->first, command->count, command->primCount);
4100 }
4101
4102 void ReferenceContext::drawElementsIndirect     (deUint32 mode, deUint32 type, const void *indirect)
4103 {
4104         struct DrawElementsIndirectCommand
4105         {
4106                 deUint32 count;
4107                 deUint32 primCount;
4108                 deUint32 firstIndex;
4109                 deInt32  baseVertex;
4110                 deUint32 reservedMustBeZero;
4111         };
4112
4113         const DrawElementsIndirectCommand* command;
4114
4115         // Check errors
4116
4117         if (!predrawErrorChecks(mode))
4118                 return;
4119
4120         RC_IF_ERROR(type != GL_UNSIGNED_BYTE &&
4121                                 type != GL_UNSIGNED_SHORT &&
4122                                 type != GL_UNSIGNED_INT, GL_INVALID_ENUM, RC_RET_VOID);
4123
4124         RC_IF_ERROR(!getBufferBinding(GL_ELEMENT_ARRAY_BUFFER), GL_INVALID_OPERATION, RC_RET_VOID);
4125
4126         // Check pointer validity
4127
4128         RC_IF_ERROR(m_drawIndirectBufferBinding == DE_NULL, GL_INVALID_OPERATION, RC_RET_VOID);
4129         RC_IF_ERROR(!deIsAlignedPtr(indirect, 4), GL_INVALID_OPERATION, RC_RET_VOID);
4130
4131         // \note watch for overflows, indirect might be close to 0xFFFFFFFF and indirect+something might overflow
4132         RC_IF_ERROR((size_t)((const char*)indirect - (const char*)DE_NULL)                                       > (size_t)m_drawIndirectBufferBinding->getSize(), GL_INVALID_OPERATION, RC_RET_VOID);
4133         RC_IF_ERROR((size_t)((const char*)indirect - (const char*)DE_NULL) + sizeof(DrawElementsIndirectCommand) > (size_t)m_drawIndirectBufferBinding->getSize(), GL_INVALID_OPERATION, RC_RET_VOID);
4134
4135         // Check values
4136
4137         command = (const DrawElementsIndirectCommand*)(m_drawIndirectBufferBinding->getData() + ((const char*)indirect - (const char*)DE_NULL));
4138         RC_IF_ERROR(command->reservedMustBeZero != 0, GL_INVALID_OPERATION, RC_RET_VOID);
4139
4140         // Check command error conditions
4141         RC_IF_ERROR((int)command->count < 0 || (int)command->primCount < 0, GL_INVALID_VALUE, RC_RET_VOID);
4142
4143         // Draw
4144         {
4145                 const size_t                    sizeOfType              = (type == GL_UNSIGNED_BYTE) ?  (1) : ((type == GL_UNSIGNED_SHORT) ? (2) : (4));
4146                 const void*                             indicesPtr              = (deUint8*)DE_NULL + (command->firstIndex * sizeOfType);
4147
4148                 drawElementsInstancedBaseVertex(mode, (int)command->count, type, indicesPtr, (int)command->primCount, command->baseVertex);
4149         }
4150 }
4151
4152 void ReferenceContext::multiDrawArrays (deUint32 mode, const int* first, const int* count, int primCount)
4153 {
4154         DE_UNREF(mode);
4155         DE_UNREF(first);
4156         DE_UNREF(count);
4157         DE_UNREF(primCount);
4158
4159         // not supported in gles, prevent accidental use
4160         DE_ASSERT(false);
4161 }
4162
4163 void ReferenceContext::multiDrawElements (deUint32 mode, const int* count, deUint32 type, const void** indices, int primCount)
4164 {
4165         DE_UNREF(mode);
4166         DE_UNREF(count);
4167         DE_UNREF(type);
4168         DE_UNREF(indices);
4169         DE_UNREF(primCount);
4170
4171         // not supported in gles, prevent accidental use
4172         DE_ASSERT(false);
4173 }
4174
4175 void ReferenceContext::multiDrawElementsBaseVertex (deUint32 mode, const int* count, deUint32 type, const void** indices, int primCount, const int* baseVertex)
4176 {
4177         DE_UNREF(mode);
4178         DE_UNREF(count);
4179         DE_UNREF(type);
4180         DE_UNREF(indices);
4181         DE_UNREF(primCount);
4182         DE_UNREF(baseVertex);
4183
4184         // not supported in gles, prevent accidental use
4185         DE_ASSERT(false);
4186 }
4187
4188 bool ReferenceContext::predrawErrorChecks (deUint32 mode)
4189 {
4190         RC_IF_ERROR(mode != GL_POINTS &&
4191                                 mode != GL_LINE_STRIP && mode != GL_LINE_LOOP && mode != GL_LINES &&
4192                                 mode != GL_TRIANGLE_STRIP && mode != GL_TRIANGLE_FAN && mode != GL_TRIANGLES &&
4193                                 mode != GL_LINES_ADJACENCY && mode != GL_LINE_STRIP_ADJACENCY &&
4194                                 mode != GL_TRIANGLES_ADJACENCY && mode != GL_TRIANGLE_STRIP_ADJACENCY,
4195                                 GL_INVALID_ENUM, false);
4196
4197         // \todo [jarkko] Uncomment following code when the buffer mapping support is added
4198         //for (size_t ndx = 0; ndx < vao.m_arrays.size(); ++ndx)
4199         //      if (vao.m_arrays[ndx].enabled && vao.m_arrays[ndx].bufferBinding && vao.m_arrays[ndx].bufferBinding->isMapped)
4200         //              RC_ERROR_RET(GL_INVALID_OPERATION, RC_RET_VOID);
4201
4202         RC_IF_ERROR(checkFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE, GL_INVALID_FRAMEBUFFER_OPERATION, false);
4203
4204         // Geometry shader checks
4205         if (m_currentProgram && m_currentProgram->m_program->m_hasGeometryShader)
4206         {
4207                 RC_IF_ERROR(m_currentProgram->m_program->rr::GeometryShader::getInputType() == rr::GEOMETRYSHADERINPUTTYPE_POINTS && mode != GL_POINTS, GL_INVALID_OPERATION, false);
4208
4209                 RC_IF_ERROR(m_currentProgram->m_program->rr::GeometryShader::getInputType() == rr::GEOMETRYSHADERINPUTTYPE_LINES &&
4210                         (mode != GL_LINES &&
4211                          mode != GL_LINE_STRIP &&
4212                          mode != GL_LINE_LOOP),
4213                          GL_INVALID_OPERATION, false);
4214
4215                 RC_IF_ERROR(m_currentProgram->m_program->rr::GeometryShader::getInputType() == rr::GEOMETRYSHADERINPUTTYPE_TRIANGLES &&
4216                         (mode != GL_TRIANGLES &&
4217                          mode != GL_TRIANGLE_STRIP &&
4218                          mode != GL_TRIANGLE_FAN),
4219                          GL_INVALID_OPERATION, false);
4220
4221                 RC_IF_ERROR(m_currentProgram->m_program->rr::GeometryShader::getInputType() == rr::GEOMETRYSHADERINPUTTYPE_LINES_ADJACENCY &&
4222                         (mode != GL_LINES_ADJACENCY &&
4223                          mode != GL_LINE_STRIP_ADJACENCY),
4224                          GL_INVALID_OPERATION, false);
4225
4226                 RC_IF_ERROR(m_currentProgram->m_program->rr::GeometryShader::getInputType() == rr::GEOMETRYSHADERINPUTTYPE_TRIANGLES_ADJACENCY &&
4227                         (mode != GL_TRIANGLES_ADJACENCY &&
4228                          mode != GL_TRIANGLE_STRIP_ADJACENCY),
4229                          GL_INVALID_OPERATION, false);
4230         }
4231
4232         return true;
4233 }
4234
4235 static rr::PrimitiveType getPrimitiveBaseType (rr::PrimitiveType derivedType)
4236 {
4237         switch (derivedType)
4238         {
4239                 case rr::PRIMITIVETYPE_TRIANGLES:
4240                 case rr::PRIMITIVETYPE_TRIANGLE_STRIP:
4241                 case rr::PRIMITIVETYPE_TRIANGLE_FAN:
4242                 case rr::PRIMITIVETYPE_TRIANGLES_ADJACENCY:
4243                 case rr::PRIMITIVETYPE_TRIANGLE_STRIP_ADJACENCY:
4244                         return rr::PRIMITIVETYPE_TRIANGLES;
4245
4246                 case rr::PRIMITIVETYPE_LINES:
4247                 case rr::PRIMITIVETYPE_LINE_STRIP:
4248                 case rr::PRIMITIVETYPE_LINE_LOOP:
4249                 case rr::PRIMITIVETYPE_LINES_ADJACENCY:
4250                 case rr::PRIMITIVETYPE_LINE_STRIP_ADJACENCY:
4251                         return rr::PRIMITIVETYPE_LINES;
4252
4253                 case rr::PRIMITIVETYPE_POINTS:
4254                         return rr::PRIMITIVETYPE_POINTS;
4255
4256                 default:
4257                         DE_ASSERT(false);
4258                         return rr::PRIMITIVETYPE_LAST;
4259         }
4260 }
4261
4262 static deUint32 getFixedRestartIndex (rr::IndexType indexType)
4263 {
4264         switch (indexType)
4265         {
4266                 case rr::INDEXTYPE_UINT8:               return 0xFF;
4267                 case rr::INDEXTYPE_UINT16:              return 0xFFFF;
4268                 case rr::INDEXTYPE_UINT32:              return 0xFFFFFFFFul;
4269
4270                 case rr::INDEXTYPE_LAST:
4271                 default:
4272                         DE_ASSERT(false);
4273                         return 0;
4274         }
4275 }
4276
4277 void ReferenceContext::drawWithReference (const rr::PrimitiveList& primitives, int instanceCount)
4278 {
4279         // undefined results
4280         if (m_currentProgram == DE_NULL)
4281                 return;
4282
4283         rr::MultisamplePixelBufferAccess        colorBuf0       = getDrawColorbuffer();
4284         rr::MultisamplePixelBufferAccess        depthBuf        = getDepthMultisampleAccess(getDrawDepthbuffer());
4285         rr::MultisamplePixelBufferAccess        stencilBuf      = getStencilMultisampleAccess(getDrawStencilbuffer());
4286         const bool                                                      hasStencil      = !isEmpty(stencilBuf);
4287         const int                                                       stencilBits     = (hasStencil) ? (getNumStencilBits(stencilBuf.raw().getFormat())) : (0);
4288
4289         const rr::RenderTarget                          renderTarget(colorBuf0, depthBuf, stencilBuf);
4290         const rr::Program                                       program         (m_currentProgram->m_program->getVertexShader(),
4291                                                                                                          m_currentProgram->m_program->getFragmentShader(),
4292                                                                                                          (m_currentProgram->m_program->m_hasGeometryShader) ? (m_currentProgram->m_program->getGeometryShader()) : (DE_NULL));
4293         rr::RenderState                                         state           ((rr::ViewportState)(colorBuf0));
4294
4295         const rr::Renderer                                      referenceRenderer;
4296         std::vector<rr::VertexAttrib>           vertexAttribs;
4297
4298         // Gen state
4299         {
4300                 const rr::PrimitiveType baseType                                                        = getPrimitiveBaseType(primitives.getPrimitiveType());
4301                 const bool                              polygonOffsetEnabled                            = (baseType == rr::PRIMITIVETYPE_TRIANGLES) ? (m_polygonOffsetFillEnabled) : (false);
4302
4303                 //state.cullMode                                                                                        = m_cullMode
4304
4305                 state.fragOps.scissorTestEnabled                                                        = m_scissorEnabled;
4306                 state.fragOps.scissorRectangle                                                          = rr::WindowRectangle(m_scissorBox.x(), m_scissorBox.y(), m_scissorBox.z(), m_scissorBox.w());
4307
4308                 state.fragOps.numStencilBits                                                            = stencilBits;
4309                 state.fragOps.stencilTestEnabled                                                        = m_stencilTestEnabled;
4310
4311                 for (int faceType = 0; faceType < rr::FACETYPE_LAST; faceType++)
4312                 {
4313                         state.fragOps.stencilStates[faceType].compMask  = m_stencil[faceType].opMask;
4314                         state.fragOps.stencilStates[faceType].writeMask = m_stencil[faceType].writeMask;
4315                         state.fragOps.stencilStates[faceType].ref               = m_stencil[faceType].ref;
4316                         state.fragOps.stencilStates[faceType].func              = sglr::rr_util::mapGLTestFunc(m_stencil[faceType].func);
4317                         state.fragOps.stencilStates[faceType].sFail             = sglr::rr_util::mapGLStencilOp(m_stencil[faceType].opStencilFail);
4318                         state.fragOps.stencilStates[faceType].dpFail    = sglr::rr_util::mapGLStencilOp(m_stencil[faceType].opDepthFail);
4319                         state.fragOps.stencilStates[faceType].dpPass    = sglr::rr_util::mapGLStencilOp(m_stencil[faceType].opDepthPass);
4320                 }
4321
4322                 state.fragOps.depthTestEnabled                                                          = m_depthTestEnabled;
4323                 state.fragOps.depthFunc                                                                         = sglr::rr_util::mapGLTestFunc(m_depthFunc);
4324                 state.fragOps.depthMask                                                                         = m_depthMask;
4325
4326                 state.fragOps.blendMode                                                                         = m_blendEnabled ? rr::BLENDMODE_STANDARD : rr::BLENDMODE_NONE;
4327                 state.fragOps.blendRGBState.equation                                            = sglr::rr_util::mapGLBlendEquation(m_blendModeRGB);
4328                 state.fragOps.blendRGBState.srcFunc                                                     = sglr::rr_util::mapGLBlendFunc(m_blendFactorSrcRGB);
4329                 state.fragOps.blendRGBState.dstFunc                                                     = sglr::rr_util::mapGLBlendFunc(m_blendFactorDstRGB);
4330                 state.fragOps.blendAState.equation                                                      = sglr::rr_util::mapGLBlendEquation(m_blendModeAlpha);
4331                 state.fragOps.blendAState.srcFunc                                                       = sglr::rr_util::mapGLBlendFunc(m_blendFactorSrcAlpha);
4332                 state.fragOps.blendAState.dstFunc                                                       = sglr::rr_util::mapGLBlendFunc(m_blendFactorDstAlpha);
4333                 state.fragOps.blendColor                                                                        = m_blendColor;
4334
4335                 state.fragOps.sRGBEnabled                                                                       = m_sRGBUpdateEnabled;
4336
4337                 state.fragOps.colorMask                                                                         = m_colorMask;
4338
4339                 state.fragOps.depthClampEnabled                                                         = m_depthClampEnabled;
4340
4341                 state.viewport.rect                                                                                     = rr::WindowRectangle(m_viewport.x(), m_viewport.y(), m_viewport.z(), m_viewport.w());
4342                 state.viewport.zn                                                                                       = m_depthRangeNear;
4343                 state.viewport.zf                                                                                       = m_depthRangeFar;
4344
4345                 //state.point.pointSize                                                                         = m_pointSize;
4346                 state.line.lineWidth                                                                            = m_lineWidth;
4347
4348                 state.fragOps.polygonOffsetEnabled                                                      = polygonOffsetEnabled;
4349                 state.fragOps.polygonOffsetFactor                                                       = m_polygonOffsetFactor;
4350                 state.fragOps.polygonOffsetUnits                                                        = m_polygonOffsetUnits;
4351
4352                 {
4353                         const rr::IndexType indexType = primitives.getIndexType();
4354
4355                         if (m_primitiveRestartFixedIndex && indexType != rr::INDEXTYPE_LAST)
4356                         {
4357                                 state.restart.enabled = true;
4358                                 state.restart.restartIndex = getFixedRestartIndex(indexType);
4359                         }
4360                         else if (m_primitiveRestartSettableIndex)
4361                         {
4362                                 // \note PRIMITIVE_RESTART is active for non-indexed (DrawArrays) operations too.
4363                                 state.restart.enabled = true;
4364                                 state.restart.restartIndex = m_primitiveRestartIndex;
4365                         }
4366                         else
4367                         {
4368                                 state.restart.enabled = false;
4369                         }
4370                 }
4371
4372                 state.provokingVertexConvention                                                         = (m_provokingFirstVertexConvention) ? (rr::PROVOKINGVERTEX_FIRST) : (rr::PROVOKINGVERTEX_LAST);
4373         }
4374
4375         // gen attributes
4376         {
4377                 rc::VertexArray& vao = (m_vertexArrayBinding) ? (*m_vertexArrayBinding) : (m_clientVertexArray);
4378
4379                 vertexAttribs.resize(vao.m_arrays.size());
4380                 for (size_t ndx = 0; ndx < vao.m_arrays.size(); ++ndx)
4381                 {
4382                         if (!vao.m_arrays[ndx].enabled)
4383                         {
4384                                 vertexAttribs[ndx].type = rr::VERTEXATTRIBTYPE_DONT_CARE; // reading with wrong type is allowed, but results are undefined
4385                                 vertexAttribs[ndx].generic = m_currentAttribs[ndx];
4386                         }
4387                         else if (vao.m_arrays[ndx].bufferDeleted)
4388                         {
4389                                 vertexAttribs[ndx].type = rr::VERTEXATTRIBTYPE_DONT_CARE; // reading from deleted buffer, output zeros
4390                                 vertexAttribs[ndx].generic = tcu::Vec4(0, 0, 0, 0);
4391                         }
4392                         else
4393                         {
4394                                 vertexAttribs[ndx].type                         = (vao.m_arrays[ndx].integer) ?
4395                                                                                                                 (sglr::rr_util::mapGLPureIntegerVertexAttributeType(vao.m_arrays[ndx].type)) :
4396                                                                                                                 (sglr::rr_util::mapGLFloatVertexAttributeType(vao.m_arrays[ndx].type, vao.m_arrays[ndx].normalized, vao.m_arrays[ndx].size, this->getType()));
4397                                 vertexAttribs[ndx].size                         = sglr::rr_util::mapGLSize(vao.m_arrays[ndx].size);
4398                                 vertexAttribs[ndx].stride                       = vao.m_arrays[ndx].stride;
4399                                 vertexAttribs[ndx].instanceDivisor      = vao.m_arrays[ndx].divisor;
4400                                 vertexAttribs[ndx].pointer                      = (vao.m_arrays[ndx].bufferBinding) ? (vao.m_arrays[ndx].bufferBinding->getData() + ((const deUint8*)vao.m_arrays[ndx].pointer - (const deUint8*)DE_NULL)) : (vao.m_arrays[ndx].pointer);
4401                         }
4402                 }
4403         }
4404
4405         // Set shader samplers
4406         for (size_t uniformNdx = 0; uniformNdx < m_currentProgram->m_program->m_uniforms.size(); ++uniformNdx)
4407         {
4408                 const tcu::Sampler::DepthStencilMode    depthStencilMode        = tcu::Sampler::MODE_DEPTH; // \todo[jarkko] support sampler state
4409                 const int                                                               texNdx                          = m_currentProgram->m_program->m_uniforms[uniformNdx].value.i;
4410
4411                 switch (m_currentProgram->m_program->m_uniforms[uniformNdx].type)
4412                 {
4413                         case glu::TYPE_SAMPLER_1D:
4414                         case glu::TYPE_UINT_SAMPLER_1D:
4415                         case glu::TYPE_INT_SAMPLER_1D:
4416                         {
4417                                 rc::Texture1D* tex = DE_NULL;
4418
4419                                 if (texNdx >= 0 && (size_t)texNdx < m_textureUnits.size())
4420                                         tex = (m_textureUnits[texNdx].tex1DBinding) ? (m_textureUnits[texNdx].tex1DBinding) : (&m_textureUnits[texNdx].default1DTex);
4421
4422                                 if (tex && tex->isComplete())
4423                                 {
4424                                         tex->updateView(depthStencilMode);
4425                                         m_currentProgram->m_program->m_uniforms[uniformNdx].sampler.tex1D = tex;
4426                                 }
4427                                 else
4428                                         m_currentProgram->m_program->m_uniforms[uniformNdx].sampler.tex1D = &m_emptyTex1D;
4429
4430                                 break;
4431                         }
4432                         case glu::TYPE_SAMPLER_2D:
4433                         case glu::TYPE_UINT_SAMPLER_2D:
4434                         case glu::TYPE_INT_SAMPLER_2D:
4435                         {
4436                                 rc::Texture2D* tex = DE_NULL;
4437
4438                                 if (texNdx >= 0 && (size_t)texNdx < m_textureUnits.size())
4439                                         tex = (m_textureUnits[texNdx].tex2DBinding) ? (m_textureUnits[texNdx].tex2DBinding) : (&m_textureUnits[texNdx].default2DTex);
4440
4441                                 if (tex && tex->isComplete())
4442                                 {
4443                                         tex->updateView(depthStencilMode);
4444                                         m_currentProgram->m_program->m_uniforms[uniformNdx].sampler.tex2D = tex;
4445                                 }
4446                                 else
4447                                         m_currentProgram->m_program->m_uniforms[uniformNdx].sampler.tex2D = &m_emptyTex2D;
4448
4449                                 break;
4450                         }
4451                         case glu::TYPE_SAMPLER_CUBE:
4452                         case glu::TYPE_UINT_SAMPLER_CUBE:
4453                         case glu::TYPE_INT_SAMPLER_CUBE:
4454                         {
4455                                 rc::TextureCube* tex = DE_NULL;
4456
4457                                 if (texNdx >= 0 && (size_t)texNdx < m_textureUnits.size())
4458                                         tex = (m_textureUnits[texNdx].texCubeBinding) ? (m_textureUnits[texNdx].texCubeBinding) : (&m_textureUnits[texNdx].defaultCubeTex);
4459
4460                                 if (tex && tex->isComplete())
4461                                 {
4462                                         tex->updateView(depthStencilMode);
4463                                         m_currentProgram->m_program->m_uniforms[uniformNdx].sampler.texCube = tex;
4464                                 }
4465                                 else
4466                                         m_currentProgram->m_program->m_uniforms[uniformNdx].sampler.texCube = &m_emptyTexCube;
4467
4468                                 break;
4469                         }
4470                         case glu::TYPE_SAMPLER_2D_ARRAY:
4471                         case glu::TYPE_UINT_SAMPLER_2D_ARRAY:
4472                         case glu::TYPE_INT_SAMPLER_2D_ARRAY:
4473                         {
4474                                 rc::Texture2DArray* tex = DE_NULL;
4475
4476                                 if (texNdx >= 0 && (size_t)texNdx < m_textureUnits.size())
4477                                         tex = (m_textureUnits[texNdx].tex2DArrayBinding) ? (m_textureUnits[texNdx].tex2DArrayBinding) : (&m_textureUnits[texNdx].default2DArrayTex);
4478
4479                                 if (tex && tex->isComplete())
4480                                 {
4481                                         tex->updateView(depthStencilMode);
4482                                         m_currentProgram->m_program->m_uniforms[uniformNdx].sampler.tex2DArray = tex;
4483                                 }
4484                                 else
4485                                         m_currentProgram->m_program->m_uniforms[uniformNdx].sampler.tex2DArray = &m_emptyTex2DArray;
4486
4487                                 break;
4488                         }
4489                         case glu::TYPE_SAMPLER_3D:
4490                         case glu::TYPE_UINT_SAMPLER_3D:
4491                         case glu::TYPE_INT_SAMPLER_3D:
4492                         {
4493                                 rc::Texture3D* tex = DE_NULL;
4494
4495                                 if (texNdx >= 0 && (size_t)texNdx < m_textureUnits.size())
4496                                         tex = (m_textureUnits[texNdx].tex3DBinding) ? (m_textureUnits[texNdx].tex3DBinding) : (&m_textureUnits[texNdx].default3DTex);
4497
4498                                 if (tex && tex->isComplete())
4499                                 {
4500                                         tex->updateView(depthStencilMode);
4501                                         m_currentProgram->m_program->m_uniforms[uniformNdx].sampler.tex3D = tex;
4502                                 }
4503                                 else
4504                                         m_currentProgram->m_program->m_uniforms[uniformNdx].sampler.tex3D = &m_emptyTex3D;
4505
4506                                 break;
4507                         }
4508                         case glu::TYPE_SAMPLER_CUBE_ARRAY:
4509                         case glu::TYPE_UINT_SAMPLER_CUBE_ARRAY:
4510                         case glu::TYPE_INT_SAMPLER_CUBE_ARRAY:
4511                         {
4512                                 rc::TextureCubeArray* tex = DE_NULL;
4513
4514                                 if (texNdx >= 0 && (size_t)texNdx < m_textureUnits.size())
4515                                         tex = (m_textureUnits[texNdx].texCubeArrayBinding) ? (m_textureUnits[texNdx].texCubeArrayBinding) : (&m_textureUnits[texNdx].defaultCubeArrayTex);
4516
4517                                 if (tex && tex->isComplete())
4518                                 {
4519                                         tex->updateView(depthStencilMode);
4520                                         m_currentProgram->m_program->m_uniforms[uniformNdx].sampler.texCubeArray = tex;
4521                                 }
4522                                 else
4523                                         m_currentProgram->m_program->m_uniforms[uniformNdx].sampler.texCubeArray = &m_emptyTexCubeArray;
4524
4525                                 break;
4526                         }
4527                         default:
4528                                 // nothing
4529                                 break;
4530                 }
4531         }
4532
4533         referenceRenderer.drawInstanced(rr::DrawCommand(state, renderTarget, program, (int)vertexAttribs.size(), &vertexAttribs[0], primitives), instanceCount);
4534 }
4535
4536 deUint32 ReferenceContext::createProgram (ShaderProgram* program)
4537 {
4538         int name = m_programs.allocateName();
4539
4540         m_programs.insert(new rc::ShaderProgramObjectContainer(name, program));
4541
4542         return name;
4543 }
4544
4545 void ReferenceContext::useProgram (deUint32 program)
4546 {
4547         rc::ShaderProgramObjectContainer* shaderProg                    = DE_NULL;
4548         rc::ShaderProgramObjectContainer* programToBeDeleted    = DE_NULL;
4549
4550         if (program)
4551         {
4552                 shaderProg = m_programs.find(program);
4553
4554                 // shader has not been linked
4555                 if (!shaderProg || shaderProg->m_deleteFlag)
4556                         RC_ERROR_RET(GL_INVALID_OPERATION, RC_RET_VOID);
4557         }
4558
4559         if (m_currentProgram && m_currentProgram->m_deleteFlag)
4560                 programToBeDeleted = m_currentProgram;
4561
4562         m_currentProgram = shaderProg;
4563
4564         if (programToBeDeleted)
4565         {
4566                 DE_ASSERT(programToBeDeleted->getRefCount() == 1);
4567                 deleteProgramObject(programToBeDeleted);
4568         }
4569 }
4570
4571 void ReferenceContext::deleteProgram (deUint32 program)
4572 {
4573         if (!program)
4574                 return;
4575
4576         rc::ShaderProgramObjectContainer* shaderProg = m_programs.find(program);
4577         if (shaderProg)
4578         {
4579                 if (shaderProg == m_currentProgram)
4580                 {
4581                         m_currentProgram->m_deleteFlag = true;
4582                 }
4583                 else
4584                 {
4585                         DE_ASSERT(shaderProg->getRefCount() == 1);
4586                         m_programs.releaseReference(shaderProg);
4587                 }
4588         }
4589 }
4590
4591 void ReferenceContext::readPixels (int x, int y, int width, int height, deUint32 format, deUint32 type, void* data)
4592 {
4593         rr::MultisamplePixelBufferAccess        src = getReadColorbuffer();
4594         TextureFormat                                           transferFmt;
4595
4596         // Map transfer format.
4597         transferFmt = glu::mapGLTransferFormat(format, type);
4598         RC_IF_ERROR(transferFmt.order   == TextureFormat::CHANNELORDER_LAST ||
4599                                 transferFmt.type        == TextureFormat::CHANNELTYPE_LAST, GL_INVALID_ENUM, RC_RET_VOID);
4600
4601         // Clamp input values
4602         const int copyX                 = deClamp32(x,          0, src.raw().getHeight());
4603         const int copyY                 = deClamp32(y,          0, src.raw().getDepth());
4604         const int copyWidth             = deClamp32(width,      0, src.raw().getHeight()-x);
4605         const int copyHeight    = deClamp32(height,     0, src.raw().getDepth()-y);
4606
4607         PixelBufferAccess dst(transferFmt, width, height, 1, deAlign32(width*transferFmt.getPixelSize(), m_pixelPackAlignment), 0, getPixelPackPtr(data));
4608         rr::resolveMultisampleColorBuffer(tcu::getSubregion(dst, 0, 0, copyWidth, copyHeight), rr::getSubregion(src, copyX, copyY, copyWidth, copyHeight));
4609 }
4610
4611 deUint32 ReferenceContext::getError (void)
4612 {
4613         deUint32 err = m_lastError;
4614         m_lastError = GL_NO_ERROR;
4615         return err;
4616 }
4617
4618 void ReferenceContext::finish (void)
4619 {
4620 }
4621
4622 inline void ReferenceContext::setError (deUint32 error)
4623 {
4624         if (m_lastError == GL_NO_ERROR)
4625                 m_lastError = error;
4626 }
4627
4628 void ReferenceContext::getIntegerv (deUint32 pname, int* param)
4629 {
4630         switch (pname)
4631         {
4632                 case GL_MAX_TEXTURE_SIZE:                       *param = m_limits.maxTexture2DSize;                     break;
4633                 case GL_MAX_CUBE_MAP_TEXTURE_SIZE:      *param = m_limits.maxTextureCubeSize;           break;
4634                 case GL_MAX_ARRAY_TEXTURE_LAYERS:       *param = m_limits.maxTexture2DArrayLayers;      break;
4635                 case GL_MAX_3D_TEXTURE_SIZE:            *param = m_limits.maxTexture3DSize;                     break;
4636                 case GL_MAX_RENDERBUFFER_SIZE:          *param = m_limits.maxRenderbufferSize;          break;
4637                 case GL_MAX_TEXTURE_IMAGE_UNITS:        *param = m_limits.maxTextureImageUnits;         break;
4638                 case GL_MAX_VERTEX_ATTRIBS:                     *param = m_limits.maxVertexAttribs;                     break;
4639
4640                 default:
4641                         setError(GL_INVALID_ENUM);
4642                         break;
4643         }
4644 }
4645
4646 const char* ReferenceContext::getString (deUint32 pname)
4647 {
4648         switch (pname)
4649         {
4650                 case GL_EXTENSIONS:             return m_limits.extensionStr.c_str();
4651
4652                 default:
4653                         setError(GL_INVALID_ENUM);
4654                         return DE_NULL;
4655         }
4656 }
4657
4658 namespace rc
4659 {
4660
4661 TextureLevelArray::TextureLevelArray (void)
4662 {
4663 }
4664
4665 TextureLevelArray::~TextureLevelArray (void)
4666 {
4667         clear();
4668 }
4669
4670 void TextureLevelArray::clear (void)
4671 {
4672         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(m_data) == DE_LENGTH_OF_ARRAY(m_access));
4673
4674         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(m_data); ndx++)
4675         {
4676                 m_data[ndx].clear();
4677                 m_access[ndx] = PixelBufferAccess();
4678         }
4679 }
4680
4681 void TextureLevelArray::allocLevel (int level, const tcu::TextureFormat& format, int width, int height, int depth)
4682 {
4683         const int dataSize = format.getPixelSize()*width*height*depth;
4684
4685         DE_ASSERT(deInBounds32(level, 0, DE_LENGTH_OF_ARRAY(m_data)));
4686
4687         if (hasLevel(level))
4688                 clearLevel(level);
4689
4690         m_data[level].setStorage(dataSize);
4691         m_access[level] = PixelBufferAccess(format, width, height, depth, m_data[level].getPtr());
4692 }
4693
4694 void TextureLevelArray::clearLevel (int level)
4695 {
4696         DE_ASSERT(deInBounds32(level, 0, DE_LENGTH_OF_ARRAY(m_data)));
4697
4698         m_data[level].clear();
4699         m_access[level] = PixelBufferAccess();
4700 }
4701
4702 void TextureLevelArray::updateSamplerMode (tcu::Sampler::DepthStencilMode mode)
4703 {
4704         for (int levelNdx = 0; hasLevel(levelNdx); ++levelNdx)
4705                 m_effectiveAccess[levelNdx] = tcu::getEffectiveDepthStencilAccess(m_access[levelNdx], mode);
4706 }
4707
4708 Texture::Texture (deUint32 name, Type type)
4709         : NamedObject   (name)
4710         , m_type                (type)
4711         , m_immutable   (false)
4712         , m_sampler             (tcu::Sampler::REPEAT_GL,
4713                                          tcu::Sampler::REPEAT_GL,
4714                                          tcu::Sampler::REPEAT_GL,
4715                                          tcu::Sampler::NEAREST_MIPMAP_LINEAR,
4716                                          tcu::Sampler::LINEAR,
4717                                          0.0f,                          // LOD threshold
4718                                          true,                          // normalized coords
4719                                          tcu::Sampler::COMPAREMODE_NONE,
4720                                          0,                                     // cmp channel ndx
4721                                          tcu::Vec4(0.0f),       // border color
4722                                          true                           // seamless cube map \todo [2014-02-19 pyry] Default value ok?
4723                                          )
4724         , m_baseLevel   (0)
4725         , m_maxLevel    (1000)
4726 {
4727 }
4728
4729 Texture1D::Texture1D (deUint32 name)
4730         : Texture       (name, TYPE_1D)
4731         , m_view        (0, DE_NULL)
4732 {
4733 }
4734
4735 Texture1D::~Texture1D (void)
4736 {
4737 }
4738
4739 void Texture1D::allocLevel (int level, const tcu::TextureFormat& format, int width)
4740 {
4741         m_levels.allocLevel(level, format, width, 1, 1);
4742 }
4743
4744 bool Texture1D::isComplete (void) const
4745 {
4746         const int       baseLevel       = getBaseLevel();
4747
4748         if (hasLevel(baseLevel))
4749         {
4750                 const tcu::ConstPixelBufferAccess&      level0          = getLevel(baseLevel);
4751                 const bool                                                      mipmap          = isMipmapFilter(getSampler().minFilter);
4752
4753                 if (mipmap)
4754                 {
4755                         const TextureFormat&    format          = level0.getFormat();
4756                         const int                               w                       = level0.getWidth();
4757                         const int                               numLevels       = de::min(getMaxLevel()-baseLevel+1, getNumMipLevels1D(w));
4758
4759                         for (int levelNdx = 1; levelNdx < numLevels; levelNdx++)
4760                         {
4761                                 if (hasLevel(baseLevel+levelNdx))
4762                                 {
4763                                         const tcu::ConstPixelBufferAccess&      level           = getLevel(baseLevel+levelNdx);
4764                                         const int                                                       expectedW       = getMipLevelSize(w, levelNdx);
4765
4766                                         if (level.getWidth()    != expectedW    ||
4767                                                 level.getFormat()       != format)
4768                                                 return false;
4769                                 }
4770                                 else
4771                                         return false;
4772                         }
4773                 }
4774
4775                 return true;
4776         }
4777         else
4778                 return false;
4779 }
4780
4781 tcu::Vec4 Texture1D::sample (float s, float lod) const
4782 {
4783         return m_view.sample(getSampler(), s, 0.0f, lod);
4784 }
4785
4786 void Texture1D::sample4 (tcu::Vec4 output[4], const float packetTexcoords[4], float lodBias) const
4787 {
4788         const float texWidth = (float)m_view.getWidth();
4789
4790         const float dFdx0 = packetTexcoords[1] - packetTexcoords[0];
4791         const float dFdx1 = packetTexcoords[3] - packetTexcoords[2];
4792         const float dFdy0 = packetTexcoords[2] - packetTexcoords[0];
4793         const float dFdy1 = packetTexcoords[3] - packetTexcoords[1];
4794
4795         for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
4796         {
4797                 const float& dFdx = (fragNdx > 2) ? dFdx1 : dFdx0;
4798                 const float& dFdy = (fragNdx % 2) ? dFdy1 : dFdy0;
4799
4800                 const float mu = de::max(de::abs(dFdx), de::abs(dFdy));
4801                 const float p = mu * texWidth;
4802
4803                 const float     lod = deFloatLog2(p) + lodBias;
4804
4805                 output[fragNdx] = sample(packetTexcoords[fragNdx], lod);
4806         }
4807 }
4808
4809 void Texture1D::updateView (tcu::Sampler::DepthStencilMode mode)
4810 {
4811         const int baseLevel     = getBaseLevel();
4812
4813         if (hasLevel(baseLevel) && !isEmpty(getLevel(baseLevel)))
4814         {
4815                 const int       width           = getLevel(baseLevel).getWidth();
4816                 const bool      isMipmap        = isMipmapFilter(getSampler().minFilter);
4817                 const int       numLevels       = isMipmap ? de::min(getMaxLevel()-baseLevel+1, getNumMipLevels1D(width)) : 1;
4818
4819                 m_levels.updateSamplerMode(mode);
4820                 m_view = tcu::Texture2DView(numLevels, m_levels.getEffectiveLevels() + baseLevel);
4821         }
4822         else
4823                 m_view = tcu::Texture2DView(0, DE_NULL);
4824 }
4825
4826 Texture2D::Texture2D (deUint32 name)
4827         : Texture       (name, TYPE_2D)
4828         , m_view        (0, DE_NULL)
4829 {
4830 }
4831
4832 Texture2D::~Texture2D (void)
4833 {
4834 }
4835
4836 void Texture2D::allocLevel (int level, const tcu::TextureFormat& format, int width, int height)
4837 {
4838         m_levels.allocLevel(level, format, width, height, 1);
4839 }
4840
4841 bool Texture2D::isComplete (void) const
4842 {
4843         const int       baseLevel       = getBaseLevel();
4844
4845         if (hasLevel(baseLevel))
4846         {
4847                 const tcu::ConstPixelBufferAccess&      level0          = getLevel(baseLevel);
4848                 const bool                                                      mipmap          = isMipmapFilter(getSampler().minFilter);
4849
4850                 if (mipmap)
4851                 {
4852                         const TextureFormat&    format          = level0.getFormat();
4853                         const int                               w                       = level0.getWidth();
4854                         const int                               h                       = level0.getHeight();
4855                         const int                               numLevels       = de::min(getMaxLevel()-baseLevel+1, getNumMipLevels2D(w, h));
4856
4857                         for (int levelNdx = 1; levelNdx < numLevels; levelNdx++)
4858                         {
4859                                 if (hasLevel(baseLevel+levelNdx))
4860                                 {
4861                                         const tcu::ConstPixelBufferAccess&      level           = getLevel(baseLevel+levelNdx);
4862                                         const int                                                       expectedW       = getMipLevelSize(w, levelNdx);
4863                                         const int                                                       expectedH       = getMipLevelSize(h, levelNdx);
4864
4865                                         if (level.getWidth()    != expectedW    ||
4866                                                 level.getHeight()       != expectedH    ||
4867                                                 level.getFormat()       != format)
4868                                                 return false;
4869                                 }
4870                                 else
4871                                         return false;
4872                         }
4873                 }
4874
4875                 return true;
4876         }
4877         else
4878                 return false;
4879 }
4880
4881 void Texture2D::updateView (tcu::Sampler::DepthStencilMode mode)
4882 {
4883         const int baseLevel     = getBaseLevel();
4884
4885         if (hasLevel(baseLevel) && !isEmpty(getLevel(baseLevel)))
4886         {
4887                 // Update number of levels in mipmap pyramid.
4888                 const int       width           = getLevel(baseLevel).getWidth();
4889                 const int       height          = getLevel(baseLevel).getHeight();
4890                 const bool      isMipmap        = isMipmapFilter(getSampler().minFilter);
4891                 const int       numLevels       = isMipmap ? de::min(getMaxLevel()-baseLevel+1, getNumMipLevels2D(width, height)) : 1;
4892
4893                 m_levels.updateSamplerMode(mode);
4894                 m_view = tcu::Texture2DView(numLevels, m_levels.getEffectiveLevels() + baseLevel);
4895         }
4896         else
4897                 m_view = tcu::Texture2DView(0, DE_NULL);
4898 }
4899
4900 tcu::Vec4 Texture2D::sample (float s, float t, float lod) const
4901 {
4902         return m_view.sample(getSampler(), s, t, lod);
4903 }
4904
4905 void Texture2D::sample4 (tcu::Vec4 output[4], const tcu::Vec2 packetTexcoords[4], float lodBias) const
4906 {
4907         const float texWidth  = (float)m_view.getWidth();
4908         const float texHeight = (float)m_view.getHeight();
4909
4910         const tcu::Vec2 dFdx0 = packetTexcoords[1] - packetTexcoords[0];
4911         const tcu::Vec2 dFdx1 = packetTexcoords[3] - packetTexcoords[2];
4912         const tcu::Vec2 dFdy0 = packetTexcoords[2] - packetTexcoords[0];
4913         const tcu::Vec2 dFdy1 = packetTexcoords[3] - packetTexcoords[1];
4914
4915         for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
4916         {
4917                 const tcu::Vec2& dFdx = (fragNdx & 2) ? dFdx1 : dFdx0;
4918                 const tcu::Vec2& dFdy = (fragNdx & 1) ? dFdy1 : dFdy0;
4919
4920                 const float mu = de::max(de::abs(dFdx.x()), de::abs(dFdy.x()));
4921                 const float mv = de::max(de::abs(dFdx.y()), de::abs(dFdy.y()));
4922                 const float p = de::max(mu * texWidth, mv * texHeight);
4923
4924                 const float     lod = deFloatLog2(p) + lodBias;
4925
4926                 output[fragNdx] = sample(packetTexcoords[fragNdx].x(), packetTexcoords[fragNdx].y(), lod);
4927         }
4928 }
4929
4930 TextureCube::TextureCube (deUint32 name)
4931         : Texture(name, TYPE_CUBE_MAP)
4932 {
4933 }
4934
4935 TextureCube::~TextureCube (void)
4936 {
4937 }
4938
4939 void TextureCube::clearLevels (void)
4940 {
4941         for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
4942                 m_levels[face].clear();
4943 }
4944
4945 void TextureCube::allocFace (int level, tcu::CubeFace face, const tcu::TextureFormat& format, int width, int height)
4946 {
4947         m_levels[face].allocLevel(level, format, width, height, 1);
4948 }
4949
4950 bool TextureCube::isComplete (void) const
4951 {
4952         const int       baseLevel       = getBaseLevel();
4953
4954         if (hasFace(baseLevel, tcu::CUBEFACE_NEGATIVE_X))
4955         {
4956                 const int                                       width           = getFace(baseLevel, tcu::CUBEFACE_NEGATIVE_X).getWidth();
4957                 const int                                       height          = getFace(baseLevel, tcu::CUBEFACE_NEGATIVE_X).getHeight();
4958                 const tcu::TextureFormat&       format          = getFace(baseLevel, tcu::CUBEFACE_NEGATIVE_X).getFormat();
4959                 const bool                                      mipmap          = isMipmapFilter(getSampler().minFilter);
4960                 const int                                       numLevels       = mipmap ? de::min(getMaxLevel()-baseLevel+1, getNumMipLevels2D(width, height)) : 1;
4961
4962                 if (width != height)
4963                         return false; // Non-square is not supported.
4964
4965                 // \note Level 0 is always checked for consistency
4966                 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
4967                 {
4968                         const int levelW        = getMipLevelSize(width,        levelNdx);
4969                         const int levelH        = getMipLevelSize(height,       levelNdx);
4970
4971                         for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
4972                         {
4973                                 if (hasFace(baseLevel+levelNdx, (tcu::CubeFace)face))
4974                                 {
4975                                         const tcu::ConstPixelBufferAccess& level = getFace(baseLevel+levelNdx, (tcu::CubeFace)face);
4976
4977                                         if (level.getWidth()    != levelW       ||
4978                                                 level.getHeight()       != levelH       ||
4979                                                 level.getFormat()       != format)
4980                                                 return false;
4981                                 }
4982                                 else
4983                                         return false;
4984                         }
4985                 }
4986
4987                 return true;
4988         }
4989         else
4990                 return false;
4991 }
4992
4993 void TextureCube::updateView (tcu::Sampler::DepthStencilMode mode)
4994 {
4995         const int                                                       baseLevel       = getBaseLevel();
4996         const tcu::ConstPixelBufferAccess*      faces[tcu::CUBEFACE_LAST];
4997
4998         deMemset(&faces[0], 0, sizeof(faces));
4999
5000         if (isComplete())
5001         {
5002                 const int       size            = getFace(baseLevel, tcu::CUBEFACE_NEGATIVE_X).getWidth();
5003                 const bool      isMipmap        = isMipmapFilter(getSampler().minFilter);
5004                 const int       numLevels       = isMipmap ? de::min(getMaxLevel()-baseLevel+1, getNumMipLevels1D(size)) : 1;
5005
5006                 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
5007                 {
5008                         m_levels[face].updateSamplerMode(mode);
5009                         faces[face] = m_levels[face].getEffectiveLevels() + baseLevel;
5010                 }
5011
5012                 m_view = tcu::TextureCubeView(numLevels, faces);
5013         }
5014         else
5015                 m_view = tcu::TextureCubeView(0, faces);
5016 }
5017
5018 tcu::Vec4 TextureCube::sample (float s, float t, float p, float lod) const
5019 {
5020         return m_view.sample(getSampler(), s, t, p, lod);
5021 }
5022
5023 void TextureCube::sample4 (tcu::Vec4 output[4], const tcu::Vec3 packetTexcoords[4], float lodBias) const
5024 {
5025         const float cubeSide = (float)m_view.getSize();
5026
5027         // Each tex coord might be in a different face.
5028
5029         for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
5030         {
5031                 const tcu::CubeFace face                = tcu::selectCubeFace(packetTexcoords[fragNdx]);
5032                 const tcu::Vec2         coords[4]       =
5033                 {
5034                         tcu::projectToFace(face, packetTexcoords[0]),
5035                         tcu::projectToFace(face, packetTexcoords[1]),
5036                         tcu::projectToFace(face, packetTexcoords[2]),
5037                         tcu::projectToFace(face, packetTexcoords[3]),
5038                 };
5039
5040                 const tcu::Vec2 dFdx0 = coords[1] - coords[0];
5041                 const tcu::Vec2 dFdx1 = coords[3] - coords[2];
5042                 const tcu::Vec2 dFdy0 = coords[2] - coords[0];
5043                 const tcu::Vec2 dFdy1 = coords[3] - coords[1];
5044
5045                 const tcu::Vec2& dFdx = (fragNdx & 2) ? dFdx1 : dFdx0;
5046                 const tcu::Vec2& dFdy = (fragNdx & 1) ? dFdy1 : dFdy0;
5047
5048                 const float mu = de::max(de::abs(dFdx.x()), de::abs(dFdy.x()));
5049                 const float mv = de::max(de::abs(dFdx.y()), de::abs(dFdy.y()));
5050                 const float p = de::max(mu * cubeSide, mv * cubeSide);
5051
5052                 const float     lod = deFloatLog2(p) + lodBias;
5053
5054                 output[fragNdx] = sample(packetTexcoords[fragNdx].x(), packetTexcoords[fragNdx].y(), packetTexcoords[fragNdx].z(), lod);
5055         }
5056 }
5057
5058 Texture2DArray::Texture2DArray (deUint32 name)
5059         : Texture       (name, TYPE_2D_ARRAY)
5060         , m_view        (0, DE_NULL)
5061 {
5062 }
5063
5064 Texture2DArray::~Texture2DArray (void)
5065 {
5066 }
5067
5068 void Texture2DArray::allocLevel (int level, const tcu::TextureFormat& format, int width, int height, int numLayers)
5069 {
5070         m_levels.allocLevel(level, format, width, height, numLayers);
5071 }
5072
5073 bool Texture2DArray::isComplete (void) const
5074 {
5075         const int       baseLevel       = getBaseLevel();
5076
5077         if (hasLevel(baseLevel))
5078         {
5079                 const tcu::ConstPixelBufferAccess&      level0          = getLevel(baseLevel);
5080                 const bool                                                      mipmap          = isMipmapFilter(getSampler().minFilter);
5081
5082                 if (mipmap)
5083                 {
5084                         const TextureFormat&    format          = level0.getFormat();
5085                         const int                               w                       = level0.getWidth();
5086                         const int                               h                       = level0.getHeight();
5087                         const int                               numLayers       = level0.getDepth();
5088                         const int                               numLevels       = de::min(getMaxLevel()-baseLevel+1, getNumMipLevels2D(w, h));
5089
5090                         for (int levelNdx = 1; levelNdx < numLevels; levelNdx++)
5091                         {
5092                                 if (hasLevel(baseLevel+levelNdx))
5093                                 {
5094                                         const tcu::ConstPixelBufferAccess&      level           = getLevel(baseLevel+levelNdx);
5095                                         const int                                                       expectedW       = getMipLevelSize(w, levelNdx);
5096                                         const int                                                       expectedH       = getMipLevelSize(h, levelNdx);
5097
5098                                         if (level.getWidth()    != expectedW    ||
5099                                                 level.getHeight()       != expectedH    ||
5100                                                 level.getDepth()        != numLayers    ||
5101                                                 level.getFormat()       != format)
5102                                                 return false;
5103                                 }
5104                                 else
5105                                         return false;
5106                         }
5107                 }
5108
5109                 return true;
5110         }
5111         else
5112                 return false;
5113 }
5114
5115 void Texture2DArray::updateView (tcu::Sampler::DepthStencilMode mode)
5116 {
5117         const int baseLevel     = getBaseLevel();
5118
5119         if (hasLevel(baseLevel) && !isEmpty(getLevel(baseLevel)))
5120         {
5121                 const int       width           = getLevel(baseLevel).getWidth();
5122                 const int       height          = getLevel(baseLevel).getHeight();
5123                 const bool      isMipmap        = isMipmapFilter(getSampler().minFilter);
5124                 const int       numLevels       = isMipmap ? de::min(getMaxLevel()-baseLevel+1, getNumMipLevels2D(width, height)) : 1;
5125
5126                 m_levels.updateSamplerMode(mode);
5127                 m_view = tcu::Texture2DArrayView(numLevels, m_levels.getEffectiveLevels() + baseLevel);
5128         }
5129         else
5130                 m_view = tcu::Texture2DArrayView(0, DE_NULL);
5131 }
5132
5133 tcu::Vec4 Texture2DArray::sample (float s, float t, float r, float lod) const
5134 {
5135         return m_view.sample(getSampler(), s, t, r, lod);
5136 }
5137
5138 void Texture2DArray::sample4 (tcu::Vec4 output[4], const tcu::Vec3 packetTexcoords[4], float lodBias) const
5139 {
5140         const float texWidth  = (float)m_view.getWidth();
5141         const float texHeight = (float)m_view.getHeight();
5142
5143         const tcu::Vec3 dFdx0 = packetTexcoords[1] - packetTexcoords[0];
5144         const tcu::Vec3 dFdx1 = packetTexcoords[3] - packetTexcoords[2];
5145         const tcu::Vec3 dFdy0 = packetTexcoords[2] - packetTexcoords[0];
5146         const tcu::Vec3 dFdy1 = packetTexcoords[3] - packetTexcoords[1];
5147
5148         for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
5149         {
5150                 const tcu::Vec3& dFdx = (fragNdx & 2) ? dFdx1 : dFdx0;
5151                 const tcu::Vec3& dFdy = (fragNdx & 1) ? dFdy1 : dFdy0;
5152
5153                 const float mu = de::max(de::abs(dFdx.x()), de::abs(dFdy.x()));
5154                 const float mv = de::max(de::abs(dFdx.y()), de::abs(dFdy.y()));
5155                 const float p = de::max(mu * texWidth, mv * texHeight);
5156
5157                 const float     lod = deFloatLog2(p) + lodBias;
5158
5159                 output[fragNdx] = sample(packetTexcoords[fragNdx].x(), packetTexcoords[fragNdx].y(), packetTexcoords[fragNdx].z(), lod);
5160         }
5161 }
5162
5163 TextureCubeArray::TextureCubeArray (deUint32 name)
5164         : Texture       (name, TYPE_CUBE_MAP_ARRAY)
5165         , m_view        (0, DE_NULL)
5166 {
5167 }
5168
5169 TextureCubeArray::~TextureCubeArray (void)
5170 {
5171 }
5172
5173 void TextureCubeArray::allocLevel (int level, const tcu::TextureFormat& format, int width, int height, int numLayers)
5174 {
5175         DE_ASSERT(numLayers % 6 == 0);
5176         m_levels.allocLevel(level, format, width, height, numLayers);
5177 }
5178
5179 bool TextureCubeArray::isComplete (void) const
5180 {
5181         const int       baseLevel       = getBaseLevel();
5182
5183         if (hasLevel(baseLevel))
5184         {
5185                 const tcu::ConstPixelBufferAccess&      level0          = getLevel(baseLevel);
5186                 const bool                                                      mipmap          = isMipmapFilter(getSampler().minFilter);
5187
5188                 if (mipmap)
5189                 {
5190                         const TextureFormat&    format          = level0.getFormat();
5191                         const int                               w                       = level0.getWidth();
5192                         const int                               h                       = level0.getHeight();
5193                         const int                               numLayers       = level0.getDepth();
5194                         const int                               numLevels       = de::min(getMaxLevel()-baseLevel+1, getNumMipLevels2D(w, h));
5195
5196                         for (int levelNdx = 1; levelNdx < numLevels; levelNdx++)
5197                         {
5198                                 if (hasLevel(baseLevel+levelNdx))
5199                                 {
5200                                         const tcu::ConstPixelBufferAccess&      level           = getLevel(baseLevel+levelNdx);
5201                                         const int                                                       expectedW       = getMipLevelSize(w, levelNdx);
5202                                         const int                                                       expectedH       = getMipLevelSize(h, levelNdx);
5203
5204                                         if (level.getWidth()    != expectedW    ||
5205                                                 level.getHeight()       != expectedH    ||
5206                                                 level.getDepth()        != numLayers    ||
5207                                                 level.getFormat()       != format)
5208                                                 return false;
5209                                 }
5210                                 else
5211                                         return false;
5212                         }
5213                 }
5214
5215                 return true;
5216         }
5217         else
5218                 return false;
5219 }
5220
5221 void TextureCubeArray::updateView (tcu::Sampler::DepthStencilMode mode)
5222 {
5223         const int baseLevel     = getBaseLevel();
5224
5225         if (hasLevel(baseLevel) && !isEmpty(getLevel(baseLevel)))
5226         {
5227                 const int       width           = getLevel(baseLevel).getWidth();
5228                 const int       height          = getLevel(baseLevel).getHeight();
5229                 const bool      isMipmap        = isMipmapFilter(getSampler().minFilter);
5230                 const int       numLevels       = isMipmap ? de::min(getMaxLevel()-baseLevel+1, getNumMipLevels2D(width, height)) : 1;
5231
5232                 m_levels.updateSamplerMode(mode);
5233                 m_view = tcu::TextureCubeArrayView(numLevels, m_levels.getEffectiveLevels() + baseLevel);
5234         }
5235         else
5236                 m_view = tcu::TextureCubeArrayView(0, DE_NULL);
5237 }
5238
5239 tcu::Vec4 TextureCubeArray::sample (float s, float t, float r, float q, float lod) const
5240 {
5241         return m_view.sample(getSampler(), s, t, r, q, lod);
5242 }
5243
5244 void TextureCubeArray::sample4 (tcu::Vec4 output[4], const tcu::Vec4 packetTexcoords[4], float lodBias) const
5245 {
5246         const float             cubeSide                = (float)m_view.getSize();
5247         const tcu::Vec3 cubeCoords[4]   =
5248         {
5249                 packetTexcoords[0].toWidth<3>(),
5250                 packetTexcoords[1].toWidth<3>(),
5251                 packetTexcoords[2].toWidth<3>(),
5252                 packetTexcoords[3].toWidth<3>()
5253         };
5254
5255         for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
5256         {
5257                 const tcu::CubeFace face                        = tcu::selectCubeFace(cubeCoords[fragNdx]);
5258                 const tcu::Vec2         faceCoords[4]   =
5259                 {
5260                         tcu::projectToFace(face, cubeCoords[0]),
5261                         tcu::projectToFace(face, cubeCoords[1]),
5262                         tcu::projectToFace(face, cubeCoords[2]),
5263                         tcu::projectToFace(face, cubeCoords[3]),
5264                 };
5265
5266                 const tcu::Vec2 dFdx0 = faceCoords[1] - faceCoords[0];
5267                 const tcu::Vec2 dFdx1 = faceCoords[3] - faceCoords[2];
5268                 const tcu::Vec2 dFdy0 = faceCoords[2] - faceCoords[0];
5269                 const tcu::Vec2 dFdy1 = faceCoords[3] - faceCoords[1];
5270
5271                 const tcu::Vec2& dFdx = (fragNdx & 2) ? dFdx1 : dFdx0;
5272                 const tcu::Vec2& dFdy = (fragNdx & 1) ? dFdy1 : dFdy0;
5273
5274                 const float mu = de::max(de::abs(dFdx.x()), de::abs(dFdy.x()));
5275                 const float mv = de::max(de::abs(dFdx.y()), de::abs(dFdy.y()));
5276                 const float p = de::max(mu * cubeSide, mv * cubeSide);
5277
5278                 const float     lod = deFloatLog2(p) + lodBias;
5279
5280                 output[fragNdx] = sample(packetTexcoords[fragNdx].x(), packetTexcoords[fragNdx].y(), packetTexcoords[fragNdx].z(), packetTexcoords[fragNdx].w(), lod);
5281         }
5282 }
5283
5284 Texture3D::Texture3D (deUint32 name)
5285         : Texture       (name, TYPE_3D)
5286         , m_view        (0, DE_NULL)
5287 {
5288 }
5289
5290 Texture3D::~Texture3D (void)
5291 {
5292 }
5293
5294 void Texture3D::allocLevel (int level, const tcu::TextureFormat& format, int width, int height, int depth)
5295 {
5296         m_levels.allocLevel(level, format, width, height, depth);
5297 }
5298
5299 bool Texture3D::isComplete (void) const
5300 {
5301         const int       baseLevel       = getBaseLevel();
5302
5303         if (hasLevel(baseLevel))
5304         {
5305                 const tcu::ConstPixelBufferAccess&      level0          = getLevel(baseLevel);
5306                 const bool                                                      mipmap          = isMipmapFilter(getSampler().minFilter);
5307
5308                 if (mipmap)
5309                 {
5310                         const TextureFormat&    format          = level0.getFormat();
5311                         const int                               w                       = level0.getWidth();
5312                         const int                               h                       = level0.getHeight();
5313                         const int                               d                       = level0.getDepth();
5314                         const int                               numLevels       = de::min(getMaxLevel()-baseLevel+1, getNumMipLevels3D(w, h, d));
5315
5316                         for (int levelNdx = 1; levelNdx < numLevels; levelNdx++)
5317                         {
5318                                 if (hasLevel(baseLevel+levelNdx))
5319                                 {
5320                                         const tcu::ConstPixelBufferAccess&      level           = getLevel(baseLevel+levelNdx);
5321                                         const int                                                       expectedW       = getMipLevelSize(w, levelNdx);
5322                                         const int                                                       expectedH       = getMipLevelSize(h, levelNdx);
5323                                         const int                                                       expectedD       = getMipLevelSize(d, levelNdx);
5324
5325                                         if (level.getWidth()    != expectedW    ||
5326                                                 level.getHeight()       != expectedH    ||
5327                                                 level.getDepth()        != expectedD    ||
5328                                                 level.getFormat()       != format)
5329                                                 return false;
5330                                 }
5331                                 else
5332                                         return false;
5333                         }
5334                 }
5335
5336                 return true;
5337         }
5338         else
5339                 return false;
5340 }
5341
5342 tcu::Vec4 Texture3D::sample (float s, float t, float r, float lod) const
5343 {
5344         return m_view.sample(getSampler(), s, t, r, lod);
5345 }
5346
5347 void Texture3D::sample4 (tcu::Vec4 output[4], const tcu::Vec3 packetTexcoords[4], float lodBias) const
5348 {
5349         const float texWidth  = (float)m_view.getWidth();
5350         const float texHeight = (float)m_view.getHeight();
5351         const float texDepth  = (float)m_view.getDepth();
5352
5353         const tcu::Vec3 dFdx0 = packetTexcoords[1] - packetTexcoords[0];
5354         const tcu::Vec3 dFdx1 = packetTexcoords[3] - packetTexcoords[2];
5355         const tcu::Vec3 dFdy0 = packetTexcoords[2] - packetTexcoords[0];
5356         const tcu::Vec3 dFdy1 = packetTexcoords[3] - packetTexcoords[1];
5357
5358         for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
5359         {
5360                 const tcu::Vec3& dFdx = (fragNdx & 2) ? dFdx1 : dFdx0;
5361                 const tcu::Vec3& dFdy = (fragNdx & 1) ? dFdy1 : dFdy0;
5362
5363                 const float mu = de::max(de::abs(dFdx.x()), de::abs(dFdy.x()));
5364                 const float mv = de::max(de::abs(dFdx.y()), de::abs(dFdy.y()));
5365                 const float mw = de::max(de::abs(dFdx.z()), de::abs(dFdy.z()));
5366                 const float p = de::max(de::max(mu * texWidth, mv * texHeight), mw * texDepth);
5367
5368                 const float     lod = deFloatLog2(p) + lodBias;
5369
5370                 output[fragNdx] = sample(packetTexcoords[fragNdx].x(), packetTexcoords[fragNdx].y(), packetTexcoords[fragNdx].z(), lod);
5371         }
5372 }
5373
5374 void Texture3D::updateView (tcu::Sampler::DepthStencilMode mode)
5375 {
5376         const int baseLevel     = getBaseLevel();
5377
5378         if (hasLevel(baseLevel) && !isEmpty(getLevel(baseLevel)))
5379         {
5380                 const int       width           = getLevel(baseLevel).getWidth();
5381                 const int       height          = getLevel(baseLevel).getHeight();
5382                 const int       depth           = getLevel(baseLevel).getDepth();
5383                 const bool      isMipmap        = isMipmapFilter(getSampler().minFilter);
5384                 const int       numLevels       = isMipmap ? de::min(getMaxLevel()-baseLevel+1, getNumMipLevels3D(width, height, depth)) : 1;
5385
5386                 m_levels.updateSamplerMode(mode);
5387                 m_view = tcu::Texture3DView(numLevels, m_levels.getEffectiveLevels() + baseLevel);
5388         }
5389         else
5390                 m_view = tcu::Texture3DView(0, DE_NULL);
5391 }
5392
5393 Renderbuffer::Renderbuffer (deUint32 name)
5394         : NamedObject           (name)
5395 {
5396 }
5397
5398 Renderbuffer::~Renderbuffer (void)
5399 {
5400 }
5401
5402 void Renderbuffer::setStorage (const TextureFormat& format, int width, int height)
5403 {
5404         m_data.setStorage(format, width, height);
5405 }
5406
5407 Framebuffer::Framebuffer (deUint32 name)
5408         : NamedObject(name)
5409 {
5410 }
5411
5412 Framebuffer::~Framebuffer (void)
5413 {
5414 }
5415
5416 VertexArray::VertexArray (deUint32 name, int maxVertexAttribs)
5417         : NamedObject                                   (name)
5418         , m_elementArrayBufferBinding   (DE_NULL)
5419         , m_arrays                                              (maxVertexAttribs)
5420 {
5421         for (int i = 0; i < maxVertexAttribs; ++i)
5422         {
5423                 m_arrays[i].enabled                     = false;
5424                 m_arrays[i].size                        = 4;
5425                 m_arrays[i].stride                      = 0;
5426                 m_arrays[i].type                        = GL_FLOAT;
5427                 m_arrays[i].normalized          = false;
5428                 m_arrays[i].integer                     = false;
5429                 m_arrays[i].divisor                     = 0;
5430                 m_arrays[i].bufferDeleted       = false;
5431                 m_arrays[i].bufferBinding       = DE_NULL;
5432                 m_arrays[i].pointer                     = DE_NULL;
5433         }
5434 }
5435
5436 ShaderProgramObjectContainer::ShaderProgramObjectContainer (deUint32 name, ShaderProgram* program)
5437         : NamedObject   (name)
5438         , m_program             (program)
5439         , m_deleteFlag  (false)
5440 {
5441 }
5442
5443 ShaderProgramObjectContainer::~ShaderProgramObjectContainer (void)
5444 {
5445 }
5446
5447 } // rc
5448 } // sglr