diff options
Diffstat (limited to '')
-rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureWrapTests.js | 434 |
1 files changed, 434 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureWrapTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureWrapTests.js new file mode 100644 index 0000000000..a6d6e96d14 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureWrapTests.js @@ -0,0 +1,434 @@ +/*------------------------------------------------------------------------- + * 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.es3fTextureWrapTests'); +goog.require('framework.common.tcuCompressedTexture'); +goog.require('framework.common.tcuPixelFormat'); +goog.require('framework.common.tcuSurface'); +goog.require('framework.common.tcuTestCase'); +goog.require('framework.common.tcuTexLookupVerifier'); +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.gluTexture'); +goog.require('framework.opengl.gluTextureUtil'); +goog.require('modules.shared.glsTextureTestUtil'); + +goog.scope(function() { + /** @type {?WebGL2RenderingContext} */ var gl; + + var es3fTextureWrapTests = functional.gles3.es3fTextureWrapTests; + var tcuTestCase = framework.common.tcuTestCase; + var gluTexture = framework.opengl.gluTexture; + var gluTextureUtil = framework.opengl.gluTextureUtil; + var gluShaderUtil = framework.opengl.gluShaderUtil; + var glsTextureTestUtil = modules.shared.glsTextureTestUtil; + var tcuCompressedTexture = framework.common.tcuCompressedTexture; + var deRandom = framework.delibs.debase.deRandom; + var deMath = framework.delibs.debase.deMath; + var tcuPixelFormat = framework.common.tcuPixelFormat; + var tcuSurface = framework.common.tcuSurface; + var tcuTexLookupVerifier = framework.common.tcuTexLookupVerifier; + var tcuTexture = framework.common.tcuTexture; + var tcuTextureUtil = framework.common.tcuTextureUtil; + var deString = framework.delibs.debase.deString; + + /** + * @enum {number} + */ + var Viewport = { + WIDTH: 256, + HEIGHT: 256 + }; + + /** + * @constructor + * @param {Array<number>=} bl + * @param {Array<number>=} tr + */ + es3fTextureWrapTests.Case = function(bl, tr) { + /** @type {?Array<number>} */ this.bottomLeft = bl || null; + /** @type {?Array<number>} */ this.topRight = tr || null; + }; + + /** + * @constructor + * @extends {tcuTestCase.DeqpTest} + * @param {string} name + * @param {string} description + * @param {?tcuCompressedTexture.Format} compressedFormat + * @param {number} wrapS + * @param {number} wrapT + * @param {number} minFilter + * @param {number} magFilter + * @param {number} width + * @param {number} height + */ + es3fTextureWrapTests.TextureWrapCase = function(name, description, compressedFormat, wrapS, wrapT, minFilter, magFilter, width, height) { + tcuTestCase.DeqpTest.call(this, name, description); + /** @type {number} */ this.m_format = gl.NONE; + /** @type {number} */ this.m_dataType = gl.NONE; + /** @type {?tcuCompressedTexture.Format} */ this.m_compressedFormat = compressedFormat; + /** @type {number} */ this.m_wrapS = wrapS; + /** @type {number} */ this.m_wrapT = wrapT; + /** @type {number} */ this.m_minFilter = minFilter; + /** @type {number} */ this.m_magFilter = magFilter; + /** @type {number} */ this.m_width = width; + /** @type {number} */ this.m_height = height; + /** @type {Array<es3fTextureWrapTests.Case>} */ this.m_cases = []; + /** @type {number} */ this.m_caseNdx = 0; + /** @type {gluTexture.Texture2D} */ this.m_texture = null; + /** @type {glsTextureTestUtil.TextureRenderer} */ + this.m_renderer = new glsTextureTestUtil.TextureRenderer(gluShaderUtil.getGLSLVersionString(gluShaderUtil.GLSLVersion.V300_ES), gluShaderUtil.precision.PRECISION_MEDIUMP); + }; + + es3fTextureWrapTests.TextureWrapCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); + + /** Copy the constructor */ + es3fTextureWrapTests.TextureWrapCase.prototype.constructor = es3fTextureWrapTests.TextureWrapCase; + + /** + * @param {string} name + * @param {string} description + * @param {number} format + * @param {number} dataType + * @param {number} wrapS + * @param {number} wrapT + * @param {number} minFilter + * @param {number} magFilter + * @param {number} width + * @param {number} height + * @return {es3fTextureWrapTests.TextureWrapCase} + */ + es3fTextureWrapTests.textureWrapCaseFromFormat = function(name, description, format, dataType, wrapS, wrapT, minFilter, magFilter, width, height) { + var texWrapCase = new es3fTextureWrapTests.TextureWrapCase(name, description, null, wrapS, wrapT, minFilter, magFilter, width, height); + texWrapCase.m_format = gl.RGBA; + texWrapCase.m_dataType = gl.UNSIGNED_BYTE; + return texWrapCase; + }; + + /** + */ + es3fTextureWrapTests.TextureWrapCase.prototype.init = function() { + if (this.m_compressedFormat !== null) { + // Generate compressed texture. + + assertMsgOptions(this.m_format == gl.NONE && this.m_dataType == gl.NONE, 'init/compressedFormat', false, true); + if (tcuCompressedTexture.isEtcFormat(this.m_compressedFormat)) { + // Create ETC texture. Any content is valid. + + /** @type {tcuCompressedTexture.CompressedTexture}*/ + var compressedTexture = new tcuCompressedTexture.CompressedTexture(this.m_compressedFormat, this.m_width, this.m_height); + /** @type {number} */ var dataSize = compressedTexture.getDataSize(); + /** @type {goog.NumberArray} */ var data = compressedTexture.getData(); + /** @type {deRandom.Random} */ var rnd = new deRandom.Random(deString.deStringHash(this.name)); + + for (var i = 0; i < dataSize; i++) + data[i] = rnd.getFloat() & 0xff; + + this.m_texture = gluTexture.texture2DFromCompressedTexture(gl, 1, [compressedTexture]); + } else + throw new Error('Only ETC2 and EAC are supported.'); + } else{ + this.m_texture = gluTexture.texture2DFromFormat(gl, this.m_format, this.m_dataType, this.m_width, this.m_height); + + // Fill level 0. + this.m_texture.getRefTexture().allocLevel(0); + tcuTextureUtil.fillWithComponentGradients(this.m_texture.getRefTexture().getLevel(0), [-0.5, -0.5, -0.5, 2.0], [1.0, 1.0, 1.0, 0.0]); + + this.m_texture.upload(); + } + + // Sub-cases. + + this.m_cases.push(new es3fTextureWrapTests.Case([-1.5, -3.0], [1.5, 2.5])); + this.m_cases.push(new es3fTextureWrapTests.Case([-0.5, 0.75], [0.25, 1.25])); + assertMsgOptions(this.m_caseNdx == 0, 'm_caseNdx != 0', false, true); + }; + + /** + * @return {tcuTestCase.IterateResult} + */ + es3fTextureWrapTests.TextureWrapCase.prototype.iterate = function() { + /** @type {glsTextureTestUtil.RandomViewport} */ var viewport = new glsTextureTestUtil.RandomViewport(gl.canvas, Viewport.WIDTH, Viewport.HEIGHT, deString.deStringHash(this.name) + this.m_caseNdx); + /** @type {tcuSurface.Surface} */ var renderedFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /** @type {tcuSurface.Surface} */ var referenceFrame = new tcuSurface.Surface(viewport.width, viewport.height); + /** @type {glsTextureTestUtil.ReferenceParams} */ var refParams = new glsTextureTestUtil.ReferenceParams(glsTextureTestUtil.textureType.TEXTURETYPE_2D); + /** @type {tcuTexture.TextureFormat} */ var texFormat = this.m_texture.getRefTexture().getFormat(); + /** @type {Array<number>} */ var texCoord; + /** @type {tcuTextureUtil.TextureFormatInfo} */ var texFormatInfo = tcuTextureUtil.getTextureFormatInfo(texFormat); + /** @type {boolean} */ var useDefaultColorScaleAndBias = true; + + // Bind to unit 0. + gl.activeTexture(gl.TEXTURE0); + gl.bindTexture(gl.TEXTURE_2D, this.m_texture.getGLTexture()); + + // Setup filtering and wrap modes. + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, this.m_wrapS); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, this.m_wrapT); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, this.m_minFilter); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, this.m_magFilter); + + // Parameters for reference images. + refParams.sampler = gluTextureUtil.mapGLSamplerWrapST(this.m_wrapS, this.m_wrapT, this.m_minFilter, this.m_magFilter); + refParams.lodMode = glsTextureTestUtil.lodMode.EXACT; + refParams.samplerType = glsTextureTestUtil.getSamplerType(this.m_texture.getRefTexture().getFormat()); + refParams.colorScale = useDefaultColorScaleAndBias ? texFormatInfo.lookupScale : [1.0, 1.0, 1.0, 1.0]; + refParams.colorBias = useDefaultColorScaleAndBias ? texFormatInfo.lookupBias : [0, 0, 0, 0]; + + gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); + texCoord = glsTextureTestUtil.computeQuadTexCoord2D(this.m_cases[this.m_caseNdx].bottomLeft, this.m_cases[this.m_caseNdx].topRight); + this.m_renderer.renderQuad(0, texCoord, refParams); + + // gluPixelTransfer.readPixels(viewport.x, viewport.y, renderedFrame.getAccess()); + /** @type {number} */ var pixelSize = renderedFrame.getAccess().getFormat().getPixelSize(); + /** @type {number} */ var param = deMath.deIsPowerOfTwo32(pixelSize) ? Math.min(pixelSize, 8) : 1; + + gl.pixelStorei(gl.PACK_ALIGNMENT, param); + /** @type {gluTextureUtil.TransferFormat} */ var format = gluTextureUtil.getTransferFormat(renderedFrame.getAccess().getFormat()); + + renderedFrame.readViewport(gl, viewport); + + // const tcu::ScopedLogSection section (log, string("Test") + de::toString(m_caseNdx), string("Test ") + de::toString(m_caseNdx)); + /** @type {boolean} */ var isNearestOnly = this.m_minFilter == gl.NEAREST && this.m_magFilter == gl.NEAREST; + /** @type {boolean} */ var isSRGB = texFormat.order == tcuTexture.ChannelOrder.sRGB || texFormat.order == tcuTexture.ChannelOrder.sRGBA; + /** @type {tcuPixelFormat.PixelFormat} */ var pixelFormat = new tcuPixelFormat.PixelFormat(8, 8, 8, 8); + /** @type {Array<number>} */ var colorBits = deMath.max(deMath.subtract(glsTextureTestUtil.getBitsVec(pixelFormat), (isNearestOnly && !isSRGB ? [1, 1, 1, 1] : [2, 2, 2, 2])), [0, 0, 0, 0]); + /** @type {tcuTexLookupVerifier.LodPrecision} */ var lodPrecision = new tcuTexLookupVerifier.LodPrecision(18, 5); + /** @type {tcuTexLookupVerifier.LookupPrecision} */ + var lookupPrecision = new tcuTexLookupVerifier.LookupPrecision( + [20, 20, 0], + [5, 5, 0], + deMath.divide(tcuTexLookupVerifier.computeFixedPointThreshold(colorBits), refParams.colorScale), + glsTextureTestUtil.getCompareMask(pixelFormat) + ); + + // log << TestLog::Message << "Note: lookup coordinates: bottom-left " << m_cases[m_caseNdx].bottomLeft << ", top-right " << m_cases[m_caseNdx].topRight << TestLog::EndMessage; + + /** @type {boolean} */ var isOk = glsTextureTestUtil.verifyTexture2DResult(renderedFrame.getAccess(), this.m_texture.getRefTexture(), texCoord, refParams, lookupPrecision, lodPrecision, pixelFormat); + + if (!isOk) + testFailedOptions('Case ' + this.m_caseNdx + ': verifyTexture2DResult is false', false); + else + testPassedOptions('Case ' + this.m_caseNdx + ': OK', true); + + this.m_caseNdx++; + + return this.m_caseNdx < this.m_cases.length ? tcuTestCase.IterateResult.CONTINUE : tcuTestCase.IterateResult.STOP; + }; + + /** + * Initialize test + */ + es3fTextureWrapTests.init = function() { + var testGroup = tcuTestCase.runner.testCases; + /** @type {string} */ var name; + /** + * @constructor + * @struct + * @param {string} name + * @param {number} mode + */ + var WrapMode = function(name, mode) { + /** @type {string} */ this.name = name; + /** @type {number} */ this.mode = mode; + }; + + /** @type {Array<WrapMode>} */ var wrapModes = [ + new WrapMode('clamp', gl.CLAMP_TO_EDGE), + new WrapMode('repeat', gl.REPEAT), + new WrapMode('mirror', gl.MIRRORED_REPEAT) + ]; + + /** + * @constructor + * @struct + * @param {string} name + * @param {number} mode + */ + var FilteringMode = function(name, mode) { + /** @type {string} */ this.name = name; + /** @type {number} */ this.mode = mode; + }; + + /** @type {Array<FilteringMode>} */ var filteringModes = [ + new FilteringMode('nearest', gl.NEAREST), + new FilteringMode('linear', gl.LINEAR) + ]; + + /* Begin RGBA8 Cases */ + /** + * @constructor + * @struct + * @param {string} name + * @param {number} width + * @param {number} height + */ + var Rgba8Size = function(name, width, height) { + /** @type {string} */ this.name = name; + /** @type {number} */ this.width = width; + /** @type {number} */ this.height = height; + }; + + /** @type {Array<Rgba8Size>} */ var rgba8Sizes = [ + new Rgba8Size('pot', 64, 128), + new Rgba8Size('npot', 63, 112) + ]; + + for (var size = 0; size < rgba8Sizes.length; size++) { + /** @type {tcuTestCase.DeqpTest} */ var rgba8Group = tcuTestCase.newTest('rgba8', ''); + testGroup.addChild(rgba8Group); + for (var wrapS = 0; wrapS < wrapModes.length; wrapS++) { + for (var wrapT = 0; wrapT < wrapModes.length; wrapT++) { + for (var filter = 0; filter < filteringModes.length; filter++) { + name = [ + wrapModes[wrapS].name, + wrapModes[wrapT].name, + filteringModes[filter].name, + rgba8Sizes[size].name + ].join('_'); + + rgba8Group.addChild(es3fTextureWrapTests.textureWrapCaseFromFormat( + name, '', + gl.RGBA, gl.UNSIGNED_BYTE, + wrapModes[wrapS].mode, + wrapModes[wrapT].mode, + filteringModes[filter].mode, filteringModes[filter].mode, + rgba8Sizes[size].width, rgba8Sizes[size].height + )); + } + } + } + } + /* End RGBA8 Cases */ + + /* Begin ETC-2 (and EAC) cases */ + /** + * @constructor + * @struct + * @param {string} name + * @param {tcuCompressedTexture.Format} format + */ + var Etc2Format = function(name, format) { + /** @type {string} */ this.name = name; + /** @type {tcuCompressedTexture.Format} */ this.format = format; + }; + + var etc2Formats = [ + new Etc2Format('eac_r11', tcuCompressedTexture.Format.EAC_R11), + new Etc2Format('eac_signed_r11', tcuCompressedTexture.Format.EAC_SIGNED_R11), + new Etc2Format('eac_rg11', tcuCompressedTexture.Format.EAC_RG11), + new Etc2Format('eac_signed_rg11', tcuCompressedTexture.Format.EAC_SIGNED_RG11), + new Etc2Format('etc2_rgb8', tcuCompressedTexture.Format.ETC2_RGB8), + new Etc2Format('etc2_srgb8', tcuCompressedTexture.Format.ETC2_SRGB8), + new Etc2Format('etc2_rgb8_punchthrough_alpha1', tcuCompressedTexture.Format.ETC2_RGB8_PUNCHTHROUGH_ALPHA1), + new Etc2Format('etc2_srgb8_punchthrough_alpha1', tcuCompressedTexture.Format.ETC2_SRGB8_PUNCHTHROUGH_ALPHA1), + new Etc2Format('etc2_eac_rgba8', tcuCompressedTexture.Format.ETC2_EAC_RGBA8), + new Etc2Format('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 = []; + } + + /** + * @constructor + * @struct + * @param {string} name + * @param {number} width + * @param {number} height + */ + var Etc2Size = function(name, width, height) { + /** @type {string} */ this.name = name; + /** @type {number} */ this.width = width; + /** @type {number} */ this.height = height; + }; + + /** @type {Array<Etc2Size>} */ var etc2Sizes = [ + new Etc2Size('pot', 64, 128), + new Etc2Size('npot', 123, 107) + ]; + + for (var formatNdx = 0; formatNdx < etc2Formats.length; formatNdx++) { + for (var size = 0; size < etc2Sizes.length; size++) { + /** @type {tcuTestCase.DeqpTest} */ var formatGroup = tcuTestCase.newTest(etc2Formats[formatNdx].name, ''); + testGroup.addChild(formatGroup); + for (var wrapS = 0; wrapS < wrapModes.length; wrapS++) { + for (var wrapT = 0; wrapT < wrapModes.length; wrapT++) { + for (var filter = 0; filter < filteringModes.length; filter++) { + name = [ + wrapModes[wrapS].name, + wrapModes[wrapT].name, + filteringModes[filter].name, + etc2Sizes[size].name + ].join('_'); + + formatGroup.addChild(new es3fTextureWrapTests.TextureWrapCase( + name, '', + etc2Formats[formatNdx].format, + wrapModes[wrapS].mode, + wrapModes[wrapT].mode, + filteringModes[filter].mode, filteringModes[filter].mode, + etc2Sizes[size].width, etc2Sizes[size].height + )); + } + } + } + } + } + }; + + /** + * Run test + * @param {WebGL2RenderingContext} context + */ + es3fTextureWrapTests.run = function(context, range) { + gl = context; + //Set up Test Root parameters + var testName = 'texture_wrap'; + var testDescription = 'Texture Wrap Tests'; + var state = tcuTestCase.runner; + + state.testName = testName; + state.setRoot(tcuTestCase.newTest(testName, testDescription, null)); + + //Set up name and description of this test series. + setCurrentTestName(testName); + description(testDescription); + + try { + //Create test cases + es3fTextureWrapTests.init(); + if (range) + state.setRange(range); + //Run test cases + tcuTestCase.runTestCases(); + } + catch (err) { + testFailedOptions('Failed to es3fTextureWrapTests.run tests', false); + state.terminate(); + } + }; + +}); |