diff options
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureSpecificationTests.js')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureSpecificationTests.js | 7456 |
1 files changed, 7456 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureSpecificationTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureSpecificationTests.js new file mode 100644 index 0000000000..5ff5edc550 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureSpecificationTests.js @@ -0,0 +1,7456 @@ +/*------------------------------------------------------------------------- + * drawElements Quality Program OpenGL ES Utilities + * ------------------------------------------------ + * + * Copyright 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the 'License'); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an 'AS IS' BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +'use strict'; +goog.provide('functional.gles3.es3fTextureSpecificationTests'); +goog.require('framework.common.tcuImageCompare'); +goog.require('framework.common.tcuLogImage'); +goog.require('framework.common.tcuPixelFormat'); +goog.require('framework.common.tcuSurface'); +goog.require('framework.common.tcuTestCase'); +goog.require('framework.common.tcuTexture'); +goog.require('framework.common.tcuTextureUtil'); +goog.require('framework.delibs.debase.deMath'); +goog.require('framework.delibs.debase.deRandom'); +goog.require('framework.delibs.debase.deString'); +goog.require('framework.opengl.gluShaderUtil'); +goog.require('framework.opengl.gluTextureUtil'); +goog.require('framework.opengl.simplereference.sglrGLContext'); +goog.require('framework.opengl.simplereference.sglrReferenceContext'); +goog.require('framework.referencerenderer.rrUtil'); +goog.require('functional.gles3.es3fFboTestUtil'); + +goog.scope(function() { + var es3fTextureSpecificationTests = + functional.gles3.es3fTextureSpecificationTests; + var tcuPixelFormat = framework.common.tcuPixelFormat; + var tcuImageCompare = framework.common.tcuImageCompare; + var tcuSurface = framework.common.tcuSurface; + var tcuTestCase = framework.common.tcuTestCase; + var tcuTexture = framework.common.tcuTexture; + var tcuTextureUtil = framework.common.tcuTextureUtil; + var deMath = framework.delibs.debase.deMath; + var deRandom = framework.delibs.debase.deRandom; + var deString = framework.delibs.debase.deString; + var gluShaderUtil = framework.opengl.gluShaderUtil; + var gluTextureUtil = framework.opengl.gluTextureUtil; + var sglrGLContext = framework.opengl.simplereference.sglrGLContext; + var sglrReferenceContext = + framework.opengl.simplereference.sglrReferenceContext; + var rrUtil = framework.referencerenderer.rrUtil; + var es3fFboTestUtil = functional.gles3.es3fFboTestUtil; + var tcuLogImage = framework.common.tcuLogImage; + + /** + * @param {number} internalFormat + * @return {tcuTexture.TextureFormat} + */ + es3fTextureSpecificationTests.mapGLUnsizedInternalFormat = function( + internalFormat + ) { + switch (internalFormat) { + case gl.ALPHA: + return new tcuTexture.TextureFormat( + tcuTexture.ChannelOrder.A, + tcuTexture.ChannelType.UNORM_INT8 + ); + case gl.LUMINANCE: + return new tcuTexture.TextureFormat( + tcuTexture.ChannelOrder.L, + tcuTexture.ChannelType.UNORM_INT8 + ); + case gl.LUMINANCE_ALPHA: + return new tcuTexture.TextureFormat( + tcuTexture.ChannelOrder.LA, + tcuTexture.ChannelType.UNORM_INT8 + ); + case gl.RGB: + return new tcuTexture.TextureFormat( + tcuTexture.ChannelOrder.RGB, + tcuTexture.ChannelType.UNORM_INT8 + ); + case gl.RGBA: + return new tcuTexture.TextureFormat( + tcuTexture.ChannelOrder.RGBA, + tcuTexture.ChannelType.UNORM_INT8 + ); + default: + throw new Error( + 'Can\'t map GL unsized internal format (' + + internalFormat.toString(16) + ') to texture format' + ); + } + }; + + var VIEWPORT_WIDTH = 256; + var VIEWPORT_HEIGHT = 256; + + /** + * @param {number} width + * @param {number} height + * @param {number=} depth + * @return {number} + */ + es3fTextureSpecificationTests.maxLevelCount = function( + width, height, depth + ) { + depth = depth || 0; + return deMath.logToFloor(Math.max(width, Math.max(height, depth))) + 1; + }; + + /** + * @param {deRandom.Random} rnd + * @param {Array<number>} minVal + * @param {Array<number>} maxVal + * @param {number} size + * @return {Array<number>} + */ + es3fTextureSpecificationTests.randomVector = function( + rnd, minVal, maxVal, size + ) { + var res = []; + for (var ndx = 0; ndx < size; ndx++) + res[ndx] = rnd.getFloat(minVal[ndx], maxVal[ndx]); + return res; + }; + + /** + * @param {tcuPixelFormat.PixelFormat} pixelFormat + * @param {tcuTexture.TextureFormat} textureFormat + * @return {Array<number>} (ivec4) + */ + es3fTextureSpecificationTests.getPixelFormatCompareDepth = function( + pixelFormat, textureFormat + ) { + switch (textureFormat.order) { + case tcuTexture.ChannelOrder.L: + case tcuTexture.ChannelOrder.LA: + return [ + pixelFormat.redBits, pixelFormat.redBits, + pixelFormat.redBits, pixelFormat.alphaBits + ]; + default: + return [ + pixelFormat.redBits, pixelFormat.greenBits, + pixelFormat.blueBits, pixelFormat.alphaBits + ]; + } + }; + + /** + * @param {tcuPixelFormat.PixelFormat} pixelFormat + * @param {tcuTexture.TextureFormat} textureFormat + * @return {Array<number>} (uvec4) + */ + es3fTextureSpecificationTests.computeCompareThreshold = function( + pixelFormat, textureFormat + ) { + /** @type {Array<number>} */ + var texFormatBits = tcuTextureUtil.getTextureFormatBitDepth( + textureFormat + ); + /** @type {Array<number>} */ + var pixelFormatBits = + es3fTextureSpecificationTests.getPixelFormatCompareDepth( + pixelFormat, textureFormat + ); + /** @type {Array<number>} */ + var accurateFmtBits = deMath.min(pixelFormatBits, texFormatBits); + /** @type {Array<number>} */ + var compareBits = deMath.addScalar( + tcuTextureUtil.select( + accurateFmtBits, [8, 8, 8, 8], + deMath.greaterThan(accurateFmtBits, [0, 0, 0, 0]) + ), - 1 + ); + + var result = []; + for (var i = 0; i < compareBits.length; i++) + result.push(1 << compareBits[i]); + return result; + }; + + /** + * @constructor + * @extends {tcuTestCase.DeqpTest} + * @param {string} name + * @param {string} desc + * context + */ + es3fTextureSpecificationTests.TextureSpecCase = function(name, desc) { + tcuTestCase.DeqpTest.call(this, name, desc); + /** + * @type { + * ?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext + * } + */ + this.m_context = null; + }; + + es3fTextureSpecificationTests.TextureSpecCase.prototype = Object.create( + tcuTestCase.DeqpTest.prototype + ); + + es3fTextureSpecificationTests.TextureSpecCase.prototype.constructor = + es3fTextureSpecificationTests.TextureSpecCase; + + /** + * deinit + */ + es3fTextureSpecificationTests.TextureSpecCase.prototype.deinit = + function() { + gl.pixelStorei(gl.UNPACK_ALIGNMENT, 4); + gl.pixelStorei(gl.UNPACK_ROW_LENGTH, 0); + gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, 0); + gl.pixelStorei(gl.UNPACK_SKIP_PIXELS, 0); + gl.pixelStorei(gl.UNPACK_SKIP_ROWS, 0); + gl.pixelStorei(gl.UNPACK_SKIP_IMAGES, 0); + + gl.bindBuffer(gl.PIXEL_UNPACK_BUFFER, null); + } + + /** + * createTexture - Needs to be overridden + */ + es3fTextureSpecificationTests.TextureSpecCase.prototype.createTexture = + function() { + throw new Error('Must override'); + }; + + /** + * verifyTexture - Needs to be overridden + * @param {sglrGLContext.GLContext} webgl2Context + * @param {sglrReferenceContext.ReferenceContext} refContext + * @return {boolean} + */ + es3fTextureSpecificationTests.TextureSpecCase.prototype.verifyTexture = + function( + webgl2Context, refContext + ) { + throw new Error('Must override'); + }; + + /** + * @return {tcuTestCase.IterateResult} + */ + es3fTextureSpecificationTests.TextureSpecCase.prototype.iterate = function() { + if (gl.canvas.width < VIEWPORT_WIDTH || + gl.canvas.height < VIEWPORT_HEIGHT) + throw new Error('Too small viewport', ''); + + // Context size, and viewport for GLES3 + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + var width = Math.min(gl.canvas.width, VIEWPORT_WIDTH); + var height = Math.min(gl.canvas.height, VIEWPORT_HEIGHT); + var x = rnd.getInt(0, gl.canvas.width - width); + var y = rnd.getInt(0, gl.canvas.height - height); + + // Contexts. + /** @type {sglrGLContext.GLContext} */ + var webgl2Context = new sglrGLContext.GLContext( + gl, [x, y, width, height] + ); + + /** @type {sglrReferenceContext.ReferenceContextBuffers} */ + var refBuffers = new sglrReferenceContext.ReferenceContextBuffers( + new tcuPixelFormat.PixelFormat( + 8, 8, 8, gl.getParameter(gl.ALPHA_BITS) ? 8 : 0 + ), 0 /* depth */, 0 /* stencil */, width, height + ); + + /** @type {sglrReferenceContext.ReferenceContext} */ + var refContext = new sglrReferenceContext.ReferenceContext( + new sglrReferenceContext.ReferenceContextLimits(gl), + refBuffers.getColorbuffer(), refBuffers.getDepthbuffer(), + refBuffers.getStencilbuffer() + ); + + // Clear color buffer. + for (var ndx = 0; ndx < 2; ndx++) { + this.m_context = ndx ? refContext : webgl2Context; + // C++ port uses (0.125, 0.25, 0.5, 1.0), but here we use (0, 0, 0, 0) + // in order to optimize the `clear' op in ReferenceContext. + this.m_context.clearColor(0, 0, 0, 0); + this.m_context.clear( + gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | + gl.STENCIL_BUFFER_BIT + ); + } + + // Construct texture using both GLES3 and reference contexts. + for (var ndx = 0; ndx < 2; ndx++) { + this.m_context = ndx ? refContext : webgl2Context; + this.createTexture(); + checkMessage( + this.m_context.getError() == gl.NO_ERROR, + 'Problem creating texture.' + ); + } + + // Verify results. + if (this.verifyTexture(webgl2Context, refContext)) + testPassed(); + else + testFailed('Verification failed'); + + return tcuTestCase.IterateResult.STOP; + }; + + /** + * @param {tcuSurface.Surface} dst + * @param { + * ?WebGLProgram| + * framework.opengl.simplereference.sglrShaderProgram.ShaderProgram + * } program + * @param {number} width + * @param {number} height + */ + es3fTextureSpecificationTests.TextureSpecCase.prototype.renderTex = + function(dst, program, width, height) { + var targetW = this.m_context.getWidth(); + var targetH = this.m_context.getHeight(); + + var w = width / targetW; + var h = height / targetH; + + rrUtil.drawQuad( + this.m_context, program, [-1.0, -1.0, 0.0], + [-1.0 + w * 2.0, -1.0 + h * 2.0, 0.0] + ); + + // Read pixels back. + dst.readViewport(this.m_context, [0, 0, width, height]); + }; + + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureSpecCase} + * @param {string} name + * @param {string} desc + * @param {tcuTexture.TextureFormat} format + * @param {number} width + * @param {number} height + * @param {number} numLevels + */ + es3fTextureSpecificationTests.Texture2DSpecCase = function( + name, desc, format, width, height, numLevels + ) { + es3fTextureSpecificationTests.TextureSpecCase.call(this, name, desc); + + this.m_texFormat = format; + this.m_texFormatInfo = tcuTextureUtil.getTextureFormatInfo(format); + this.m_width = width; + this.m_height = height; + this.m_numLevels = numLevels; + }; + + es3fTextureSpecificationTests.Texture2DSpecCase.prototype = Object.create( + es3fTextureSpecificationTests.TextureSpecCase.prototype + ); + + es3fTextureSpecificationTests.Texture2DSpecCase.prototype.constructor = + es3fTextureSpecificationTests.Texture2DSpecCase; + + /** + * @param {sglrGLContext.GLContext} webgl2Context + * @param {sglrReferenceContext.ReferenceContext} refContext + */ + es3fTextureSpecificationTests.Texture2DSpecCase.prototype.verifyTexture = + function( + webgl2Context, refContext + ) { + /** @type {es3fFboTestUtil.Texture2DShader} */ + var shader = new es3fFboTestUtil.Texture2DShader( + [gluTextureUtil.getSampler2DType(this.m_texFormat)], + gluShaderUtil.DataType.FLOAT_VEC4 + ); + + var shaderIDgles = webgl2Context.createProgram(shader); + var shaderIDRef = refContext.createProgram(shader); + + shader.setTexScaleBias( + 0, this.m_texFormatInfo.lookupScale, + this.m_texFormatInfo.lookupBias + ); + + // Set state. + for (var ndx = 0; ndx < 2; ndx++) { + var ctx = ndx ? refContext : webgl2Context; + + this.m_context = ctx; + + this.m_context.texParameteri( + gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST_MIPMAP_NEAREST + ); + this.m_context.texParameteri( + gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST + ); + this.m_context.texParameteri( + gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE + ); + this.m_context.texParameteri( + gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE + ); + this.m_context.texParameteri( + gl.TEXTURE_2D, gl.TEXTURE_MAX_LEVEL, this.m_numLevels - 1 + ); + } + + for (var levelNdx = 0; levelNdx < this.m_numLevels; levelNdx++) { + var levelW = Math.max(1, this.m_width >> levelNdx); + var levelH = Math.max(1, this.m_height >> levelNdx); + /** @type {tcuSurface.Surface} */ var reference = new tcuSurface.Surface(); + /** @type {tcuSurface.Surface} */ var result = new tcuSurface.Surface(); + + for (var ndx = 0; ndx < 2; ndx++) { + /** @type {tcuSurface.Surface} */ + var dst = ndx ? reference : result; + var ctx = ndx ? refContext : webgl2Context; + var shaderID = ndx ? shaderIDRef : shaderIDgles; + + this.m_context = ctx; + shader.setUniforms(ctx, shaderID); + this.renderTex(dst, shaderID, levelW, levelH); + } + + var threshold = + es3fTextureSpecificationTests.computeCompareThreshold( + tcuPixelFormat.PixelFormatFromContext(gl), this.m_texFormat + ); + var levelStr = levelNdx.toString(); + var name = 'Level' + levelStr; + var desc = 'Level ' + levelStr; + var isOk = tcuImageCompare.intThresholdCompare( + name, desc, reference.getAccess(), result.getAccess(), + threshold, levelNdx == 0 ? + tcuImageCompare.CompareLogMode.RESULT : + tcuImageCompare.CompareLogMode.ON_ERROR + ); + + if (!isOk) { + testFailed('Image comparison failed'); + return false; + } else { + // tcuLogImage.logImageWithInfo(result.getAccess(),'Comparison OK on level: ' + levelNdx); + } + } + return true; + }; + + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureSpecCase} + * @param {string} name + * @param {string} desc + * @param {tcuTexture.TextureFormat} format + * @param {number} size + * @param {number} numLevels + */ + es3fTextureSpecificationTests.TextureCubeSpecCase = function( + name, desc, format, size, numLevels + ) { + es3fTextureSpecificationTests.TextureSpecCase.call( + this, name, desc + ); + this.m_texFormat = format; + this.m_texFormatInfo = tcuTextureUtil.getTextureFormatInfo(format); + this.m_size = size; + this.m_numLevels = numLevels; + }; + + es3fTextureSpecificationTests.TextureCubeSpecCase.prototype = + Object.create(es3fTextureSpecificationTests.TextureSpecCase.prototype); + + es3fTextureSpecificationTests.TextureCubeSpecCase.prototype.constructor = + es3fTextureSpecificationTests.TextureCubeSpecCase; + + /** + * @param {sglrGLContext.GLContext} webgl2Context + * @param {sglrReferenceContext.ReferenceContext} refContext + */ + es3fTextureSpecificationTests.TextureCubeSpecCase.prototype.verifyTexture = + function( + webgl2Context, refContext + ) { + /** @type {es3fFboTestUtil.TextureCubeShader} */ + var shader = new es3fFboTestUtil.TextureCubeShader( + gluTextureUtil.getSamplerCubeType(this.m_texFormat), + gluShaderUtil.DataType.FLOAT_VEC4 + ); + var shaderIDgles = webgl2Context.createProgram(shader); + var shaderIDRef = refContext.createProgram(shader); + + shader.setTexScaleBias( + this.m_texFormatInfo.lookupScale, this.m_texFormatInfo.lookupBias + ); + + // Set state. + for (var ndx = 0; ndx < 2; ndx++) { + var ctx = ndx ? refContext : webgl2Context; + + this.m_context = ctx; + + this.m_context.texParameteri( + gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, + gl.NEAREST_MIPMAP_NEAREST + ); + this.m_context.texParameteri( + gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, + gl.NEAREST + ); + this.m_context.texParameteri( + gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, + gl.CLAMP_TO_EDGE + ); + this.m_context.texParameteri( + gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, + gl.CLAMP_TO_EDGE + ); + this.m_context.texParameteri( + gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAX_LEVEL, + this.m_numLevels - 1 + ); + } + + for (var levelNdx = 0; levelNdx < this.m_numLevels; levelNdx++) { + var levelSize = Math.max(1, this.m_size >> levelNdx); + var isOk = true; + + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + /** @type {tcuSurface.Surface} */ + var reference = new tcuSurface.Surface(); + /** @type {tcuSurface.Surface} */ + var result = new tcuSurface.Surface(); + + if (levelSize <= 2) + continue; // Fuzzy compare doesn't work for images this small. + + shader.setFace(face); + + for (var ndx = 0; ndx < 2; ndx++) { + /** @type {tcuSurface.Surface} */ + var dst = ndx ? reference : result; + ctx = ndx ? refContext : webgl2Context; + var shaderID = ndx ? shaderIDRef : shaderIDgles; + + this.m_context = ctx; + shader.setUniforms(ctx, shaderID); + this.renderTex(dst, shaderID, levelSize, levelSize); + } + + var threshold = 0.02; + var faceStr = face.toString(); + var levelStr = levelNdx.toString(); + var name = 'Level' + levelStr; + var desc = 'Level ' + levelStr + ', face ' + faceStr; + var isFaceOk = tcuImageCompare.fuzzyCompare( + name, desc, reference.getAccess(), result.getAccess(), + threshold, levelNdx == 0 ? + tcuImageCompare.CompareLogMode.RESULT : + tcuImageCompare.CompareLogMode.ON_ERROR + ); + + if (!isFaceOk) { + testFailed('Image comparison failed'); + return false; + } + } + + } + return true; + }; + + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureSpecCase} + * @param {string} name + * @param {string} desc + * @param {tcuTexture.TextureFormat} format + * @param {number} width + * @param {number} height + * @param {number} numLayers + * @param {number} numLevels + */ + es3fTextureSpecificationTests.Texture2DArraySpecCase = function( + name, desc, format, width, height, numLayers, numLevels + ) { + es3fTextureSpecificationTests.TextureSpecCase.call( + this, name, desc + ); + this.m_texFormat = format; + this.m_texFormatInfo = tcuTextureUtil.getTextureFormatInfo(format); + this.m_width = width; + this.m_height = height; + this.m_numLayers = numLayers; + this.m_numLevels = numLevels; + }; + + es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype = + Object.create(es3fTextureSpecificationTests.TextureSpecCase.prototype); + + es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype.constructor = + es3fTextureSpecificationTests.Texture2DArraySpecCase; + + /** + * @param {sglrGLContext.GLContext} webgl2Context + * @param {sglrReferenceContext.ReferenceContext} refContext + */ + es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype.verifyTexture = + function( + webgl2Context, refContext + ) { + /** @type {es3fFboTestUtil.Texture2DArrayShader} */ + var shader = new es3fFboTestUtil.Texture2DArrayShader( + gluTextureUtil.getSampler2DArrayType(this.m_texFormat), + gluShaderUtil.DataType.FLOAT_VEC4 + ); + var shaderIDgles = webgl2Context.createProgram(shader); + var shaderIDRef = refContext.createProgram(shader); + + shader.setTexScaleBias( + this.m_texFormatInfo.lookupScale, this.m_texFormatInfo.lookupBias + ); + + // Set state. + for (var ndx = 0; ndx < 2; ndx++) { + var ctx = ndx ? refContext : webgl2Context; + + this.m_context = ctx; + + this.m_context.texParameteri( + gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, + gl.NEAREST_MIPMAP_NEAREST + ); + this.m_context.texParameteri( + gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, + gl.NEAREST + ); + this.m_context.texParameteri( + gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, + gl.CLAMP_TO_EDGE + ); + this.m_context.texParameteri( + gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, + gl.CLAMP_TO_EDGE + ); + this.m_context.texParameteri( + gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_R, + gl.CLAMP_TO_EDGE + ); + this.m_context.texParameteri( + gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAX_LEVEL, + this.m_numLevels - 1 + ); + } + + for (var layerNdx = 0; layerNdx < this.m_numLayers; layerNdx++) { + var layerOk = true; + + shader.setLayer(layerNdx); + for (var levelNdx = 0; levelNdx < this.m_numLevels; levelNdx++) { + var levelW = Math.max(1, this.m_width >> levelNdx); + var levelH = Math.max(1, this.m_height >> levelNdx); + + if (levelW == 1 || levelH == 1) { + // Rendering to texture of size x1 is problematic in referencerenderer + // due to its deviation from c++ code: crbug.com/613206 + continue; + } + /** @type {tcuSurface.Surface} */ + var reference = new tcuSurface.Surface(); + /** @type {tcuSurface.Surface} */ + var result = new tcuSurface.Surface(); + + var isOk = true; + + for (var ndx = 0; ndx < 2; ndx++) { + /** @type {tcuSurface.Surface} */ + var dst = ndx ? reference : result; + ctx = ndx ? refContext : webgl2Context; + var shaderID = ndx ? shaderIDRef : shaderIDgles; + + this.m_context = ctx; + shader.setUniforms(ctx, shaderID); + this.renderTex(dst, shaderID, levelW, levelH); + } + + var threshold = + es3fTextureSpecificationTests.computeCompareThreshold( + tcuPixelFormat.PixelFormatFromContext(gl), this.m_texFormat + ); + var levelStr = levelNdx.toString(); + var layerStr = layerNdx.toString(); + var name = 'Layer' + layerStr + 'Level' + levelStr; + var desc = 'Layer ' + layerStr + ', Level ' + levelStr; + var depthOk = tcuImageCompare.intThresholdCompare( + name, desc, reference.getAccess(), result.getAccess(), + threshold, (levelNdx == 0 && layerNdx == 0) ? + tcuImageCompare.CompareLogMode.RESULT : + tcuImageCompare.CompareLogMode.ON_ERROR + ); + + if (!depthOk) { + testFailed('Image comparison failed'); + return false; + } + } + + } + return true; + }; + + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureSpecCase} + * @param {string} name + * @param {string} desc + * @param {tcuTexture.TextureFormat} format + * @param {number} width + * @param {number} height + * @param {number} depth + * @param {number} numLevels + */ + es3fTextureSpecificationTests.Texture3DSpecCase = function( + name, desc, format, width, height, depth, numLevels + ) { + es3fTextureSpecificationTests.TextureSpecCase.call( + this, name, desc + ); + this.m_texFormat = format; + this.m_texFormatInfo = tcuTextureUtil.getTextureFormatInfo(format); + this.m_width = width; + this.m_height = height; + this.m_depth = depth; + this.m_numLevels = numLevels; + }; + + es3fTextureSpecificationTests.Texture3DSpecCase.prototype = + Object.create(es3fTextureSpecificationTests.TextureSpecCase.prototype); + + es3fTextureSpecificationTests.Texture3DSpecCase.prototype.constructor = + es3fTextureSpecificationTests.Texture3DSpecCase; + + /** + * @param {sglrGLContext.GLContext} webgl2Context + * @param {sglrReferenceContext.ReferenceContext} refContext + */ + es3fTextureSpecificationTests.Texture3DSpecCase.prototype.verifyTexture = + function( + webgl2Context, refContext + ) { + /** @type {es3fFboTestUtil.Texture3DShader} */ + var shader = new es3fFboTestUtil.Texture3DShader( + gluTextureUtil.getSampler3D(this.m_texFormat), + gluShaderUtil.DataType.FLOAT_VEC4 + ); + var shaderIDgles = webgl2Context.createProgram(shader); + var shaderIDRef = refContext.createProgram(shader); + + shader.setTexScaleBias( + this.m_texFormatInfo.lookupScale, this.m_texFormatInfo.lookupBias + ); + + // Set state. + for (var ndx = 0; ndx < 2; ndx++) { + var ctx = ndx ? refContext : webgl2Context; + + this.m_context = ctx; + + this.m_context.texParameteri( + gl.TEXTURE_3D, gl.TEXTURE_MIN_FILTER, + gl.NEAREST_MIPMAP_NEAREST + ); + this.m_context.texParameteri( + gl.TEXTURE_3D, gl.TEXTURE_MAG_FILTER, + gl.NEAREST + ); + this.m_context.texParameteri( + gl.TEXTURE_3D, gl.TEXTURE_WRAP_S, + gl.CLAMP_TO_EDGE + ); + this.m_context.texParameteri( + gl.TEXTURE_3D, gl.TEXTURE_WRAP_T, + gl.CLAMP_TO_EDGE + ); + this.m_context.texParameteri( + gl.TEXTURE_3D, gl.TEXTURE_WRAP_R, + gl.CLAMP_TO_EDGE + ); + this.m_context.texParameteri( + gl.TEXTURE_3D, gl.TEXTURE_MAX_LEVEL, + this.m_numLevels - 1 + ); + } + + for (var levelNdx = 0; levelNdx < this.m_numLevels; levelNdx++) { + var levelW = Math.max(1, this.m_width >> levelNdx); + var levelH = Math.max(1, this.m_height >> levelNdx); + var levelD = Math.max(1, this.m_depth >> levelNdx); + var levelOk = true; + + if (levelW == 1 || levelH == 1) { + // Rendering to texture of size x1 is problematic in referencerenderer + // due to its deviation from c++ code: crbug.com/613206 + continue; + } + + for (var depth = 0; depth < levelD; depth++) { + /** @type {tcuSurface.Surface} */ + var reference = new tcuSurface.Surface(); + /** @type {tcuSurface.Surface} */ + var result = new tcuSurface.Surface(); + + shader.setDepth((depth + 0.5) / levelD); + + for (var ndx = 0; ndx < 2; ndx++) { + /** @type {tcuSurface.Surface} */ + var dst = ndx ? reference : result; + ctx = ndx ? refContext : webgl2Context; + var shaderID = ndx ? shaderIDRef : shaderIDgles; + + this.m_context = ctx; + shader.setUniforms(ctx, shaderID); + this.renderTex(dst, shaderID, levelW, levelH); + } + + var threshold = + es3fTextureSpecificationTests.computeCompareThreshold( + tcuPixelFormat.PixelFormatFromContext(gl), this.m_texFormat + ); + var levelStr = levelNdx.toString(); + var sliceStr = depth.toString(); + var name = 'Layer' + levelStr + 'Slice' + sliceStr; + var desc = 'Layer ' + levelStr + ', Slice ' + sliceStr; + var depthOk = tcuImageCompare.intThresholdCompare( + name, desc, reference.getAccess(), result.getAccess(), + threshold, (levelNdx == 0 && depth == 0) ? + tcuImageCompare.CompareLogMode.RESULT : + tcuImageCompare.CompareLogMode.ON_ERROR + ); + + if (!depthOk) { + testFailed('Image comparison failed'); + return false; + } + } + + } + return true; + }; + + // Basic TexImage2D() with 2D texture usage + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} width + * @param {number} height + */ + es3fTextureSpecificationTests.BasicTexImage2DCase = function( + name, desc, format, dataType, width, height + ) { + // Unsized internal format. + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), width, height, + es3fTextureSpecificationTests.maxLevelCount( + width, height + ) + ); + + this.m_internalFormat = format; + this.m_format = format; + this.m_dataType = dataType; + }; + + es3fTextureSpecificationTests.BasicTexImage2DCase.prototype = Object.create( + es3fTextureSpecificationTests.Texture2DSpecCase.prototype + ); + + es3fTextureSpecificationTests.BasicTexImage2DCase.prototype.constructor = + es3fTextureSpecificationTests.BasicTexImage2DCase; + + /** + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @return {es3fTextureSpecificationTests.BasicTexImage2DCase} + */ + es3fTextureSpecificationTests.newBasicTexImage2DCaseInternal = function( + name, desc, internalFormat, width, height + ) { + // Sized internal format. + var fmt = gluTextureUtil.getTransferFormat( + gluTextureUtil.mapGLInternalFormat(internalFormat) + ); + var testcase = new es3fTextureSpecificationTests.BasicTexImage2DCase( + name, desc, fmt.format, fmt.dataType, width, height + ); + testcase.m_internalFormat = internalFormat; + return testcase; + }; + + /** + * createTexture + */ + es3fTextureSpecificationTests.BasicTexImage2DCase.prototype.createTexture = + function() { + var tex = null; + var levelData = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_width, this.m_height + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + levelData.setSize(levelW, levelH); + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + + this.m_context.texImage2D( + gl.TEXTURE_2D, ndx, this.m_internalFormat, levelW, levelH, 0, + this.m_format, this.m_dataType, + levelData.getAccess().getDataPtr() + ); + } + }; + + // Basic TexImage2D() with cubemap usage + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} size + */ + es3fTextureSpecificationTests.BasicTexImageCubeCase = function( + name, desc, format, dataType, size + ) { + // Unsized internal format. + es3fTextureSpecificationTests.TextureCubeSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), size, deMath.logToFloor(size) + 1 + ); + + this.m_internalFormat = format; + this.m_format = format; + this.m_dataType = dataType; + }; + + es3fTextureSpecificationTests.BasicTexImageCubeCase.prototype = + Object.create( + es3fTextureSpecificationTests.TextureCubeSpecCase.prototype + ); + + es3fTextureSpecificationTests. + BasicTexImageCubeCase.prototype.constructor = + es3fTextureSpecificationTests.BasicTexImageCubeCase; + + /** + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} size + * @return {es3fTextureSpecificationTests.BasicTexImageCubeCase} + */ + es3fTextureSpecificationTests.newBasicTexImageCubeCaseInternal = function( + name, desc, internalFormat, size + ) { + // Sized internal format. + var fmt = gluTextureUtil.getTransferFormat( + gluTextureUtil.mapGLInternalFormat(internalFormat) + ); + var testcase = new es3fTextureSpecificationTests.BasicTexImageCubeCase( + name, desc, fmt.format, fmt.dataType, size + ); + testcase.m_internalFormat = internalFormat; + return testcase; + }; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + BasicTexImageCubeCase.prototype.createTexture = + function() { + var tex = null; + var levelData = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_size, this.m_size + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelSize = Math.max(1, this.m_size >> ndx); + + levelData.setSize(levelSize, levelSize); + + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + + this.m_context.texImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], + ndx, this.m_internalFormat, levelSize, levelSize, 0, + this.m_format, this.m_dataType, + levelData.getAccess().getDataPtr() + ); + } + } + }; + + // Basic TexImage3D() with 2D array texture usage + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} numLayers + */ + es3fTextureSpecificationTests.BasicTexImage2DArrayCase = function( + name, desc, internalFormat, width, height, numLayers + ) { + es3fTextureSpecificationTests.Texture2DArraySpecCase.call( + this, name, desc, + gluTextureUtil.mapGLInternalFormat(internalFormat), width, height, + numLayers, es3fTextureSpecificationTests.maxLevelCount( + width, height + ) + ); + + this.m_internalFormat = internalFormat; + }; + + es3fTextureSpecificationTests.BasicTexImage2DArrayCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype + ); + + es3fTextureSpecificationTests. + BasicTexImage2DArrayCase.prototype.constructor = + es3fTextureSpecificationTests.BasicTexImage2DArrayCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + BasicTexImage2DArrayCase.prototype.createTexture = + function() { + var tex = null; + var levelData = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_width, this.m_height + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + levelData.setSize(levelW, levelH, this.m_numLayers); + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + + this.m_context.texImage3D( + gl.TEXTURE_2D_ARRAY, ndx, this.m_internalFormat, levelW, levelH, + this.m_numLayers, 0, transferFmt.format, + transferFmt.dataType, levelData.getAccess().getDataPtr() + ); + } + }; + + // Basic TexImage3D() with 3D texture usage + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture3DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} depth + */ + es3fTextureSpecificationTests.BasicTexImage3DCase = function( + name, desc, internalFormat, width, height, depth + ) { + es3fTextureSpecificationTests.Texture3DSpecCase.call( + this, name, desc, + gluTextureUtil.mapGLInternalFormat(internalFormat), width, height, + depth, es3fTextureSpecificationTests.maxLevelCount( + width, height, depth + ) + ); + + this.m_internalFormat = internalFormat; + }; + + es3fTextureSpecificationTests.BasicTexImage3DCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture3DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + BasicTexImage3DCase.prototype.constructor = + es3fTextureSpecificationTests.BasicTexImage3DCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + BasicTexImage3DCase.prototype.createTexture = + function() { + var tex = null; + var levelData = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_width, this.m_height + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_3D, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var levelD = Math.max(1, this.m_depth >> ndx); + + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + levelData.setSize(levelW, levelH, levelD); + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + + this.m_context.texImage3D( + gl.TEXTURE_3D, ndx, this.m_internalFormat, levelW, levelH, + levelD, 0, transferFmt.format, transferFmt.dataType, + levelData.getAccess().getDataPtr() + ); + } + }; + + // Randomized 2D texture specification using TexImage2D + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} width + * @param {number} height + */ + es3fTextureSpecificationTests.RandomOrderTexImage2DCase = function( + name, desc, format, dataType, width, height + ) { + // Unsized internal format. + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), width, height, + es3fTextureSpecificationTests.maxLevelCount( + width, height + ) + ); + + this.m_internalFormat = format; + this.m_format = format; + this.m_dataType = dataType; + }; + + es3fTextureSpecificationTests.RandomOrderTexImage2DCase.prototype = Object.create( + es3fTextureSpecificationTests.Texture2DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + RandomOrderTexImage2DCase.prototype.constructor = + es3fTextureSpecificationTests.RandomOrderTexImage2DCase; + + /** + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @return {es3fTextureSpecificationTests.RandomOrderTexImage2DCase} + */ + es3fTextureSpecificationTests.newRandomOrderTexImage2DCaseInternal = + function(name, desc, internalFormat, width, height) { + // Sized internal format. + var fmt = gluTextureUtil.getTransferFormat( + gluTextureUtil.mapGLInternalFormat(internalFormat) + ); + var testcase = new es3fTextureSpecificationTests.RandomOrderTexImage2DCase( + name, desc, fmt.format, fmt.dataType, width, height + ); + testcase.m_internalFormat = internalFormat; + return testcase; + }; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + RandomOrderTexImage2DCase.prototype.createTexture = function() { + var tex = null; + var levelData = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_width, this.m_height + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + var levels = []; + for (var i = 0; i < this.m_numLevels; i++) + levels[i] = i; + levels = rnd.shuffle(levels); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelNdx = levels[ndx]; + var levelW = Math.max(1, this.m_width >> levelNdx); + var levelH = Math.max(1, this.m_height >> levelNdx); + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + levelData.setSize(levelW, levelH); + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + + this.m_context.texImage2D( + gl.TEXTURE_2D, levelNdx, this.m_internalFormat, levelW, levelH, 0, + this.m_format, this.m_dataType, + levelData.getAccess().getDataPtr() + ); + } + }; + + // Randomized cubemap texture specification using TexImage2D + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} size + */ + es3fTextureSpecificationTests.RandomOrderTexImageCubeCase = function( + name, desc, format, dataType, size + ) { + // Unsized internal format. + es3fTextureSpecificationTests.TextureCubeSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), size, deMath.logToFloor(size) + 1 + ); + + this.m_internalFormat = format; + this.m_format = format; + this.m_dataType = dataType; + }; + + es3fTextureSpecificationTests.RandomOrderTexImageCubeCase.prototype = + Object.create( + es3fTextureSpecificationTests.TextureCubeSpecCase.prototype + ); + + es3fTextureSpecificationTests. + RandomOrderTexImageCubeCase.prototype.constructor = + es3fTextureSpecificationTests.RandomOrderTexImageCubeCase; + + /** + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} size + * @return {es3fTextureSpecificationTests.RandomOrderTexImageCubeCase} + */ + es3fTextureSpecificationTests.newRandomOrderTexImageCubeCaseInternal = + function(name, desc, internalFormat, size) { + // Sized internal format. + var fmt = gluTextureUtil.getTransferFormat( + gluTextureUtil.mapGLInternalFormat(internalFormat) + ); + var testcase = new es3fTextureSpecificationTests.RandomOrderTexImageCubeCase( + name, desc, fmt.format, fmt.dataType, size + ); + testcase.m_internalFormat = internalFormat; + return testcase; + }; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + RandomOrderTexImageCubeCase.prototype.createTexture = + function() { + var tex = null; + var levelData = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_size, this.m_size + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + // Level-face pairs. + var images = []; + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + images[ndx * 6 + face] = {ndx: ndx, face: face}; + } + + images = rnd.shuffle(images); + + for (var ndx = 0; ndx < images.length; ndx++) { + var levelNdx = images[ndx].ndx; + /** @type {framework.common.tcuTexture.CubeFace} */ + var face = images[ndx].face; + var levelSize = Math.max(1, this.m_size >> levelNdx); + + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + levelData.setSize(levelSize, levelSize); + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + + this.m_context.texImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], + levelNdx, this.m_internalFormat, levelSize, levelSize, 0, + this.m_format, this.m_dataType, + levelData.getAccess().getDataPtr() + ); + } + }; + + // TexImage2D() unpack alignment case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} width + * @param {number} height + * @param {number} numLevels + * @param {number} alignment + */ + es3fTextureSpecificationTests.TexImage2DAlignCase = function( + name, desc, format, dataType, width, height, numLevels, alignment + ) { + // Unsized internal format. + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), width, height, numLevels + ); + + this.m_internalFormat = format; + this.m_format = format; + this.m_dataType = dataType; + this.m_alignment = alignment; + }; + + es3fTextureSpecificationTests.TexImage2DAlignCase.prototype = Object.create( + es3fTextureSpecificationTests.Texture2DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexImage2DAlignCase.prototype.constructor = + es3fTextureSpecificationTests.TexImage2DAlignCase; + + /** + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} numLevels + * @param {number} alignment + * @return {es3fTextureSpecificationTests.TexImage2DAlignCase} + */ + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal = function( + name, desc, internalFormat, width, height, numLevels, alignment + ) { + // Sized internal format. + var fmt = gluTextureUtil.getTransferFormat( + gluTextureUtil.mapGLInternalFormat(internalFormat) + ); + var testcase = new es3fTextureSpecificationTests.TexImage2DAlignCase( + name, desc, fmt.format, fmt.dataType, + width, height, numLevels, alignment + ); + testcase.m_internalFormat = internalFormat; + return testcase; + }; + + /** + * createTexture + */ + es3fTextureSpecificationTests.TexImage2DAlignCase.prototype.createTexture = + function() { + var tex = null; + /** @type {ArrayBuffer} */ var data; + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var colorA = deMath.add( + deMath.multiply( + [1.0, 0.0, 0.0, 1.0], + deMath.subtract( + this.m_texFormatInfo.valueMax, + this.m_texFormatInfo.valueMin + ) + ), this.m_texFormatInfo.valueMin + ); + var colorB = deMath.add( + deMath.multiply( + [0.0, 1.0, 0.0, 1.0], + deMath.subtract( + this.m_texFormatInfo.valueMax, + this.m_texFormatInfo.valueMin + ) + ), this.m_texFormatInfo.valueMin + ); + + var rowPitch = deMath.deAlign32( + levelW * this.m_texFormat.getPixelSize(), this.m_alignment + ); + var cellSize = Math.max(1, Math.min(levelW >> 2, levelH >> 2)); + data = new ArrayBuffer(rowPitch * levelH); + var access = new tcuTexture.PixelBufferAccess({format: this.m_texFormat, width: levelW, + height: levelH, rowPitch: rowPitch, data: data} + ); + tcuTextureUtil.fillWithGrid(access, cellSize, colorA, colorB + ); + + this.m_context.texImage2D( + gl.TEXTURE_2D, ndx, this.m_internalFormat, levelW, levelH, 0, + this.m_format, this.m_dataType, + access.getDataPtr() + ); + } + }; + + // TexImageCube unpack alignment case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} size + * @param {number} numLevels + * @param {number} alignment + */ + es3fTextureSpecificationTests.TexImageCubeAlignCase = function( + name, desc, format, dataType, size, numLevels, alignment + ) { + // Unsized internal format. + es3fTextureSpecificationTests.TextureCubeSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), size, numLevels + ); + + this.m_internalFormat = format; + this.m_format = format; + this.m_dataType = dataType; + this.m_alignment = alignment; + }; + + es3fTextureSpecificationTests.TexImageCubeAlignCase.prototype = + Object.create( + es3fTextureSpecificationTests.TextureCubeSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexImageCubeAlignCase.prototype.constructor = + es3fTextureSpecificationTests.TexImageCubeAlignCase; + + /** + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} size + * @param {number} numLevels + * @param {number} alignment + * @return {es3fTextureSpecificationTests.TexImageCubeAlignCase} + */ + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal = + function(name, desc, internalFormat, size, numLevels, alignment) { + // Sized internal format. + var fmt = gluTextureUtil.getTransferFormat( + gluTextureUtil.mapGLInternalFormat(internalFormat) + ); + var testcase = new es3fTextureSpecificationTests.TexImageCubeAlignCase( + name, desc, fmt.format, fmt.dataType, size, numLevels, alignment + ); + testcase.m_internalFormat = internalFormat; + return testcase; + }; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexImageCubeAlignCase.prototype.createTexture = + function() { + var tex = null; + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + /** @type {ArrayBuffer} */ var data; + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelSize = Math.max(1, this.m_size >> ndx); + var cellSize = Math.max(1, levelSize >> 2); + var rowPitch = deMath.deAlign32( + this.m_texFormat.getPixelSize() * levelSize, this.m_alignment + ); + var colorA = deMath.add(deMath.multiply( + [1.0, 0.0, 0.0, 1.0], deMath.subtract( + this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin + )), this.m_texFormatInfo.valueMin + ); + var colorB = deMath.add(deMath.multiply( + [0.0, 1.0, 0.0, 1.0], deMath.subtract( + this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin + )), this.m_texFormatInfo.valueMin + ); + + data = new ArrayBuffer(rowPitch * levelSize); + var access = new tcuTexture.PixelBufferAccess({format: this.m_texFormat, width: levelSize, + height: levelSize, rowPitch: rowPitch, data: data} + ); + tcuTextureUtil.fillWithGrid(access, cellSize, colorA, colorB + ); + + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + this.m_context.texImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], + ndx, this.m_internalFormat, levelSize, levelSize, 0, + this.m_format, this.m_dataType, + access.getDataPtr() + ); + } + } + }; + + // TexImage2D() unpack parameters case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} rowLength + * @param {number} skipRows + * @param {number} skipPixels + * @param {number} alignment + */ + es3fTextureSpecificationTests.TexImage2DParamsCase = function( + name, desc, internalFormat, width, height, rowLength, skipRows, + skipPixels, alignment + ) { + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, + gluTextureUtil.mapGLInternalFormat(internalFormat), + width, height, 1 + ); + this.m_internalFormat = internalFormat; + this.m_rowLength = rowLength; + this.m_skipRows = skipRows; + this.m_skipPixels = skipPixels; + this.m_alignment = alignment; + }; + + es3fTextureSpecificationTests.TexImage2DParamsCase.prototype = + Object.create(es3fTextureSpecificationTests.Texture2DSpecCase.prototype); + + es3fTextureSpecificationTests.TexImage2DParamsCase.prototype.constructor = + es3fTextureSpecificationTests.TexImage2DParamsCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests.TexImage2DParamsCase.prototype.createTexture = + function() { + var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + var pixelSize = this.m_texFormat.getPixelSize(); + var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_width; + var rowPitch = deMath.deAlign32(rowLength * pixelSize, this.m_alignment); + var height = this.m_height + this.m_skipRows; + var tex = null; + /** @type {ArrayBuffer} */ var data; + + assertMsgOptions( + this.m_numLevels == 1, 'Number of levels different to 1', + false, true + ); + + // Fill data with grid. + data = new ArrayBuffer(rowPitch * height + this.m_skipPixels * pixelSize); + + var cScale = deMath.subtract( + this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin + ); + var cBias = this.m_texFormatInfo.valueMin; + var colorA = deMath.add( + deMath.multiply( + [1.0, 0.0, 0.0, 1.0], cScale + ), cBias + ); + var colorB = deMath.add( + deMath.multiply( + [0.0, 1.0, 0.0, 1.0], cScale + ), cBias + ); + + var accessWithOffset = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + rowPitch: rowPitch, + data: data, + offset: this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize + }); + tcuTextureUtil.fillWithGrid(accessWithOffset, 4, colorA, colorB + ); + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + rowPitch: rowPitch, + data: data, + }); + + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + this.m_context.texImage2D( + gl.TEXTURE_2D, 0, this.m_internalFormat, + this.m_width, this.m_height, 0, + transferFmt.format, transferFmt.dataType, access.getDataPtr() + ); + }; + + // TexImage3D() unpack parameters case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture3DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} depth + * @param {number} imageHeight + * @param {number} rowLength + * @param {number} skipImages + * @param {number} skipRows + * @param {number} skipPixels + * @param {number} alignment + */ + es3fTextureSpecificationTests.TexImage3DParamsCase = function( + name, desc, internalFormat, width, height, depth, imageHeight, + rowLength, skipImages, skipRows, skipPixels, alignment + ) { + es3fTextureSpecificationTests.Texture3DSpecCase.call( + this, name, desc, + gluTextureUtil.mapGLInternalFormat(internalFormat), + width, height, depth, 1 + ); + + this.m_internalFormat = internalFormat; + this.m_imageHeight = imageHeight; + this.m_rowLength = rowLength; + this.m_skipImages = skipImages; + this.m_skipRows = skipRows; + this.m_skipPixels = skipPixels; + this.m_alignment = alignment; + }; + + es3fTextureSpecificationTests.TexImage3DParamsCase.prototype = + Object.create(es3fTextureSpecificationTests.Texture3DSpecCase.prototype); + + es3fTextureSpecificationTests.TexImage3DParamsCase.prototype.constructor = + es3fTextureSpecificationTests.Texture3DSpecCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests.TexImage3DParamsCase.prototype.createTexture = + function() { + var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + var pixelSize = this.m_texFormat.getPixelSize(); + var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_width; + var rowPitch = deMath.deAlign32(rowLength * pixelSize, this.m_alignment); + var imageHeight = this.m_imageHeight > 0 ? + this.m_imageHeight : this.m_height; + var slicePitch = imageHeight * rowPitch; + + var tex = null; + /** @type {ArrayBuffer} */ var data; + + assertMsgOptions( + this.m_numLevels == 1, 'Number of levels different to 1', + false, true + ); + + // Fill data with grid. + data = new ArrayBuffer(slicePitch * (this.m_depth + this.m_skipImages) + + this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize); + + var cScale = deMath.subtract( + this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin + ); + var cBias = this.m_texFormatInfo.valueMin; + var colorA = deMath.add( + deMath.multiply( + [1.0, 0.0, 0.0, 1.0], cScale + ), cBias + ); + var colorB = deMath.add( + deMath.multiply( + [0.0, 1.0, 0.0, 1.0], cScale + ), cBias + ); + + var accessWithOffset = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + depth: this.m_depth, + rowPitch: rowPitch, + slicePitch: slicePitch, + data: data, + offset: this.m_skipImages * slicePitch + this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize + }); + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + depth: this.m_depth, + rowPitch: rowPitch, + slicePitch: slicePitch, + data: data + }); + tcuTextureUtil.fillWithGrid( + accessWithOffset, 4, colorA, colorB + ); + + this.m_context.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, this.m_imageHeight); + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_IMAGES, this.m_skipImages); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_3D, tex); + this.m_context.texImage3D( + gl.TEXTURE_3D, 0, this.m_internalFormat, + this.m_width, this.m_height, this.m_depth, 0, + transferFmt.format, transferFmt.dataType, access.getDataPtr() + ); + }; + + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} width + * @param {number} height + */ + es3fTextureSpecificationTests.BasicTexSubImage2DCase = function( + name, desc, format, dataType, width, height + ) { + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), width, height, es3fTextureSpecificationTests.maxLevelCount( + width, height + ) + ); + + this.m_format = format; + this.m_internalFormat = format; + this.m_dataType = dataType; + }; + + es3fTextureSpecificationTests.BasicTexSubImage2DCase.prototype = + Object.create(es3fTextureSpecificationTests.Texture2DSpecCase.prototype); + + es3fTextureSpecificationTests.BasicTexSubImage2DCase.prototype.constructor = + es3fTextureSpecificationTests.BasicTexSubImage2DCase; + + /** + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @return {es3fTextureSpecificationTests.BasicTexSubImage2DCase} + */ + es3fTextureSpecificationTests.newBasicTexSubImage2DCaseInternal = + function(name, desc, internalFormat, width, height) { + // Sized internal format. + var fmt = gluTextureUtil.getTransferFormat( + gluTextureUtil.mapGLInternalFormat(internalFormat) + ); + var testcase = new es3fTextureSpecificationTests.BasicTexSubImage2DCase( + name, desc, fmt.format, fmt.dataType, width, height + ); + testcase.m_internalFormat = internalFormat; + return testcase; + }; + + /** + */ + es3fTextureSpecificationTests. + BasicTexSubImage2DCase.prototype.createTexture = function() { + var tex = null; + var data = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_width, this.m_height + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + data.setSize(levelW, levelH); + tcuTextureUtil.fillWithComponentGradients( + data.getAccess(), gMin, gMax + ); + + this.m_context.texImage2D( + gl.TEXTURE_2D, ndx, this.m_internalFormat, levelW, levelH, 0, + this.m_format, this.m_dataType, + data.getAccess().getDataPtr() + ); + } + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + + var w = rnd.getInt(1, levelW); + var h = rnd.getInt(1, levelH); + var x = rnd.getInt(0, levelW - w); + var y = rnd.getInt(0, levelH - h); + + var colorA = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var colorB = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var cellSize = rnd.getInt(2, 16); + + data.setSize(w, h); + tcuTextureUtil.fillWithGrid( + data.getAccess(), cellSize, colorA, colorB + ); + + this.m_context.texSubImage2D( + gl.TEXTURE_2D, ndx, x, y, w, h, this.m_format, this.m_dataType, + data.getAccess().getDataPtr() + ); + } + }; + + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} size + */ + es3fTextureSpecificationTests.BasicTexSubImageCubeCase = function( + name, desc, format, dataType, size + ) { + es3fTextureSpecificationTests.TextureCubeSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), size, deMath.logToFloor(size) + 1 + ); + + this.m_internalFormat = format; + this.m_format = format; + this.m_dataType = dataType; + }; + + es3fTextureSpecificationTests.BasicTexSubImageCubeCase.prototype = + Object.create(es3fTextureSpecificationTests.TextureCubeSpecCase.prototype); + + es3fTextureSpecificationTests. + BasicTexSubImageCubeCase.prototype.constructor = + es3fTextureSpecificationTests.BasicTexSubImageCubeCase; + + /** + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} size + */ + es3fTextureSpecificationTests.newBasicTexSubImageCubeCaseInternal = + function(name, desc, internalFormat, size) { + // Sized internal format. + var fmt = gluTextureUtil.getTransferFormat( + gluTextureUtil.mapGLInternalFormat(internalFormat) + ); + var testcase = + new es3fTextureSpecificationTests.BasicTexSubImageCubeCase( + name, desc, fmt.format, fmt.dataType, + size); + testcase.m_internalFormat = internalFormat; + return testcase; + }; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + BasicTexSubImageCubeCase.prototype.createTexture = function() { + var tex = null; + var data = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_size, this.m_size + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelSize = Math.max(1, this.m_size >> ndx); + data.setSize(levelSize, levelSize); + + for (var face = /** @type {tcuTexture.CubeFace} */ (0); + face < es3fTextureSpecificationTests.s_cubeMapFaces.length; + face++) { + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + tcuTextureUtil.fillWithComponentGradients( + data.getAccess(), gMin, gMax + ); + + this.m_context.texImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], ndx, + this.m_internalFormat, levelSize, levelSize, 0, + this.m_format, this.m_dataType, + data.getAccess().getDataPtr() + ); + } + } + + // Re-specify parts of each face and level. + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelSize = Math.max(1, this.m_size >> ndx); + + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + + var w = rnd.getInt(1, levelSize); + var h = rnd.getInt(1, levelSize); + var x = rnd.getInt(0, levelSize - w); + var y = rnd.getInt(0, levelSize - h); + + var colorA = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var colorB = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var cellSize = rnd.getInt(2, 16); + + data.setSize(w, h); + tcuTextureUtil.fillWithGrid( + data.getAccess(), cellSize, colorA, colorB + ); + + this.m_context.texSubImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], + ndx, x, y, w, h, this.m_format, + this.m_dataType, data.getAccess().getDataPtr() + ); + } + } + }; + + // TexSubImage2D() unpack parameters case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} subX + * @param {number} subY + * @param {number} subW + * @param {number} subH + * @param {number} rowLength + * @param {number} skipRows + * @param {number} skipPixels + * @param {number} alignment + */ + es3fTextureSpecificationTests.TexSubImage2DParamsCase = function( + name, desc, internalFormat, width, height, subX, subY, subW, subH, + rowLength, skipRows, skipPixels, alignment + ) { + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, + gluTextureUtil.mapGLInternalFormat(internalFormat), + width, height, 1 + ); + this.m_internalFormat = internalFormat; + this.m_subX = subX; + this.m_subY = subY; + this.m_subW = subW; + this.m_subH = subH; + this.m_rowLength = rowLength; + this.m_skipRows = skipRows; + this.m_skipPixels = skipPixels; + this.m_alignment = alignment; + }; + + es3fTextureSpecificationTests.TexSubImage2DParamsCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexSubImage2DParamsCase.prototype.constructor = + es3fTextureSpecificationTests.TexSubImage2DParamsCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexSubImage2DParamsCase.prototype.createTexture = function() { + var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + var pixelSize = this.m_texFormat.getPixelSize(); + var tex = null; + /** @type {ArrayBuffer} */ var data; + + assertMsgOptions( + this.m_numLevels == 1, 'Number of levels different to 1', + false, true + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + + // First fill texture with gradient. + data = new ArrayBuffer( + deMath.deAlign32(this.m_width * pixelSize, 4) * this.m_height + ); + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + rowPitch: deMath.deAlign32(this.m_width * pixelSize, 4), + data: data + }); + tcuTextureUtil.fillWithComponentGradients(access, this.m_texFormatInfo.valueMin, this.m_texFormatInfo.valueMax + ); + this.m_context.texImage2D( + gl.TEXTURE_2D, 0, this.m_internalFormat, this.m_width, + this.m_height, 0, transferFmt.format, transferFmt.dataType, + access.getDataPtr() + ); + + // Fill data with grid. + var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_subW; + var rowPitch = deMath.deAlign32(rowLength * pixelSize, this.m_alignment); + var height = this.m_subH + this.m_skipRows; + var cScale = deMath.subtract( + this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin + ); + var cBias = this.m_texFormatInfo.valueMin; + var colorA = deMath.add( + deMath.multiply( + [1.0, 0.0, 0.0, 1.0], cScale + ), cBias + ); + var colorB = deMath.add( + deMath.multiply( + [0.0, 1.0, 0.0, 1.0], cScale + ), cBias + ); + + data = new ArrayBuffer(rowPitch * height + this.m_skipPixels * pixelSize); + tcuTextureUtil.fillWithGrid( + new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_subW, + height: this.m_subH, + rowPitch: rowPitch, + data: data, + offset: this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize + }) , + 4, colorA, colorB + ); + + access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_subW, + height: this.m_subH, + rowPitch: rowPitch, + data: data + }); + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + this.m_context.texSubImage2D( + gl.TEXTURE_2D, 0, this.m_subX, this.m_subY, + this.m_subW, this.m_subH, + transferFmt.format, transferFmt.dataType, + access.getDataPtr() + ); + }; + + // Basic TexSubImage3D() with 3D texture usage + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture3DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} depth + */ + es3fTextureSpecificationTests.BasicTexSubImage3DCase = function( + name, desc, internalFormat, width, height, depth + ) { + es3fTextureSpecificationTests.Texture3DSpecCase.call( + this, name, desc, + gluTextureUtil.mapGLInternalFormat(internalFormat), + width, height, depth, es3fTextureSpecificationTests.maxLevelCount( + width, height, depth + ) + ); + + this.m_internalFormat = internalFormat; + }; + + es3fTextureSpecificationTests.BasicTexSubImage3DCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture3DSpecCase.prototype + ); + + es3fTextureSpecificationTests.BasicTexSubImage3DCase.prototype.constructor = + es3fTextureSpecificationTests.BasicTexSubImage3DCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + BasicTexSubImage3DCase.prototype.createTexture = function() { + var tex = null; + var data = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_width, this.m_height + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_3D, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + // First specify full texture. + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var levelD = Math.max(1, this.m_depth >> ndx); + + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + data.setSize(levelW, levelH, levelD); + tcuTextureUtil.fillWithComponentGradients( + data.getAccess(), gMin, gMax + ); + + this.m_context.texImage3D( + gl.TEXTURE_3D, ndx, this.m_internalFormat, levelW, levelH, + levelD, 0, transferFmt.format, transferFmt.dataType, + data.getAccess().getDataPtr() + ); + } + + // Re-specify parts of each level. + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var levelD = Math.max(1, this.m_depth >> ndx); + + var w = rnd.getInt(1, levelW); + var h = rnd.getInt(1, levelH); + var d = rnd.getInt(1, levelD); + var x = rnd.getInt(0, levelW - w); + var y = rnd.getInt(0, levelH - h); + var z = rnd.getInt(0, levelD - d); + + var colorA = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var colorB = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var cellSize = rnd.getInt(2, 16); + + data.setSize(w, h, d); + tcuTextureUtil.fillWithGrid( + data.getAccess(), cellSize, colorA, colorB + ); + + this.m_context.texSubImage3D( + gl.TEXTURE_3D, ndx, x, y, z, w, h, d, + transferFmt.format, transferFmt.dataType, + data.getAccess().getDataPtr() + ); + } + }; + + // TexSubImage2D() to texture initialized with empty data + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} width + * @param {number} height + */ + es3fTextureSpecificationTests.TexSubImage2DEmptyTexCase = function( + name, desc, format, dataType, width, height + ) { + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), width, height, es3fTextureSpecificationTests.maxLevelCount( + width, height + ) + ); + + this.m_format = format; + this.m_internalFormat = format; + this.m_dataType = dataType; + }; + + es3fTextureSpecificationTests.TexSubImage2DEmptyTexCase.prototype = + Object.create(es3fTextureSpecificationTests.Texture2DSpecCase.prototype); + + es3fTextureSpecificationTests. + TexSubImage2DEmptyTexCase.prototype.constructor = + es3fTextureSpecificationTests.TexSubImage2DEmptyTexCase; + + /** + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + */ + es3fTextureSpecificationTests.newTexSubImage2DEmptyTexCaseInternal = + function(name, desc, internalFormat, width, height) { + // Sized internal format. + var fmt = gluTextureUtil.getTransferFormat( + gluTextureUtil.mapGLInternalFormat(internalFormat) + ); + var testcase = + new es3fTextureSpecificationTests.TexSubImage2DEmptyTexCase( + name, desc, fmt.format, fmt.dataType, width, height + ); + testcase.m_internalFormat = internalFormat; + return testcase; + }; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexSubImage2DEmptyTexCase.prototype.createTexture = function() { + var tex = null; + var data = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_width, this.m_height + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + // First allocate storage for each level. + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + + this.m_context.texImage2D( + gl.TEXTURE_2D, ndx, this.m_internalFormat, levelW, levelH, 0, + this.m_format, this.m_dataType, + null + ); + } + + // Specify pixel data to all levels using glTexSubImage2D() + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + data.setSize(levelW, levelH); + tcuTextureUtil.fillWithComponentGradients( + data.getAccess(), gMin, gMax + ); + + this.m_context.texSubImage2D( + gl.TEXTURE_2D, ndx, 0, 0, levelW, levelH, + this.m_format, this.m_dataType, + data.getAccess().getDataPtr() + ); + } + }; + + // TexSubImage2D() to empty cubemap texture + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} size + */ + es3fTextureSpecificationTests.TexSubImageCubeEmptyTexCase = function( + name, desc, format, dataType, size + ) { + // Unsized internal format. + es3fTextureSpecificationTests.TextureCubeSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), size, deMath.logToFloor(size) + 1 + ); + + this.m_internalFormat = format; + this.m_format = format; + this.m_dataType = dataType; + }; + + es3fTextureSpecificationTests.TexSubImageCubeEmptyTexCase.prototype = + Object.create( + es3fTextureSpecificationTests.TextureCubeSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexSubImageCubeEmptyTexCase.prototype.constructor = + es3fTextureSpecificationTests.TexSubImageCubeEmptyTexCase; + + /** + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} size + * @return {es3fTextureSpecificationTests.TexSubImageCubeEmptyTexCase} + */ + es3fTextureSpecificationTests.newTexSubImageCubeEmptyTexCaseInternal = + function(name, desc, internalFormat, size) { + // Sized internal format. + var fmt = gluTextureUtil.getTransferFormat( + gluTextureUtil.mapGLInternalFormat(internalFormat) + ); + var testcase = + new es3fTextureSpecificationTests.TexSubImageCubeEmptyTexCase( + name, desc, fmt.format, fmt.dataType, size + ); + testcase.m_internalFormat = internalFormat; + return testcase; + }; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexSubImageCubeEmptyTexCase.prototype.createTexture = + function() { + var tex = null; + var data = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_size, this.m_size + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + // Specify storage for each level. + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelSize = Math.max(1, this.m_size >> ndx); + + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + this.m_context.texImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], + ndx, this.m_internalFormat, levelSize, levelSize, 0, + this.m_format, this.m_dataType, + null + ); + } + } + + // Specify data using glTexSubImage2D() + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelSize = Math.max(1, this.m_size >> ndx); + + data.setSize(levelSize, levelSize); + + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + tcuTextureUtil.fillWithComponentGradients( + data.getAccess(), gMin, gMax + ); + + this.m_context.texSubImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], + ndx, 0, 0, levelSize, levelSize, this.m_format, + this.m_dataType, data.getAccess().getDataPtr() + ); + } + } + }; + + // TexSubImage2D() unpack alignment with 2D texture + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} width + * @param {number} height + * @param {number} subX + * @param {number} subY + * @param {number} subW + * @param {number} subH + * @param {number} alignment + */ + es3fTextureSpecificationTests.TexSubImage2DAlignCase = function( + name, desc, format, dataType, width, height, subX, subY, subW, subH, + alignment + ) { + // Unsized internal format. + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), width, height, 1 + ); + + this.m_internalFormat = format; + this.m_format = format; + this.m_dataType = dataType; + this.m_subX = subX; + this.m_subY = subY; + this.m_subW = subW; + this.m_subH = subH; + this.m_alignment = alignment; + }; + + es3fTextureSpecificationTests.TexSubImage2DAlignCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexSubImage2DAlignCase.prototype.constructor = + es3fTextureSpecificationTests.TexSubImage2DAlignCase; + + /** + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} subX + * @param {number} subY + * @param {number} subW + * @param {number} subH + * @param {number} alignment + * @return {es3fTextureSpecificationTests.TexSubImage2DAlignCase} + */ + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal = function( + name, desc, internalFormat, width, height, subX, subY, subW, subH, + alignment + ) { + // Sized internal format. + var fmt = gluTextureUtil.getTransferFormat( + gluTextureUtil.mapGLInternalFormat(internalFormat) + ); + var testcase = new es3fTextureSpecificationTests.TexSubImage2DAlignCase( + name, desc, fmt.format, fmt.dataType, + width, height, subX, subY, subW, subH, alignment + ); + testcase.m_internalFormat = internalFormat; + return testcase; + }; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexSubImage2DAlignCase.prototype.createTexture = function() { + var tex = null; + /** @type {ArrayBuffer} */ var data; + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + + // Specify base level. + data = new ArrayBuffer(this.m_texFormat.getPixelSize() * + this.m_width * this.m_height + ); + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + data: data + }); + tcuTextureUtil.fillWithComponentGradients(access, [0, 0, 0, 0], [1, 1, 1, 1]); + + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + this.m_context.texImage2D(gl.TEXTURE_2D, 0, this.m_internalFormat, + this.m_width, this.m_height, 0, this.m_format, this.m_dataType, + access.getDataPtr() + ); + + // Re-specify subrectangle. + var rowPitch = deMath.deAlign32( + this.m_texFormat.getPixelSize() * this.m_subW, this.m_alignment + ); + data = new ArrayBuffer(rowPitch * this.m_subH); + access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_subW, + height: this.m_subH, + rowPitch: rowPitch, + data: data + }); + tcuTextureUtil.fillWithGrid(access, 4, [1, 0, 0, 1], [0, 1, 0, 1] + ); + + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + this.m_context.texSubImage2D( + gl.TEXTURE_2D, 0, this.m_subX, this.m_subY, this.m_subW, + this.m_subH, this.m_format, this.m_dataType, access.getDataPtr() + ); + }; + + // TexSubImage2D() unpack alignment with cubemap texture + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} size + * @param {number} subX + * @param {number} subY + * @param {number} subW + * @param {number} subH + * @param {number} alignment + */ + es3fTextureSpecificationTests.TexSubImageCubeAlignCase = function( + name, desc, format, dataType, size, subX, subY, subW, subH, alignment + ) { + // Unsized internal format. + es3fTextureSpecificationTests.TextureCubeSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), size, 1 + ); + + this.m_internalFormat = format; + this.m_format = format; + this.m_dataType = dataType; + this.m_subX = subX; + this.m_subY = subY; + this.m_subW = subW; + this.m_subH = subH; + this.m_alignment = alignment; + }; + + es3fTextureSpecificationTests.TexSubImageCubeAlignCase.prototype = + Object.create( + es3fTextureSpecificationTests.TextureCubeSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexSubImageCubeAlignCase.prototype.constructor = + es3fTextureSpecificationTests.TexSubImageCubeAlignCase; + + /** + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} size + * @param {number} subX + * @param {number} subY + * @param {number} subW + * @param {number} subH + * @param {number} alignment + * @return {es3fTextureSpecificationTests.TexSubImageCubeAlignCase} + */ + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal = + function( + name, desc, internalFormat, size, + subX, subY, subW, subH, alignment + ) { + // Sized internal format. + var fmt = gluTextureUtil.getTransferFormat( + gluTextureUtil.mapGLInternalFormat(internalFormat) + ); + var testcase = + new es3fTextureSpecificationTests.TexSubImageCubeAlignCase( + name, desc, fmt.format, fmt.dataType, size, + subX, subY, subW, subH, alignment + ); + testcase.m_internalFormat = internalFormat; + return testcase; + }; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexSubImageCubeAlignCase.prototype.createTexture = + function() { + var tex = null; + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex); + + var data = new ArrayBuffer(this.m_texFormat.getPixelSize() * this.m_size * this.m_size); + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_size, + height: this.m_size, + data: data + }); + tcuTextureUtil.fillWithComponentGradients(access, [0, 0, 0, 0], [1, 1, 1, 1] + ); + + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + this.m_context.texImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], + 0, this.m_internalFormat, this.m_size, this.m_size, 0, + this.m_format, this.m_dataType, + access.getDataPtr() + ); + } + + // Re-specify subrectangle. + var rowPitch = deMath.deAlign32( + this.m_texFormat.getPixelSize() * this.m_subW, this.m_alignment + ); + data = new ArrayBuffer(rowPitch * this.m_subH); + access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_subW, + height: this.m_subH, + rowPitch: rowPitch, + data: data + }); + tcuTextureUtil.fillWithGrid(access, 4, [1, 0, 0, 1], [0, 1, 0, 1] + ); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + this.m_context.texSubImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], + 0, this.m_subX, this.m_subY, this.m_subW, this.m_subH, + this.m_format, this.m_dataType, access.getDataPtr() + ); + } + }; + + // TexSubImage3D() unpack parameters case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture3DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} depth + * @param {number} subX , + * @param {number} subY , + * @param {number} subZ , + * @param {number} subW , + * @param {number} subH , + * @param {number} subD , + * @param {number} imageHeight , + * @param {number} rowLength , + * @param {number} skipImages , + * @param {number} skipRows , + * @param {number} skipPixels , + * @param {number} alignment + */ + es3fTextureSpecificationTests.TexSubImage3DParamsCase = function( + name, desc, internalFormat, width, height, depth, + subX, subY, subZ, subW, subH, subD, + imageHeight, rowLength, skipImages, skipRows, skipPixels, alignment + ) { + es3fTextureSpecificationTests.Texture3DSpecCase.call( + this, name, desc, + gluTextureUtil.mapGLInternalFormat(internalFormat), + width, height, depth, 1 + ); + + this.m_internalFormat = internalFormat; + this.m_subX = subX; + this.m_subY = subY; + this.m_subZ = subZ; + this.m_subW = subW; + this.m_subH = subH; + this.m_subD = subD; + this.m_imageHeight = imageHeight; + this.m_rowLength = rowLength; + this.m_skipImages = skipImages; + this.m_skipRows = skipRows; + this.m_skipPixels = skipPixels; + this.m_alignment = alignment; + }; + + es3fTextureSpecificationTests.TexSubImage3DParamsCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture3DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexSubImage3DParamsCase.prototype.constructor = + es3fTextureSpecificationTests.TexSubImage3DParamsCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexSubImage3DParamsCase.prototype.createTexture = function() { + var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + var pixelSize = this.m_texFormat.getPixelSize(); + var tex = null; + var rowPitch = deMath.deAlign32(pixelSize * this.m_width, 4); + var slicePitch = rowPitch * this.m_height; + assertMsgOptions( + this.m_numLevels == 1, 'Numbel of levels different than 1', + false, true + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_3D, tex); + + // Fill with gradient. + + var data = new ArrayBuffer(slicePitch * this.m_depth); + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + depth: this.m_depth, + rowPitch: rowPitch, + slicePitch: slicePitch, + data: data + }); + tcuTextureUtil.fillWithComponentGradients(access, this.m_texFormatInfo.valueMin, this.m_texFormatInfo.valueMax); + + this.m_context.texImage3D( + gl.TEXTURE_3D, 0, this.m_internalFormat, this.m_width, + this.m_height, this.m_depth, 0, transferFmt.format, + transferFmt.dataType, access.getDataPtr() + ); + + // Fill data with grid. + var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_subW; + rowPitch = deMath.deAlign32(rowLength * pixelSize, this.m_alignment); + var imageHeight = this.m_imageHeight > 0 ? this.m_imageHeight : this.m_subH; + slicePitch = imageHeight * rowPitch; + var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin); + var cBias = this.m_texFormatInfo.valueMin; + var colorA = deMath.add( + deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias + ); + var colorB = deMath.add( + deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias + ); + + data = new ArrayBuffer(slicePitch * (this.m_depth + this.m_skipImages) + + this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize); + var accessWithOffset = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_subW, + height: this.m_subH, + depth: this.m_subD, + rowPitch: rowPitch, + slicePitch: slicePitch, + data: data, + offset: this.m_skipImages * slicePitch + this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize + }); + access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_subW, + height: this.m_subH, + depth: this.m_subD, + rowPitch: rowPitch, + slicePitch: slicePitch, + data: data + }); + tcuTextureUtil.fillWithGrid(accessWithOffset, 4, colorA, colorB); + + this.m_context.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, this.m_imageHeight); + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_IMAGES, this.m_skipImages); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + this.m_context.texSubImage3D( + gl.TEXTURE_3D, 0, this.m_subX, this.m_subY, this.m_subZ, + this.m_subW, this.m_subH, this.m_subD, + transferFmt.format, transferFmt.dataType, access.getDataPtr() + ); + }; + + // Basic CopyTexImage2D() with 2D texture usage + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + */ + es3fTextureSpecificationTests.BasicCopyTexImage2DCase = function( + name, desc, internalFormat, width, height + ) { + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + internalFormat, gl.UNSIGNED_BYTE + ), width, height, es3fTextureSpecificationTests.maxLevelCount( + width, height + ) + ); + + this.m_internalFormat = internalFormat; + }; + + es3fTextureSpecificationTests.BasicCopyTexImage2DCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + BasicCopyTexImage2DCase.prototype.constructor = + es3fTextureSpecificationTests.BasicCopyTexImage2DCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + BasicCopyTexImage2DCase.prototype.createTexture = function() { + var pixelFormat = tcuPixelFormat.PixelFormatFromContext(gl); + var targetHasRGB = pixelFormat.redBits > 0 && + pixelFormat.greenBits > 0 && + pixelFormat.blueBits > 0; + var targetHasAlpha = pixelFormat.alphaBits > 0; + var fmt = es3fTextureSpecificationTests.mapGLUnsizedInternalFormat( + this.m_internalFormat + ); + var texHasRGB = fmt.order != tcuTexture.ChannelOrder.A; + var texHasAlpha = fmt.order == tcuTexture.ChannelOrder.RGBA || + fmt.order == tcuTexture.ChannelOrder.LA || + fmt.order == tcuTexture.ChannelOrder.A; + var tex = null; + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + /** @type {es3fFboTestUtil.GradientShader} */ + var shader = new es3fFboTestUtil.GradientShader( + gluShaderUtil.DataType.FLOAT_VEC4 + ); + var shaderID = this.m_context.createProgram(shader); + + if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha)) + throw new Error( + 'Copying from current framebuffer is not supported' + ); + + // Fill render target with gradient. + shader.setGradient( + this.m_context, shaderID, [0, 0, 0, 0], [1, 1, 1, 1] + ); + rrUtil.drawQuad( + this.m_context, shaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0] + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var x = rnd.getInt(0, this.m_width - levelW); + var y = rnd.getInt(0, this.m_height - levelH); + + this.m_context.copyTexImage2D( + gl.TEXTURE_2D, ndx, this.m_internalFormat, x, y, + levelW, levelH, 0 + ); + } + }; + + // Basic CopyTexImage2D() with cubemap usage + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} size + */ + es3fTextureSpecificationTests.BasicCopyTexImageCubeCase = function( + name, desc, internalFormat, size + ) { + es3fTextureSpecificationTests.TextureCubeSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + internalFormat, gl.UNSIGNED_BYTE + ), size, deMath.logToFloor(size) + 1 + ); + + this.m_internalFormat = internalFormat; + }; + + es3fTextureSpecificationTests.BasicCopyTexImageCubeCase.prototype = + Object.create( + es3fTextureSpecificationTests.TextureCubeSpecCase.prototype + ); + + es3fTextureSpecificationTests. + BasicCopyTexImageCubeCase.prototype.constructor = + es3fTextureSpecificationTests.BasicCopyTexImageCubeCase; + + es3fTextureSpecificationTests. + BasicCopyTexImageCubeCase.prototype.createTexture = function() { + var pixelFormat = tcuPixelFormat.PixelFormatFromContext(gl); + var targetHasRGB = pixelFormat.redBits > 0 && + pixelFormat.greenBits > 0 && + pixelFormat.blueBits > 0; + var targetHasAlpha = pixelFormat.alphaBits > 0; + var fmt = es3fTextureSpecificationTests.mapGLUnsizedInternalFormat( + this.m_internalFormat + ); + var texHasRGB = fmt.order != tcuTexture.ChannelOrder.A; + var texHasAlpha = fmt.order == tcuTexture.ChannelOrder.RGBA || + fmt.order == tcuTexture.ChannelOrder.LA || + fmt.order == tcuTexture.ChannelOrder.A; + var tex = null; + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + /** @type {es3fFboTestUtil.GradientShader} */ + var shader = new es3fFboTestUtil.GradientShader( + gluShaderUtil.DataType.FLOAT_VEC4 + ); + var shaderID = this.m_context.createProgram(shader); + + if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha)) + throw new Error( + 'Copying from current framebuffer is not supported' + ); + + // Fill render target with gradient. + shader.setGradient( + this.m_context, shaderID, [0, 0, 0, 0], [1, 1, 1, 1] + ); + rrUtil.drawQuad( + this.m_context, shaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0] + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelSize = Math.max(1, this.m_size >> ndx); + + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + var x = rnd.getInt(0, this.m_size - levelSize); + var y = rnd.getInt(0, this.m_size - levelSize); + + this.m_context.copyTexImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], ndx, + this.m_internalFormat, x, y, levelSize, levelSize, 0 + ); + } + } + }; + + // Basic CopyTexSubImage2D() with 2D texture usage + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} width + * @param {number} height + */ + es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase = function( + name, desc, format, dataType, width, height + ) { + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), width, height, es3fTextureSpecificationTests.maxLevelCount( + width, height + ) + ); + + this.m_format = format; + this.m_dataType = dataType; + }; + + es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + BasicCopyTexSubImage2DCase.prototype.constructor = + es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + BasicCopyTexSubImage2DCase.prototype.createTexture = function() { + var pixelFormat = tcuPixelFormat.PixelFormatFromContext(gl); + var targetHasRGB = pixelFormat.redBits > 0 && + pixelFormat.greenBits > 0 && + pixelFormat.blueBits > 0; + var targetHasAlpha = pixelFormat.alphaBits > 0; + var fmt = gluTextureUtil.mapGLTransferFormat( + this.m_format, this.m_dataType + ); + var texHasRGB = fmt.order != tcuTexture.ChannelOrder.A; + var texHasAlpha = fmt.order == tcuTexture.ChannelOrder.RGBA || + fmt.order == tcuTexture.ChannelOrder.LA || + fmt.order == tcuTexture.ChannelOrder.A; + var tex = null; + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + /** @type {es3fFboTestUtil.GradientShader} */ + var shader = new es3fFboTestUtil.GradientShader( + gluShaderUtil.DataType.FLOAT_VEC4 + ); + var shaderID = this.m_context.createProgram(shader); + + if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha)) + throw new Error( + 'Copying from current framebuffer is not supported' + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + // First specify full texture. + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + + var colorA = es3fTextureSpecificationTests.randomVector( + rnd, [0, 0, 0, 0], [1, 1, 1, 1], 4 + ); + var colorB = es3fTextureSpecificationTests.randomVector( + rnd, [0, 0, 0, 0], [1, 1, 1, 1], 4 + ); + var cellSize = rnd.getInt(2, 16); + + var data = new tcuTexture.TextureLevel(fmt, levelW, levelH); + tcuTextureUtil.fillWithGrid( + data.getAccess(), cellSize, colorA, colorB + ); + + this.m_context.texImage2D( + gl.TEXTURE_2D, ndx, this.m_format, levelW, levelH, 0, this.m_format, this.m_dataType, data.getAccess().getDataPtr() + ); + } + + // Fill render target with gradient. + shader.setGradient( + this.m_context, shaderID, [0, 0, 0, 0], [1, 1, 1, 1] + ); + rrUtil.drawQuad( + this.m_context, shaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0] + ); + + // Re-specify parts of each level. + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + + var w = rnd.getInt(1, levelW); + var h = rnd.getInt(1, levelH); + var xo = rnd.getInt(0, levelW - w); + var yo = rnd.getInt(0, levelH - h); + + var x = rnd.getInt(0, this.m_width - w); + var y = rnd.getInt(0, this.m_height - h); + + this.m_context.copyTexSubImage2D( + gl.TEXTURE_2D, ndx, xo, yo, x, y, w, h + ); + } + }; + + // Basic CopyTexSubImage2D() with cubemap usage + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} dataType + * @param {number} size + */ + es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase = function( + name, desc, format, dataType, size + ) { + es3fTextureSpecificationTests.TextureCubeSpecCase.call( + this, name, desc, gluTextureUtil.mapGLTransferFormat( + format, dataType + ), size, deMath.logToFloor(size) + 1 + ); + + this.m_format = format; + this.m_dataType = dataType; + }; + + es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase.prototype = + Object.create( + es3fTextureSpecificationTests.TextureCubeSpecCase.prototype + ); + + es3fTextureSpecificationTests. + BasicCopyTexSubImageCubeCase.prototype.constructor = + es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase; + + es3fTextureSpecificationTests. + BasicCopyTexSubImageCubeCase.prototype.createTexture = function() { + var pixelFormat = tcuPixelFormat.PixelFormatFromContext(gl); + var targetHasRGB = pixelFormat.redBits > 0 && + pixelFormat.greenBits > 0 && + pixelFormat.blueBits > 0; + var targetHasAlpha = pixelFormat.alphaBits > 0; + var fmt = gluTextureUtil.mapGLTransferFormat(this.m_format, this.m_dataType); + var texHasRGB = fmt.order != tcuTexture.ChannelOrder.A; + var texHasAlpha = fmt.order == tcuTexture.ChannelOrder.RGBA || + fmt.order == tcuTexture.ChannelOrder.LA || + fmt.order == tcuTexture.ChannelOrder.A; + var tex = null; + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + /** @type {es3fFboTestUtil.GradientShader} */ + var shader = new es3fFboTestUtil.GradientShader( + gluShaderUtil.DataType.FLOAT_VEC4 + ); + var shaderID = this.m_context.createProgram(shader); + + if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha)) + throw new Error( + 'Copying from current framebuffer is not supported' + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + var data = new tcuTexture.TextureLevel(fmt); + + // First specify full texture. + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelSize = Math.max(1, this.m_size >> ndx); + + data.setSize(levelSize, levelSize); + + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + var colorA = es3fTextureSpecificationTests.randomVector( + rnd, [0, 0, 0, 0], [1, 1, 1, 1], 4 + ); + var colorB = es3fTextureSpecificationTests.randomVector( + rnd, [0, 0, 0, 0], [1, 1, 1, 1], 4 + ); + var cellSize = rnd.getInt(2, 16); + + tcuTextureUtil.fillWithGrid( + data.getAccess(), cellSize, colorA, colorB + ); + + this.m_context.texImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], + ndx, this.m_format, levelSize, levelSize, 0, this.m_format, + this.m_dataType, data.getAccess().getDataPtr() + ); + } + } + + // Fill render target with gradient. + shader.setGradient( + this.m_context, shaderID, [0, 0, 0, 0], [1, 1, 1, 1] + ); + rrUtil.drawQuad( + this.m_context, shaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0] + ); + + // Re-specify parts of each face and level. + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelSize = Math.max(1, this.m_size >> ndx); + + for (var f in es3fTextureSpecificationTests.s_cubeMapFaces) { + var w = rnd.getInt(1, levelSize); + var h = rnd.getInt(1, levelSize); + var xo = rnd.getInt(0, levelSize - w); + var yo = rnd.getInt(0, levelSize - h); + + var x = rnd.getInt(0, this.m_size - w); + var y = rnd.getInt(0, this.m_size - h); + + this.m_context.copyTexSubImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[f], + ndx, xo, yo, x, y, w, h + ); + } + } + }; + + // Basic glTexStorage2D() with 2D texture usage + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} numLevels + */ + es3fTextureSpecificationTests.BasicTexStorage2DCase = function( + name, desc, internalFormat, width, height, numLevels + ) { + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), width, height, numLevels + ); + + this.m_internalFormat = internalFormat; + }; + + es3fTextureSpecificationTests.BasicTexStorage2DCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DSpecCase.prototype + ); + + es3fTextureSpecificationTests.BasicTexStorage2DCase.prototype.constructor = + es3fTextureSpecificationTests.BasicTexStorage2DCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + BasicTexStorage2DCase.prototype.createTexture = function() { + var fmt = gluTextureUtil.mapGLInternalFormat(this.m_internalFormat); + var transferFmt = gluTextureUtil.getTransferFormat(fmt); + var tex = null; + var levelData = new tcuTexture.TextureLevel( + fmt, this.m_width, this.m_height + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + this.m_context.texStorage2D( + gl.TEXTURE_2D, this.m_numLevels, this.m_internalFormat, + this.m_width, this.m_height + ); + + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + levelData.setSize(levelW, levelH); + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + + this.m_context.texSubImage2D( + gl.TEXTURE_2D, ndx, 0, 0, levelW, levelH, + transferFmt.format, transferFmt.dataType, + levelData.getAccess().getDataPtr() + ); + } + }; + + // Basic glTexStorage2D() with cubemap usage + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} size + * @param {number} numLevels + */ + es3fTextureSpecificationTests.BasicTexStorageCubeCase = function( + name, desc, internalFormat, size, numLevels + ) { + es3fTextureSpecificationTests.TextureCubeSpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), size, numLevels + ); + + this.m_internalFormat = internalFormat; + }; + + es3fTextureSpecificationTests.BasicTexStorageCubeCase.prototype = + Object.create( + es3fTextureSpecificationTests.TextureCubeSpecCase.prototype + ); + + es3fTextureSpecificationTests.BasicTexStorageCubeCase.prototype.constructor = + es3fTextureSpecificationTests.BasicTexStorageCubeCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests.BasicTexStorageCubeCase.prototype.createTexture = function() { + var fmt = gluTextureUtil.mapGLInternalFormat(this.m_internalFormat); + var transferFmt = gluTextureUtil.getTransferFormat(fmt); + var tex = null; + var levelData = new tcuTexture.TextureLevel( + fmt, this.m_size, this.m_size + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex); + this.m_context.texStorage2D( + gl.TEXTURE_CUBE_MAP, this.m_numLevels, this.m_internalFormat, + this.m_size, this.m_size + ); + + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelSize = Math.max(1, this.m_size >> ndx); + + levelData.setSize(levelSize, levelSize); + + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + + this.m_context.texSubImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], + ndx, 0, 0, levelSize, levelSize, + transferFmt.format, transferFmt.dataType, + levelData.getAccess().getDataPtr() + ); + } + } + }; + + // Basic glTexStorage3D() with 2D array texture usage + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} numLayers + * @param {number} numLevels + */ + es3fTextureSpecificationTests.BasicTexStorage2DArrayCase = function( + name, desc, internalFormat, width, height, numLayers, numLevels + ) { + es3fTextureSpecificationTests.Texture2DArraySpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), width, height, numLayers, numLevels + ); + this.m_internalFormat = internalFormat; + }; + + es3fTextureSpecificationTests.BasicTexStorage2DArrayCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype + ); + + es3fTextureSpecificationTests. + BasicTexStorage2DArrayCase.prototype.constructor = + es3fTextureSpecificationTests.BasicTexStorage2DArrayCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests.BasicTexStorage2DArrayCase.prototype.createTexture = function() { + var tex = null; + var levelData = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_width, this.m_height + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + var transferFmt = gluTextureUtil.getTransferFormat( + this.m_texFormat + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex); + this.m_context.texStorage3D( + gl.TEXTURE_2D_ARRAY, this.m_numLevels, this.m_internalFormat, + this.m_width, this.m_height, this.m_numLayers + ); + + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + levelData.setSize(levelW, levelH, this.m_numLayers); + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + + this.m_context.texSubImage3D( + gl.TEXTURE_2D_ARRAY, ndx, 0, 0, 0, levelW, levelH, + this.m_numLayers, transferFmt.format, transferFmt.dataType, + levelData.getAccess().getDataPtr() + ); + } + }; + + // Basic TexStorage3D() with 3D texture usage + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture3DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} depth + * @param {number} numLevels + */ + es3fTextureSpecificationTests.BasicTexStorage3DCase = function( + name, desc, internalFormat, width, height, depth, numLevels + ) { + es3fTextureSpecificationTests.Texture3DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), width, height, depth, numLevels + ); + + this.m_internalFormat = internalFormat; + }; + + es3fTextureSpecificationTests.BasicTexStorage3DCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture3DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + BasicTexStorage3DCase.prototype.constructor = + es3fTextureSpecificationTests.BasicTexStorage3DCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + BasicTexStorage3DCase.prototype.createTexture = function() { + var tex = null; + var levelData = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_width, this.m_height + ); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + var transferFmt = gluTextureUtil.getTransferFormat( + this.m_texFormat + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_3D, tex); + this.m_context.texStorage3D( + gl.TEXTURE_3D, this.m_numLevels, this.m_internalFormat, + this.m_width, this.m_height, this.m_depth + ); + + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var levelD = Math.max(1, this.m_depth >> ndx); + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + levelData.setSize(levelW, levelH, levelD); + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + + this.m_context.texSubImage3D( + gl.TEXTURE_3D, ndx, 0, 0, 0, levelW, levelH, + levelD, transferFmt.format, transferFmt.dataType, + levelData.getAccess().getDataPtr() + ); + } + }; + + // Pixel buffer object cases. + + // TexImage2D() from pixel buffer object. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} rowLength + * @param {number} skipRows + * @param {number} skipPixels + * @param {number} alignment + * @param {number} offset + */ + es3fTextureSpecificationTests.TexImage2DBufferCase = function( + name, desc, internalFormat, width, height, rowLength, + skipRows, skipPixels, alignment, offset + ) { + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), width, height, 1 + ); + + this.m_internalFormat = internalFormat; + this.m_rowLength = rowLength; + this.m_skipRows = skipRows; + this.m_skipPixels = skipPixels; + this.m_alignment = alignment; + this.m_offset = offset; + }; + + es3fTextureSpecificationTests.TexImage2DBufferCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexImage2DBufferCase.prototype.constructor = + es3fTextureSpecificationTests.TexImage2DBufferCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests.TexImage2DBufferCase.prototype.createTexture = + function() { + var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + var pixelSize = this.m_texFormat.getPixelSize(); + var rowLength = this.m_rowLength > 0 ? + this.m_rowLength : + this.m_width + this.m_skipPixels; + var rowPitch = deMath.deAlign32( + rowLength * pixelSize, this.m_alignment + ); + var height = this.m_height + this.m_skipRows; + var buf = null; + var tex = null; + var data = new ArrayBuffer(rowPitch * height + this.m_skipPixels * pixelSize + this.m_offset); + + assertMsgOptions( + this.m_numLevels == 1, 'Number of levels different than 1', + false, true + ); + + // Fill data with grid. + var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin); + var cBias = this.m_texFormatInfo.valueMin; + var colorA = deMath.add( + deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias + ); + var colorB = deMath.add( + deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias + ); + + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + rowPitch: rowPitch, + data: data, + offset: this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize + this.m_offset + }); + tcuTextureUtil.fillWithGrid(access, 4, colorA, colorB); + + // Create buffer and upload. + buf = this.m_context.createBuffer(); + this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf); + this.m_context.bufferData(gl.PIXEL_UNPACK_BUFFER, data, gl.STATIC_DRAW + ); + + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + this.m_context.texImage2D(gl.TEXTURE_2D, 0, this.m_internalFormat, + this.m_width, this.m_height, 0, transferFmt.format, transferFmt.dataType, + this.m_offset + ); + }; + + // TexImage2D() cubemap from pixel buffer object case + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} size + * @param {number} rowLength + * @param {number} skipRows + * @param {number} skipPixels + * @param {number} alignment + * @param {number} offset + */ + es3fTextureSpecificationTests.TexImageCubeBufferCase = function( + name, desc, internalFormat, size, rowLength, skipRows, skipPixels, + alignment, offset + ) { + es3fTextureSpecificationTests.TextureCubeSpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), size, 1 + ); + + this.m_internalFormat = internalFormat; + this.m_rowLength = rowLength; + this.m_skipRows = skipRows; + this.m_skipPixels = skipPixels; + this.m_alignment = alignment; + this.m_offset = offset; + }; + + es3fTextureSpecificationTests.TexImageCubeBufferCase.prototype = + Object.create( + es3fTextureSpecificationTests.TextureCubeSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexImageCubeBufferCase.prototype.constructor = + es3fTextureSpecificationTests.TexImageCubeBufferCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexImageCubeBufferCase.prototype.createTexture = function() { + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + var tex = null; + var fmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + var pixelSize = this.m_texFormat.getPixelSize(); + var rowLength = this.m_rowLength > 0 ? + this.m_rowLength : this.m_size + this.m_skipPixels; + var rowPitch = deMath.deAlign32( + rowLength * pixelSize, this.m_alignment + ); + var height = this.m_size + this.m_skipRows; + + var data = new ArrayBuffer(rowPitch * height + this.m_skipPixels * pixelSize + this.m_offset); + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_size, + height: this.m_size, + rowPitch: rowPitch, + data: data, + offset: this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize + this.m_offset + }); + + assertMsgOptions( + this.m_numLevels == 1, 'Number of levels is different than 1', + false, true + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + var buf = null; + + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + tcuTextureUtil.fillWithComponentGradients(access, gMin, gMax); + + // Create buffer and upload. + buf = this.m_context.createBuffer(); + this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf); + this.m_context.bufferData(gl.PIXEL_UNPACK_BUFFER, data, gl.STATIC_DRAW); + + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + + this.m_context.texImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], 0, + this.m_internalFormat, this.m_size, this.m_size, 0, fmt.format, + fmt.dataType, this.m_offset); + } + }; + + // TexImage3D() 2D array from pixel buffer object. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} depth + * @param {number} imageHeight + * @param {number} rowLength + * @param {number} skipImages + * @param {number} skipRows + * @param {number} skipPixels + * @param {number} alignment + * @param {number} offset + */ + es3fTextureSpecificationTests.TexImage2DArrayBufferCase = function( + name, desc, internalFormat, width, height, depth, imageHeight, + rowLength, skipImages, skipRows, skipPixels, alignment, offset + ) { + es3fTextureSpecificationTests.Texture2DArraySpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), width, height, depth, 1 + ); + + this.m_internalFormat = internalFormat; + this.m_imageHeight = imageHeight; + this.m_rowLength = rowLength; + this.m_skipImages = skipImages; + this.m_skipRows = skipRows; + this.m_skipPixels = skipPixels; + this.m_alignment = alignment; + this.m_offset = offset; + }; + + es3fTextureSpecificationTests.TexImage2DArrayBufferCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexImage2DArrayBufferCase.prototype.constructor = + es3fTextureSpecificationTests.TexImage2DArrayBufferCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexImage2DArrayBufferCase.prototype.createTexture = function() { + var transferFmt = gluTextureUtil.getTransferFormat( + this.m_texFormat + ); + var pixelSize = this.m_texFormat.getPixelSize(); + var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_width; + var rowPitch = deMath.deAlign32( + rowLength * pixelSize, this.m_alignment + ); + var imageHeight = this.m_imageHeight > 0 ? + this.m_imageHeight : this.m_height; + var slicePitch = imageHeight * rowPitch; + var tex = null; + var buf = null; + var data = new ArrayBuffer( + slicePitch * (this.m_numLayers + this.m_skipImages) + + this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize + this.m_offset + ); + + assertMsgOptions( + this.m_numLevels == 1, 'Number of levels is different than 1', + false, true + ); + + // Fill data with grid. + var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin); + var cBias = this.m_texFormatInfo.valueMin; + var colorA = deMath.add( + deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias + ); + var colorB = deMath.add( + deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias + ); + + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + depth: this.m_numLayers, + rowPitch: rowPitch, + slicePitch: slicePitch, + data: data, + offset: this.m_skipImages * slicePitch + + this.m_skipRows * rowPitch + + this.m_skipPixels * pixelSize + + this.m_offset + }); + tcuTextureUtil.fillWithGrid(access, 4, colorA, colorB); + + // Create buffer and upload. + buf = this.m_context.createBuffer(); + this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf); + this.m_context.bufferData(gl.PIXEL_UNPACK_BUFFER, data, gl.STATIC_DRAW); + + this.m_context.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, this.m_imageHeight); + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_IMAGES, this.m_skipImages); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex); + this.m_context.texImage3D( + gl.TEXTURE_2D_ARRAY, 0, this.m_internalFormat, this.m_width, + this.m_height, this.m_numLayers, 0, transferFmt.format, + transferFmt.dataType, this.m_offset + ); + }; + + // TexImage3D() from pixel buffer object. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture3DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} depth + * @param {number} imageHeight + * @param {number} rowLength + * @param {number} skipImages + * @param {number} skipRows + * @param {number} skipPixels + * @param {number} alignment + * @param {number} offset + */ + es3fTextureSpecificationTests.TexImage3DBufferCase = function( + name, desc, internalFormat, width, height, depth, imageHeight, + rowLength, skipImages, skipRows, skipPixels, alignment, offset + ) { + es3fTextureSpecificationTests.Texture3DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), width, height, depth, 1 + ); + + this.m_internalFormat = internalFormat; + this.m_imageHeight = imageHeight; + this.m_rowLength = rowLength; + this.m_skipImages = skipImages; + this.m_skipRows = skipRows; + this.m_skipPixels = skipPixels; + this.m_alignment = alignment; + this.m_offset = offset; + }; + + es3fTextureSpecificationTests.TexImage3DBufferCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture3DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexImage3DBufferCase.prototype.constructor = + es3fTextureSpecificationTests.TexImage3DBufferCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexImage3DBufferCase.prototype.createTexture = function() { + var transferFmt = gluTextureUtil.getTransferFormat( + this.m_texFormat + ); + var pixelSize = this.m_texFormat.getPixelSize(); + var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_width; + var rowPitch = deMath.deAlign32( + rowLength * pixelSize, this.m_alignment + ); + var imageHeight = this.m_imageHeight > 0 ? + this.m_imageHeight : this.m_height; + var slicePitch = imageHeight * rowPitch; + var tex = null; + var buf = null; + var data = new ArrayBuffer( + slicePitch * (this.m_depth + this.m_skipImages) + + rowPitch * this.m_skipRows + pixelSize * this.m_skipPixels + this.m_offset + ); + + assertMsgOptions( + this.m_numLevels == 1, 'Number of levels is different than 1', + false, true + ); + + // Fill data with grid. + var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin); + var cBias = this.m_texFormatInfo.valueMin; + var colorA = deMath.add( + deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias + ); + var colorB = deMath.add( + deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias + ); + + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + depth: this.m_depth, + rowPitch: rowPitch, + slicePitch: slicePitch, + data: data, + offset: this.m_skipImages * slicePitch + + this.m_skipRows * rowPitch + + this.m_skipPixels * pixelSize + + this.m_offset + }); + tcuTextureUtil.fillWithGrid(access, 4, colorA, colorB); + + // Create buffer and upload. + buf = this.m_context.createBuffer(); + this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf); + this.m_context.bufferData(gl.PIXEL_UNPACK_BUFFER, data, gl.STATIC_DRAW); + + this.m_context.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, this.m_imageHeight); + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_IMAGES, this.m_skipImages); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_3D, tex); + this.m_context.texImage3D( + gl.TEXTURE_3D, 0, this.m_internalFormat, this.m_width, + this.m_height, this.m_depth, 0, transferFmt.format, + transferFmt.dataType, this.m_offset + ); + }; + + // TexSubImage2D() PBO case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} subX + * @param {number} subY + * @param {number} subW + * @param {number} subH + * @param {number} rowLength + * @param {number} skipRows + * @param {number} skipPixels + * @param {number} alignment + * @param {number} offset + */ + es3fTextureSpecificationTests.TexSubImage2DBufferCase = function( + name, desc, internalFormat, width, height, subX, subY, subW, subH, + rowLength, skipRows, skipPixels, alignment, offset + ) { + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), width, height, 1 + ); + this.m_internalFormat = internalFormat; + this.m_subX = subX; + this.m_subY = subY; + this.m_subW = subW; + this.m_subH = subH; + this.m_rowLength = rowLength; + this.m_skipRows = skipRows; + this.m_skipPixels = skipPixels; + this.m_alignment = alignment; + this.m_offset = offset; + }; + + es3fTextureSpecificationTests.TexSubImage2DBufferCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexSubImage2DBufferCase.prototype.constructor = + es3fTextureSpecificationTests.TexSubImage2DBufferCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexSubImage2DBufferCase.prototype.createTexture = function() { + var transferFmt = gluTextureUtil.getTransferFormat( + this.m_texFormat + ); + var pixelSize = this.m_texFormat.getPixelSize(); + var tex = null; + var buf = null; + var data = new ArrayBuffer( + deMath.deAlign32(this.m_width * pixelSize, 4) * this.m_height + ); + + assertMsgOptions( + this.m_numLevels == 1, 'Number of levels is different than 1', + false, true + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + rowPitch: deMath.deAlign32(this.m_width * pixelSize, 4), + data: data + }); + // First fill texture with gradient. + tcuTextureUtil.fillWithComponentGradients(access, this.m_texFormatInfo.valueMin, this.m_texFormatInfo.valueMax); + this.m_context.texImage2D( + gl.TEXTURE_2D, 0, this.m_internalFormat, + this.m_width, this.m_height, 0, transferFmt.format, + transferFmt.dataType, access.getDataPtr() + ); + + // Fill data with grid. + var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_subW; + var rowPitch = deMath.deAlign32( + rowLength * pixelSize, this.m_alignment + ); + var height = this.m_subH + this.m_skipRows; + var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin); + var cBias = this.m_texFormatInfo.valueMin; + var colorA = deMath.add( + deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias + ); + var colorB = deMath.add( + deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias + ); + + access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_subW, + height: this.m_subH, + rowPitch: rowPitch, + data: new ArrayBuffer(rowPitch * height + this.m_offset), + offset: this.m_skipRows * rowPitch + + this.m_skipPixels * pixelSize + + this.m_offset + }); + tcuTextureUtil.fillWithGrid(access, 4, colorA, colorB); + + buf = this.m_context.createBuffer(); + this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf); + this.m_context.bufferData(gl.PIXEL_UNPACK_BUFFER, access.getBuffer(), gl.STATIC_DRAW); + + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + + this.m_context.texSubImage2D( + gl.TEXTURE_2D, 0, this.m_subX, this.m_subY, + this.m_subW, this.m_subH, transferFmt.format, + transferFmt.dataType, this.m_offset + ); + }; + + // TexSubImage2D() cubemap PBO case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} size + * @param {number} subX + * @param {number} subY + * @param {number} subW + * @param {number} subH + * @param {number} rowLength + * @param {number} skipRows + * @param {number} skipPixels + * @param {number} alignment + * @param {number} offset + */ + es3fTextureSpecificationTests.TexSubImageCubeBufferCase = function( + name, desc, internalFormat, size, subX, subY, subW, subH, rowLength, + skipRows, skipPixels, alignment, offset + ) { + es3fTextureSpecificationTests.TextureCubeSpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), size, 1 + ); + + this.m_internalFormat = internalFormat; + this.m_subX = subX; + this.m_subY = subY; + this.m_subW = subW; + this.m_subH = subH; + this.m_rowLength = rowLength; + this.m_skipRows = skipRows; + this.m_skipPixels = skipPixels; + this.m_alignment = alignment; + this.m_offset = offset; + }; + + es3fTextureSpecificationTests.TexSubImageCubeBufferCase.prototype = + Object.create( + es3fTextureSpecificationTests.TextureCubeSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexSubImageCubeBufferCase.prototype.constructor = + es3fTextureSpecificationTests.TexSubImageCubeBufferCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexSubImageCubeBufferCase.prototype.createTexture = function() { + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + var transferFmt = gluTextureUtil.getTransferFormat( + this.m_texFormat + ); + var pixelSize = this.m_texFormat.getPixelSize(); + var tex = null; + var buf = null; + var data = new ArrayBuffer( + deMath.deAlign32(this.m_size * pixelSize, 4) * this.m_size + ); + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_size, + height: this.m_size, + rowPitch: deMath.deAlign32(this.m_size * pixelSize, 4), + data: data + }); + assertMsgOptions( + this.m_numLevels == 1, 'Number of levels is different than 1', + false, true + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex); + + // Fill faces with different gradients. + + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + var gMin = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + var gMax = es3fTextureSpecificationTests.randomVector( + rnd, this.m_texFormatInfo.valueMin, + this.m_texFormatInfo.valueMax, 4 + ); + + tcuTextureUtil.fillWithComponentGradients(access, gMin, gMax); + + this.m_context.texImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], 0, + this.m_internalFormat, this.m_size, this.m_size, 0, + transferFmt.format, transferFmt.dataType, + access.getDataPtr() + ); + } + + // Fill data with grid. + var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_subW; + var rowPitch = deMath.deAlign32( + rowLength * pixelSize, this.m_alignment + ); + var height = this.m_subH + this.m_skipRows; + var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin); + var cBias = this.m_texFormatInfo.valueMin; + var colorA = deMath.add( + deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias + ); + var colorB = deMath.add( + deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias + ); + + data = new ArrayBuffer(rowPitch * height + this.m_skipPixels * pixelSize + this.m_offset); + var accessSub = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_subW, + height: this.m_subH, + rowPitch: rowPitch, + data: data, + offset: this.m_skipRows * rowPitch + + this.m_skipPixels * pixelSize + + this.m_offset + }); + tcuTextureUtil.fillWithGrid(accessSub, 4, colorA, colorB); + + buf = this.m_context.createBuffer(); + this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf); + this.m_context.bufferData( + gl.PIXEL_UNPACK_BUFFER, data, gl.STATIC_DRAW + ); + + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + + for (var f in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[f]; + this.m_context.texSubImage2D( + es3fTextureSpecificationTests.s_cubeMapFaces[face], 0, + this.m_subX, this.m_subY, this.m_subW, this.m_subH, + transferFmt.format, transferFmt.dataType, this.m_offset + ); + } + }; + + // TexSubImage3D() 2D array PBO case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} depth + * @param {number} subX + * @param {number} subY + * @param {number} subZ + * @param {number} subW + * @param {number} subH + * @param {number} subD + * @param {number} imageHeight + * @param {number} rowLength + * @param {number} skipImages + * @param {number} skipRows + * @param {number} skipPixels + * @param {number} alignment + * @param {number} offset + */ + es3fTextureSpecificationTests.TexSubImage2DArrayBufferCase = function( + name, desc, internalFormat, width, height, depth, subX, subY, subZ, + subW, subH, subD, imageHeight, rowLength, skipImages, skipRows, + skipPixels, alignment, offset + ) { + es3fTextureSpecificationTests.Texture2DArraySpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), width, height, depth, 1 + ); + this.m_internalFormat = internalFormat; + this.m_subX = subX; + this.m_subY = subY; + this.m_subZ = subZ; + this.m_subW = subW; + this.m_subH = subH; + this.m_subD = subD; + this.m_imageHeight = imageHeight; + this.m_rowLength = rowLength; + this.m_skipImages = skipImages; + this.m_skipRows = skipRows; + this.m_skipPixels = skipPixels; + this.m_alignment = alignment; + this.m_offset = offset; + }; + + es3fTextureSpecificationTests.TexSubImage2DArrayBufferCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexSubImage2DArrayBufferCase.prototype.constructor = + es3fTextureSpecificationTests.TexSubImage2DArrayBufferCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexSubImage2DArrayBufferCase.prototype.createTexture = function() { + var transferFmt = gluTextureUtil.getTransferFormat( + this.m_texFormat + ); + var pixelSize = this.m_texFormat.getPixelSize(); + var tex = null; + var buf = null; + /** @type {ArrayBuffer} */ var data; + + assertMsgOptions( + this.m_numLevels == 1, 'Number of levels is different than 1', + false, true + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex); + + // Fill with gradient. + var rowPitch = deMath.deAlign32(pixelSize * this.m_width, 4); + var slicePitch = rowPitch * this.m_height; + + data = new ArrayBuffer(slicePitch * this.m_numLayers); + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + depth: this.m_numLayers, + rowPitch: rowPitch, + slicePitch: slicePitch, + data: data + }); + tcuTextureUtil.fillWithComponentGradients(access, this.m_texFormatInfo.valueMin, this.m_texFormatInfo.valueMax + ); + + this.m_context.texImage3D(gl.TEXTURE_2D_ARRAY, 0, this.m_internalFormat, this.m_width, this.m_height, + this.m_numLayers, 0, transferFmt.format, transferFmt.dataType, access.getDataPtr()); + + // Fill data with grid. + var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_subW; + rowPitch = deMath.deAlign32( + rowLength * pixelSize, this.m_alignment + ); + var height = this.m_subH + this.m_skipRows; + var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin); + + var cBias = this.m_texFormatInfo.valueMin; + var colorA = deMath.add( + deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias + ); + var colorB = deMath.add( + deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias + ); + + var accessSub = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_subW, + height: this.m_subH, + rowPitch: rowPitch, + data: new ArrayBuffer(rowPitch * height + this.m_offset), + offset: this.m_skipRows * rowPitch + + this.m_skipPixels * pixelSize + + this.m_offset + }); + tcuTextureUtil.fillWithGrid(accessSub, 4, colorA, colorB); + + buf = this.m_context.createBuffer(); + this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf); + this.m_context.bufferData( + gl.PIXEL_UNPACK_BUFFER, accessSub.getBuffer(), gl.STATIC_DRAW + ); + + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + }; + + // TexSubImage3D() PBO case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture3DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} width + * @param {number} height + * @param {number} depth + * @param {number} subX + * @param {number} subY + * @param {number} subZ + * @param {number} subW + * @param {number} subH + * @param {number} subD + * @param {number} imageHeight + * @param {number} rowLength + * @param {number} skipImages + * @param {number} skipRows + * @param {number} skipPixels + * @param {number} alignment + * @param {number} offset + */ + es3fTextureSpecificationTests.TexSubImage3DBufferCase = function( + name, desc, internalFormat, width, height, depth, subX, subY, subZ, + subW, subH, subD, imageHeight, rowLength, skipImages, skipRows, + skipPixels, alignment, offset + ) { + es3fTextureSpecificationTests.Texture3DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), width, height, depth, 1 + ); + + this.m_internalFormat = internalFormat; + this.m_subX = subX; + this.m_subY = subY; + this.m_subZ = subZ; + this.m_subW = subW; + this.m_subH = subH; + this.m_subD = subD; + this.m_imageHeight = imageHeight; + this.m_rowLength = rowLength; + this.m_skipImages = skipImages; + this.m_skipRows = skipRows; + this.m_skipPixels = skipPixels; + this.m_alignment = alignment; + this.m_offset = offset; + }; + + es3fTextureSpecificationTests.TexSubImage3DBufferCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture3DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexSubImage3DBufferCase.prototype.constructor = + es3fTextureSpecificationTests.TexSubImage3DBufferCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexSubImage3DBufferCase.prototype.createTexture = function() { + var transferFmt = gluTextureUtil.getTransferFormat( + this.m_texFormat + ); + var pixelSize = this.m_texFormat.getPixelSize(); + var tex = null; + var buf = null; + /** @type {ArrayBuffer} */ var data; + + assertMsgOptions( + this.m_numLevels == 1, 'Number of levels is different than 1', + false, true + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_3D, tex); + + // Fill with gradient. + var rowPitch = deMath.deAlign32(pixelSize * this.m_width, 4); + var slicePitch = rowPitch * this.m_height; + + data = new ArrayBuffer(slicePitch * this.m_depth); + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + depth: this.m_depth, + rowPitch: rowPitch, + slicePitch: slicePitch, + data: data}); + tcuTextureUtil.fillWithComponentGradients(access, this.m_texFormatInfo.valueMin, this.m_texFormatInfo.valueMax + ); + + this.m_context.texImage3D( + gl.TEXTURE_3D, 0, this.m_internalFormat, this.m_width, + this.m_height, this.m_depth, 0, transferFmt.format, + transferFmt.dataType, access.getDataPtr() + ); + + // Fill data with grid. + var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_subW; + rowPitch = deMath.deAlign32( + rowLength * pixelSize, this.m_alignment + ); + var imageHeight = this.m_imageHeight > 0 ? + this.m_imageHeight : this.m_subH; + slicePitch = imageHeight * rowPitch; + var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin); + var cBias = this.m_texFormatInfo.valueMin; + var colorA = deMath.add( + deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias + ); + var colorB = deMath.add( + deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias + ); + + data = new ArrayBuffer(slicePitch * (this.m_subD + this.m_skipImages) + + rowPitch * this.m_skipRows + pixelSize * this.m_skipPixels + this.m_offset); + var accessSub = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_subW, + height: this.m_subH, + depth: this.m_subD, + rowPitch: rowPitch, + slicePitch: slicePitch, + data: data, + offset: this.m_skipImages * slicePitch + + this.m_skipRows * rowPitch + + this.m_skipPixels * pixelSize + + this.m_offset + }); + tcuTextureUtil.fillWithGrid(accessSub, 4, colorA, colorB + ); + + buf = this.m_context.createBuffer(); + this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf); + this.m_context.bufferData( + gl.PIXEL_UNPACK_BUFFER, data, gl.STATIC_DRAW + ); + + this.m_context.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, this.m_imageHeight); + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_IMAGES, this.m_skipImages); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment); + this.m_context.texSubImage3D( + gl.TEXTURE_3D, 0, this.m_subX, this.m_subY, this.m_subZ, + this.m_subW, this.m_subH, this.m_subD, transferFmt.format, + transferFmt.dataType, this.m_offset + ); + }; + + // TexImage2D() depth case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} imageWidth + * @param {number} imageHeight + */ + es3fTextureSpecificationTests.TexImage2DDepthCase = function( + name, desc, internalFormat, imageWidth, imageHeight + ) { + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), imageWidth, imageHeight, + es3fTextureSpecificationTests.maxLevelCount( + imageWidth, imageHeight + ) + ); + + this.m_internalFormat = internalFormat; + // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] + this.m_texFormatInfo.lookupBias = [0.25, 0.0, 0.0, 1.0]; + this.m_texFormatInfo.lookupScale = [0.5, 1.0, 1.0, 0.0]; + }; + + es3fTextureSpecificationTests.TexImage2DDepthCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexImage2DDepthCase.prototype.constructor = + es3fTextureSpecificationTests.TexImage2DDepthCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests.TexImage2DDepthCase.prototype.createTexture = + function() { + var fmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + var tex = null; + var levelData = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_width, this.m_height + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var gMin = [-1.5, -2.0, 1.7, -1.5]; + var gMax = [2.0, 1.5, -1.0, 2.0]; + + levelData.setSize(levelW, levelH); + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + + this.m_context.texImage2D( + gl.TEXTURE_2D, ndx, this.m_internalFormat, levelW, levelH, 0, + fmt.format, fmt.dataType, levelData.getAccess().getDataPtr() + ); + } + }; + + // TexImage3D() depth case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} imageWidth + * @param {number} imageHeight + * @param {number} numLayers + */ + es3fTextureSpecificationTests.TexImage2DArrayDepthCase = function( + name, desc, internalFormat, imageWidth, imageHeight, numLayers + ) { + es3fTextureSpecificationTests.Texture2DArraySpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), imageWidth, imageHeight, numLayers, + es3fTextureSpecificationTests.maxLevelCount( + imageWidth, imageHeight + ) + ); + + this.m_internalFormat = internalFormat; + // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] + this.m_texFormatInfo.lookupBias = [0.25, 0.0, 0.0, 1.0]; + this.m_texFormatInfo.lookupScale = [0.5, 1.0, 1.0, 0.0]; + }; + + es3fTextureSpecificationTests.TexImage2DArrayDepthCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexImage2DArrayDepthCase.prototype.constructor = + es3fTextureSpecificationTests.TexImage2DArrayDepthCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexImage2DArrayDepthCase.prototype.createTexture = function() { + var fmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + var tex = null; + var levelData = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_width, this.m_height + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var gMin = [-1.5, -2.0, 1.7, -1.5]; + var gMax = [2.0, 1.5, -1.0, 2.0]; + + levelData.setSize(levelW, levelH, this.m_numLayers); + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + + this.m_context.texImage3D( + gl.TEXTURE_2D_ARRAY, ndx, this.m_internalFormat, levelW, levelH, + this.m_numLayers, 0, fmt.format, fmt.dataType, + levelData.getAccess().getDataPtr() + ); + } + }; + + // TexSubImage2D() depth case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} imageWidth + * @param {number} imageHeight + */ + es3fTextureSpecificationTests.TexSubImage2DDepthCase = function( + name, desc, internalFormat, imageWidth, imageHeight + ) { + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), imageWidth, imageHeight, + es3fTextureSpecificationTests.maxLevelCount( + imageWidth, imageHeight + ) + ); + + this.m_internalFormat = internalFormat; + // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] + this.m_texFormatInfo.lookupBias = [0.25, 0.0, 0.0, 1.0]; + this.m_texFormatInfo.lookupScale = [0.5, 1.0, 1.0, 0.0]; + }; + + es3fTextureSpecificationTests.TexSubImage2DDepthCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexSubImage2DDepthCase.prototype.constructor = + es3fTextureSpecificationTests.TexSubImage2DDepthCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexSubImage2DDepthCase.prototype.createTexture = function() { + var fmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + var tex = null; + var levelData = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_width, this.m_height + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + // First specify full texture. + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var gMin = [-1.5, -2.0, 1.7, -1.5]; + var gMax = [2.0, 1.5, -1.0, 2.0]; + + levelData.setSize(levelW, levelH); + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + + this.m_context.texImage2D( + gl.TEXTURE_2D, ndx, this.m_internalFormat, levelW, levelH, 0, + fmt.format, fmt.dataType, levelData.getAccess().getDataPtr() + ); + } + + // Re-specify parts of each level. + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + + var w = rnd.getInt(1, levelW); + var h = rnd.getInt(1, levelH); + var x = rnd.getInt(0, levelW - w); + var y = rnd.getInt(0, levelH - h); + + var colorA = [2.0, 1.5, -1.0, 2.0]; + var colorB = [-1.5, -2.0, 1.7, -1.5]; + var cellSize = rnd.getInt(2, 16); + + levelData.setSize(w, h); + tcuTextureUtil.fillWithGrid( + levelData.getAccess(), cellSize, colorA, colorB + ); + + this.m_context.texSubImage2D( + gl.TEXTURE_2D, ndx, x, y, w, h, fmt.format, fmt.dataType, + levelData.getAccess().getDataPtr() + ); + } + }; + + // TexSubImage3D() depth case. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} imageWidth + * @param {number} imageHeight + * @param {number} numLayers + */ + es3fTextureSpecificationTests.TexSubImage2DArrayDepthCase = function( + name, desc, internalFormat, imageWidth, imageHeight, numLayers + ) { + es3fTextureSpecificationTests.Texture2DArraySpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), imageWidth, imageHeight, numLayers, + es3fTextureSpecificationTests.maxLevelCount( + imageWidth, imageHeight + ) + ); + + this.m_internalFormat = internalFormat; + // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] + this.m_texFormatInfo.lookupBias = [0.25, 0.0, 0.0, 1.0]; + this.m_texFormatInfo.lookupScale = [0.5, 1.0, 1.0, 0.0]; + }; + + es3fTextureSpecificationTests.TexSubImage2DArrayDepthCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexSubImage2DArrayDepthCase.prototype.constructor = + es3fTextureSpecificationTests.TexSubImage2DArrayDepthCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexSubImage2DArrayDepthCase.prototype.createTexture = function() { + var fmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + var rnd = new deRandom.Random(deString.deStringHash(this.fullName())); + var tex = null; + var levelData = new tcuTexture.TextureLevel( + this.m_texFormat, this.m_width, this.m_height + ); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + + // First specify full texture. + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + var gMin = [-1.5, -2.0, 1.7, -1.5]; + var gMax = [2.0, 1.5, -1.0, 2.0]; + + levelData.setSize(levelW, levelH, this.m_numLayers); + tcuTextureUtil.fillWithComponentGradients( + levelData.getAccess(), gMin, gMax + ); + this.m_context.texImage3D( + gl.TEXTURE_2D_ARRAY, ndx, this.m_internalFormat, levelW, levelH, + this.m_numLayers, 0, fmt.format, fmt.dataType, + levelData.getAccess().getDataPtr() + ); + } + + // Re-specify parts of each level. + for (var ndx = 0; ndx < this.m_numLevels; ndx++) { + var levelW = Math.max(1, this.m_width >> ndx); + var levelH = Math.max(1, this.m_height >> ndx); + + var w = rnd.getInt(1, levelW); + var h = rnd.getInt(1, levelH); + var d = rnd.getInt(1, this.m_numLayers); + var x = rnd.getInt(0, levelW - w); + var y = rnd.getInt(0, levelH - h); + var z = rnd.getInt(0, this.m_numLayers - d); + + var colorA = [2.0, 1.5, -1.0, 2.0]; + var colorB = [-1.5, -2.0, 1.7, -1.5]; + var cellSize = rnd.getInt(2, 16); + + levelData.setSize(w, h, d); + tcuTextureUtil.fillWithGrid( + levelData.getAccess(), cellSize, colorA, colorB + ); + + this.m_context.texSubImage3D( + gl.TEXTURE_2D_ARRAY, ndx, x, y, z, w, h, d, fmt.format, + fmt.dataType, levelData.getAccess().getDataPtr() + ); + } + }; + + // TexImage2D() depth case with pbo. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DSpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} imageWidth + * @param {number} imageHeight + */ + es3fTextureSpecificationTests.TexImage2DDepthBufferCase = function( + name, desc, internalFormat, imageWidth, imageHeight + ) { + es3fTextureSpecificationTests.Texture2DSpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), imageWidth, imageHeight, 1 + ); + + this.m_internalFormat = internalFormat; + // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] + this.m_texFormatInfo.lookupBias = [0.25, 0.0, 0.0, 1.0]; + this.m_texFormatInfo.lookupScale = [0.5, 1.0, 1.0, 0.0]; + }; + + es3fTextureSpecificationTests.TexImage2DDepthBufferCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DSpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexImage2DDepthBufferCase.prototype.constructor = + es3fTextureSpecificationTests.TexImage2DDepthBufferCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexImage2DDepthBufferCase.prototype.createTexture = function() { + var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + var pixelSize = this.m_texFormat.getPixelSize(); + var rowLength = this.m_width; + var alignment = 4; + var rowPitch = deMath.deAlign32(rowLength * pixelSize, alignment); + var height = this.m_height; + var buf = null; + var tex = null; + var data = new ArrayBuffer(rowPitch * height); + + assertMsgOptions( + this.m_numLevels == 1, 'Number of levels is different than 1', + false, true + ); + + // Fill data with gradient + var gMin = [-1.5, -2.0, 1.7, -1.5]; + var gMax = [2.0, 1.5, -1.0, 2.0]; + + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + rowPitch: rowPitch, + data: data + }); + tcuTextureUtil.fillWithComponentGradients(access, gMin, gMax); + + // Create buffer and upload. + buf = this.m_context.createBuffer(); + this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf); + this.m_context.bufferData( + gl.PIXEL_UNPACK_BUFFER, access.getBuffer(), gl.STATIC_DRAW + ); + + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, 0); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, 0); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, alignment); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D, tex); + this.m_context.texImage2D( + gl.TEXTURE_2D, 0, this.m_internalFormat, this.m_width, + this.m_height, 0, transferFmt.format, transferFmt.dataType, 0 + ); + this.m_context.deleteBuffer(buf); + }; + + // TexImage3D() depth case with pbo. + /** + * @constructor + * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase} + * @param {string} name + * @param {string} desc + * @param {number} internalFormat + * @param {number} imageWidth + * @param {number} imageHeight + */ + es3fTextureSpecificationTests.TexImage2DArrayDepthBufferCase = function( + name, desc, internalFormat, imageWidth, imageHeight, numLayers + ) { + es3fTextureSpecificationTests.Texture2DArraySpecCase.call( + this, name, desc, gluTextureUtil.mapGLInternalFormat( + internalFormat + ), imageWidth, imageHeight, numLayers, 1 + ); + + this.m_internalFormat = internalFormat; + // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] + this.m_texFormatInfo.lookupBias = [0.25, 0.0, 0.0, 1.0]; + this.m_texFormatInfo.lookupScale = [0.5, 1.0, 1.0, 0.0]; + }; + + es3fTextureSpecificationTests.TexImage2DArrayDepthBufferCase.prototype = + Object.create( + es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype + ); + + es3fTextureSpecificationTests. + TexImage2DArrayDepthBufferCase.prototype.constructor = + es3fTextureSpecificationTests.TexImage2DArrayDepthBufferCase; + + /** + * createTexture + */ + es3fTextureSpecificationTests. + TexImage2DArrayDepthBufferCase.prototype.createTexture = function() { + var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat); + var pixelSize = this.m_texFormat.getPixelSize(); + var rowLength = this.m_width; + var alignment = 4; + var rowPitch = deMath.deAlign32(rowLength * pixelSize, alignment); + var imageHeight = this.m_height; + var slicePitch = imageHeight * rowPitch; + var tex = null; + var buf = null; + var data = new ArrayBuffer(slicePitch * this.m_numLayers); + + assertMsgOptions( + this.m_numLevels == 1, 'Number of levels is different than 1', + false, true + ); + + // Fill data with gradient + var gMin = [-1.5, -2.0, 1.7, -1.5]; + var gMax = [2.0, 1.5, -1.0, 2.0]; + + var access = new tcuTexture.PixelBufferAccess({ + format: this.m_texFormat, + width: this.m_width, + height: this.m_height, + depth: this.m_numLayers, + rowPitch: rowPitch, + slicePitch: slicePitch, + data: data + }); + tcuTextureUtil.fillWithComponentGradients(access, gMin, gMax); + + buf = this.m_context.createBuffer(); + this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf); + this.m_context.bufferData( + gl.PIXEL_UNPACK_BUFFER, access.getBuffer(), gl.STATIC_DRAW + ); + + this.m_context.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, rowLength); + this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, rowLength); + this.m_context.pixelStorei(gl.UNPACK_SKIP_IMAGES, 0); + this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, 0); + this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, 0); + this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, alignment); + + tex = this.m_context.createTexture(); + this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex); + this.m_context.texImage3D( + gl.TEXTURE_2D_ARRAY, 0, this.m_internalFormat, this.m_width, + this.m_height, this.m_numLayers, 0, transferFmt.format, + transferFmt.dataType, 0 + ); + this.m_context.deleteBuffer(buf); + }; + + /** + * @constructor + * @extends {tcuTestCase.DeqpTest} + */ + es3fTextureSpecificationTests.TextureSpecificationTests = function() { + tcuTestCase.DeqpTest.call( + this, 'specification', 'Texture Specification Tests' + ); + }; + + es3fTextureSpecificationTests.TextureSpecificationTests.prototype = + Object.create(tcuTestCase.DeqpTest.prototype); + es3fTextureSpecificationTests.TextureSpecificationTests.prototype.constructor = + es3fTextureSpecificationTests.TextureSpecificationTests; + + es3fTextureSpecificationTests.TextureSpecificationTests.prototype.init = function() { + /** + * @type {Array<number>} + */ + es3fTextureSpecificationTests.s_cubeMapFaces = [ + gl.TEXTURE_CUBE_MAP_NEGATIVE_X, + gl.TEXTURE_CUBE_MAP_POSITIVE_X, + gl.TEXTURE_CUBE_MAP_NEGATIVE_Y, + gl.TEXTURE_CUBE_MAP_POSITIVE_Y, + gl.TEXTURE_CUBE_MAP_NEGATIVE_Z, + gl.TEXTURE_CUBE_MAP_POSITIVE_Z + ]; + + /** @type {Array<{name: string, format: number, dataType: number}>} */ + var unsizedFormats = [{ + name: 'alpha_unsigned_byte', + format: gl.ALPHA, + dataType: gl.UNSIGNED_BYTE + }, { + name: 'luminance_unsigned_byte', + format: gl.LUMINANCE, + dataType: gl.UNSIGNED_BYTE + }, { + name: 'luminance_alpha_unsigned_byte', + format: gl.LUMINANCE_ALPHA, + dataType: gl.UNSIGNED_BYTE + }, { + name: 'rgb_unsigned_short_5_6_5', + format: gl.RGB, + dataType: gl.UNSIGNED_SHORT_5_6_5 + }, { + name: 'rgb_unsigned_byte', + format: gl.RGB, + dataType: gl.UNSIGNED_BYTE + }, { + name: 'rgba_unsigned_short_4_4_4_4', + format: gl.RGBA, + dataType: gl.UNSIGNED_SHORT_4_4_4_4 + }, { + name: 'rgba_unsigned_short_5_5_5_1', + format: gl.RGBA, + dataType: gl.UNSIGNED_SHORT_5_5_5_1 + }, { + name: 'rgba_unsigned_byte', + format: gl.RGBA, + dataType: gl.UNSIGNED_BYTE + } + ]; + + /** @type {Array<{name: string, internalFormat: number}>} */ + var colorFormats = [{ + name: 'rgba32f', internalFormat: gl.RGBA32F + }, { + name: 'rgba32i', internalFormat: gl.RGBA32I + }, { + name: 'rgba32ui', internalFormat: gl.RGBA32UI + }, { + name: 'rgba16f', internalFormat: gl.RGBA16F + }, { + name: 'rgba16i', internalFormat: gl.RGBA16I + }, { + name: 'rgba16ui', internalFormat: gl.RGBA16UI + }, { + name: 'rgba8', internalFormat: gl.RGBA8 + }, { + name: 'rgba8i', internalFormat: gl.RGBA8I + }, { + name: 'rgba8ui', internalFormat: gl.RGBA8UI + }, { + name: 'srgb8_alpha8', internalFormat: gl.SRGB8_ALPHA8 + }, { + name: 'rgb10_a2', internalFormat: gl.RGB10_A2 + }, { + name: 'rgb10_a2ui', internalFormat: gl.RGB10_A2UI + }, { + name: 'rgba4', internalFormat: gl.RGBA4 + }, { + name: 'rgb5_a1', internalFormat: gl.RGB5_A1 + }, { + name: 'rgba8_snorm', internalFormat: gl.RGBA8_SNORM + }, { + name: 'rgb8', internalFormat: gl.RGB8 + }, { + name: 'rgb565', internalFormat: gl.RGB565 + }, { + name: 'r11f_g11f_b10f', internalFormat: gl.R11F_G11F_B10F + }, { + name: 'rgb32f', internalFormat: gl.RGB32F + }, { + name: 'rgb32i', internalFormat: gl.RGB32I + }, { + name: 'rgb32ui', internalFormat: gl.RGB32UI + }, { + name: 'rgb16f', internalFormat: gl.RGB16F + }, { + name: 'rgb16i', internalFormat: gl.RGB16I + }, { + name: 'rgb16ui', internalFormat: gl.RGB16UI + }, { + name: 'rgb8_snorm', internalFormat: gl.RGB8_SNORM + }, { + name: 'rgb8i', internalFormat: gl.RGB8I + }, { + name: 'rgb8ui', internalFormat: gl.RGB8UI + }, { + name: 'srgb8', internalFormat: gl.SRGB8 + }, { + name: 'rgb9_e5', internalFormat: gl.RGB9_E5 + }, { + name: 'rg32f', internalFormat: gl.RG32F + }, { + name: 'rg32i', internalFormat: gl.RG32I + }, { + name: 'rg32ui', internalFormat: gl.RG32UI + }, { + name: 'rg16f', internalFormat: gl.RG16F + }, { + name: 'rg16i', internalFormat: gl.RG16I + }, { + name: 'rg16ui', internalFormat: gl.RG16UI + }, { + name: 'rg8', internalFormat: gl.RG8 + }, { + name: 'rg8i', internalFormat: gl.RG8I + }, { + name: 'rg8ui', internalFormat: gl.RG8UI + }, { + name: 'rg8_snorm', internalFormat: gl.RG8_SNORM + }, { + name: 'r32f', internalFormat: gl.R32F + }, { + name: 'r32i', internalFormat: gl.R32I + }, { + name: 'r32ui', internalFormat: gl.R32UI + }, { + name: 'r16f', internalFormat: gl.R16F + }, { + name: 'r16i', internalFormat: gl.R16I + }, { + name: 'r16ui', internalFormat: gl.R16UI + }, { + name: 'r8', internalFormat: gl.R8 + }, { + name: 'r8i', internalFormat: gl.R8I + }, { + name: 'r8ui', internalFormat: gl.R8UI + }, { + name: 'r8_snorm', internalFormat: gl.R8_SNORM + } + ]; + + // Depth and stencil formats + /** @type {Array<{name: string, internalFormat: number}>} */ + var depthStencilFormats = [{ + name: 'depth_component32f', + internalFormat: gl.DEPTH_COMPONENT32F + }, { + name: 'depth_component24', + internalFormat: gl.DEPTH_COMPONENT24 + }, { + name: 'depth_component16', + internalFormat: gl.DEPTH_COMPONENT16 + }, { + name: 'depth32f_stencil8', + internalFormat: gl.DEPTH32F_STENCIL8 + }, { + name: 'depth24_stencil8', + internalFormat: gl.DEPTH24_STENCIL8 + } + ]; + + // Basic TexImage2D usage. + var splitBasicTex2D = 2, splitBasicTexCube = 5; + /** @type {Array<{tcuTestCase.DeqpTest}>} */ + var basicTexImageGroup2D = []; + for (var ii = 0; ii < splitBasicTex2D; ++ii) { + basicTexImageGroup2D.push( + new tcuTestCase.DeqpTest('basic_teximage2d', 'Basic glTexImage2D() usage') + ); + this.addChild(basicTexImageGroup2D[ii]); + } + /** @type {Array<{tcuTestCase.DeqpTest}>} */ + var basicTexImageGroupCube = []; + for (var ii = 0; ii < splitBasicTexCube; ++ii) { + basicTexImageGroupCube.push( + new tcuTestCase.DeqpTest('basic_teximage2d', 'Basic glTexImage2D() usage') + ); + this.addChild(basicTexImageGroupCube[ii]); + } + for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) { + /** @type {string} */ + var fmtName = colorFormats[formatNdx].name; + /** @type {number} */ + var format = colorFormats[formatNdx].internalFormat; + /** @type {number} */ + var tex2DWidth = 64; + /** @type {number} */ + var tex2DHeight = 128; + /** @type {number} */ + var texCubeSize = 64; + + basicTexImageGroup2D[formatNdx % splitBasicTex2D].addChild( + es3fTextureSpecificationTests.newBasicTexImage2DCaseInternal( + fmtName + '_2d', '', format, tex2DWidth, tex2DHeight + ) + ); + basicTexImageGroupCube[formatNdx % splitBasicTexCube].addChild( + es3fTextureSpecificationTests.newBasicTexImageCubeCaseInternal( + fmtName + '_cube', '', format, texCubeSize + ) + ); + } + + // Randomized TexImage2D order. + /** @type {tcuTestCase.DeqpTest} */ + var randomTexImageGroup = new tcuTestCase.DeqpTest( + 'random_teximage2d', 'Randomized glTexImage2D() usage' + ); + this.addChild(randomTexImageGroup); + var rnd = new deRandom.Random(9); + + // 2D cases. + for (var ndx = 0; ndx < 10; ndx++) { + var formatNdx = rnd.getInt(0, colorFormats.length - 1); + var width = 1 << rnd.getInt(2, 8); + var height = 1 << rnd.getInt(2, 8); + + randomTexImageGroup.addChild( + es3fTextureSpecificationTests.newRandomOrderTexImage2DCaseInternal( + '2d.' + colorFormats[formatNdx].name, '', + colorFormats[formatNdx].internalFormat, width, height + ) + ); + } + + // Cubemap cases. + randomTexImageGroup = new tcuTestCase.DeqpTest( + 'random_teximage2d', 'Randomized glTexImage2D() usage' + ); + this.addChild(randomTexImageGroup); + + for (var ndx = 0; ndx < 10; ndx++) { + formatNdx = rnd.getInt(0, colorFormats.length - 1); + /** @type {number} */ var size = 1 << rnd.getInt(2, 8); + + randomTexImageGroup.addChild( + es3fTextureSpecificationTests.newRandomOrderTexImageCubeCaseInternal( + 'cube.' + colorFormats[formatNdx].name, '', + colorFormats[formatNdx].internalFormat, size + ) + ); + } + + // TexImage2D unpack alignment. + /** @type {tcuTestCase.DeqpTest} */ + var alignGroup = new tcuTestCase.DeqpTest( + 'teximage2d_align', 'glTexImage2D() unpack alignment tests' + ); + this.addChild(alignGroup); + + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_r8_4_8', '', gl.R8, 4, 8, 4, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_r8_63_1', '', gl.R8, 63, 30, 1, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_r8_63_2', '', gl.R8, 63, 30, 1, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_r8_63_4', '', gl.R8, 63, 30, 1, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_r8_63_8', '', gl.R8, 63, 30, 1, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_rgba4_51_1', '', gl.RGBA4, 51, 30, 1, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_rgba4_51_2', '', gl.RGBA4, 51, 30, 1, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_rgba4_51_4', '', gl.RGBA4, 51, 30, 1, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_rgba4_51_8', '', gl.RGBA4, 51, 30, 1, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_rgb8_39_1', '', gl.RGB8, 39, 43, 1, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_rgb8_39_2', '', gl.RGB8, 39, 43, 1, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_rgb8_39_4', '', gl.RGB8, 39, 43, 1, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_rgb8_39_8', '', gl.RGB8, 39, 43, 1, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_rgba8_47_1', '', gl.RGBA8, 47, 27, 1, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_rgba8_47_2', '', gl.RGBA8, 47, 27, 1, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_rgba8_47_4', '', gl.RGBA8, 47, 27, 1, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal( + '2d_rgba8_47_8', '', gl.RGBA8, 47, 27, 1, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_r8_4_8', '', gl.R8, 4, 3, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_r8_63_1', '', gl.R8, 63, 1, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_r8_63_2', '', gl.R8, 63, 1, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_r8_63_4', '', gl.R8, 63, 1, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_r8_63_8', '', gl.R8, 63, 1, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_rgba4_51_1', '', gl.RGBA4, 51, 1, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_rgba4_51_2', '', gl.RGBA4, 51, 1, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_rgba4_51_4', '', gl.RGBA4, 51, 1, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_rgba4_51_8', '', gl.RGBA4, 51, 1, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_rgb8_39_1', '', gl.RGB8, 39, 1, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_rgb8_39_2', '', gl.RGB8, 39, 1, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_rgb8_39_4', '', gl.RGB8, 39, 1, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_rgb8_39_8', '', gl.RGB8, 39, 1, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_rgba8_47_1', '', gl.RGBA8, 47, 1, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_rgba8_47_2', '', gl.RGBA8, 47, 1, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_rgba8_47_4', '', gl.RGBA8, 47, 1, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal( + 'cube_rgba8_47_8', '', gl.RGBA8, 47, 1, 8 + ) + ); + + // glTexImage2D() unpack parameter cases. + /** @type {tcuTestCase.DeqpTest} */ + var paramGroup = new tcuTestCase.DeqpTest( + 'teximage2d_unpack_params', + 'glTexImage2D() pixel transfer mode cases' + ); + this.addChild(paramGroup); + + var cases = [{ + name: 'rgb8_alignment', format: gl.RGB8, width: 31, + height: 30, rowLength: 0, skipRows: 0, skipPixels: 0, + alignment: 2 + }, { + name: 'rgb8_row_length', format: gl.RGB8, width: 31, + height: 30, rowLength: 50, skipRows: 0, skipPixels: 0, + alignment: 4 + }, { + name: 'rgb8_skip_rows', format: gl.RGB8, width: 31, + height: 30, rowLength: 0, skipRows: 3, skipPixels: 0, + alignment: 4 + }, { + name: 'rgb8_skip_pixels', format: gl.RGB8, width: 31, + height: 30, rowLength: 36, skipRows: 0, skipPixels: 5, + alignment: 4 + }, { + name: 'r8_complex1', format: gl.R8, width: 31, + height: 30, rowLength: 64, skipRows: 1, skipPixels: 3, + alignment: 1 + }, { + name: 'r8_complex2', format: gl.R8, width: 31, + height: 30, rowLength: 64, skipRows: 1, skipPixels: 3, + alignment: 2 + }, { + name: 'r8_complex3', format: gl.R8, width: 31, + height: 30, rowLength: 64, skipRows: 1, skipPixels: 3, + alignment: 4 + }, { + name: 'r8_complex4', format: gl.R8, width: 31, + height: 30, rowLength: 64, skipRows: 1, skipPixels: 3, + alignment: 8 + }, { + name: 'rgba8_complex1', format: gl.RGBA8, width: 56, + height: 61, rowLength: 69, skipRows: 0, skipPixels: 0, + alignment: 8 + }, { + name: 'rgba8_complex2', format: gl.RGBA8, width: 56, + height: 61, rowLength: 69, skipRows: 0, skipPixels: 7, + alignment: 8 + }, { + name: 'rgba8_complex3', format: gl.RGBA8, width: 56, + height: 61, rowLength: 69, skipRows: 3, skipPixels: 0, + alignment: 8 + }, { + name: 'rgba8_complex4', format: gl.RGBA8, width: 56, + height: 61, rowLength: 69, skipRows: 3, skipPixels: 7, + alignment: 8 + }, { + name: 'rgba32f_complex', format: gl.RGBA32F, width: 19, + height: 10, rowLength: 27, skipRows: 1, skipPixels: 7, + alignment: 8 + } + ]; + + for (var ndx = 0; ndx < cases.length; ndx++) + paramGroup.addChild( + new es3fTextureSpecificationTests.TexImage2DParamsCase( + cases[ndx].name, '', cases[ndx].format, cases[ndx].width, + cases[ndx].height, cases[ndx].rowLength, + cases[ndx].skipRows, cases[ndx].skipPixels, + cases[ndx].alignment + ) + ); + + // glTexImage2D() pbo cases. + var splitPboTex2D = 2, splitPboTexCube = 5; + /** @type {Array<{tcuTestCase.DeqpTest}>} */ var pboGroup2D = []; + for (var ii = 0; ii < splitPboTex2D; ++ii) { + pboGroup2D.push(new tcuTestCase.DeqpTest('teximage2d_pbo', 'glTexImage2D() from PBO')); + this.addChild(pboGroup2D[ii]); + } + /** @type {Array<{tcuTestCase.DeqpTest}>} */ var pboGroupCube = []; + for (var ii = 0; ii < splitPboTexCube; ++ii) { + pboGroupCube.push(new tcuTestCase.DeqpTest('teximage2d_pbo', 'glTexImage2D() from PBO')); + this.addChild(pboGroupCube[ii]); + } + for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) { + fmtName = colorFormats[formatNdx].name; + format = colorFormats[formatNdx].internalFormat; + tex2DWidth = 65; + tex2DHeight = 37; + texCubeSize = 64; + + pboGroup2D[formatNdx % splitPboTex2D].addChild( + new es3fTextureSpecificationTests.TexImage2DBufferCase( + fmtName + '_2d', '', format, + tex2DWidth, tex2DHeight, 0, 0, 0, 4, 0 + ) + ); + pboGroupCube[formatNdx % splitPboTexCube].addChild( + new es3fTextureSpecificationTests.TexImageCubeBufferCase( + fmtName + '_cube', '', format, + texCubeSize, 0, 0, 0, 4, 0 + ) + ); + } + + // Parameter cases + var pboGroupParams = new tcuTestCase.DeqpTest( + 'teximage2d_pbo', 'glTexImage2D() from PBO' + ); + this.addChild(pboGroupParams); + /** + * @type {Array<{name: string, format: number, width: number, + * height: number, rowLength: number, skipRows: number, + * skipPixels: number, alignment: number, offset: number}>} + */ + var parameterCases = [{ + name: 'rgb8_offset', format: gl.RGB8, width: 31, + height: 30, rowLength: 0, skipRows: 0, skipPixels: 0, + alignment: 4, offset: 67 + }, { + name: 'rgb8_alignment', format: gl.RGB8, width: 31, + height: 30, rowLength: 0, skipRows: 0, skipPixels: 0, + alignment: 2, offset: 0 + }, { + name: 'rgb8_row_length', format: gl.RGB8, width: 31, + height: 30, rowLength: 50, skipRows: 0, skipPixels: 0, + alignment: 4, offset: 0 + }, { + name: 'rgb8_skip_rows', format: gl.RGB8, width: 31, + height: 30, rowLength: 0, skipRows: 3, skipPixels: 0, + alignment: 4, offset: 0 + }, { + name: 'rgb8_skip_pixels', format: gl.RGB8, width: 31, + height: 30, rowLength: 36, skipRows: 0, skipPixels: 5, + alignment: 4, offset: 0 + } + ]; + for (var ndx = 0; ndx < parameterCases.length; ndx++) { + pboGroupParams.addChild( + new es3fTextureSpecificationTests.TexImage2DBufferCase( + parameterCases[ndx].name + '_2d', '', + parameterCases[ndx].format, parameterCases[ndx].width, + parameterCases[ndx].height, parameterCases[ndx].rowLength, + parameterCases[ndx].skipRows, + parameterCases[ndx].skipPixels, + parameterCases[ndx].alignment, + parameterCases[ndx].offset + ) + ); + pboGroupParams.addChild( + new es3fTextureSpecificationTests.TexImageCubeBufferCase( + parameterCases[ndx].name + '_cube', '', + parameterCases[ndx].format, parameterCases[ndx].width, + parameterCases[ndx].rowLength, parameterCases[ndx].skipRows, + parameterCases[ndx].skipPixels, + parameterCases[ndx].alignment, parameterCases[ndx].offset + ) + ); + } + + // glTexImage2D() depth cases. + /** @type {tcuTestCase.DeqpTest} */ + var shadow2dGroup = new tcuTestCase.DeqpTest( + 'teximage2d_depth', + 'glTexImage2D() with depth or depth/stencil format' + ); + this.addChild(shadow2dGroup); + + for (var ndx = 0; ndx < depthStencilFormats.length; ndx++) { + // WebGL 2 specific constraint. + if (depthStencilFormats[ndx].internalFormat == gl.DEPTH32F_STENCIL8) + continue; + var tex2DWidth = 64; + var tex2DHeight = 128; + + shadow2dGroup.addChild( + new es3fTextureSpecificationTests.TexImage2DDepthCase( + depthStencilFormats[ndx].name, '', + depthStencilFormats[ndx].internalFormat, + tex2DWidth, tex2DHeight + ) + ); + } + + // glTexImage2D() depth cases with pbo. + shadow2dGroup = new tcuTestCase.DeqpTest( + 'teximage2d_depth_pbo', + 'glTexImage2D() with depth or depth/stencil format with pbo' + ); + this.addChild(shadow2dGroup); + + for (var ndx = 0; ndx < depthStencilFormats.length; ndx++) { + tex2DWidth = 64; + tex2DHeight = 128; + + shadow2dGroup.addChild( + new es3fTextureSpecificationTests.TexImage2DDepthBufferCase( + depthStencilFormats[ndx].name, '', + depthStencilFormats[ndx].internalFormat, + tex2DWidth, tex2DHeight + ) + ); + } + + // Basic TexSubImage2D usage. + splitBasicTex2D = 3; + splitBasicTexCube = 5; + /** @type {Array<{tcuTestCase.DeqpTest}>} */ + var basicTexSubImageGroup2D = []; + for (var ii = 0; ii < splitBasicTex2D; ++ii) { + basicTexSubImageGroup2D.push( + new tcuTestCase.DeqpTest('basic_texsubimage2d', 'Basic glTexSubImage2D() usage') + ); + this.addChild(basicTexSubImageGroup2D[ii]); + } + /** @type {Array<{tcuTestCase.DeqpTest}>} */ + var basicTexSubImageGroupCube = []; + for (var ii = 0; ii < splitBasicTexCube; ++ii) { + basicTexSubImageGroupCube.push( + new tcuTestCase.DeqpTest('basic_texsubimage2d', 'Basic glTexSubImage2D() usage') + ); + this.addChild(basicTexSubImageGroupCube[ii]); + } + for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) { + fmtName = colorFormats[formatNdx].name; + format = colorFormats[formatNdx].internalFormat; + tex2DWidth = 64; + tex2DHeight = 128; + texCubeSize = 64; + + basicTexSubImageGroup2D[formatNdx % splitBasicTex2D].addChild( + es3fTextureSpecificationTests.newBasicTexSubImage2DCaseInternal( + fmtName + '_2d', '', format, tex2DWidth, tex2DHeight + ) + ); + basicTexSubImageGroupCube[formatNdx % splitBasicTexCube].addChild( + es3fTextureSpecificationTests.newBasicTexImageCubeCaseInternal( + fmtName + '_cube', '', format, texCubeSize + ) + ); + } + + // TexSubImage2D to empty texture. + /** @type {tcuTestCase.DeqpTest} */ + var texSubImageEmptyTexGroup = new tcuTestCase.DeqpTest( + 'texsubimage2d_empty_tex', + 'glTexSubImage2D() to texture that has storage but no data' + ); + this.addChild(texSubImageEmptyTexGroup); + for (var formatNdx = 0; formatNdx < unsizedFormats.length; formatNdx++) { + fmtName = unsizedFormats[formatNdx].name; + format = unsizedFormats[formatNdx].format; + /** @type {number} */ + var dataType = unsizedFormats[formatNdx].dataType; + tex2DWidth = 64; + tex2DHeight = 32; + texCubeSize = 32; + + texSubImageEmptyTexGroup.addChild( + new es3fTextureSpecificationTests.TexSubImage2DEmptyTexCase( + fmtName + '_2d', '', format, dataType, tex2DWidth, tex2DHeight + ) + ); + texSubImageEmptyTexGroup.addChild( + new es3fTextureSpecificationTests.TexSubImageCubeEmptyTexCase( + fmtName + '_cube', '', format, dataType, texCubeSize + ) + ); + } + + // TexSubImage2D alignment cases. + alignGroup = new tcuTestCase.DeqpTest( + 'texsubimage2d_align', 'glTexSubImage2D() unpack alignment tests' + ); + this.addChild(alignGroup); + + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_r8_1_1', '', gl.R8, 64, 64, 13, 17, 1, 6, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_r8_1_2', '', gl.R8, 64, 64, 13, 17, 1, 6, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_r8_1_4', '', gl.R8, 64, 64, 13, 17, 1, 6, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_r8_1_8', '', gl.R8, 64, 64, 13, 17, 1, 6, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_r8_63_1', '', gl.R8, 64, 64, 1, 9, 63, 30, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_r8_63_2', '', gl.R8, 64, 64, 1, 9, 63, 30, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_r8_63_4', '', gl.R8, 64, 64, 1, 9, 63, 30, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_r8_63_8', '', gl.R8, 64, 64, 1, 9, 63, 30, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_rgba4_51_1', '', gl.RGBA4, 64, 64, 7, 29, 51, 30, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_rgba4_51_2', '', gl.RGBA4, 64, 64, 7, 29, 51, 30, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_rgba4_51_4', '', gl.RGBA4, 64, 64, 7, 29, 51, 30, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_rgba4_51_8', '', gl.RGBA4, 64, 64, 7, 29, 51, 30, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_rgb8_39_1', '', gl.RGB8, 64, 64, 11, 8, 39, 43, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_rgb8_39_2', '', gl.RGB8, 64, 64, 11, 8, 39, 43, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_rgb8_39_4', '', gl.RGB8, 64, 64, 11, 8, 39, 43, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_rgb8_39_8', '', gl.RGB8, 64, 64, 11, 8, 39, 43, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_rgba8_47_1', '', gl.RGBA8, 64, 64, 10, 1, 47, 27, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_rgba8_47_2', '', gl.RGBA8, 64, 64, 10, 1, 47, 27, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_rgba8_47_4', '', gl.RGBA8, 64, 64, 10, 1, 47, 27, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal( + '2d_rgba8_47_8', '', gl.RGBA8, 64, 64, 10, 1, 47, 27, 8 + ) + ); + + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_r8_1_1', '', gl.R8, 64, 13, 17, 1, 6, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_r8_1_2', '', gl.R8, 64, 13, 17, 1, 6, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_r8_1_4', '', gl.R8, 64, 13, 17, 1, 6, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_r8_1_8', '', gl.R8, 64, 13, 17, 1, 6, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_r8_63_1', '', gl.R8, 64, 1, 9, 63, 30, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_r8_63_2', '', gl.R8, 64, 1, 9, 63, 30, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_r8_63_4', '', gl.R8, 64, 1, 9, 63, 30, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_r8_63_8', '', gl.R8, 64, 1, 9, 63, 30, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_rgba4_51_1', '', gl.RGBA4, 64, 7, 29, 51, 30, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_rgba4_51_2', '', gl.RGBA4, 64, 7, 29, 51, 30, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_rgba4_51_4', '', gl.RGBA4, 64, 7, 29, 51, 30, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_rgba4_51_8', '', gl.RGBA4, 64, 7, 29, 51, 30, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_rgb8_39_1', '', gl.RGB8, 64, 11, 8, 39, 43, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_rgb8_39_2', '', gl.RGB8, 64, 11, 8, 39, 43, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_rgb8_39_4', '', gl.RGB8, 64, 11, 8, 39, 43, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_rgb8_39_8', '', gl.RGB8, 64, 11, 8, 39, 43, 8 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_rgba8_47_1', '', gl.RGBA8, 64, 10, 1, 47, 27, 1 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_rgba8_47_2', '', gl.RGBA8, 64, 10, 1, 47, 27, 2 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_rgba8_47_4', '', gl.RGBA8, 64, 10, 1, 47, 27, 4 + ) + ); + alignGroup.addChild( + es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal( + 'cube_rgba8_47_8', '', gl.RGBA8, 64, 10, 1, 47, 27, 8 + ) + ); + + // glTexSubImage2D() pixel transfer mode cases. + paramGroup = new tcuTestCase.DeqpTest( + 'texsubimage2d_unpack_params', + 'glTexSubImage2D() pixel transfer mode cases' + ); + this.addChild(paramGroup); + + cases = [{ + name: 'rgb8_alignment', format: gl.RGB8, width: 54, + height: 60, subX: 11, subY: 7, subW: 31, subH: 30, + rowLength: 0, skipRows: 0, skipPixels: 0, alignment: 2 + }, { + name: 'rgb8_row_length', format: gl.RGB8, width: 54, + height: 60, subX: 11, subY: 7, subW: 31, subH: 30, + rowLength: 50, skipRows: 0, skipPixels: 0, alignment: 4 + }, { + name: 'rgb8_skip_rows', format: gl.RGB8, width: 54, + height: 60, subX: 11, subY: 7, subW: 31, subH: 30, + rowLength: 0, skipRows: 3, skipPixels: 0, alignment: 4 + }, { + name: 'rgb8_skip_pixels', format: gl.RGB8, width: 54, + height: 60, subX: 11, subY: 7, subW: 31, subH: 30, + rowLength: 36, skipRows: 0, skipPixels: 5, alignment: 4 + }, { + name: 'r8_complex1', format: gl.R8, width: 54, + height: 60, subX: 11, subY: 7, subW: 31, subH: 30, + rowLength: 64, skipRows: 1, skipPixels: 3, alignment: 1 + }, { + name: 'r8_complex2', format: gl.R8, width: 54, + height: 60, subX: 11, subY: 7, subW: 31, subH: 30, + rowLength: 64, skipRows: 1, skipPixels: 3, alignment: 2 + }, { + name: 'r8_complex3', format: gl.R8, width: 54, + height: 60, subX: 11, subY: 7, subW: 31, subH: 30, + rowLength: 64, skipRows: 1, skipPixels: 3, alignment: 4 + }, { + name: 'r8_complex4', format: gl.R8, width: 54, + height: 60, subX: 11, subY: 7, subW: 31, subH: 30, + rowLength: 64, skipRows: 1, skipPixels: 3, alignment: 8 + }, { + name: 'rgba8_complex1', format: gl.RGBA8, width: 92, + height: 84, subX: 13, subY: 19, subW: 56, subH: 61, + rowLength: 69, skipRows: 0, skipPixels: 0, alignment: 8 + }, { + name: 'rgba8_complex2', format: gl.RGBA8, width: 92, + height: 84, subX: 13, subY: 19, subW: 56, subH: 61, + rowLength: 69, skipRows: 0, skipPixels: 7, alignment: 8 + }, { + name: 'rgba8_complex3', format: gl.RGBA8, width: 92, + height: 84, subX: 13, subY: 19, subW: 56, subH: 61, + rowLength: 69, skipRows: 3, skipPixels: 0, alignment: 8 + }, { + name: 'rgba8_complex4', format: gl.RGBA8, width: 92, + height: 84, subX: 13, subY: 19, subW: 56, subH: 61, + rowLength: 69, skipRows: 3, skipPixels: 7, alignment: 8 + }, { + name: 'rgba32f_complex', format: gl.RGBA32F, width: 92, + height: 84, subX: 13, subY: 19, subW: 56, subH: 61, + rowLength: 69, skipRows: 3, skipPixels: 7, alignment: 8 + } + ]; + + for (var ndx = 0; ndx < cases.length; ndx++) + paramGroup.addChild( + new es3fTextureSpecificationTests.TexSubImage2DParamsCase( + cases[ndx].name, '', cases[ndx].format, cases[ndx].width, + cases[ndx].height, cases[ndx].subX, cases[ndx].subY, + cases[ndx].subW, cases[ndx].subH, cases[ndx].rowLength, + cases[ndx].skipRows, cases[ndx].skipPixels, + cases[ndx].alignment + ) + ); + + // glTexSubImage2D() PBO cases. + splitPboTex2D = 2; + splitPboTexCube = 5; + pboGroup2D = []; + for (var ii = 0; ii < splitPboTex2D; ++ii) { + pboGroup2D.push(new tcuTestCase.DeqpTest( + 'texsubimage2d_pbo', + 'glTexSubImage2D() pixel buffer object tests' + )); + this.addChild(pboGroup2D[ii]); + } + pboGroupCube = []; + for (var ii = 0; ii < splitPboTexCube; ++ii) { + pboGroupCube.push(new tcuTestCase.DeqpTest( + 'texsubimage2d_pbo', + 'glTexSubImage2D() pixel buffer object tests' + )); + this.addChild(pboGroupCube[ii]); + } + + for (var ndx = 0; ndx < colorFormats.length; ndx++) { + pboGroup2D[ndx % splitPboTex2D].addChild( + new es3fTextureSpecificationTests.TexSubImage2DBufferCase( + colorFormats[ndx].name + '_2d', '', + colorFormats[ndx].internalFormat, + 54, // Width + 60, // Height + 11, // Sub X + 7, // Sub Y + 31, // Sub W + 30, // Sub H + 0, // Row len + 0, // Skip rows + 0, // Skip pixels + 4, // Alignment + 0 /* offset */ + ) + ); + pboGroupCube[ndx % splitPboTexCube].addChild( + new es3fTextureSpecificationTests.TexSubImageCubeBufferCase( + colorFormats[ndx].name + '_cube', '', + colorFormats[ndx].internalFormat, + 64, // Size + 11, // Sub X + 7, // Sub Y + 31, // Sub W + 30, // Sub H + 0, // Row len + 0, // Skip rows + 0, // Skip pixels + 4, // Alignment + 0 /* offset */ + ) + ); + } + + pboGroupParams = new tcuTestCase.DeqpTest( + 'texsubimage2d_pbo', + 'glTexSubImage2D() pixel buffer object tests' + ); + this.addChild(pboGroupParams); + /** @type {Array<{name: string, format: number, width: number, + * height: number, subX: number, subY: number, + * subW: number, subH: number, rowLength: number, skipRows: number, + * skipPixels: number, alignment: number, offset: number}>} + */ + var paramCases = [{ + name: 'rgb8_offset', format: gl.RGB8, width: 54, + height: 60, subX: 11, subY: 7, subW: 31, subH: 30, + rowLength: 0, skipRows: 0, skipPixels: 0, + alignment: 4, offset: 67 + }, { + name: 'rgb8_alignment', format: gl.RGB8, width: 54, + height: 60, subX: 11, subY: 7, subW: 31, subH: 30, + rowLength: 0, skipRows: 0, skipPixels: 0, + alignment: 2, offset: 0 + }, { + name: 'rgb8_row_length', format: gl.RGB8, width: 54, + height: 60, subX: 11, subY: 7, subW: 31, subH: 30, + rowLength: 50, skipRows: 0, skipPixels: 0, + alignment: 4, offset: 0 + }, { + name: 'rgb8_skip_rows', format: gl.RGB8, width: 54, + height: 60, subX: 11, subY: 7, subW: 31, subH: 30, + rowLength: 0, skipRows: 3, skipPixels: 0, + alignment: 4, offset: 0 + }, { + name: 'rgb8_skip_pixels', format: gl.RGB8, width: 54, + height: 60, subX: 11, subY: 7, subW: 31, subH: 30, + rowLength: 36, skipRows: 0, skipPixels: 5, + alignment: 4, offset: 0 + } + ]; + + for (var ndx = 0; ndx < paramCases.length; ndx++) { + pboGroupParams.addChild( + new es3fTextureSpecificationTests.TexSubImage2DBufferCase( + paramCases[ndx].name + '_2d', '', + paramCases[ndx].format, + paramCases[ndx].width, + paramCases[ndx].height, + paramCases[ndx].subX, + paramCases[ndx].subY, + paramCases[ndx].subW, + paramCases[ndx].subH, + paramCases[ndx].rowLength, + paramCases[ndx].skipRows, + paramCases[ndx].skipPixels, + paramCases[ndx].alignment, + paramCases[ndx].offset)); + pboGroupParams.addChild( + new es3fTextureSpecificationTests.TexSubImageCubeBufferCase( + paramCases[ndx].name + '_cube', '', + paramCases[ndx].format, + paramCases[ndx].width, + paramCases[ndx].subX, + paramCases[ndx].subY, + paramCases[ndx].subW, + paramCases[ndx].subH, + paramCases[ndx].rowLength, + paramCases[ndx].skipRows, + paramCases[ndx].skipPixels, + paramCases[ndx].alignment, + paramCases[ndx].offset + ) + ); + } + + // glTexSubImage2D() depth cases. + shadow2dGroup = new tcuTestCase.DeqpTest( + 'texsubimage2d_depth', + 'glTexSubImage2D() with depth or depth/stencil format' + ); + this.addChild(shadow2dGroup); + + for (var ndx = 0; ndx < depthStencilFormats.length; ndx++) { + // WebGL 2 specific constraint. + if (depthStencilFormats[ndx].internalFormat == gl.DEPTH32F_STENCIL8) + continue; + tex2DWidth = 64; + tex2DHeight = 32; + + shadow2dGroup.addChild( + new es3fTextureSpecificationTests.TexSubImage2DDepthCase( + depthStencilFormats[ndx].name, '', + depthStencilFormats[ndx].internalFormat, + tex2DWidth, tex2DHeight + ) + ); + } + + // Basic glCopyTexImage2D() cases + /** @type {tcuTestCase.DeqpTest} */ + var copyTexImageGroup = new tcuTestCase.DeqpTest( + 'basic_copyteximage2d', 'Basic glCopyTexImage2D() usage' + ); + this.addChild(copyTexImageGroup); + + copyTexImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexImage2DCase( + '2d_alpha', '', gl.ALPHA, 128, 64 + ) + ); + copyTexImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexImage2DCase( + '2d_luminance', '', gl.LUMINANCE, 128, 64 + ) + ); + copyTexImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexImage2DCase( + '2d_luminance_alpha', '', gl.LUMINANCE_ALPHA, 128, 64 + ) + ); + copyTexImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexImage2DCase( + '2d_rgb', '', gl.RGB, 128, 64 + ) + ); + copyTexImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexImage2DCase( + '2d_rgba', '', gl.RGBA, 128, 64 + ) + ); + + copyTexImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexImageCubeCase( + 'cube_alpha', '', gl.ALPHA, 64 + ) + ); + copyTexImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexImageCubeCase( + 'cube_luminance', '', gl.LUMINANCE, 64 + ) + ); + copyTexImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexImageCubeCase( + 'cube_luminance_alpha', '', gl.LUMINANCE_ALPHA, 64 + ) + ); + copyTexImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexImageCubeCase( + 'cube_rgb', '', gl.RGB, 64 + ) + ); + copyTexImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexImageCubeCase( + 'cube_rgba', '', gl.RGBA, 64 + ) + ); + + // Basic glCopyTexSubImage2D() cases + /** @type {tcuTestCase.DeqpTest} */ + var copyTexSubImageGroup = new tcuTestCase.DeqpTest( + 'basic_copytexsubimage2d', 'Basic glCopyTexSubImage2D() usage' + ); + this.addChild(copyTexSubImageGroup); + + copyTexSubImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase( + '2d_alpha', '', gl.ALPHA, gl.UNSIGNED_BYTE, 128, 64 + ) + ); + copyTexSubImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase( + '2d_luminance', '', gl.LUMINANCE, gl.UNSIGNED_BYTE, 128, 64 + ) + ); + copyTexSubImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase( + '2d_luminance_alpha', '', gl.LUMINANCE_ALPHA, gl.UNSIGNED_BYTE, 128, 64 + ) + ); + copyTexSubImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase( + '2d_rgb', '', gl.RGB, gl.UNSIGNED_BYTE, 128, 64 + ) + ); + copyTexSubImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase( + '2d_rgba', '', gl.RGBA, gl.UNSIGNED_BYTE, 128, 64 + ) + ); + + copyTexSubImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase( + 'cube_alpha', '', gl.ALPHA, gl.UNSIGNED_BYTE, 64 + ) + ); + copyTexSubImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase( + 'cube_luminance', '', gl.LUMINANCE, gl.UNSIGNED_BYTE, 64 + ) + ); + copyTexSubImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase( + 'cube_luminance_alpha', '', gl.LUMINANCE_ALPHA, gl.UNSIGNED_BYTE, 64 + ) + ); + copyTexSubImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase( + 'cube_rgb', '', gl.RGB, gl.UNSIGNED_BYTE, 64 + ) + ); + copyTexSubImageGroup.addChild( + new es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase( + 'cube_rgba', '', gl.RGBA, gl.UNSIGNED_BYTE, 64 + ) + ); + + // Basic TexImage3D usage. + var splitBasicTex2DArray = 3, splitBasicTex3D = 5; + /** @type {Array<{tcuTestCase.DeqpTest}>} */ + var basicTexImageGroup2DArray = []; + for (var ii = 0; ii < splitBasicTex2DArray; ++ii) { + basicTexImageGroup2DArray.push( + new tcuTestCase.DeqpTest('basic_teximage3d', 'Basic glTexImage3D() usage') + ); + this.addChild(basicTexImageGroup2DArray[ii]); + } + /** @type {Array<{tcuTestCase.DeqpTest}>} */ + var basicTexImageGroup3D = []; + for (var ii = 0; ii < splitBasicTex3D; ++ii) { + basicTexImageGroup3D.push( + new tcuTestCase.DeqpTest('basic_teximage3d', 'Basic glTexImage3D() usage') + ); + this.addChild(basicTexImageGroup3D[ii]); + } + for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) { + fmtName = colorFormats[formatNdx].name; + format = colorFormats[formatNdx].internalFormat; + /** @type {number} */ var tex2DArrayWidth = 57; + /** @type {number} */ var tex2DArrayHeight = 44; + /** @type {number} */ var tex2DArrayLevels = 5; + /** @type {number} */ var tex3DWidth = 63; + /** @type {number} */ var tex3DHeight = 29; + /** @type {number} */ var tex3DDepth = 11; + + basicTexImageGroup2DArray[formatNdx % splitBasicTex2DArray].addChild( + new es3fTextureSpecificationTests.BasicTexImage2DArrayCase( + fmtName + '_2d_array', '', format, + tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLevels + ) + ); + basicTexImageGroup3D[formatNdx % splitBasicTex3D].addChild( + new es3fTextureSpecificationTests.BasicTexImage3DCase( + fmtName + '_3d', '', format, + tex3DWidth, tex3DHeight, tex3DDepth + ) + ); + } + + // glTexImage3D() unpack params cases. + paramGroup = new tcuTestCase.DeqpTest( + 'teximage3d_unpack_params', 'glTexImage3D() unpack parameters' + ); + this.addChild(paramGroup); + + cases = [{ + name: 'rgb8_image_height', format: gl.RGB8, width: 23, + height: 19, depth: 8, imageHeight: 26, rowLength: 0, + skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 4 + }, { + name: 'rgb8_row_length', format: gl.RGB8, width: 23, + height: 19, depth: 8, imageHeight: 0, rowLength: 27, + skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 4 + }, { + name: 'rgb8_skip_images', format: gl.RGB8, width: 23, + height: 19, depth: 8, imageHeight: 0, rowLength: 0, + skipImages: 3, skipRows: 0, skipPixels: 0, alignment: 4 + }, { + name: 'rgb8_skip_rows', format: gl.RGB8, width: 23, + height: 19, depth: 8, imageHeight: 22, rowLength: 0, + skipImages: 0, skipRows: 3, skipPixels: 0, alignment: 4 + }, { + name: 'rgb8_skip_pixels', format: gl.RGB8, width: 23, + height: 19, depth: 8, imageHeight: 0, rowLength: 25, + skipImages: 0, skipRows: 0, skipPixels: 2, alignment: 4 + }, { + name: 'r8_complex1', format: gl.R8, width: 13, + height: 17, depth: 11, imageHeight: 23, rowLength: 15, + skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 1 + }, { + name: 'r8_complex2', format: gl.R8, width: 13, + height: 17, depth: 11, imageHeight: 23, rowLength: 15, + skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 2 + }, { + name: 'r8_complex3', format: gl.R8, width: 13, + height: 17, depth: 11, imageHeight: 23, rowLength: 15, + skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 4 + }, { + name: 'r8_complex4', format: gl.R8, width: 13, + height: 17, depth: 11, imageHeight: 23, rowLength: 15, + skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 8 + }, { + name: 'rgba8_complex1', format: gl.RGBA8, width: 11, + height: 20, depth: 8, imageHeight: 25, rowLength: 14, + skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 8 + }, { + name: 'rgba8_complex2', format: gl.RGBA8, width: 11, + height: 20, depth: 8, imageHeight: 25, rowLength: 14, + skipImages: 0, skipRows: 2, skipPixels: 0, alignment: 8 + }, { + name: 'rgba8_complex3', format: gl.RGBA8, width: 11, + height: 20, depth: 8, imageHeight: 25, rowLength: 14, + skipImages: 0, skipRows: 0, skipPixels: 3, alignment: 8 + }, { + name: 'rgba8_complex4', format: gl.RGBA8, width: 11, + height: 20, depth: 8, imageHeight: 25, rowLength: 14, + skipImages: 0, skipRows: 2, skipPixels: 3, alignment: 8 + }, { + name: 'rgba32f_complex', format: gl.RGBA32F, width: 11, + height: 20, depth: 8, imageHeight: 25, rowLength: 14, + skipImages: 0, skipRows: 2, skipPixels: 3, alignment: 8 + } + ]; + + for (var ndx = 0; ndx < cases.length; ndx++) + paramGroup.addChild( + new es3fTextureSpecificationTests.TexImage3DParamsCase( + cases[ndx].name, '', cases[ndx].format, cases[ndx].width, + cases[ndx].height, cases[ndx].depth, cases[ndx].imageHeight, + cases[ndx].rowLength, cases[ndx].skipImages, + cases[ndx].skipRows, cases[ndx].skipPixels, + cases[ndx].alignment + ) + ); + + // glTexImage3D() pbo cases. + var splitTex2DArray = 2, splitTex3D = 2; + /** @type {Array<{tcuTestCase.DeqpTest}>} */ var pboGroup2DArray = []; + for (var ii = 0; ii < splitTex2DArray; ++ii) { + pboGroup2DArray.push( + new tcuTestCase.DeqpTest('teximage3d_pbo', 'glTexImage3D() from PBO') + ); + this.addChild(pboGroup2DArray[ii]); + } + /** @type {Array<{tcuTestCase.DeqpTest}>} */ var pboGroup3D = []; + for (var ii = 0; ii < splitTex3D; ++ii) { + pboGroup3D.push( + new tcuTestCase.DeqpTest('teximage3d_pbo', 'glTexImage3D() from PBO') + ); + this.addChild(pboGroup3D[ii]); + } + + for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) { + fmtName = colorFormats[formatNdx].name; + format = colorFormats[formatNdx].internalFormat; + tex3DWidth = 11; + tex3DHeight = 20; + tex3DDepth = 8; + + pboGroup2DArray[formatNdx % splitTex2DArray].addChild( + new es3fTextureSpecificationTests.TexImage2DArrayBufferCase( + fmtName + '_2d_array', '', format, tex3DWidth, tex3DHeight, + tex3DDepth, 0, 0, 0, 0, 0, 4, 0 + ) + ); + pboGroup3D[formatNdx % splitTex3D].addChild( + new es3fTextureSpecificationTests.TexImage3DBufferCase( + fmtName + '_3d', '', format, tex3DWidth, tex3DHeight, + tex3DDepth, 0, 0, 0, 0, 0, 4, 0 + ) + ); + } + + // Parameter cases + parameterCases = [{ + name: 'rgb8_offset', format: gl.RGB8, width: 23, + height: 19, depth: 8, imageHeight: 0, rowLength: 0, + skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 1, + offset: 67 + }, { + name: 'rgb8_alignment', format: gl.RGB8, width: 23, + height: 19, depth: 8, imageHeight: 0, rowLength: 0, + skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 2, + offset: 0 + }, { + name: 'rgb8_image_height', format: gl.RGB8, width: 23, + height: 19, depth: 8, imageHeight: 26, rowLength: 0, + skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 4, + offset: 0 + }, { + name: 'rgb8_row_length', format: gl.RGB8, width: 23, + height: 19, depth: 8, imageHeight: 0, rowLength: 27, + skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 4, + offset: 0 + }, { + name: 'rgb8_skip_images', format: gl.RGB8, width: 23, + height: 19, depth: 8, imageHeight: 0, rowLength: 0, + skipImages: 3, skipRows: 0, skipPixels: 0, alignment: 4, + offset: 0 + }, { + name: 'rgb8_skip_rows', format: gl.RGB8, width: 23, + height: 19, depth: 8, imageHeight: 22, rowLength: 0, + skipImages: 0, skipRows: 3, skipPixels: 0, alignment: 4, + offset: 0 + }, { + name: 'rgb8_skip_pixels', format: gl.RGB8, width: 23, + height: 19, depth: 8, imageHeight: 0, rowLength: 25, + skipImages: 0, skipRows: 0, skipPixels: 2, alignment: 4, + offset: 0 + } + ]; + + pboGroupParams = new tcuTestCase.DeqpTest('teximage3d_pbo', 'glTexImage3D() from PBO'); + this.addChild(pboGroupParams); + for (var ndx = 0; ndx < parameterCases.length; ndx++) { + pboGroupParams.addChild( + new es3fTextureSpecificationTests.TexImage2DArrayBufferCase( + parameterCases[ndx].name + '_2d_array', '', + parameterCases[ndx].format, parameterCases[ndx].width, + parameterCases[ndx].height, parameterCases[ndx].depth, + parameterCases[ndx].imageHeight, + parameterCases[ndx].rowLength, + parameterCases[ndx].skipImages, + parameterCases[ndx].skipRows, + parameterCases[ndx].skipPixels, + parameterCases[ndx].alignment, parameterCases[ndx].offset + ) + ); + pboGroupParams.addChild( + new es3fTextureSpecificationTests.TexImage3DBufferCase( + parameterCases[ndx].name + '_3d', '', + parameterCases[ndx].format, parameterCases[ndx].width, + parameterCases[ndx].height, parameterCases[ndx].depth, + parameterCases[ndx].imageHeight, + parameterCases[ndx].rowLength, + parameterCases[ndx].skipImages, + parameterCases[ndx].skipRows, + parameterCases[ndx].skipPixels, + parameterCases[ndx].alignment, parameterCases[ndx].offset + ) + ); + } + + // glTexImage3D() depth cases. + /** @type {tcuTestCase.DeqpTest} */ + var shadow3dGroup = new tcuTestCase.DeqpTest( + 'teximage3d_depth', + 'glTexImage3D() with depth or depth/stencil format' + ); + this.addChild(shadow3dGroup); + + for (var ndx = 0; ndx < depthStencilFormats.length; ndx++) { + // WebGL 2 specific constraint. + if (depthStencilFormats[ndx].internalFormat == gl.DEPTH32F_STENCIL8) + continue; + tex3DWidth = 32; + tex3DHeight = 64; + tex3DDepth = 8; + + shadow3dGroup.addChild( + new es3fTextureSpecificationTests.TexImage2DArrayDepthCase( + depthStencilFormats[ndx].name + '_2d_array', '', + depthStencilFormats[ndx].internalFormat, + tex3DWidth, tex3DHeight, tex3DDepth + ) + ); + } + + // glTexImage3D() depth cases with pbo. + shadow3dGroup = new tcuTestCase.DeqpTest( + 'teximage3d_depth_pbo', + 'glTexImage3D() with depth or depth/stencil format with pbo' + ); + this.addChild(shadow3dGroup); + + for (var ndx = 0; ndx < depthStencilFormats.length; ndx++) { + tex3DWidth = 32; + tex3DHeight = 64; + tex3DDepth = 8; + + shadow3dGroup.addChild( + new es3fTextureSpecificationTests.TexImage2DArrayDepthBufferCase( + depthStencilFormats[ndx].name + '_2d_array', '', + depthStencilFormats[ndx].internalFormat, + tex3DWidth, tex3DHeight, tex3DDepth + ) + ); + } + + // Basic TexSubImage3D usage. + splitTex3D = 5; + /** @type {Array<{tcuTestCase.DeqpTest}>} */ var basicTexSubImageGroup = []; + for (var ii = 0; ii < splitTex3D; ++ii) { + basicTexSubImageGroup.push( + new tcuTestCase.DeqpTest('basic_texsubimage3d', 'Basic glTexSubImage3D() usage') + ); + this.addChild(basicTexSubImageGroup[ii]); + } + + for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) { + fmtName = colorFormats[formatNdx].name; + format = colorFormats[formatNdx].internalFormat; + tex3DWidth = 32; + tex3DHeight = 64; + tex3DDepth = 8; + + basicTexSubImageGroup[formatNdx % splitTex3D].addChild( + new es3fTextureSpecificationTests.BasicTexSubImage3DCase( + fmtName + '_3d', '', format, + tex3DWidth, tex3DHeight, tex3DDepth + ) + ); + } + + // glTexSubImage3D() unpack params cases. + paramGroup = new tcuTestCase.DeqpTest( + 'texsubimage3d_unpack_params', 'glTexSubImage3D() unpack parameters' + ); + this.addChild(paramGroup); + + /** @type {Array<{name: string, format: number, width: number, + * height: number, depth: number, subX: number, subY: number, + * subZ: number, subW: number, subH: number, subD: number, + * imageHeight: number, rowLength: number, skipImages: number, + * skipRows: number, skipPixels: number, alignment: number}>} + */ + var casesSubImage3D = [{ + name: 'rgb8_image_height', format: gl.RGB8, width: 26, + height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23, + subH: 19, subD: 8, imageHeight: 26, rowLength: 0, + skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 4 + }, { + name: 'rgb8_row_length', format: gl.RGB8, width: 26, + height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23, + subH: 19, subD: 8, imageHeight: 0, rowLength: 27, + skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 4 + }, { + name: 'rgb8_skip_images', format: gl.RGB8, width: 26, + height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23, + subH: 19, subD: 8, imageHeight: 0, rowLength: 0, + skipImages: 3, skipRows: 0, skipPixels: 0, alignment: 4 + }, { + name: 'rgb8_skip_rows', format: gl.RGB8, width: 26, + height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23, + subH: 19, subD: 8, imageHeight: 22, rowLength: 0, + skipImages: 0, skipRows: 3, skipPixels: 0, alignment: 4 + }, { + name: 'rgb8_skip_pixels', format: gl.RGB8, width: 26, + height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23, + subH: 19, subD: 8, imageHeight: 0, rowLength: 25, + skipImages: 0, skipRows: 0, skipPixels: 2, alignment: 4 + }, { + name: 'r8_complex1', format: gl.R8, width: 15, + height: 20, depth: 11, subX: 1, subY: 1, subZ: 0, subW: 13, + subH: 17, subD: 11, imageHeight: 23, rowLength: 15, + skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 1 + }, { + name: 'r8_complex2', format: gl.R8, width: 15, + height: 20, depth: 11, subX: 1, subY: 1, subZ: 0, subW: 13, + subH: 17, subD: 11, imageHeight: 23, rowLength: 15, + skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 2 + }, { + name: 'r8_complex3', format: gl.R8, width: 15, + height: 20, depth: 11, subX: 1, subY: 1, subZ: 0, subW: 13, + subH: 17, subD: 11, imageHeight: 23, rowLength: 15, + skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 4 + }, { + name: 'r8_complex4', format: gl.R8, width: 15, + height: 20, depth: 11, subX: 1, subY: 1, subZ: 0, subW: 13, + subH: 17, subD: 11, imageHeight: 23, rowLength: 15, + skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 8 + }, { + name: 'rgba8_complex1', format: gl.RGBA8, width: 15, + height: 25, depth: 10, subX: 0, subY: 5, subZ: 1, subW: 11, + subH: 20, subD: 8, imageHeight: 25, rowLength: 14, + skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 8 + }, { + name: 'rgba8_complex2', format: gl.RGBA8, width: 15, + height: 25, depth: 10, subX: 0, subY: 5, subZ: 1, subW: 11, + subH: 20, subD: 8, imageHeight: 25, rowLength: 14, + skipImages: 0, skipRows: 2, skipPixels: 0, alignment: 8 + }, { + name: 'rgba8_complex3', format: gl.RGBA8, width: 15, + height: 25, depth: 10, subX: 0, subY: 5, subZ: 1, subW: 11, + subH: 20, subD: 8, imageHeight: 25, rowLength: 14, + skipImages: 0, skipRows: 0, skipPixels: 3, alignment: 8 + }, { + name: 'rgba8_complex4', format: gl.RGBA8, width: 15, + height: 25, depth: 10, subX: 0, subY: 5, subZ: 1, subW: 11, + subH: 20, subD: 8, imageHeight: 25, rowLength: 14, + skipImages: 0, skipRows: 2, skipPixels: 3, alignment: 8 + }, { + name: 'rgba32f_complex', format: gl.RGBA32F, width: 15, + height: 25, depth: 10, subX: 0, subY: 5, subZ: 1, subW: 11, + subH: 20, subD: 8, imageHeight: 25, rowLength: 14, + skipImages: 0, skipRows: 2, skipPixels: 3, alignment: 8 + } + ]; + + for (var ndx = 0; ndx < casesSubImage3D.length; ndx++) + paramGroup.addChild( + new es3fTextureSpecificationTests.TexSubImage3DParamsCase( + casesSubImage3D[ndx].name, '', casesSubImage3D[ndx].format, + casesSubImage3D[ndx].width, casesSubImage3D[ndx].height, casesSubImage3D[ndx].depth, + casesSubImage3D[ndx].subX, casesSubImage3D[ndx].subY, casesSubImage3D[ndx].subZ, + casesSubImage3D[ndx].subW, casesSubImage3D[ndx].subH, casesSubImage3D[ndx].subD, + casesSubImage3D[ndx].imageHeight, casesSubImage3D[ndx].rowLength, + casesSubImage3D[ndx].skipImages, casesSubImage3D[ndx].skipRows, + casesSubImage3D[ndx].skipPixels, casesSubImage3D[ndx].alignment + ) + ); + + // glTexSubImage3D() PBO cases. + splitTex2DArray = 2; + pboGroup2DArray = []; + for (var ii = 0; ii < splitTex2DArray; ++ii) { + pboGroup2DArray.push( + new tcuTestCase.DeqpTest('texsubimage3d_pbo', 'glTexSubImage3D() pixel buffer object tests') + ); + this.addChild(pboGroup2DArray[ii]); + } + + splitTex3D = 2; + pboGroup3D = []; + for (var ii = 0; ii < splitTex3D; ++ii) { + pboGroup3D.push( + new tcuTestCase.DeqpTest('texsubimage3d_pbo', 'glTexSubImage3D() pixel buffer object tests') + ); + this.addChild(pboGroup3D[ii]); + } + + for (var ndx = 0; ndx < colorFormats.length; ndx++) { + pboGroup2DArray[ndx % splitTex2DArray].addChild( + new es3fTextureSpecificationTests.TexSubImage2DArrayBufferCase( + colorFormats[ndx].name + '_2d_array', '', + colorFormats[ndx].internalFormat, + 26, // Width + 25, // Height + 10, // Depth + 1, // Sub X + 2, // Sub Y + 0, // Sub Z + 23, // Sub W + 19, // Sub H + 8, // Sub D + 0, // Image height + 0, // Row length + 0, // Skip images + 0, // Skip rows + 0, // Skip pixels + 4, // Alignment + 0 // offset + ) + ); + pboGroup3D[ndx % splitTex3D].addChild( + new es3fTextureSpecificationTests.TexSubImage3DBufferCase( + colorFormats[ndx].name + '_3d', '', + colorFormats[ndx].internalFormat, + 26, // Width + 25, // Height + 10, // Depth + 1, // Sub X + 2, // Sub Y + 0, // Sub Z + 23, // Sub W + 19, // Sub H + 8, // Sub D + 0, // Image height + 0, // Row length + 0, // Skip images + 0, // Skip rows + 0, // Skip pixels + 4, // Alignment + 0 // offset + ) + ); + } + + paramCases = [{ + name: 'rgb8_offset', format: gl.RGB8, width: 26, + height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23, + subH: 19, subD: 8, imageHeight: 0, rowLength: 0, skipImages: 0, + skipRows: 0, skipPixels: 0, alignment: 4, offset: 67 + }, { + name: 'rgb8_image_height', format: gl.RGB8, width: 26, + height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23, + subH: 19, subD: 8, imageHeight: 26, rowLength: 0, skipImages: 0, + skipRows: 0, skipPixels: 0, alignment: 4, offset: 0 + }, { + name: 'rgb8_row_length', format: gl.RGB8, width: 26, + height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23, + subH: 19, subD: 8, imageHeight: 0, rowLength: 27, skipImages: 0, + skipRows: 0, skipPixels: 0, alignment: 4, offset: 0 + }, { + name: 'rgb8_skip_images', format: gl.RGB8, width: 26, + height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23, + subH: 19, subD: 8, imageHeight: 0, rowLength: 0, skipImages: 3, + skipRows: 0, skipPixels: 0, alignment: 4, offset: 0 + }, { + name: 'rgb8_skip_rows', format: gl.RGB8, width: 26, + height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23, + subH: 19, subD: 8, imageHeight: 22, rowLength: 0, skipImages: 0, + skipRows: 3, skipPixels: 0, alignment: 4, offset: 0 + }, { + name: 'rgb8_skip_pixels', format: gl.RGB8, width: 26, + height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23, + subH: 19, subD: 8, imageHeight: 0, rowLength: 25, skipImages: 0, + skipRows: 0, skipPixels: 2, alignment: 4, offset: 0 + } + ]; + + pboGroupParams = new tcuTestCase.DeqpTest( + 'texsubimage3d_pbo', 'glTexSubImage3D() pixel buffer object tests' + ); + this.addChild(pboGroupParams); + + for (var ndx = 0; ndx < paramCases.length; ndx++) { + pboGroupParams.addChild( + new es3fTextureSpecificationTests.TexSubImage2DArrayBufferCase( + paramCases[ndx].name + '_2d_array', '', + paramCases[ndx].format, paramCases[ndx].width, + paramCases[ndx].height, paramCases[ndx].depth, + paramCases[ndx].subX, paramCases[ndx].subY, + paramCases[ndx].subZ, paramCases[ndx].subW, + paramCases[ndx].subH, paramCases[ndx].subD, + paramCases[ndx].imageHeight, paramCases[ndx].rowLength, + paramCases[ndx].skipImages, paramCases[ndx].skipRows, + paramCases[ndx].skipPixels, paramCases[ndx].alignment, + paramCases[ndx].offset + ) + ); + pboGroupParams.addChild( + new es3fTextureSpecificationTests.TexSubImage3DBufferCase( + paramCases[ndx].name + '_3d', '', + paramCases[ndx].format, paramCases[ndx].width, + paramCases[ndx].height, paramCases[ndx].depth, + paramCases[ndx].subX, paramCases[ndx].subY, + paramCases[ndx].subZ, paramCases[ndx].subW, + paramCases[ndx].subH, paramCases[ndx].subD, + paramCases[ndx].imageHeight, paramCases[ndx].rowLength, + paramCases[ndx].skipImages, paramCases[ndx].skipRows, + paramCases[ndx].skipPixels, paramCases[ndx].alignment, + paramCases[ndx].offset + ) + ); + } + + // glTexSubImage3D() depth cases. + shadow3dGroup = new tcuTestCase.DeqpTest( + 'texsubimage3d_depth', + 'glTexSubImage3D() with depth or depth/stencil format' + ); + this.addChild(shadow3dGroup); + + for (var ndx = 0; ndx < depthStencilFormats.length; ndx++) { + // WebGL 2 specific constraint. + if (depthStencilFormats[ndx].internalFormat == gl.DEPTH32F_STENCIL8) + continue; + tex2DArrayWidth = 57; + tex2DArrayHeight = 44; + tex2DArrayLevels = 5; + + shadow3dGroup.addChild( + new es3fTextureSpecificationTests.TexSubImage2DArrayDepthCase( + depthStencilFormats[ndx].name + '_2d_array', '', + depthStencilFormats[ndx].internalFormat, tex2DArrayWidth, + tex2DArrayHeight, tex2DArrayLevels + ) + ); + } + + // glTexStorage2D() cases. + + // Color formats + var splitStorage2D = 3, splitStorageCube = 5; + /** @type {Array<{tcuTestCase.DeqpTest}>} */ var colorFormatGroup2D = []; + for (var ii = 0; ii < splitStorage2D; ++ii) { + colorFormatGroup2D.push( + new tcuTestCase.DeqpTest('texstorage2d.format', 'glTexStorage2D() with all formats') + ); + this.addChild(colorFormatGroup2D[ii]); + } + /** @type {Array<{tcuTestCase.DeqpTest}>} */ var colorFormatGroupCube = []; + for (var ii = 0; ii < splitStorageCube; ++ii) { + colorFormatGroupCube.push( + new tcuTestCase.DeqpTest('texstorage2d.format', 'glTexStorage2D() with all formats') + ); + this.addChild(colorFormatGroupCube[ii]); + } + + for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) { + fmtName = colorFormats[formatNdx].name; + /** @type {number} */ var internalFormat = colorFormats[formatNdx].internalFormat; + var tex2DWidth = 117; + var tex2DHeight = 97; + var tex2DLevels = es3fTextureSpecificationTests.maxLevelCount(tex2DWidth, tex2DHeight); + /** @type {number} */ var cubeSize = 57; + /** @type {number} */ + var cubeLevels = es3fTextureSpecificationTests.maxLevelCount( + cubeSize, cubeSize + ); + + colorFormatGroup2D[formatNdx % splitStorage2D].addChild( + new es3fTextureSpecificationTests.BasicTexStorage2DCase( + fmtName + '_2d', '', internalFormat, + tex2DWidth, tex2DHeight, tex2DLevels + ) + ); + colorFormatGroupCube[formatNdx % splitStorageCube].addChild( + new es3fTextureSpecificationTests.BasicTexStorageCubeCase( + fmtName + '_cube', '', internalFormat, cubeSize, cubeLevels + ) + ); + } + + // Depth / stencil formats. + /** @type {tcuTestCase.DeqpTest} */ + var storageGroup = new tcuTestCase.DeqpTest( + 'texstorage2d.format', + 'glTexStorage2D() with all formats' + ); + this.addChild(storageGroup); + + for (var formatNdx = 0; formatNdx < depthStencilFormats.length; formatNdx++) { + fmtName = depthStencilFormats[formatNdx].name; + internalFormat = depthStencilFormats[formatNdx].internalFormat; + // WebGL 2 specific constraint. + if (internalFormat == gl.DEPTH32F_STENCIL8) + continue; + + tex2DWidth = 117; + tex2DHeight = 97; + tex2DLevels = es3fTextureSpecificationTests.maxLevelCount( + tex2DWidth, tex2DHeight + ); + cubeSize = 57; + cubeLevels = es3fTextureSpecificationTests.maxLevelCount( + cubeSize, cubeSize + ); + + storageGroup.addChild( + new es3fTextureSpecificationTests.BasicTexStorage2DCase( + fmtName + '_2d', '', internalFormat, + tex2DWidth, tex2DHeight, tex2DLevels + ) + ); + storageGroup.addChild( + new es3fTextureSpecificationTests.BasicTexStorageCubeCase( + fmtName + '_cube', '', internalFormat, cubeSize, cubeLevels + ) + ); + } + + // Sizes. + storageGroup = new tcuTestCase.DeqpTest( + 'texstorage2d.size', + 'glTexStorage2D() with various sizes' + ); + this.addChild(storageGroup); + + // W H L + /** @type {Array<{width: number, height: number, levels: number}>} */ + var tex2DSizes = [{ + width: 1, height: 1, levels: 1 + }, { + width: 2, height: 2, levels: 2 + }, { + width: 64, height: 32, levels: 7 + }, { + width: 32, height: 64, levels: 4 + }, { + width: 57, height: 63, levels: 1 + }, { + width: 57, height: 63, levels: 2 + }, { + width: 57, height: 63, levels: 6 + } + ]; + + // S L + /** @type {Array<{sizes: number, levels: number}>} */ + var cubeSizes = [{ + sizes: 1, levels: 1 + }, { + sizes: 2, levels: 2 + }, { + sizes: 57, levels: 1 + }, { + sizes: 57, levels: 2 + }, { + sizes: 57, levels: 6 + }, { + sizes: 64, levels: 4 + }, { + sizes: 64, levels: 7 + } + ]; + + for (var ndx = 0; ndx < tex2DSizes.length; ndx++) { + format = gl.RGBA8; + /** @type {number} */ var width = tex2DSizes[ndx].width; + /** @type {number} */ var height = tex2DSizes[ndx].height; + /** @type {number} */ var levels = tex2DSizes[ndx].levels; + /** @type {string} */ + var name = '2d_' + width + 'x' + height + '_' + levels + '_levels'; + + storageGroup.addChild( + new es3fTextureSpecificationTests.BasicTexStorage2DCase( + name, '', format, width, height, levels + ) + ); + } + + for (var ndx = 0; ndx < cubeSizes.length; ndx++) { + format = gl.RGBA8; + size = cubeSizes[ndx].sizes; + levels = cubeSizes[ndx].levels; + name = 'cube_' + size + 'x' + size + '_' + levels + '_levels'; + + storageGroup.addChild( + new es3fTextureSpecificationTests.BasicTexStorageCubeCase( + name, '', format, size, levels + ) + ); + } + + // glTexStorage3D() cases. + + // Color formats. + var splitStorage2DArray = 3, splitStorage3D = 4; + /** @type {Array<{tcuTestCase.DeqpTest}>} */ var colorFormatGroup2DArray = []; + for (var ii = 0; ii < splitStorage2DArray; ++ii) { + colorFormatGroup2DArray.push( + new tcuTestCase.DeqpTest('texstorage3d.format', 'glTexStorage3D() with all formats') + ); + this.addChild(colorFormatGroup2DArray[ii]); + } + /** @type {Array<{tcuTestCase.DeqpTest}>} */ var colorFormatGroup3D = []; + for (var ii = 0; ii < splitStorage3D; ++ii) { + colorFormatGroup3D.push( + new tcuTestCase.DeqpTest('texstorage3d.format', 'glTexStorage3D() with all formats') + ); + this.addChild(colorFormatGroup3D[ii]); + } + + // Color formats. + for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) { + fmtName = colorFormats[formatNdx].name; + internalFormat = colorFormats[formatNdx].internalFormat; + tex2DArrayWidth = 57; + tex2DArrayHeight = 13; + var tex2DArrayLayers = 7; + tex2DArrayLevels = es3fTextureSpecificationTests.maxLevelCount( + tex2DArrayWidth, tex2DArrayHeight + ); + tex3DWidth = 59; + tex3DHeight = 37; + tex3DDepth = 11; + var tex3DLevels = es3fTextureSpecificationTests.maxLevelCount( + tex3DWidth, tex3DHeight, tex3DDepth + ); + + colorFormatGroup2DArray[formatNdx % splitStorage2DArray].addChild( + new es3fTextureSpecificationTests.BasicTexStorage2DArrayCase( + fmtName + '_2d_array', '', internalFormat, tex2DArrayWidth, + tex2DArrayHeight, tex2DArrayLayers, tex2DArrayLevels + ) + ); + colorFormatGroup3D[formatNdx % splitStorage3D].addChild( + new es3fTextureSpecificationTests.BasicTexStorage3DCase( + fmtName + '_3d', '', internalFormat, tex3DWidth, + tex3DHeight, tex3DDepth, tex3DLevels + ) + ); + } + + storageGroup = new tcuTestCase.DeqpTest( + 'texstorage3d.format', + 'glTexStorage3D() with all formats' + ); + this.addChild(storageGroup); + + // Depth/stencil formats (only 2D texture array is supported). + for (var formatNdx = 0; + formatNdx < depthStencilFormats.length; + formatNdx++) { + fmtName = depthStencilFormats[formatNdx].name; + internalFormat = depthStencilFormats[formatNdx].internalFormat; + // WebGL 2 specific constraint. + if (internalFormat == gl.DEPTH32F_STENCIL8) + continue; + + tex2DArrayWidth = 57; + tex2DArrayHeight = 13; + tex2DArrayLayers = 7; + tex2DArrayLevels = es3fTextureSpecificationTests.maxLevelCount( + tex2DArrayWidth, tex2DArrayHeight + ); + + storageGroup.addChild( + new es3fTextureSpecificationTests.BasicTexStorage2DArrayCase( + fmtName + '_2d_array', '', internalFormat, tex2DArrayWidth, + tex2DArrayHeight, tex2DArrayLayers, tex2DArrayLevels + ) + ); + } + + // Sizes. + // W H La Le + /** + * @type {Array<{width: number, height: number, + * layers: number, levels: number}>} + */ + var tex2DArraySizes = [{ + width: 1, height: 1, layers: 1, levels: 1 + }, { + width: 2, height: 2, layers: 2, levels: 2 + }, { + width: 64, height: 32, layers: 3, levels: 7 + }, { + width: 32, height: 64, layers: 3, levels: 4 + }, { + width: 57, height: 63, layers: 5, levels: 1 + }, { + width: 57, height: 63, layers: 5, levels: 2 + }, { + width: 57, height: 63, layers: 5, levels: 6 + } + ]; + + // W H D L + /** + * @type {Array<{width: number, height: number, + * depth: number, levels: number}>} + */ + var tex3DSizes = [{ + width: 1, height: 1, depth: 1, levels: 1 + }, { + width: 2, height: 2, depth: 2, levels: 2 + }, { + width: 64, height: 32, depth: 16, levels: 7 + }, { + width: 32, height: 64, depth: 16, levels: 4 + }, { + width: 32, height: 16, depth: 64, levels: 4 + }, { + width: 57, height: 63, depth: 11, levels: 1 + }, { + width: 57, height: 63, depth: 11, levels: 2 + }, { + width: 57, height: 63, depth: 11, levels: 6 + } + ]; + + storageGroup = new tcuTestCase.DeqpTest( + 'texstorage3d.size', 'glTexStorage3D() with various sizes' + ); + this.addChild(storageGroup); + + for (var ndx = 0; ndx < tex2DArraySizes.length; ndx++) { + format = gl.RGBA8; + width = tex2DArraySizes[ndx].width; + height = tex2DArraySizes[ndx].height; + /** @type {number} */ var layers = tex2DArraySizes[ndx].layers; + levels = tex2DArraySizes[ndx].levels; + name = '2d_array_' + width + 'x' + height + 'x' + + layers + '_' + levels + '_levels'; + + storageGroup.addChild( + new es3fTextureSpecificationTests.BasicTexStorage2DArrayCase( + name, '', format, width, height, layers, levels + ) + ); + } + + for (var ndx = 0; ndx < tex3DSizes.length; ndx++) { + format = gl.RGBA8; + width = tex3DSizes[ndx].width; + height = tex3DSizes[ndx].height; + var depth = tex3DSizes[ndx].depth; + levels = tex3DSizes[ndx].levels; + name = '3d_' + width + 'x' + height + 'x' + + depth + '_' + levels + '_levels'; + + storageGroup.addChild( + new es3fTextureSpecificationTests.BasicTexStorage3DCase( + name, '', format, width, height, depth, levels + ) + ); + } + }; + + /** + * Run test + * @param {WebGL2RenderingContext} context + * @param {Array<number>=} range Test range + */ + es3fTextureSpecificationTests.run = function(context, range) { + gl = context; + //Set up Test Root parameters + var state = tcuTestCase.runner; + state.setRoot(new es3fTextureSpecificationTests.TextureSpecificationTests()); + if (range) + state.setRange(range); + + //Set up name and description of this test series. + setCurrentTestName(state.testCases.fullName()); + description(state.testCases.getDescription()); + + try { + //Run test cases + tcuTestCase.runTestCases(); + } + catch (err) { + testFailedOptions('Failed to es3fTextureSpecificationTests.run tests', false); + tcuTestCase.runner.terminate(); + } + }; + +}); |