Source code
Revision control
Copy as Markdown
Other Tools
/*-------------------------------------------------------------------------
* 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
*
*
* 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();
}
};
});