diff options
Diffstat (limited to '')
-rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/framework/common/tcuTexVerifierUtil.js | 265 |
1 files changed, 265 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/framework/common/tcuTexVerifierUtil.js b/dom/canvas/test/webgl-conf/checkout/deqp/framework/common/tcuTexVerifierUtil.js new file mode 100644 index 0000000000..4c88f44608 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/framework/common/tcuTexVerifierUtil.js @@ -0,0 +1,265 @@ +/*------------------------------------------------------------------------- + * 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('framework.common.tcuTexVerifierUtil'); +goog.require('framework.common.tcuFloat'); +goog.require('framework.common.tcuTexture'); +goog.require('framework.delibs.debase.deMath'); +goog.require('framework.delibs.debase.deUtil'); + +goog.scope(function() { + + var tcuTexVerifierUtil = framework.common.tcuTexVerifierUtil; + var deMath = framework.delibs.debase.deMath; + var deUtil = framework.delibs.debase.deUtil; + var tcuFloat = framework.common.tcuFloat; + var tcuTexture = framework.common.tcuTexture; + + /** + * @param {number} value + * @param {number} numAccurateBits + * @return {number} + */ + tcuTexVerifierUtil.computeFloatingPointError = function(value, numAccurateBits) { + /** @type {number} */ var numGarbageBits = 23 - numAccurateBits; + /** @type {number} */ var mask = (1 << numGarbageBits) - 1; + /** @type {number} */ var exp = tcuFloat.newFloat32(value).exponent(); + + /** @type {tcuFloat.deFloat} */ var v1 = new tcuFloat.deFloat(); + /** @type {tcuFloat.deFloat} */ var v2 = new tcuFloat.deFloat(); + return v1.construct(1, exp, 1 << 23 | mask).getValue() - v2.construct(1, exp, 1 << 23).getValue(); + }; + + /** + * @param {number} numAccurateBits + * @return {number} + */ + tcuTexVerifierUtil.computeFixedPointError = function(numAccurateBits) { + return tcuTexVerifierUtil.computeFloatingPointError(1.0, numAccurateBits); + }; + + /** + * @param {Array<number>} numAccurateBits + * @return {Array<number>} + */ + tcuTexVerifierUtil.computeFixedPointError_Vector = function(numAccurateBits) { + /** @type {Array<number>} */ var res = []; + for (var ndx = 0; ndx < numAccurateBits.length; ndx++) + res[ndx] = tcuTexVerifierUtil.computeFixedPointError(numAccurateBits[ndx]); + return res; + }; + + /** + * @param {Array<number>} value + * @param {Array<number>} numAccurateBits + * @return {Array<number>} + */ + tcuTexVerifierUtil.computeFloatingPointError_Vector = function(value, numAccurateBits) { + assertMsgOptions(value.length === numAccurateBits.length, '', false, true); + /** @type {Array<number>} */ var res = []; + for (var ndx = 0; ndx < value.length; ndx++) + res[ndx] = tcuTexVerifierUtil.computeFloatingPointError(value[ndx], numAccurateBits[ndx]); + return res; + }; + + // Sampler introspection + + /** + * @param {tcuTexture.FilterMode} mode + * @return {boolean} + */ + tcuTexVerifierUtil.isNearestMipmapFilter = function(mode) { + return mode == tcuTexture.FilterMode.NEAREST_MIPMAP_NEAREST || mode == tcuTexture.FilterMode.LINEAR_MIPMAP_NEAREST; + }; + + /** + * @param {tcuTexture.FilterMode} mode + * @return {boolean} + */ + tcuTexVerifierUtil.isLinearMipmapFilter = function(mode) { + return mode == tcuTexture.FilterMode.NEAREST_MIPMAP_LINEAR || mode == tcuTexture.FilterMode.LINEAR_MIPMAP_LINEAR; + }; + + /** + * @param {tcuTexture.FilterMode} mode + * @return {boolean} + */ + tcuTexVerifierUtil.isMipmapFilter = function(mode) { + return tcuTexVerifierUtil.isNearestMipmapFilter(mode) || tcuTexVerifierUtil.isLinearMipmapFilter(mode); + }; + + /** + * @param {tcuTexture.FilterMode} mode + * @return {boolean} + */ + tcuTexVerifierUtil.isLinearFilter = function(mode) { + return mode == tcuTexture.FilterMode.LINEAR || mode == tcuTexture.FilterMode.LINEAR_MIPMAP_NEAREST || mode == tcuTexture.FilterMode.LINEAR_MIPMAP_LINEAR; + }; + + /** + * @param {tcuTexture.FilterMode} mode + * @return {boolean} + */ + tcuTexVerifierUtil.isNearestFilter = function(mode) { + return !tcuTexVerifierUtil.isLinearFilter(mode); + }; + + /** + * @param {tcuTexture.FilterMode} mode + * @return {tcuTexture.FilterMode} + */ + tcuTexVerifierUtil.getLevelFilter = function(mode) { + return tcuTexVerifierUtil.isLinearFilter(mode) ? tcuTexture.FilterMode.LINEAR : tcuTexture.FilterMode.NEAREST; + }; + + /** + * @param {tcuTexture.WrapMode} mode + * @return {boolean} + */ + tcuTexVerifierUtil.isWrapModeSupported = function(mode) { + return mode != tcuTexture.WrapMode.MIRRORED_REPEAT_CL && mode != tcuTexture.WrapMode.REPEAT_CL; + }; + + /** + * + * @param {boolean} normalizedCoords + * @param {number} dim + * @param {number} coord + * @param {number} coordBits + * @param {number} uvBits + * @return {Array<number>} + */ + tcuTexVerifierUtil.computeNonNormalizedCoordBounds = function(normalizedCoords, dim, coord, coordBits, uvBits) { + /** @type {number} */ var coordErr = tcuTexVerifierUtil.computeFloatingPointError(coord, coordBits); + /** @type {number} */ var minN = coord - coordErr; + /** @type {number} */ var maxN = coord + coordErr; + /** @type {number} */ var minA = normalizedCoords ? minN * dim : minN; + /** @type {number} */ var maxA = normalizedCoords ? maxN * dim : maxN; + /** @type {number} */ var minC = minA - tcuTexVerifierUtil.computeFixedPointError(uvBits); + /** @type {number} */ var maxC = maxA + tcuTexVerifierUtil.computeFixedPointError(uvBits); + assertMsgOptions(minC <= maxC, '', false, true); + return [minC, maxC]; + }; + + /** + * @param {Array<number>} coord + * @param {Array<number>} bits + * @return {?Array<tcuTexture.CubeFace>} + */ + tcuTexVerifierUtil.getPossibleCubeFaces = function(coord, bits) { + + /** @type {Array<tcuTexture.CubeFace>} */ var faces = []; + + /** @type {number} */ var x = coord[0]; + /** @type {number} */ var y = coord[1]; + /** @type {number} */ var z = coord[2]; + /** @type {number} */ var ax = Math.abs(x); + /** @type {number} */ var ay = Math.abs(y); + /** @type {number} */ var az = Math.abs(z); + /** @type {number} */ var ex = tcuTexVerifierUtil.computeFloatingPointError(x, bits[0]); + /** @type {number} */ var ey = tcuTexVerifierUtil.computeFloatingPointError(y, bits[1]); + /** @type {number} */ var ez = tcuTexVerifierUtil.computeFloatingPointError(z, bits[2]); + /** @type {number} */ var numFaces = 0; + + if (ay + ey < ax - ex && az + ez < ax - ex) { + if (x >= ex) faces.push(tcuTexture.CubeFace.CUBEFACE_POSITIVE_X); + if (x <= ex) faces.push(tcuTexture.CubeFace.CUBEFACE_NEGATIVE_X); + } else if (ax + ex < ay - ey && az + ez < ay - ey) { + if (y >= ey) faces.push(tcuTexture.CubeFace.CUBEFACE_POSITIVE_Y); + if (y <= ey) faces.push(tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Y); + } else if (ax + ex < az - ez && ay + ey < az - ez) { + if (z >= ez) faces.push(tcuTexture.CubeFace.CUBEFACE_POSITIVE_Z); + if (z <= ez) faces.push(tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Z); + } else { + // One or more components are equal (or within error bounds). Allow all faces where major axis is not zero. + if (ax > ex) { + faces.push(tcuTexture.CubeFace.CUBEFACE_NEGATIVE_X); + faces.push(tcuTexture.CubeFace.CUBEFACE_POSITIVE_X); + } + + if (ay > ey) { + faces.push(tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Y); + faces.push(tcuTexture.CubeFace.CUBEFACE_POSITIVE_Y); + } + + if (az > ez) { + faces.push(tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Z); + faces.push(tcuTexture.CubeFace.CUBEFACE_POSITIVE_Z); + } + } + + return faces.length == 0 ? null : faces; + }; + + /** + * @param {tcuTexture.Sampler} sampler + * @return {tcuTexture.Sampler} + */ + tcuTexVerifierUtil.getUnnormalizedCoordSampler = function(sampler) { + var copy = /** @type {tcuTexture.Sampler} */ (deUtil.clone(sampler)); + copy.normalizedCoords = false; + return copy; + }; + + /** + * @param {number} a + * @param {number} b + * @return {number} + */ + tcuTexVerifierUtil.imod = function(a, b) { + return deMath.imod(a, b); + }; + + /** + * @param {number} a + * @return {number} + */ + tcuTexVerifierUtil.mirror = function(a) { + return deMath.mirror(a); + }; + + /** + * @param {tcuTexture.WrapMode} mode + * @param {number} c + * @param {number} size + * @return {number} + */ + tcuTexVerifierUtil.wrap = function(mode, c, size) { + switch (mode) { + // \note CL and GL modes are handled identically here, as verification process accounts for + // accuracy differences caused by different methods (wrapping vs. denormalizing first). + case tcuTexture.WrapMode.CLAMP_TO_EDGE: + return deMath.clamp(c, 0, size - 1); + + case tcuTexture.WrapMode.REPEAT_GL: + case tcuTexture.WrapMode.REPEAT_CL: + return deMath.imod(c, size); + + case tcuTexture.WrapMode.MIRRORED_REPEAT_GL: + case tcuTexture.WrapMode.MIRRORED_REPEAT_CL: + return (size - 1) - deMath.mirror(deMath.imod(c, 2 * size) - size); + + default: + throw new Error('Wrap mode not supported.'); + } + }; + +}); |