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();
+        }
+    };
+
+});