diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
commit | 36d22d82aa202bb199967e9512281e9a53db42c9 (patch) | |
tree | 105e8c98ddea1c1e4784a60a5a6410fa416be2de /dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureFormatTests.js | |
parent | Initial commit. (diff) | |
download | firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip |
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureFormatTests.js')
-rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureFormatTests.js | 1185 |
1 files changed, 1185 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureFormatTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureFormatTests.js new file mode 100644 index 0000000000..7300225a8d --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureFormatTests.js @@ -0,0 +1,1185 @@ +/*------------------------------------------------------------------------- + * drawElements Quality Program OpenGL ES Utilities + * ------------------------------------------------ + * + * Copyright 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +'use strict'; +goog.provide('functional.gles3.es3fTextureFormatTests'); +goog.require('framework.common.tcuCompressedTexture'); +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.opengl.gluShaderUtil'); +goog.require('framework.opengl.gluStrUtil'); +goog.require('framework.opengl.gluTexture'); +goog.require('framework.opengl.gluTextureUtil'); +goog.require('modules.shared.glsTextureTestUtil'); + +goog.scope(function() { + +var es3fTextureFormatTests = functional.gles3.es3fTextureFormatTests; +var gluShaderUtil = framework.opengl.gluShaderUtil; +var deRandom = framework.delibs.debase.deRandom; +var tcuTestCase = framework.common.tcuTestCase; +var tcuSurface = framework.common.tcuSurface; +var gluTexture = framework.opengl.gluTexture; +var gluTextureUtil = framework.opengl.gluTextureUtil; +var tcuTexture = framework.common.tcuTexture; +var glsTextureTestUtil = modules.shared.glsTextureTestUtil; +var tcuTextureUtil = framework.common.tcuTextureUtil; +var gluStrUtil = framework.opengl.gluStrUtil; +var deMath = framework.delibs.debase.deMath; +var tcuCompressedTexture = framework.common.tcuCompressedTexture; + +/** @type {WebGL2RenderingContext} */ var gl; + +var DE_ASSERT = function(x) { + if (!x) + throw new Error('Assert failed'); +}; + +es3fTextureFormatTests.version = '300 es'; + +es3fTextureFormatTests.testDescription = function() { + var test = tcuTestCase.runner.currentTest; + return test.description; +}; + +es3fTextureFormatTests.setParentClass = function(child, parent) { + child.prototype = Object.create(parent.prototype); + child.prototype.constructor = child; +}; + +/** + * @constructor + * @extends {tcuTestCase.DeqpTest} + */ +es3fTextureFormatTests.Texture2DFormatCase = function(descriptor) { + tcuTestCase.DeqpTest.call(this, descriptor.name, descriptor.description); + this.m_format = descriptor.format; + this.m_dataType = descriptor.dataType; + this.m_width = descriptor.width; + this.m_height = descriptor.height; + this.m_renderer = new glsTextureTestUtil.TextureRenderer(es3fTextureFormatTests.version, gluShaderUtil.precision.PRECISION_HIGHP); +}; + +es3fTextureFormatTests.setParentClass(es3fTextureFormatTests.Texture2DFormatCase, tcuTestCase.DeqpTest); + +es3fTextureFormatTests.Texture2DFormatCase.prototype.init = function() { + /*tcu::TextureFormat*/ var fmt = this.m_dataType ? gluTextureUtil.mapGLTransferFormat(this.m_format, this.m_dataType) : gluTextureUtil.mapGLInternalFormat(this.m_format); + /*tcu::TextureFormatInfo*/ var spec = tcuTextureUtil.getTextureFormatInfo(fmt); + /* TODO : Port + + std::ostringstream fmtName; + + if (m_dataType) + fmtName << glu::getPixelFormatStr(m_format) << ", " << glu::getTypeStr(m_dataType); + else + fmtName << glu::getPixelFormatStr(m_format); + + log << TestLog::Message << "2D texture, " << fmtName.str() << ", " << m_width << "x" << m_height + << ",\n fill with " << formatGradient(&spec.valueMin, &spec.valueMax) << " gradient" + << TestLog::EndMessage; + */ + + this.m_texture = this.m_dataType ? + gluTexture.texture2DFromFormat(gl, this.m_format, this.m_dataType, this.m_width, this.m_height) : // Implicit internal format. + gluTexture.texture2DFromInternalFormat(gl, this.m_format, this.m_width, this.m_height); // Explicit internal format. + + // Fill level 0. + this.m_texture.getRefTexture().allocLevel(0); + tcuTextureUtil.fillWithComponentGradients(this.m_texture.getRefTexture().getLevel(0), spec.valueMin, spec.valueMax); +}; + +es3fTextureFormatTests.Texture2DFormatCase.prototype.deinit = function() { + /* TODO: Implement */ +}; + +es3fTextureFormatTests.Texture2DFormatCase.prototype.iterate = function() { + /* TODO: Implement */ + + var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), this.m_width, this.m_height/*, deStringHash(getName())*/); + + /* tcu::Surface */ var renderedFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /* tcu::Surface */ var referenceFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /* TODO: Implement + // tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); + */ + var threshold = [3, 3, 3, 3]; + var renderParams = new glsTextureTestUtil.ReferenceParams(glsTextureTestUtil.textureType.TEXTURETYPE_2D); + + /* tcu::TextureFormatInfo*/ var spec = tcuTextureUtil.getTextureFormatInfo(this.m_texture.getRefTexture().getFormat()); + /** @const */ var wrapS = gl.CLAMP_TO_EDGE; + /** @const */ var wrapT = gl.CLAMP_TO_EDGE; + /** @const */ var minFilter = gl.NEAREST; + /** @const */ var magFilter = gl.NEAREST; + + renderParams.flags.log_programs = true; + renderParams.flags.log_uniforms = true; + + renderParams.samplerType = glsTextureTestUtil.getSamplerType(this.m_texture.getRefTexture().getFormat()); + renderParams.sampler = new tcuTexture.Sampler(tcuTexture.WrapMode.CLAMP_TO_EDGE, tcuTexture.WrapMode.CLAMP_TO_EDGE, tcuTexture.WrapMode.CLAMP_TO_EDGE, + tcuTexture.FilterMode.NEAREST, tcuTexture.FilterMode.NEAREST); + renderParams.colorScale = spec.lookupScale; + renderParams.colorBias = spec.lookupBias; + + var texCoord = glsTextureTestUtil.computeQuadTexCoord2D([0, 0], [1, 1]); + + // log << TestLog::Message << "Texture parameters:" + // << "\n WRAP_S = " << glu::getTextureParameterValueStr(gl.TEXTURE_WRAP_S, wrapS) + // << "\n WRAP_T = " << glu::getTextureParameterValueStr(gl.TEXTURE_WRAP_T, wrapT) + // << "\n MIN_FILTER = " << glu::getTextureParameterValueStr(gl.TEXTURE_MIN_FILTER, minFilter) + // << "\n MAG_FILTER = " << glu::getTextureParameterValueStr(gl.TEXTURE_MAG_FILTER, magFilter) + // << TestLog::EndMessage; + + // Setup base viewport. + gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); + + // Upload texture data to GL. + this.m_texture.upload(); + + // Bind to unit 0. + gl.activeTexture(gl.TEXTURE0); + gl.bindTexture(gl.TEXTURE_2D, this.m_texture.getGLTexture()); + + // Setup nearest neighbor filtering and clamp-to-edge. + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrapS); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrapT); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, minFilter); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, magFilter); + + // // Draw. + this.m_renderer.renderQuad(0, texCoord, renderParams); + renderedFrame.readViewport(gl, viewport); + + // // Compute reference. + glsTextureTestUtil.sampleTexture2D(new glsTextureTestUtil.SurfaceAccess(referenceFrame, undefined /*m_renderCtx.getRenderTarget().getPixelFormat()*/), + this.m_texture.getRefTexture(), texCoord, renderParams); + + // Compare and log. + var isOk = glsTextureTestUtil.compareImages(referenceFrame, renderedFrame, threshold); + + assertMsgOptions(isOk, es3fTextureFormatTests.testDescription(), true, false); + return tcuTestCase.IterateResult.STOP; +}; + +/** + * @constructor + * @extends {tcuTestCase.DeqpTest} + */ +es3fTextureFormatTests.TextureCubeFormatCase = function(descriptor) { + tcuTestCase.DeqpTest.call(this, descriptor.name, descriptor.description); + this.m_format = descriptor.format; + this.m_dataType = descriptor.dataType; + this.m_width = descriptor.width; + this.m_height = descriptor.height; + this.m_renderer = new glsTextureTestUtil.TextureRenderer(es3fTextureFormatTests.version, gluShaderUtil.precision.PRECISION_HIGHP); + DE_ASSERT(this.m_width == this.m_height); +}; + +es3fTextureFormatTests.setParentClass(es3fTextureFormatTests.TextureCubeFormatCase, tcuTestCase.DeqpTest); + +es3fTextureFormatTests.TextureCubeFormatCase.prototype.init = function() { + /*tcu::TextureFormat*/ var fmt = this.m_dataType ? gluTextureUtil.mapGLTransferFormat(this.m_format, this.m_dataType) : gluTextureUtil.mapGLInternalFormat(this.m_format); + /*tcu::TextureFormatInfo*/ var spec = tcuTextureUtil.getTextureFormatInfo(fmt); + /* TODO : Port + + std::ostringstream fmtName; + + if (m_dataType) + fmtName << glu::getPixelFormatStr(m_format) << ", " << glu::getTypeStr(m_dataType); + else + fmtName << glu::getPixelFormatStr(m_format); + + log << TestLog::Message << "2D texture, " << fmtName.str() << ", " << m_width << "x" << m_height + << ",\n fill with " << formatGradient(&spec.valueMin, &spec.valueMax) << " gradient" + << TestLog::EndMessage; + */ + + this.m_texture = this.m_dataType ? + gluTexture.cubeFromFormat(gl, this.m_format, this.m_dataType, this.m_width) : // Implicit internal format. + gluTexture.cubeFromInternalFormat(gl, this.m_format, this.m_width); // Explicit internal format. + + // Fill level 0. + for (var face in tcuTexture.CubeFace) { + var gMin = null; + var gMax = null; + + switch (tcuTexture.CubeFace[face]) { + case 0: gMin = deMath.swizzle(spec.valueMin, [0, 1, 2, 3]); gMax = deMath.swizzle(spec.valueMax, [0, 1, 2, 3]); break; + case 1: gMin = deMath.swizzle(spec.valueMin, [2, 1, 0, 3]); gMax = deMath.swizzle(spec.valueMax, [2, 1, 0, 3]); break; + case 2: gMin = deMath.swizzle(spec.valueMin, [1, 2, 0, 3]); gMax = deMath.swizzle(spec.valueMax, [1, 2, 0, 3]); break; + case 3: gMin = deMath.swizzle(spec.valueMax, [0, 1, 2, 3]); gMax = deMath.swizzle(spec.valueMin, [0, 1, 2, 3]); break; + case 4: gMin = deMath.swizzle(spec.valueMax, [2, 1, 0, 3]); gMax = deMath.swizzle(spec.valueMin, [2, 1, 0, 3]); break; + case 5: gMin = deMath.swizzle(spec.valueMax, [1, 2, 0, 3]); gMax = deMath.swizzle(spec.valueMin, [1, 2, 0, 3]); break; + default: + DE_ASSERT(false); + } + + this.m_texture.getRefTexture().allocLevel(tcuTexture.CubeFace[face], 0); + tcuTextureUtil.fillWithComponentGradients(this.m_texture.getRefTexture().getLevelFace(0, tcuTexture.CubeFace[face]), gMin, gMax); + } + + this.m_texture.upload(); + this.m_curFace = 0; + this.m_isOk = true; +}; + +es3fTextureFormatTests.TextureCubeFormatCase.prototype.testFace = function(face) { + /* TODO: Implement */ + + var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), this.m_width, this.m_height/*, deStringHash(getName())*/); + + /* tcu::Surface */ var renderedFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /* tcu::Surface */ var referenceFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /* TODO: Implement + // tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); + */ + var threshold = [3, 3, 3, 3]; + var renderParams = new glsTextureTestUtil.ReferenceParams(glsTextureTestUtil.textureType.TEXTURETYPE_CUBE); + + /* tcu::TextureFormatInfo*/ var spec = tcuTextureUtil.getTextureFormatInfo(this.m_texture.getRefTexture().getFormat()); + /** @const */ var wrapS = gl.CLAMP_TO_EDGE; + /** @const */ var wrapT = gl.CLAMP_TO_EDGE; + /** @const */ var minFilter = gl.NEAREST; + /** @const */ var magFilter = gl.NEAREST; + + renderParams.flags.log_programs = true; + renderParams.flags.log_uniforms = true; + + renderParams.samplerType = glsTextureTestUtil.getSamplerType(this.m_texture.getRefTexture().getFormat()); + renderParams.sampler = new tcuTexture.Sampler(tcuTexture.WrapMode.CLAMP_TO_EDGE, tcuTexture.WrapMode.CLAMP_TO_EDGE, tcuTexture.WrapMode.CLAMP_TO_EDGE, + tcuTexture.FilterMode.NEAREST, tcuTexture.FilterMode.NEAREST); + renderParams.colorScale = spec.lookupScale; + renderParams.colorBias = spec.lookupBias; + + // Log render info on first face. + if (face === tcuTexture.CubeFace.CUBEFACE_NEGATIVE_X) { + renderParams.flags.log_programs = true; + renderParams.flags.log_uniforms = true; + } + + var texCoord = glsTextureTestUtil.computeQuadTexCoordCube(face); + + // log << TestLog::Message << "Texture parameters:" + // << "\n WRAP_S = " << glu::getTextureParameterValueStr(gl.TEXTURE_WRAP_S, wrapS) + // << "\n WRAP_T = " << glu::getTextureParameterValueStr(gl.TEXTURE_WRAP_T, wrapT) + // << "\n MIN_FILTER = " << glu::getTextureParameterValueStr(gl.TEXTURE_MIN_FILTER, minFilter) + // << "\n MAG_FILTER = " << glu::getTextureParameterValueStr(gl.TEXTURE_MAG_FILTER, magFilter) + // << TestLog::EndMessage; + + // Setup base viewport. + gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); + + // Bind to unit 0. + gl.activeTexture(gl.TEXTURE0); + gl.bindTexture(gl.TEXTURE_CUBE_MAP, this.m_texture.getGLTexture()); + + // Setup nearest neighbor filtering and clamp-to-edge. + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, wrapS); + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, wrapT); + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, minFilter); + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, magFilter); + + // // Draw. + this.m_renderer.renderQuad(0, texCoord, renderParams); + renderedFrame.readViewport(gl, viewport); + + // // Compute reference. + glsTextureTestUtil.sampleTextureCube(new glsTextureTestUtil.SurfaceAccess(referenceFrame, undefined /*m_renderCtx.getRenderTarget().getPixelFormat()*/), + this.m_texture.getRefTexture(), texCoord, renderParams); + + // Compare and log. + var skipPixels = null; + if (renderParams.samplerType == glsTextureTestUtil.samplerType.SAMPLERTYPE_INT || + renderParams.samplerType == glsTextureTestUtil.samplerType.SAMPLERTYPE_UINT) { + // Skip top right pixel due to Mac Intel driver bug. + // https://github.com/KhronosGroup/WebGL/issues/1819 + skipPixels = [ + [this.m_width - 1, this.m_height - 1] + ]; + } + var isOk = glsTextureTestUtil.compareImages(referenceFrame, renderedFrame, threshold, skipPixels); + + assertMsgOptions(isOk, 'Face: ' + this.m_curFace + ' ' + es3fTextureFormatTests.testDescription(), true, false); + return isOk; +}; + +es3fTextureFormatTests.TextureCubeFormatCase.prototype.iterate = function() { + debug('Testing face ' + this.m_curFace); + // Execute test for all faces. + if (!this.testFace(this.m_curFace)) + this.m_isOk = false; + + this.m_curFace += 1; + + if (this.m_curFace < Object.keys(tcuTexture.CubeFace).length) + return tcuTestCase.IterateResult.CONTINUE; + else + return tcuTestCase.IterateResult.STOP; +}; + +/** + * @constructor + * @extends {tcuTestCase.DeqpTest} + */ +es3fTextureFormatTests.Texture2DArrayFormatCase = function(descriptor) { + tcuTestCase.DeqpTest.call(this, descriptor.name, descriptor.description); + this.m_format = descriptor.format; + this.m_dataType = descriptor.dataType; + this.m_width = descriptor.width; + this.m_height = descriptor.height; + this.m_numLayers = descriptor.numLayers; + this.m_renderer = new glsTextureTestUtil.TextureRenderer(es3fTextureFormatTests.version, gluShaderUtil.precision.PRECISION_HIGHP); +}; + +es3fTextureFormatTests.setParentClass(es3fTextureFormatTests.Texture2DArrayFormatCase, tcuTestCase.DeqpTest); + +es3fTextureFormatTests.Texture2DArrayFormatCase.prototype.init = function() { + /*tcu::TextureFormat*/ var fmt = this.m_dataType ? gluTextureUtil.mapGLTransferFormat(this.m_format, this.m_dataType) : gluTextureUtil.mapGLInternalFormat(this.m_format); + /*tcu::TextureFormatInfo*/ var spec = tcuTextureUtil.getTextureFormatInfo(fmt); + /* TODO : Port + + std::ostringstream fmtName; + + if (m_dataType) + fmtName << glu::getPixelFormatStr(m_format) << ", " << glu::getTypeStr(m_dataType); + else + fmtName << glu::getPixelFormatStr(m_format); + + log << TestLog::Message << "2D texture, " << fmtName.str() << ", " << m_width << "x" << m_height + << ",\n fill with " << formatGradient(&spec.valueMin, &spec.valueMax) << " gradient" + << TestLog::EndMessage; + */ + + this.m_texture = this.m_dataType ? + gluTexture.texture2DArrayFromFormat(gl, this.m_format, this.m_dataType, this.m_width, this.m_height, this.m_numLayers) : // Implicit internal format. + gluTexture.texture2DArrayFromInternalFormat(gl, this.m_format, this.m_width, this.m_height, this.m_numLayers); // Explicit internal format. + + this.m_texture.getRefTexture().allocLevel(0); + tcuTextureUtil.fillWithComponentGradients(this.m_texture.getRefTexture().getLevel(0), spec.valueMin, spec.valueMax); + + this.m_curLayer = 0; + this.m_isOk = true; +}; + +es3fTextureFormatTests.Texture2DArrayFormatCase.prototype.testLayer = function(layerNdx) { + /* TODO: Implement */ + + var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), this.m_width, this.m_height/*, deStringHash(getName())*/); + + /* tcu::Surface */ var renderedFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /* tcu::Surface */ var referenceFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /* TODO: Implement + // tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); + */ + var threshold = [3, 3, 3, 3]; + var renderParams = new glsTextureTestUtil.ReferenceParams(glsTextureTestUtil.textureType.TEXTURETYPE_2D_ARRAY); + + /* tcu::TextureFormatInfo*/ var spec = tcuTextureUtil.getTextureFormatInfo(this.m_texture.getRefTexture().getFormat()); + /** @const */ var wrapS = gl.CLAMP_TO_EDGE; + /** @const */ var wrapT = gl.CLAMP_TO_EDGE; + /** @const */ var minFilter = gl.NEAREST; + /** @const */ var magFilter = gl.NEAREST; + + renderParams.flags.log_programs = true; + renderParams.flags.log_uniforms = true; + + renderParams.samplerType = glsTextureTestUtil.getSamplerType(this.m_texture.getRefTexture().getFormat()); + renderParams.sampler = new tcuTexture.Sampler(tcuTexture.WrapMode.CLAMP_TO_EDGE, tcuTexture.WrapMode.CLAMP_TO_EDGE, tcuTexture.WrapMode.CLAMP_TO_EDGE, + tcuTexture.FilterMode.NEAREST, tcuTexture.FilterMode.NEAREST); + renderParams.colorScale = spec.lookupScale; + renderParams.colorBias = spec.lookupBias; + + var texCoord = glsTextureTestUtil.computeQuadTexCoord2DArray(layerNdx, [0, 0], [1, 1]); + + // log << TestLog::Message << "Texture parameters:" + // << "\n WRAP_S = " << glu::getTextureParameterValueStr(gl.TEXTURE_WRAP_S, wrapS) + // << "\n WRAP_T = " << glu::getTextureParameterValueStr(gl.TEXTURE_WRAP_T, wrapT) + // << "\n MIN_FILTER = " << glu::getTextureParameterValueStr(gl.TEXTURE_MIN_FILTER, minFilter) + // << "\n MAG_FILTER = " << glu::getTextureParameterValueStr(gl.TEXTURE_MAG_FILTER, magFilter) + // << TestLog::EndMessage; + + // Setup base viewport. + gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); + + this.m_texture.upload(); + + // Bind to unit 0. + gl.activeTexture(gl.TEXTURE0); + gl.bindTexture(gl.TEXTURE_2D_ARRAY, this.m_texture.getGLTexture()); + + // Setup nearest neighbor filtering and clamp-to-edge. + gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, wrapS); + gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, wrapT); + gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, minFilter); + gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, magFilter); + + // // Draw. + this.m_renderer.renderQuad(0, texCoord, renderParams); + renderedFrame.readViewport(gl, viewport); + + // // Compute reference. + glsTextureTestUtil.sampleTexture2DArray(new glsTextureTestUtil.SurfaceAccess(referenceFrame, undefined /*m_renderCtx.getRenderTarget().getPixelFormat()*/), + this.m_texture.getRefTexture().getView(), texCoord, renderParams); + + // Compare and log. + var isOk = glsTextureTestUtil.compareImages(referenceFrame, renderedFrame, threshold); + + assertMsgOptions(isOk, 'Layer: ' + this.m_curLayer + ' ' + es3fTextureFormatTests.testDescription(), true, false); + return isOk; +}; + +es3fTextureFormatTests.Texture2DArrayFormatCase.prototype.iterate = function() { + debug('Testing layer ' + this.m_curLayer); + // Execute test for all layers. + if (!this.testLayer(this.m_curLayer)) + this.m_isOk = false; + + this.m_curLayer += 1; + + if (this.m_curLayer == this.m_numLayers) + return tcuTestCase.IterateResult.STOP; + else + return tcuTestCase.IterateResult.CONTINUE; +}; + +/** + * @constructor + * @extends {tcuTestCase.DeqpTest} + */ +es3fTextureFormatTests.Texture3DFormatCase = function(descriptor) { + tcuTestCase.DeqpTest.call(this, descriptor.name, descriptor.description); + this.m_format = descriptor.format; + this.m_dataType = descriptor.dataType; + this.m_width = descriptor.width; + this.m_height = descriptor.height; + this.m_depth = descriptor.depth; + this.m_renderer = new glsTextureTestUtil.TextureRenderer(es3fTextureFormatTests.version, gluShaderUtil.precision.PRECISION_HIGHP); +}; + +es3fTextureFormatTests.setParentClass(es3fTextureFormatTests.Texture3DFormatCase, tcuTestCase.DeqpTest); + +es3fTextureFormatTests.Texture3DFormatCase.prototype.init = function() { + /*tcu::TextureFormat*/ var fmt = this.m_dataType ? gluTextureUtil.mapGLTransferFormat(this.m_format, this.m_dataType) : gluTextureUtil.mapGLInternalFormat(this.m_format); + /*tcu::TextureFormatInfo*/ var spec = tcuTextureUtil.getTextureFormatInfo(fmt); + /* TODO : Port + + std::ostringstream fmtName; + + if (m_dataType) + fmtName << glu::getPixelFormatStr(m_format) << ", " << glu::getTypeStr(m_dataType); + else + fmtName << glu::getPixelFormatStr(m_format); + + log << TestLog::Message << "2D texture, " << fmtName.str() << ", " << m_width << "x" << m_height + << ",\n fill with " << formatGradient(&spec.valueMin, &spec.valueMax) << " gradient" + << TestLog::EndMessage; + */ + + this.m_texture = this.m_dataType ? + gluTexture.texture3DFromFormat(gl, this.m_format, this.m_dataType, this.m_width, this.m_height, this.m_depth) : // Implicit internal format. + gluTexture.texture3DFromInternalFormat(gl, this.m_format, this.m_width, this.m_height, this.m_depth); // Explicit internal format. + + this.m_texture.getRefTexture().allocLevel(0); + tcuTextureUtil.fillWithComponentGradients(this.m_texture.getRefTexture().getLevel(0), spec.valueMin, spec.valueMax); + + this.m_curSlice = 0; + this.m_isOk = true; +}; + +es3fTextureFormatTests.Texture3DFormatCase.prototype.testSlice = function(sliceNdx) { + /* TODO: Implement */ + + var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), this.m_width, this.m_height/*, deStringHash(getName())*/); + + /* tcu::Surface */ var renderedFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /* tcu::Surface */ var referenceFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /* TODO: Implement + // tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); + */ + var threshold = [3, 3, 3, 3]; + var renderParams = new glsTextureTestUtil.ReferenceParams(glsTextureTestUtil.textureType.TEXTURETYPE_3D); + + /* tcu::TextureFormatInfo*/ var spec = tcuTextureUtil.getTextureFormatInfo(this.m_texture.getRefTexture().getFormat()); + var r = (sliceNdx + 0.5) / this.m_depth; + /** @const */ var wrapS = gl.CLAMP_TO_EDGE; + /** @const */ var wrapT = gl.CLAMP_TO_EDGE; + /** @const */ var minFilter = gl.NEAREST; + /** @const */ var magFilter = gl.NEAREST; + + renderParams.flags.log_programs = true; + renderParams.flags.log_uniforms = true; + + renderParams.samplerType = glsTextureTestUtil.getSamplerType(this.m_texture.getRefTexture().getFormat()); + renderParams.sampler = new tcuTexture.Sampler(tcuTexture.WrapMode.CLAMP_TO_EDGE, tcuTexture.WrapMode.CLAMP_TO_EDGE, tcuTexture.WrapMode.CLAMP_TO_EDGE, + tcuTexture.FilterMode.NEAREST, tcuTexture.FilterMode.NEAREST); + renderParams.colorScale = spec.lookupScale; + renderParams.colorBias = spec.lookupBias; + + var texCoord = glsTextureTestUtil.computeQuadTexCoord3D([0, 0, r], [1, 1, r], [0, 1, 2]); + + // log << TestLog::Message << "Texture parameters:" + // << "\n WRAP_S = " << glu::getTextureParameterValueStr(gl.TEXTURE_WRAP_S, wrapS) + // << "\n WRAP_T = " << glu::getTextureParameterValueStr(gl.TEXTURE_WRAP_T, wrapT) + // << "\n MIN_FILTER = " << glu::getTextureParameterValueStr(gl.TEXTURE_MIN_FILTER, minFilter) + // << "\n MAG_FILTER = " << glu::getTextureParameterValueStr(gl.TEXTURE_MAG_FILTER, magFilter) + // << TestLog::EndMessage; + + // Setup base viewport. + gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); + + this.m_texture.upload(); + + // Bind to unit 0. + gl.activeTexture(gl.TEXTURE0); + gl.bindTexture(gl.TEXTURE_3D, this.m_texture.getGLTexture()); + + // Setup nearest neighbor filtering and clamp-to-edge. + gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_S, wrapS); + gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_T, wrapT); + gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MIN_FILTER, minFilter); + gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MAG_FILTER, magFilter); + + // // Draw. + this.m_renderer.renderQuad(0, texCoord, renderParams); + renderedFrame.readViewport(gl, viewport); + + // // Compute reference. + glsTextureTestUtil.sampleTexture3D(new glsTextureTestUtil.SurfaceAccess(referenceFrame, undefined /*m_renderCtx.getRenderTarget().getPixelFormat()*/), + this.m_texture.getRefTexture(), texCoord, renderParams); + + // Compare and log. + var isOk = glsTextureTestUtil.compareImages(referenceFrame, renderedFrame, threshold); + + assertMsgOptions(isOk, 'Slice: ' + this.m_curSlice + ' ' + es3fTextureFormatTests.testDescription(), true, false); + return isOk; +}; + +es3fTextureFormatTests.Texture3DFormatCase.prototype.iterate = function() { + debug('Testing slice ' + this.m_curSlice); + // Execute test for all layers. + if (!this.testSlice(this.m_curSlice)) + this.m_isOk = false; + + this.m_curSlice += 1; + + if (this.m_curSlice >= this.m_depth) + return tcuTestCase.IterateResult.STOP; + else + return tcuTestCase.IterateResult.CONTINUE; +}; + +/** + * @constructor + * @extends {tcuTestCase.DeqpTest} + */ +es3fTextureFormatTests.Compressed2DFormatCase = function(descriptor) { + tcuTestCase.DeqpTest.call(this, descriptor.name, descriptor.description); + this.m_format = descriptor.format; + this.m_dataType = descriptor.dataType; + this.m_width = descriptor.width; + this.m_height = descriptor.height; + this.m_renderer = new glsTextureTestUtil.TextureRenderer(es3fTextureFormatTests.version, gluShaderUtil.precision.PRECISION_HIGHP); +}; + +es3fTextureFormatTests.setParentClass(es3fTextureFormatTests.Compressed2DFormatCase, tcuTestCase.DeqpTest); + +es3fTextureFormatTests.Compressed2DFormatCase.prototype.init = function() { + var compressed = new tcuCompressedTexture.CompressedTexture(this.m_format, this.m_width, this.m_height); + var rand = new deRandom.Random(0); + for (var i = 0; i < compressed.m_data.length; i++) { + compressed.m_data[i] = rand.getInt(0, 255); + } + this.m_texture = gluTexture.compressed2DFromInternalFormat(gl, this.m_format, this.m_width, this.m_height, compressed); +}; + +es3fTextureFormatTests.Compressed2DFormatCase.prototype.deinit = function() { + /* TODO: Implement */ +}; + +es3fTextureFormatTests.Compressed2DFormatCase.prototype.iterate = function() { + /* TODO: Implement */ + + var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), this.m_width, this.m_height/*, deStringHash(getName())*/); + + /* tcu::Surface */ var renderedFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /* tcu::Surface */ var referenceFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /* TODO: Implement + // tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); + */ + var threshold = [3, 3, 3, 3]; + var renderParams = new glsTextureTestUtil.ReferenceParams(glsTextureTestUtil.textureType.TEXTURETYPE_2D); + + /* tcu::TextureFormatInfo*/ var spec = tcuTextureUtil.getTextureFormatInfo(this.m_texture.getRefTexture().getFormat()); + /** @const */ var wrapS = gl.CLAMP_TO_EDGE; + /** @const */ var wrapT = gl.CLAMP_TO_EDGE; + /** @const */ var minFilter = gl.NEAREST; + /** @const */ var magFilter = gl.NEAREST; + + renderParams.flags.log_programs = true; + renderParams.flags.log_uniforms = true; + + renderParams.samplerType = glsTextureTestUtil.getSamplerType(this.m_texture.getRefTexture().getFormat()); + renderParams.sampler = new tcuTexture.Sampler(tcuTexture.WrapMode.CLAMP_TO_EDGE, tcuTexture.WrapMode.CLAMP_TO_EDGE, tcuTexture.WrapMode.CLAMP_TO_EDGE, + tcuTexture.FilterMode.NEAREST, tcuTexture.FilterMode.NEAREST); + renderParams.colorScale = spec.lookupScale; + renderParams.colorBias = spec.lookupBias; + + var texCoord = glsTextureTestUtil.computeQuadTexCoord2D([0, 0], [1, 1]); + + // log << TestLog::Message << "Texture parameters:" + // << "\n WRAP_S = " << glu::getTextureParameterValueStr(gl.TEXTURE_WRAP_S, wrapS) + // << "\n WRAP_T = " << glu::getTextureParameterValueStr(gl.TEXTURE_WRAP_T, wrapT) + // << "\n MIN_FILTER = " << glu::getTextureParameterValueStr(gl.TEXTURE_MIN_FILTER, minFilter) + // << "\n MAG_FILTER = " << glu::getTextureParameterValueStr(gl.TEXTURE_MAG_FILTER, magFilter) + // << TestLog::EndMessage; + + // Setup base viewport. + gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); + + // Bind to unit 0. + gl.activeTexture(gl.TEXTURE0); + gl.bindTexture(gl.TEXTURE_2D, this.m_texture.getGLTexture()); + + // Setup nearest neighbor filtering and clamp-to-edge. + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrapS); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrapT); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, minFilter); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, magFilter); + + // // Draw. + this.m_renderer.renderQuad(0, texCoord, renderParams); + renderedFrame.readViewport(gl, viewport); + + // // Compute reference. + glsTextureTestUtil.sampleTexture2D(new glsTextureTestUtil.SurfaceAccess(referenceFrame, undefined /*m_renderCtx.getRenderTarget().getPixelFormat()*/), + this.m_texture.getRefTexture(), texCoord, renderParams); + + // Compare and log. + var isOk = glsTextureTestUtil.compareImages(referenceFrame, renderedFrame, threshold); + + assertMsgOptions(isOk, es3fTextureFormatTests.testDescription(), true, false); + return tcuTestCase.IterateResult.STOP; +}; + +/** + * @constructor + * @extends {tcuTestCase.DeqpTest} + */ +es3fTextureFormatTests.CompressedCubeFormatCase = function(descriptor) { + tcuTestCase.DeqpTest.call(this, descriptor.name, descriptor.description); + this.m_format = descriptor.format; + this.m_dataType = descriptor.dataType; + this.m_width = descriptor.width; + this.m_height = descriptor.height; + this.m_renderer = new glsTextureTestUtil.TextureRenderer(es3fTextureFormatTests.version, gluShaderUtil.precision.PRECISION_HIGHP); + this.m_curFace = 0; + this.m_isOk = true; + DE_ASSERT(this.m_width == this.m_height); +}; + +es3fTextureFormatTests.setParentClass(es3fTextureFormatTests.CompressedCubeFormatCase, tcuTestCase.DeqpTest); + +es3fTextureFormatTests.CompressedCubeFormatCase.prototype.init = function() { + var compressed = new tcuCompressedTexture.CompressedTexture(this.m_format, this.m_width, this.m_height); + var rand = new deRandom.Random(0); + for (var i = 0; i < compressed.m_data.length; i++) { + compressed.m_data[i] = rand.getInt(0, 255); + } + this.m_texture = gluTexture.compressedCubeFromInternalFormat(gl, this.m_format, this.m_width, compressed); +}; + +es3fTextureFormatTests.CompressedCubeFormatCase.prototype.testFace = function(face) { + /* TODO: Implement */ + + var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), this.m_width, this.m_height/*, deStringHash(getName())*/); + + /* tcu::Surface */ var renderedFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /* tcu::Surface */ var referenceFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /* TODO: Implement + // tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); + */ + // Threshold high enough to cover numerical errors in software decoders on Windows and Mac. Threshold is 17 in native dEQP. + var threshold = [6, 6, 6, 6]; + var renderParams = new glsTextureTestUtil.ReferenceParams(glsTextureTestUtil.textureType.TEXTURETYPE_CUBE); + + /** @const */ var wrapS = gl.CLAMP_TO_EDGE; + /** @const */ var wrapT = gl.CLAMP_TO_EDGE; + /** @const */ var minFilter = gl.NEAREST; + /** @const */ var magFilter = gl.NEAREST; + + renderParams.flags.log_programs = true; + renderParams.flags.log_uniforms = true; + + renderParams.samplerType = glsTextureTestUtil.getSamplerType(this.m_texture.getRefTexture().getFormat()); + renderParams.sampler = new tcuTexture.Sampler(tcuTexture.WrapMode.CLAMP_TO_EDGE, tcuTexture.WrapMode.CLAMP_TO_EDGE, tcuTexture.WrapMode.CLAMP_TO_EDGE, + tcuTexture.FilterMode.NEAREST, tcuTexture.FilterMode.NEAREST); + + // Log render info on first face. + if (face === tcuTexture.CubeFace.CUBEFACE_NEGATIVE_X) { + renderParams.flags.log_programs = true; + renderParams.flags.log_uniforms = true; + } + + var texCoord = glsTextureTestUtil.computeQuadTexCoordCube(face); + + // log << TestLog::Message << "Texture parameters:" + // << "\n WRAP_S = " << glu::getTextureParameterValueStr(gl.TEXTURE_WRAP_S, wrapS) + // << "\n WRAP_T = " << glu::getTextureParameterValueStr(gl.TEXTURE_WRAP_T, wrapT) + // << "\n MIN_FILTER = " << glu::getTextureParameterValueStr(gl.TEXTURE_MIN_FILTER, minFilter) + // << "\n MAG_FILTER = " << glu::getTextureParameterValueStr(gl.TEXTURE_MAG_FILTER, magFilter) + // << TestLog::EndMessage; + + // Setup base viewport. + gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); + + // Bind to unit 0. + gl.activeTexture(gl.TEXTURE0); + gl.bindTexture(gl.TEXTURE_CUBE_MAP, this.m_texture.getGLTexture()); + + // Setup nearest neighbor filtering and clamp-to-edge. + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, wrapS); + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, wrapT); + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, minFilter); + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, magFilter); + + // // Draw. + this.m_renderer.renderQuad(0, texCoord, renderParams); + renderedFrame.readViewport(gl, viewport); + + // // Compute reference. + glsTextureTestUtil.sampleTextureCube(new glsTextureTestUtil.SurfaceAccess(referenceFrame, undefined /*m_renderCtx.getRenderTarget().getPixelFormat()*/), + this.m_texture.getRefTexture(), texCoord, renderParams); + + // Compare and log. + var isOk = glsTextureTestUtil.compareImages(referenceFrame, renderedFrame, threshold); + + assertMsgOptions(isOk, 'Face: ' + this.m_curFace + ' ' + es3fTextureFormatTests.testDescription(), true, false); + return isOk; +}; + +es3fTextureFormatTests.CompressedCubeFormatCase.prototype.iterate = function() { + debug('Testing face ' + this.m_curFace); + // Execute test for all faces. + if (!this.testFace(this.m_curFace)) + this.m_isOk = false; + + this.m_curFace += 1; + + if (this.m_curFace < Object.keys(tcuTexture.CubeFace).length) + return tcuTestCase.IterateResult.CONTINUE; + else + return tcuTestCase.IterateResult.STOP; +}; + +es3fTextureFormatTests.genTestCases = function() { + var state = tcuTestCase.runner; + state.setRoot(tcuTestCase.newTest('texture_format', 'Top level')); + + var texFormats = [ + ['alpha', gl.ALPHA, gl.UNSIGNED_BYTE], + ['luminance', gl.LUMINANCE, gl.UNSIGNED_BYTE], + ['luminance_alpha', gl.LUMINANCE_ALPHA, gl.UNSIGNED_BYTE], + ['rgb_unsigned_short_5_6_5', gl.RGB, gl.UNSIGNED_SHORT_5_6_5], + ['rgb_unsigned_byte', gl.RGB, gl.UNSIGNED_BYTE], + ['rgba_unsigned_short_4_4_4_4', gl.RGBA, gl.UNSIGNED_SHORT_4_4_4_4], + ['rgba_unsigned_short_5_5_5_1', gl.RGBA, gl.UNSIGNED_SHORT_5_5_5_1], + ['rgba_unsigned_byte', gl.RGBA, gl.UNSIGNED_BYTE] + ]; + + var unsized2DGroup = tcuTestCase.newTest('unsized', 'Unsized formats (2D, Cubemap)'); + state.testCases.addChild(unsized2DGroup); + var unsized2DArrayGroup = tcuTestCase.newTest('unsized', 'Unsized formats (2D Array)'); + state.testCases.addChild(unsized2DArrayGroup); + var unsized3DGroup = tcuTestCase.newTest('unsized', 'Unsized formats (3D)'); + state.testCases.addChild(unsized3DGroup); + + texFormats.forEach(function(elem) { + var format = elem[1]; + var dataType = elem[2]; + var nameBase = elem[0]; + var descriptionBase = gluStrUtil.getPixelFormatName(format) + ', ' + gluStrUtil.getTypeName(dataType); + unsized2DGroup.addChild(new es3fTextureFormatTests.Texture2DFormatCase({ + name: nameBase + '_2d_pot', + description: descriptionBase + ' gl.TEXTURE_2D', + format: format, + dataType: dataType, + width: 128, + height: 128 + })); + unsized2DGroup.addChild(new es3fTextureFormatTests.Texture2DFormatCase({ + name: nameBase + '_2d_npot', + description: descriptionBase + ' gl.TEXTURE_2D', + format: format, + dataType: dataType, + width: 63, + height: 112 + })); + unsized2DGroup.addChild(new es3fTextureFormatTests.TextureCubeFormatCase({ + name: nameBase + '_cube_pot', + description: descriptionBase + ' gl.TEXTURE_CUBE_MAP', + format: format, + dataType: dataType, + width: 64, + height: 64 + })); + unsized2DGroup.addChild(new es3fTextureFormatTests.TextureCubeFormatCase({ + name: nameBase + '_cube_npot', + description: descriptionBase + ' gl.TEXTURE_CUBE_MAP', + format: format, + dataType: dataType, + width: 57, + height: 57 + })); + unsized2DArrayGroup.addChild(new es3fTextureFormatTests.Texture2DArrayFormatCase({ + name: nameBase + '_2d_array_pot', + description: descriptionBase + ' gl.TEXTURE_2D_ARRAY', + format: format, + dataType: dataType, + width: 64, + height: 64, + numLayers: 8 + })); + unsized2DArrayGroup.addChild(new es3fTextureFormatTests.Texture2DArrayFormatCase({ + name: nameBase + '_2d_array_npot', + description: descriptionBase + ' gl.TEXTURE_2D_ARRAY', + format: format, + dataType: dataType, + width: 63, + height: 57, + numLayers: 7 + })); + unsized3DGroup.addChild(new es3fTextureFormatTests.Texture3DFormatCase({ + name: nameBase + '_3d_pot', + description: descriptionBase + ' gl.TEXTURE_3D', + format: format, + dataType: dataType, + width: 8, + height: 32, + depth: 16 + })); + unsized3DGroup.addChild(new es3fTextureFormatTests.Texture3DFormatCase({ + name: nameBase + '_3d_npot', + description: descriptionBase + ' gl.TEXTURE_3D', + format: format, + dataType: dataType, + width: 11, + height: 31, + depth: 7 + })); + }); + + var sizedColorFormats = [ + ['rgba32f', gl.RGBA32F], + ['rgba32i', gl.RGBA32I], + ['rgba32ui', gl.RGBA32UI], + ['rgba16f', gl.RGBA16F], + ['rgba16i', gl.RGBA16I], + ['rgba16ui', gl.RGBA16UI], + ['rgba8', gl.RGBA8], + ['rgba8i', gl.RGBA8I], + ['rgba8ui', gl.RGBA8UI], + ['srgb8_alpha8', gl.SRGB8_ALPHA8], + ['rgb10_a2', gl.RGB10_A2], + ['rgb10_a2ui', gl.RGB10_A2UI], + ['rgba4', gl.RGBA4], + ['rgb5_a1', gl.RGB5_A1], + ['rgba8_snorm', gl.RGBA8_SNORM], + ['rgb8', gl.RGB8], + ['rgb565', gl.RGB565], + ['r11f_g11f_b10f', gl.R11F_G11F_B10F], + ['rgb32f', gl.RGB32F], + ['rgb32i', gl.RGB32I], + ['rgb32ui', gl.RGB32UI], + ['rgb16f', gl.RGB16F], + ['rgb16i', gl.RGB16I], + ['rgb16ui', gl.RGB16UI], + ['rgb8_snorm', gl.RGB8_SNORM], + ['rgb8i', gl.RGB8I], + ['rgb8ui', gl.RGB8UI], + ['srgb8', gl.SRGB8], + ['rgb9_e5', gl.RGB9_E5], + ['rg32f', gl.RG32F], + ['rg32i', gl.RG32I], + ['rg32ui', gl.RG32UI], + ['rg16f', gl.RG16F], + ['rg16i', gl.RG16I], + ['rg16ui', gl.RG16UI], + ['rg8', gl.RG8], + ['rg8i', gl.RG8I], + ['rg8ui', gl.RG8UI], + ['rg8_snorm', gl.RG8_SNORM], + ['r32f', gl.R32F], + ['r32i', gl.R32I], + ['r32ui', gl.R32UI], + ['r16f', gl.R16F], + ['r16i', gl.R16I], + ['r16ui', gl.R16UI], + ['r8', gl.R8], + ['r8i', gl.R8I], + ['r8ui', gl.R8UI], + ['r8_snorm', gl.R8_SNORM] + ]; + + var splitSizedColorTests = 4; + var sizedColor2DPOTGroup = []; + for (var ii = 0; ii < splitSizedColorTests; ++ii) { + sizedColor2DPOTGroup.push(tcuTestCase.newTest('sized', 'Sized formats (2D POT)')); + state.testCases.addChild(sizedColor2DPOTGroup[ii]); + } + var sizedColor2DNPOTGroup = []; + for (var ii = 0; ii < splitSizedColorTests; ++ii) { + sizedColor2DNPOTGroup.push(tcuTestCase.newTest('sized', 'Sized formats (2D NPOT)')); + state.testCases.addChild(sizedColor2DNPOTGroup[ii]); + } + var sizedColorCubePOTGroup = []; + for (var ii = 0; ii < splitSizedColorTests; ++ii) { + sizedColorCubePOTGroup.push(tcuTestCase.newTest('sized', 'Sized formats (Cubemap POT)')); + state.testCases.addChild(sizedColorCubePOTGroup[ii]); + } + var sizedColorCubeNPOTGroup = []; + for (var ii = 0; ii < splitSizedColorTests; ++ii) { + sizedColorCubeNPOTGroup.push(tcuTestCase.newTest('sized', 'Sized formats (Cubemap NPOT)')); + state.testCases.addChild(sizedColorCubeNPOTGroup[ii]); + } + var sizedColor2DArrayPOTGroup = []; + for (var ii = 0; ii < splitSizedColorTests; ++ii) { + sizedColor2DArrayPOTGroup.push(tcuTestCase.newTest('sized', 'Sized formats (2D Array POT)')); + state.testCases.addChild(sizedColor2DArrayPOTGroup[ii]); + } + var sizedColor2DArrayNPOTGroup = []; + for (var ii = 0; ii < splitSizedColorTests; ++ii) { + sizedColor2DArrayNPOTGroup.push(tcuTestCase.newTest('sized', 'Sized formats (2D Array NPOT)')); + state.testCases.addChild(sizedColor2DArrayNPOTGroup[ii]); + } + var sizedColor3DPOTGroup = []; + for (var ii = 0; ii < splitSizedColorTests; ++ii) { + sizedColor3DPOTGroup.push(tcuTestCase.newTest('sized', 'Sized formats (3D POT)')); + state.testCases.addChild(sizedColor3DPOTGroup[ii]); + } + var sizedColor3DNPOTGroup = []; + for (var ii = 0; ii < splitSizedColorTests; ++ii) { + sizedColor3DNPOTGroup.push(tcuTestCase.newTest('sized', 'Sized formats (3D NPOT)')); + state.testCases.addChild(sizedColor3DNPOTGroup[ii]); + } + + for (var ii = 0; ii < sizedColorFormats.length; ++ii) { + var internalFormat = sizedColorFormats[ii][1]; + var nameBase = sizedColorFormats[ii][0]; + var descriptionBase = gluStrUtil.getPixelFormatName(internalFormat); + sizedColor2DPOTGroup[ii % splitSizedColorTests].addChild(new es3fTextureFormatTests.Texture2DFormatCase({ + name: nameBase + '_pot', + description: descriptionBase + ' gl.TEXTURE_2D', + format: internalFormat, + width: 128, + height: 128 + })); + sizedColor2DNPOTGroup[ii % splitSizedColorTests].addChild(new es3fTextureFormatTests.Texture2DFormatCase({ + name: nameBase + '_npot', + description: descriptionBase + ' gl.TEXTURE_2D', + format: internalFormat, + width: 63, + height: 112 + })); + sizedColorCubePOTGroup[ii % splitSizedColorTests].addChild(new es3fTextureFormatTests.TextureCubeFormatCase({ + name: nameBase + '_pot', + description: descriptionBase + ' gl.TEXTURE_CUBE_MAP', + format: internalFormat, + width: 64, + height: 64 + })); + sizedColorCubeNPOTGroup[ii % splitSizedColorTests].addChild(new es3fTextureFormatTests.TextureCubeFormatCase({ + name: nameBase + '_npot', + description: descriptionBase + ' gl.TEXTURE_CUBE_MAP', + format: internalFormat, + width: 57, + height: 57 + })); + sizedColor2DArrayPOTGroup[ii % splitSizedColorTests].addChild(new es3fTextureFormatTests.Texture2DArrayFormatCase({ + name: nameBase + '_pot', + description: descriptionBase + ' gl.TEXTURE_2D_ARRAY', + format: internalFormat, + width: 64, + height: 64, + numLayers: 8 + + })); + sizedColor2DArrayNPOTGroup[ii % splitSizedColorTests].addChild(new es3fTextureFormatTests.Texture2DArrayFormatCase({ + name: nameBase + '_npot', + description: descriptionBase + ' gl.TEXTURE_2D_ARRAY', + format: internalFormat, + width: 63, + height: 57, + numLayers: 7 + })); + sizedColor3DPOTGroup[ii % splitSizedColorTests].addChild(new es3fTextureFormatTests.Texture3DFormatCase({ + name: nameBase + '_pot', + description: descriptionBase + ' gl.TEXTURE_3D', + format: internalFormat, + width: 8, + height: 32, + depth: 16 + })); + sizedColor3DNPOTGroup[ii % splitSizedColorTests].addChild(new es3fTextureFormatTests.Texture3DFormatCase({ + name: nameBase + '_npot', + description: descriptionBase + ' gl.TEXTURE_3D', + format: internalFormat, + width: 11, + height: 31, + depth: 7 + })); + } + + var sizedDepthStencilFormats = [ + // Depth and stencil formats + ['depth_component32f', gl.DEPTH_COMPONENT32F], + ['depth_component24', gl.DEPTH_COMPONENT24], + ['depth_component16', gl.DEPTH_COMPONENT16], + // The following format is restricted in WebGL2. + // ['depth32f_stencil8', gl.DEPTH32F_STENCIL8], + ['depth24_stencil8', gl.DEPTH24_STENCIL8] + ]; + var sizedDepthStencilGroup = tcuTestCase.newTest('sized', 'Sized formats (Depth Stencil)'); + state.testCases.addChild(sizedDepthStencilGroup); + sizedDepthStencilFormats.forEach(function(elem) { + var internalFormat = elem[1]; + var nameBase = elem[0]; + var descriptionBase = gluStrUtil.getPixelFormatName(internalFormat); + sizedDepthStencilGroup.addChild(new es3fTextureFormatTests.Texture2DFormatCase({ + name: nameBase + '_pot', + description: descriptionBase + ' gl.TEXTURE_2D', + format: internalFormat, + width: 128, + height: 128 + })); + sizedDepthStencilGroup.addChild(new es3fTextureFormatTests.Texture2DFormatCase({ + name: nameBase + '_npot', + description: descriptionBase + ' gl.TEXTURE_2D', + format: internalFormat, + width: 63, + height: 112 + })); + sizedDepthStencilGroup.addChild(new es3fTextureFormatTests.TextureCubeFormatCase({ + name: nameBase + '_pot', + description: descriptionBase + ' gl.TEXTURE_CUBE_MAP', + format: internalFormat, + width: 64, + height: 64 + })); + sizedDepthStencilGroup.addChild(new es3fTextureFormatTests.TextureCubeFormatCase({ + name: nameBase + '_npot', + description: descriptionBase + ' gl.TEXTURE_CUBE_MAP', + format: internalFormat, + width: 57, + height: 57 + })); + sizedDepthStencilGroup.addChild(new es3fTextureFormatTests.Texture2DArrayFormatCase({ + name: nameBase + '_pot', + description: descriptionBase + ' gl.TEXTURE_2D_ARRAY', + format: internalFormat, + width: 64, + height: 64, + numLayers: 8 + })); + sizedDepthStencilGroup.addChild(new es3fTextureFormatTests.Texture2DArrayFormatCase({ + name: nameBase + '_npot', + description: descriptionBase + ' gl.TEXTURE_2D_ARRAY', + format: internalFormat, + width: 63, + height: 57, + numLayers: 7 + })); + }); + + var compressed2DGroup = tcuTestCase.newTest('compressed', 'Compressed formats (2D)'); + state.testCases.addChild(compressed2DGroup); + var compressedCubeGroup = tcuTestCase.newTest('compressed', 'Compressed formats (Cubemap)'); + state.testCases.addChild(compressedCubeGroup); + var etc2Formats = [ + ['gl.COMPRESSED_R11_EAC', 'eac_r11', tcuCompressedTexture.Format.EAC_R11], + ['gl.COMPRESSED_SIGNED_R11_EAC', 'eac_signed_r11', tcuCompressedTexture.Format.EAC_SIGNED_R11], + ['gl.COMPRESSED_RG11_EAC', 'eac_rg11', tcuCompressedTexture.Format.EAC_RG11], + ['gl.COMPRESSED_SIGNED_RG11_EAC', 'eac_signed_rg11', tcuCompressedTexture.Format.EAC_SIGNED_RG11], + ['gl.COMPRESSED_RGB8_ETC2', 'etc2_rgb8', tcuCompressedTexture.Format.ETC2_RGB8], + ['gl.COMPRESSED_SRGB8_ETC2', 'etc2_srgb8', tcuCompressedTexture.Format.ETC2_SRGB8], + ['gl.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2', 'etc2_rgb8_punchthrough_alpha1', tcuCompressedTexture.Format.ETC2_RGB8_PUNCHTHROUGH_ALPHA1], + ['gl.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2', 'etc2_srgb8_punchthrough_alpha1', tcuCompressedTexture.Format.ETC2_SRGB8_PUNCHTHROUGH_ALPHA1], + ['gl.COMPRESSED_RGBA8_ETC2_EAC', 'etc2_eac_rgba8', tcuCompressedTexture.Format.ETC2_EAC_RGBA8], + ['gl.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC', 'etc2_eac_srgb8_alpha8', tcuCompressedTexture.Format.ETC2_EAC_SRGB8_ALPHA8] + ]; + if (!gluTextureUtil.enableCompressedTextureETC()) { + debug('Skipping ETC2/EAC texture format tests: no support for WEBGL_compressed_texture_etc'); + etc2Formats = []; + } + etc2Formats.forEach(function(elem) { + var nameBase = elem[1]; + var descriptionBase = elem[0]; + var format = elem[2]; + compressed2DGroup.addChild(new es3fTextureFormatTests.Compressed2DFormatCase({ + name: nameBase + '_2d_pot', + description: descriptionBase + ', gl.TEXTURE_2D', + format: format, + width: 128, + height: 64 + })); + compressedCubeGroup.addChild(new es3fTextureFormatTests.CompressedCubeFormatCase({ + name: nameBase + '_cube_pot', + description: descriptionBase + ', gl.TEXTURE_CUBE_MAP', + format: format, + width: 64, + height: 64 + })); + compressed2DGroup.addChild(new es3fTextureFormatTests.Compressed2DFormatCase({ + name: nameBase + '_2d_pot', + description: descriptionBase + ', gl.TEXTURE_2D', + format: format, + width: 128, + height: 64 + })); + compressedCubeGroup.addChild(new es3fTextureFormatTests.CompressedCubeFormatCase({ + name: nameBase + '_cube_npot', + description: descriptionBase + ', gl.TEXTURE_CUBE_MAP', + format: format, + width: 51, + height: 51 + })); + }); +}; + +/** + * Create and execute the test cases + */ +es3fTextureFormatTests.run = function(context, range) { + gl = context; + var state = tcuTestCase.runner; + try { + es3fTextureFormatTests.genTestCases(); + if (range) + state.setRange(range); + state.runCallback(tcuTestCase.runTestCases); + } catch (err) { + bufferedLogToConsole(err); + state.terminate(); + } + +}; + +}); |