| /*------------------------------------------------------------------------- |
| * 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.es3fTextureStateQuery'); |
| goog.require('framework.common.tcuTestCase'); |
| goog.require('framework.delibs.debase.deRandom'); |
| goog.require('functional.gles3.es3fApiCase'); |
| goog.require('modules.shared.glsStateQuery'); |
| |
| goog.scope(function() { |
| var es3fTextureStateQuery = functional.gles3.es3fTextureStateQuery; |
| var tcuTestCase = framework.common.tcuTestCase; |
| var glsStateQuery = modules.shared.glsStateQuery; |
| var es3fApiCase = functional.gles3.es3fApiCase; |
| var deRandom = framework.delibs.debase.deRandom; |
| |
| var setParentClass = function(child, parent) { |
| child.prototype = Object.create(parent.prototype); |
| child.prototype.constructor = child; |
| }; |
| |
| /** |
| * @constructor |
| * @extends {es3fApiCase.ApiCase} |
| * @param {string} name |
| * @param {string} description |
| * @param {number} textureTarget |
| */ |
| es3fTextureStateQuery.TextureCase = function(name, description, textureTarget) { |
| es3fApiCase.ApiCase.call(this, name, description, gl); |
| /** @type {WebGLTexture} */ this.m_texture; |
| this.m_textureTarget = textureTarget; |
| }; |
| |
| setParentClass(es3fTextureStateQuery.TextureCase, es3fApiCase.ApiCase); |
| |
| es3fTextureStateQuery.TextureCase.prototype.testTexture = function() { |
| throw new Error('Virtual function. Please override.'); |
| }; |
| |
| es3fTextureStateQuery.TextureCase.prototype.test = function() { |
| this.m_texture = gl.createTexture(); |
| gl.bindTexture(this.m_textureTarget, this.m_texture); |
| |
| this.testTexture(); |
| |
| gl.bindTexture(this.m_textureTarget, null); |
| gl.deleteTexture(this.m_texture); |
| }; |
| |
| /** |
| * @constructor |
| * @extends {es3fTextureStateQuery.TextureCase} |
| * @param {string} name |
| * @param {string} description |
| * @param {number} textureTarget |
| */ |
| es3fTextureStateQuery.IsTextureCase = function(name, description, textureTarget) { |
| es3fTextureStateQuery.TextureCase.call(this, name, description, textureTarget); |
| }; |
| |
| setParentClass(es3fTextureStateQuery.IsTextureCase, es3fTextureStateQuery.TextureCase); |
| |
| es3fTextureStateQuery.IsTextureCase.prototype.testTexture = function() { |
| this.check(glsStateQuery.compare(gl.isTexture(this.m_texture), true), 'gl.isTexture() should have returned true'); |
| }; |
| |
| /** |
| * @constructor |
| * @extends {es3fTextureStateQuery.TextureCase} |
| * @param {string} name |
| * @param {string} description |
| * @param {number} textureTarget |
| * @param {number} valueName |
| * @param {number} initialValue |
| * @param {Array<number>} valueRange |
| */ |
| es3fTextureStateQuery.TextureParamCase = function(name, description, textureTarget, valueName, initialValue, valueRange) { |
| es3fTextureStateQuery.TextureCase.call(this, name, description, textureTarget); |
| this.m_valueName = valueName; |
| this.m_initialValue = initialValue; |
| this.m_valueRange = valueRange; |
| }; |
| |
| setParentClass(es3fTextureStateQuery.TextureParamCase, es3fTextureStateQuery.TextureCase); |
| |
| es3fTextureStateQuery.TextureParamCase.prototype.testTexture = function() { |
| this.check(glsStateQuery.verifyTexture(this.m_textureTarget, this.m_valueName, this.m_initialValue)); |
| |
| for (var ndx = 0; ndx < this.m_valueRange.length; ++ndx) { |
| gl.texParameteri(this.m_textureTarget, this.m_valueName, this.m_valueRange[ndx]); |
| |
| this.check(glsStateQuery.verifyTexture(this.m_textureTarget, this.m_valueName, this.m_valueRange[ndx])); |
| } |
| |
| //check unit conversions with float |
| |
| for (var ndx = 0; ndx < this.m_valueRange.length; ++ndx) { |
| gl.texParameterf(this.m_textureTarget, this.m_valueName, this.m_valueRange[ndx]); |
| |
| this.check(glsStateQuery.verifyTexture(this.m_textureTarget, this.m_valueName, this.m_valueRange[ndx])); |
| } |
| }; |
| |
| /** |
| * @constructor |
| * @extends {es3fTextureStateQuery.TextureCase} |
| * @param {string} name |
| * @param {string} description |
| * @param {number} textureTarget |
| * @param {number} lodTarget |
| * @param {number} initialValue |
| */ |
| es3fTextureStateQuery.TextureLODCase = function(name, description, textureTarget, lodTarget, initialValue) { |
| es3fTextureStateQuery.TextureCase.call(this, name, description, textureTarget); |
| this.m_lodTarget = lodTarget; |
| this.m_initialValue = initialValue; |
| }; |
| |
| setParentClass(es3fTextureStateQuery.TextureLODCase, es3fTextureStateQuery.TextureCase); |
| |
| es3fTextureStateQuery.TextureLODCase.prototype.testTexture = function() { |
| var rnd = new deRandom.Random(0xabcdef); |
| |
| this.check(glsStateQuery.verifyTexture(this.m_textureTarget, this.m_lodTarget, this.m_initialValue)); |
| |
| var numIterations = 60; |
| for (var ndx = 0; ndx < numIterations; ++ndx) { |
| var ref = rnd.getFloat(-64000, 64000); |
| |
| gl.texParameterf(this.m_textureTarget, this.m_lodTarget, ref); |
| |
| this.check(glsStateQuery.verifyTexture(this.m_textureTarget, this.m_lodTarget, ref)); |
| } |
| |
| // check unit conversions with int |
| |
| for (var ndx = 0; ndx < numIterations; ++ndx) { |
| var ref = rnd.getInt(-64000, 64000); |
| |
| gl.texParameteri(this.m_textureTarget, this.m_lodTarget, ref); |
| |
| this.check(glsStateQuery.verifyTexture(this.m_textureTarget, this.m_lodTarget, ref)); |
| } |
| }; |
| |
| /** |
| * @constructor |
| * @extends {es3fTextureStateQuery.TextureCase} |
| * @param {string} name |
| * @param {string} description |
| * @param {number} textureTarget |
| * @param {number} levelTarget |
| * @param {number} initialValue |
| */ |
| es3fTextureStateQuery.TextureLevelCase = function(name, description, textureTarget, levelTarget, initialValue) { |
| es3fTextureStateQuery.TextureCase.call(this, name, description, textureTarget); |
| this.m_levelTarget = levelTarget; |
| this.m_initialValue = initialValue; |
| }; |
| |
| setParentClass(es3fTextureStateQuery.TextureLevelCase, es3fTextureStateQuery.TextureCase); |
| |
| es3fTextureStateQuery.TextureLevelCase.prototype.testTexture = function() { |
| var rnd = new deRandom.Random(0xabcdef); |
| |
| this.check(glsStateQuery.verifyTexture(this.m_textureTarget, this.m_levelTarget, this.m_initialValue)); |
| |
| var numIterations = 60; |
| for (var ndx = 0; ndx < numIterations; ++ndx) { |
| var ref = rnd.getInt(0, 64000); |
| |
| gl.texParameteri(this.m_textureTarget, this.m_levelTarget, ref); |
| |
| this.check(glsStateQuery.verifyTexture(this.m_textureTarget, this.m_levelTarget, ref)); |
| } |
| |
| // check unit conversions with float |
| var nonSignificantOffsets = [-0.45, -0.25, 0, 0.45]; // offsets O so that for any integers z in Z, o in O roundToClosestInt(z+o)==z |
| |
| for (var ndx = 0; ndx < numIterations; ++ndx) { |
| var ref = rnd.getInt(0, 64000); |
| |
| for (var i = 0; i < nonSignificantOffsets.length; i++) { |
| gl.texParameterf(this.m_textureTarget, this.m_levelTarget, ref + nonSignificantOffsets[i]); |
| this.check(glsStateQuery.verifyTexture(this.m_textureTarget, this.m_levelTarget, ref)); |
| } |
| } |
| }; |
| |
| /** |
| * @constructor |
| * @extends {es3fTextureStateQuery.TextureCase} |
| * @param {string} name |
| * @param {string} description |
| * @param {number} textureTarget |
| */ |
| es3fTextureStateQuery.TextureImmutableLevelsCase = function(name, description, textureTarget) { |
| es3fTextureStateQuery.TextureCase.call(this, name, description, textureTarget); |
| }; |
| |
| setParentClass(es3fTextureStateQuery.TextureImmutableLevelsCase, es3fTextureStateQuery.TextureCase); |
| |
| es3fTextureStateQuery.TextureImmutableLevelsCase.prototype.testTexture = function() { |
| this.check(glsStateQuery.verifyTexture(this.m_textureTarget, gl.TEXTURE_IMMUTABLE_LEVELS, 0)); |
| for (var level = 1; level <= 8; ++level) { |
| var textureID = gl.createTexture(); |
| gl.bindTexture(this.m_textureTarget, textureID); |
| |
| if (this.m_textureTarget == gl.TEXTURE_2D_ARRAY || this.m_textureTarget == gl.TEXTURE_3D) |
| gl.texStorage3D(this.m_textureTarget, level, gl.RGB8, 256, 256, 256); |
| else |
| gl.texStorage2D(this.m_textureTarget, level, gl.RGB8, 256, 256); |
| |
| this.check(glsStateQuery.verifyTexture(this.m_textureTarget, gl.TEXTURE_IMMUTABLE_LEVELS, level)); |
| gl.deleteTexture(textureID); |
| } |
| }; |
| |
| /** |
| * @constructor |
| * @extends {es3fTextureStateQuery.TextureCase} |
| * @param {string} name |
| * @param {string} description |
| * @param {number} textureTarget |
| */ |
| es3fTextureStateQuery.TextureImmutableFormatCase = function(name, description, textureTarget) { |
| es3fTextureStateQuery.TextureCase.call(this, name, description, textureTarget); |
| }; |
| |
| setParentClass(es3fTextureStateQuery.TextureImmutableFormatCase, es3fTextureStateQuery.TextureCase); |
| |
| es3fTextureStateQuery.TextureImmutableFormatCase.prototype.testTexture = function() { |
| this.check(glsStateQuery.verifyTexture(this.m_textureTarget, gl.TEXTURE_IMMUTABLE_LEVELS, 0)); |
| var testSingleFormat = function(format) { |
| var textureID = gl.createTexture(); |
| gl.bindTexture(this.m_textureTarget, textureID); |
| |
| if (this.m_textureTarget == gl.TEXTURE_2D_ARRAY || this.m_textureTarget == gl.TEXTURE_3D) |
| gl.texStorage3D(this.m_textureTarget, 1, format, 32, 32, 32); |
| else |
| gl.texStorage2D(this.m_textureTarget, 1, format, 32, 32); |
| |
| this.check(glsStateQuery.verifyTexture(this.m_textureTarget, gl.TEXTURE_IMMUTABLE_FORMAT, 1)); |
| gl.deleteTexture(textureID); |
| }; |
| |
| var formats = [ |
| gl.RGBA32I, gl.RGBA32UI, gl.RGBA16I, gl.RGBA16UI, gl.RGBA8, gl.RGBA8I, |
| gl.RGBA8UI, gl.SRGB8_ALPHA8, gl.RGB10_A2, gl.RGB10_A2UI, gl.RGBA4, |
| gl.RGB5_A1, gl.RGB8, gl.RGB565, gl.RG32I, gl.RG32UI, gl.RG16I, gl.RG16UI, |
| gl.RG8, gl.RG8I, gl.RG8UI, gl.R32I, gl.R32UI, gl.R16I, gl.R16UI, gl.R8, |
| gl.R8I, gl.R8UI, |
| |
| gl.RGBA32F, gl.RGBA16F, gl.RGBA8_SNORM, gl.RGB32F, |
| gl.RGB32I, gl.RGB32UI, gl.RGB16F, gl.RGB16I, gl.RGB16UI, gl.RGB8_SNORM, |
| gl.RGB8I, gl.RGB8UI, gl.SRGB8, gl.R11F_G11F_B10F, gl.RGB9_E5, gl.RG32F, |
| gl.RG16F, gl.RG8_SNORM, gl.R32F, gl.R16F, gl.R8_SNORM |
| ]; |
| |
| var non3dFormats = [ |
| gl.DEPTH_COMPONENT32F, gl.DEPTH_COMPONENT24, gl.DEPTH_COMPONENT16, |
| gl.DEPTH32F_STENCIL8, gl.DEPTH24_STENCIL8 |
| ]; |
| |
| for (var formatNdx = 0; formatNdx < formats.length; ++formatNdx) |
| testSingleFormat.bind(this, formats[formatNdx]); |
| |
| if (this.m_textureTarget != gl.TEXTURE_3D) |
| for (var formatNdx = 0; formatNdx < non3dFormats.length; ++formatNdx) |
| testSingleFormat.bind(this, non3dFormats[formatNdx]); |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| */ |
| es3fTextureStateQuery.TextureStateQuery = function() { |
| tcuTestCase.DeqpTest.call(this, 'texture', 'Texture State Query tests'); |
| }; |
| |
| es3fTextureStateQuery.TextureStateQuery.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fTextureStateQuery.TextureStateQuery.prototype.constructor = es3fTextureStateQuery.TextureStateQuery; |
| |
| es3fTextureStateQuery.TextureStateQuery.prototype.init = function() { |
| var textureTargets = [ |
| ['texture_2d', gl.TEXTURE_2D], |
| ['texture_3d', gl.TEXTURE_3D], |
| ['texture_2d_array', gl.TEXTURE_2D_ARRAY], |
| ['texture_cube_map', gl.TEXTURE_CUBE_MAP] |
| ]; |
| |
| var state = this; |
| var wrapValues = [gl.CLAMP_TO_EDGE, gl.REPEAT, gl.MIRRORED_REPEAT]; |
| var magValues = [gl.NEAREST, gl.LINEAR]; |
| var minValues = [gl.NEAREST, gl.LINEAR, gl.NEAREST_MIPMAP_NEAREST, gl.NEAREST_MIPMAP_LINEAR, gl.LINEAR_MIPMAP_NEAREST, gl.LINEAR_MIPMAP_LINEAR]; |
| var modes = [gl.COMPARE_REF_TO_TEXTURE, gl.NONE]; |
| var compareFuncs = [gl.LEQUAL, gl.GEQUAL, gl.LESS, gl.GREATER, gl.EQUAL, gl.NOTEQUAL, gl.ALWAYS, gl.NEVER]; |
| textureTargets.forEach(function(elem) { |
| var name = elem[0]; |
| var target = elem[1]; |
| state.addChild(new es3fTextureStateQuery.IsTextureCase(name + '_is_texture', 'IsTexture', target)); |
| state.addChild(new es3fTextureStateQuery.TextureParamCase(name + '_texture_wrap_s' , 'TEXTURE_WRAP_S', |
| target, gl.TEXTURE_WRAP_S, gl.REPEAT, wrapValues)); |
| if (target == gl.TEXTURE_2D || |
| target == gl.TEXTURE_3D || |
| target == gl.TEXTURE_CUBE_MAP) |
| state.addChild(new es3fTextureStateQuery.TextureParamCase(name + '_texture_wrap_t' , 'TEXTURE_WRAP_T', |
| target, gl.TEXTURE_WRAP_T, gl.REPEAT, wrapValues)); |
| |
| if (target == gl.TEXTURE_3D) |
| state.addChild(new es3fTextureStateQuery.TextureParamCase(name + '_texture_wrap_r' , 'TEXTURE_WRAP_R', |
| target, gl.TEXTURE_WRAP_R, gl.REPEAT, wrapValues)); |
| |
| state.addChild(new es3fTextureStateQuery.TextureParamCase(name + '_texture_mag_filter' , 'TEXTURE_MAG_FILTER', |
| target, gl.TEXTURE_MAG_FILTER, gl.LINEAR, magValues)); |
| state.addChild(new es3fTextureStateQuery.TextureParamCase(name + '_texture_min_filter' , 'TEXTURE_MIN_FILTER', |
| target, gl.TEXTURE_MIN_FILTER, gl.NEAREST_MIPMAP_LINEAR, minValues)); |
| state.addChild(new es3fTextureStateQuery.TextureLODCase(name + '_texture_min_lod' , 'TEXTURE_MIN_LOD', target, gl.TEXTURE_MIN_LOD, -1000)); |
| state.addChild(new es3fTextureStateQuery.TextureLODCase(name + '_texture_max_lod' , 'TEXTURE_MAX_LOD', target, gl.TEXTURE_MAX_LOD, 1000)); |
| state.addChild(new es3fTextureStateQuery.TextureLevelCase(name + '_texture_base_level' , 'TEXTURE_BASE_LEVEL', target, gl.TEXTURE_BASE_LEVEL, 0)); |
| state.addChild(new es3fTextureStateQuery.TextureLevelCase(name + '_texture_max_level' , 'TEXTURE_MAX_LEVEL', target, gl.TEXTURE_MAX_LEVEL, 1000)); |
| |
| state.addChild(new es3fTextureStateQuery.TextureParamCase(name + '_texture_compare_mode' , 'TEXTURE_COMPARE_MODE', |
| target, gl.TEXTURE_COMPARE_MODE, gl.NONE, modes)); |
| state.addChild(new es3fTextureStateQuery.TextureParamCase(name + '_texture_compare_func' , 'TEXTURE_COMPARE_FUNC', |
| target, gl.TEXTURE_COMPARE_FUNC, gl.LEQUAL, compareFuncs)); |
| |
| state.addChild(new es3fTextureStateQuery.TextureImmutableLevelsCase(name + '_texture_immutable_levels', 'TEXTURE_IMMUTABLE_LEVELS', target)); |
| state.addChild(new es3fTextureStateQuery.TextureImmutableFormatCase(name + '_texture_immutable_format', 'TEXTURE_IMMUTABLE_FORMAT', target)); |
| }); |
| }; |
| |
| /** |
| * Run test |
| * @param {WebGL2RenderingContext} context |
| */ |
| es3fTextureStateQuery.run = function(context) { |
| gl = context; |
| //Set up Test Root parameters |
| var state = tcuTestCase.runner; |
| state.setRoot(new es3fTextureStateQuery.TextureStateQuery()); |
| |
| //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 es3fTextureStateQuery.run tests', false); |
| tcuTestCase.runner.terminate(); |
| } |
| }; |
| |
| }); |