Source code
Revision control
Copy as Markdown
Other Tools
/*-------------------------------------------------------------------------
* 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
*
*
* 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.es3fFramebufferBlitTests');
goog.require('framework.common.tcuImageCompare');
goog.require('framework.common.tcuRGBA');
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.opengl.gluShaderUtil');
goog.require('framework.opengl.gluTextureUtil');
goog.require('framework.opengl.simplereference.sglrGLContext');
goog.require('framework.opengl.simplereference.sglrReferenceContext');
goog.require('framework.referencerenderer.rrUtil');
goog.require('functional.gles3.es3fFboTestCase');
goog.require('functional.gles3.es3fFboTestUtil');
goog.scope(function() {
var es3fFramebufferBlitTests = functional.gles3.es3fFramebufferBlitTests;
var es3fFboTestCase = functional.gles3.es3fFboTestCase;
var es3fFboTestUtil = functional.gles3.es3fFboTestUtil;
var tcuTestCase = framework.common.tcuTestCase;
var tcuSurface = framework.common.tcuSurface;
var tcuRGBA = framework.common.tcuRGBA;
var tcuImageCompare = framework.common.tcuImageCompare;
var tcuTexture = framework.common.tcuTexture;
var tcuTextureUtil = framework.common.tcuTextureUtil;
var deMath = framework.delibs.debase.deMath;
var gluTextureUtil = framework.opengl.gluTextureUtil;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var rrUtil = framework.referencerenderer.rrUtil;
var sglrReferenceContext = framework.opengl.simplereference.sglrReferenceContext;
var sglrGLContext = framework.opengl.simplereference.sglrGLContext;
var DE_ASSERT = function(x) {
if (!x)
throw new Error('Assert failed');
};
/** @type {WebGL2RenderingContext} */ var gl;
/**
* es3fFramebufferBlitTests.BlitRectCase class, inherits from FboTestCase
* @constructor
* @extends {es3fFboTestCase.FboTestCase}
* @param {string} name
* @param {string} desc
* @param {number} filter deUint32
* @param {Array<number>} srcSize
* @param {Array<number>} srcRect
* @param {Array<number>} dstSize
* @param {Array<number>} dstRect
* @param {number=} cellSize
*/
es3fFramebufferBlitTests.BlitRectCase = function(name, desc, filter, srcSize, srcRect, dstSize, dstRect, cellSize) {
es3fFboTestCase.FboTestCase.call(this, name, desc);
/** @const {number} */ this.m_filter = filter;
/** @const {Array<number>} */ this.m_srcSize = srcSize;
/** @const {Array<number>} */ this.m_srcRect = srcRect;
/** @const {Array<number>} */ this.m_dstSize = dstSize;
/** @const {Array<number>} */ this.m_dstRect = dstRect;
/** @const {number} */ this.m_cellSize = cellSize === undefined ? 8 : cellSize;
/** @const {Array<number>} */ this.m_gridCellColorA = [0.2, 0.7, 0.1, 1.0];
/** @const {Array<number>} */ this.m_gridCellColorB = [0.7, 0.1, 0.5, 0.8];
};
es3fFramebufferBlitTests.BlitRectCase.prototype = Object.create(es3fFboTestCase.FboTestCase.prototype);
es3fFramebufferBlitTests.BlitRectCase.prototype.constructor = es3fFramebufferBlitTests.BlitRectCase;
/**
* @param {tcuSurface.Surface} dst
*/
es3fFramebufferBlitTests.BlitRectCase.prototype.render = function(dst) {
var ctx = this.getCurrentContext();
/** @type {number} */ var colorFormat = gl.RGBA8;
/** @type {es3fFboTestUtil.GradientShader} */
var gradShader = new es3fFboTestUtil.GradientShader(
gluShaderUtil.DataType.FLOAT_VEC4);
/** @type {es3fFboTestUtil.Texture2DShader} */
var texShader = new es3fFboTestUtil.Texture2DShader(
[gluShaderUtil.DataType.SAMPLER_2D],
gluShaderUtil.DataType.FLOAT_VEC4);
var gradShaderID = ctx.createProgram(gradShader);
var texShaderID = ctx.createProgram(texShader);
var srcFbo;
var dstFbo;
var srcRbo;
var dstRbo;
// Setup shaders
gradShader.setGradient(ctx, gradShaderID, [0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]);
texShader.setUniforms(ctx, texShaderID);
// Create framebuffers.
/** @type {Array<number>} */ var size;
// source framebuffers
srcFbo = ctx.createFramebuffer();
srcRbo = ctx.createRenderbuffer();
size = this.m_srcSize;
ctx.bindRenderbuffer(gl.RENDERBUFFER, srcRbo);
ctx.renderbufferStorage(gl.RENDERBUFFER, colorFormat, size[0], size[1]);
ctx.bindFramebuffer(gl.FRAMEBUFFER, srcFbo);
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, srcRbo);
this.checkError();
this.checkFramebufferStatus(gl.FRAMEBUFFER);
// destination framebuffers
dstFbo = ctx.createFramebuffer();
dstRbo = ctx.createRenderbuffer();
size = this.m_dstSize;
ctx.bindRenderbuffer(gl.RENDERBUFFER, dstRbo);
ctx.renderbufferStorage(gl.RENDERBUFFER, colorFormat, size[0], size[1]);
ctx.bindFramebuffer(gl.FRAMEBUFFER, dstFbo);
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, dstRbo);
this.checkError();
this.checkFramebufferStatus(gl.FRAMEBUFFER);
// Fill destination with gradient.
ctx.bindFramebuffer(gl.FRAMEBUFFER, dstFbo);
ctx.viewport(0, 0, this.m_dstSize[0], this.m_dstSize[1]);
rrUtil.drawQuad(ctx, gradShaderID, [-1, -1, 0], [1, 1, 0]);
// Fill source with grid pattern.
/** @const {number} */ var format = gl.RGBA;
/** @const {number} */ var dataType = gl.UNSIGNED_BYTE;
/** @const {number} */ var texW = this.m_srcSize[0];
/** @const {number} */ var texH = this.m_srcSize[1];
var gridTex;
/** @type {tcuTexture.TextureLevel} */ var data = new tcuTexture.TextureLevel(gluTextureUtil.mapGLTransferFormat(format, dataType), texW, texH, 1);
tcuTextureUtil.fillWithGrid(data.getAccess(), this.m_cellSize, this.m_gridCellColorA, this.m_gridCellColorB);
gridTex = ctx.createTexture();
ctx.bindTexture(gl.TEXTURE_2D, gridTex);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
ctx.texImage2D(gl.TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr());
ctx.bindFramebuffer(gl.FRAMEBUFFER, srcFbo);
ctx.viewport(0, 0, this.m_srcSize[0], this.m_srcSize[1]);
rrUtil.drawQuad(ctx, texShaderID, [-1, -1, 0], [1, 1, 0]);
// Perform copy.
ctx.bindFramebuffer(gl.READ_FRAMEBUFFER, srcFbo);
ctx.bindFramebuffer(gl.DRAW_FRAMEBUFFER, dstFbo);
ctx.blitFramebuffer(this.m_srcRect[0], this.m_srcRect[1], this.m_srcRect[2], this.m_srcRect[3],
this.m_dstRect[0], this.m_dstRect[1], this.m_dstRect[2], this.m_dstRect[3],
gl.COLOR_BUFFER_BIT, this.m_filter);
// Read back results.
ctx.bindFramebuffer(gl.READ_FRAMEBUFFER, dstFbo);
this.readPixelsUsingFormat(dst, 0, 0, this.m_dstSize[0], this.m_dstSize[1],
gluTextureUtil.mapGLInternalFormat(colorFormat),
[1.0, 1.0, 1.0, 1.0],
[0.0, 0.0, 0.0, 0.0]);
};
/**
* @param {tcuSurface.Surface} reference
* @param {tcuSurface.Surface} result
* @return {boolean}
*/
es3fFramebufferBlitTests.BlitRectCase.prototype.compare = function(reference, result) {
// Use pixel-threshold compare for rect cases since 1px off will mean failure.
var threshold = [7, 7, 7, 7];
return tcuImageCompare.pixelThresholdCompare('Result', 'Image comparison result', reference, result, threshold);
};
/**
* es3fFramebufferBlitTests.BlitNearestFilterConsistencyCase class
* @constructor
* @extends {es3fFramebufferBlitTests.BlitRectCase}
* @param {string} name
* @param {string} desc
* @param {Array<number>} srcSize
* @param {Array<number>} srcRect
* @param {Array<number>} dstSize
* @param {Array<number>} dstRect
*/
es3fFramebufferBlitTests.BlitNearestFilterConsistencyCase = function(name, desc, srcSize, srcRect, dstSize, dstRect) {
es3fFramebufferBlitTests.BlitRectCase.call(this, name, desc, gl.NEAREST, srcSize, srcRect, dstSize, dstRect, 1);
};
es3fFramebufferBlitTests.BlitNearestFilterConsistencyCase.prototype = Object.create(es3fFramebufferBlitTests.BlitRectCase.prototype);
es3fFramebufferBlitTests.BlitNearestFilterConsistencyCase.prototype.constructor = es3fFramebufferBlitTests.BlitNearestFilterConsistencyCase;
/**
* @param {tcuSurface.Surface} reference
* @param {tcuSurface.Surface} result
* @return {boolean}
*/
es3fFramebufferBlitTests.BlitNearestFilterConsistencyCase.prototype.compare = function(reference, result) {
assertMsgOptions(result.getWidth() == reference.getWidth() && result.getHeight() == reference.getHeight(),
'Reference and result images have different dimensions', false, true);
// Image origin must be visible (for baseColor)
DE_ASSERT(Math.min(this.m_dstRect[0], this.m_dstRect[2]) >= 0);
DE_ASSERT(Math.min(this.m_dstRect[1], this.m_dstRect[3]) >= 0);
/** @const {tcuRGBA.RGBA} */ var cellColorA = tcuRGBA.newRGBAFromVec(this.m_gridCellColorA);
/** @const {tcuRGBA.RGBA} */ var cellColorB = tcuRGBA.newRGBAFromVec(this.m_gridCellColorB);
// TODO: implement
// const tcu::RGBA threshold = this.m_context.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(7,7,7,7);
/** @type {tcuRGBA.RGBA} */ var threshold = tcuRGBA.newRGBAComponents(7, 7, 7, 7);
/** @const {Array<number>} */ //IVec4.xyzw
var destinationArea = [
deMath.clamp(Math.min(this.m_dstRect[0], this.m_dstRect[2]), 0, result.getWidth()),
deMath.clamp(Math.min(this.m_dstRect[1], this.m_dstRect[3]), 0, result.getHeight()),
deMath.clamp(Math.max(this.m_dstRect[0], this.m_dstRect[2]), 0, result.getWidth()),
deMath.clamp(Math.max(this.m_dstRect[1], this.m_dstRect[3]), 0, result.getHeight())];
/** @const {tcuRGBA.RGBA} */ var baseColor = new tcuRGBA.RGBA(result.getPixel(destinationArea[0], destinationArea[1]));
/** @const {boolean} */ var signConfig = tcuRGBA.compareThreshold(baseColor, cellColorA, threshold);
/** @type {boolean} */ var error = false;
/** @type {tcuSurface.Surface} */ var errorMask = new tcuSurface.Surface(result.getWidth(), result.getHeight());
/** @type {Array<boolean>} */ var horisontalSign = [];
/** @type {Array<boolean>} */ var verticalSign = [];
errorMask.getAccess().clear([0.0, 1.0, 0.0, 1.0]);
// Checking only area in our destination rect
// m_testCtx.getLog()
// << tcu::TestLog::Message
// << 'Verifying consistency of NEAREST filtering. Verifying rect ' << m_dstRect << '.\n'
// << 'Rounding direction of the NEAREST filter at the horisontal texel edge (x = n + 0.5) should not depend on the y-coordinate.\n'
// << 'Rounding direction of the NEAREST filter at the vertical texel edge (y = n + 0.5) should not depend on the x-coordinate.\n'
// << 'Blitting a grid (with uniform sized cells) should result in a grid (with non-uniform sized cells).'
// << tcu::TestLog::EndMessage;
// Verify that destination only contains valid colors
/** @type {tcuRGBA.RGBA} */ var color;
for (var dy = 0; dy < destinationArea[3] - destinationArea[1]; ++dy) {
for (var dx = 0; dx < destinationArea[2] - destinationArea[0]; ++dx) {
color = new tcuRGBA.RGBA(result.getPixel(destinationArea[0] + dx, destinationArea[1] + dy));
/** @const {boolean} */
var isValidColor =
tcuRGBA.compareThreshold(color, cellColorA, threshold) ||
tcuRGBA.compareThreshold(color, cellColorB, threshold);
if (!isValidColor) {
errorMask.setPixel(destinationArea[0] + dx, destinationArea[1] + dy, tcuRGBA.RGBA.red.toVec());
error = true;
}
}
}
if (error) {
// m_testCtx.getLog()
// << tcu::TestLog::Message
// << 'Image verification failed, destination rect contains unexpected values. '
// << 'Expected either ' << cellColorA << ' or ' << cellColorB << '.'
// << tcu::TestLog::EndMessage
// << tcu::TestLog::ImageSet('Result', 'Image verification result')
// << tcu::TestLog::Image('Result', 'Result', result)
// << tcu::TestLog::Image('ErrorMask', 'Error mask', errorMask)
// << tcu::TestLog::EndImageSet;
return false;
}
// Detect result edges by reading the first row and first column of the blitted area.
// Blitting a grid should result in a grid-like image. ('sign changes' should be consistent)
for (var dx = 0; dx < destinationArea[2] - destinationArea[0]; ++dx) {
color = new tcuRGBA.RGBA(result.getPixel(destinationArea[0] + dx, destinationArea[1]));
if (tcuRGBA.compareThreshold(color, cellColorA, threshold))
horisontalSign[dx] = true;
else if (tcuRGBA.compareThreshold(color, cellColorB, threshold))
horisontalSign[dx] = false;
else
DE_ASSERT(false);
}
for (var dy = 0; dy < destinationArea[3] - destinationArea[1]; ++dy) {
color = new tcuRGBA.RGBA(result.getPixel(destinationArea[0], destinationArea[1] + dy));
if (tcuRGBA.compareThreshold(color, cellColorA, threshold))
verticalSign[dy] = true;
else if (tcuRGBA.compareThreshold(color, cellColorB, threshold))
verticalSign[dy] = false;
else
DE_ASSERT(false);
}
// Verify grid-like image
for (var dy = 0; dy < destinationArea[3] - destinationArea[1]; ++dy) {
for (var dx = 0; dx < destinationArea[2] - destinationArea[0]; ++dx) {
color = new tcuRGBA.RGBA(result.getPixel(destinationArea[0] + dx, destinationArea[1] + dy));
/** @const {boolean} */ var resultSign = tcuRGBA.compareThreshold(cellColorA, color, threshold);
/** @const {boolean} */ var correctSign = (horisontalSign[dx] == verticalSign[dy]) == signConfig;
if (resultSign != correctSign) {
errorMask.setPixel(destinationArea[0] + dx, destinationArea[1] + dy, tcuRGBA.RGBA.red.toVec());
error = true;
}
}
}
// Report result
// if (error)
// {
// m_testCtx.getLog()
// << tcu::TestLog::Message
// << 'Image verification failed, nearest filter is not consistent.'
// << tcu::TestLog::EndMessage
// << tcu::TestLog::ImageSet('Result', 'Image verification result')
// << tcu::TestLog::Image('Result', 'Result', result)
// << tcu::TestLog::Image('ErrorMask', 'Error mask', errorMask)
// << tcu::TestLog::EndImageSet;
// }
// else
// {
// m_testCtx.getLog()
// << tcu::TestLog::Message
// << 'Image verification passed.'
// << tcu::TestLog::EndMessage
// << tcu::TestLog::ImageSet('Result', 'Image verification result')
// << tcu::TestLog::Image('Result', 'Result', result)
// << tcu::TestLog::EndImageSet;
// }
return !error;
};
/**
* es3fFramebufferBlitTests.FramebufferBlitTests class, inherits from TestCase
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fFramebufferBlitTests.FramebufferBlitTests = function() {
tcuTestCase.DeqpTest.call(this, 'blit', 'Framebuffer blit tests');
};
es3fFramebufferBlitTests.FramebufferBlitTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fFramebufferBlitTests.FramebufferBlitTests.prototype.constructor = es3fFramebufferBlitTests.FramebufferBlitTests;
es3fFramebufferBlitTests.FramebufferBlitTests.prototype.init = function() {
/** @const {Array<number>} */ var colorFormats = [
// RGBA 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,
// RGB formats
gl.RGB8,
gl.RGB565,
// RG formats
gl.RG32I,
gl.RG32UI,
gl.RG16I,
gl.RG16UI,
gl.RG8,
gl.RG8I,
gl.RG8UI,
// R formats
gl.R32I,
gl.R32UI,
gl.R16I,
gl.R16UI,
gl.R8,
gl.R8I,
gl.R8UI,
// gl.EXT_color_buffer_float
gl.RGBA32F,
gl.RGBA16F,
gl.R11F_G11F_B10F,
gl.RG32F,
gl.RG16F,
gl.R32F,
gl.R16F
];
/** @const {Array<number>} */ var depthStencilFormats = [
gl.DEPTH_COMPONENT32F,
gl.DEPTH_COMPONENT24,
gl.DEPTH_COMPONENT16,
gl.DEPTH32F_STENCIL8,
gl.DEPTH24_STENCIL8,
gl.STENCIL_INDEX8
];
// .rect
/** @constructor
* @param {string} name
* @param {Array<number>} srcRect
* @param {Array<number>} dstRect
*/
var CopyRect = function(name, srcRect, dstRect) {
/** @const {string} */ this.name = name;
/** @type {Array<number>} */ this.srcRect = srcRect;
/** @type {Array<number>} */ this.dstRect = dstRect;
};
/** @const {Array<CopyRect>} */ var copyRects = [
new CopyRect('basic', [10, 20, 65, 100], [45, 5, 100, 85]),
new CopyRect('scale', [10, 20, 65, 100], [25, 30, 125, 94]),
new CopyRect('out_of_bounds', [-10, -15, 100, 63], [50, 30, 136, 144])
];
/** @const {Array<CopyRect>} */ var filterConsistencyRects = [
new CopyRect('mag', [20, 10, 74, 88], [10, 10, 91, 101]),
new CopyRect('min', [10, 20, 78, 100], [20, 20, 71, 80]),
new CopyRect('out_of_bounds_mag', [21, 10, 73, 82], [11, 43, 141, 151]),
new CopyRect('out_of_bounds_min', [11, 21, 77, 97], [80, 82, 135, 139])
];
/** @constructor
* @param {?string} name
* @param {Array<number>} srcSwizzle
* @param {Array<number>} dstSwizzle
*/
var Swizzle = function(name, srcSwizzle, dstSwizzle) {
/** @const {?string} */ this.name = name;
/** @type {Array<number>} */ this.srcSwizzle = srcSwizzle;
/** @type {Array<number>} */ this.dstSwizzle = dstSwizzle;
};
/** @const {Array<Swizzle>} */ var swizzles = [
new Swizzle(null, [0, 1, 2, 3], [0, 1, 2, 3]),
new Swizzle('reverse_src_x', [2, 1, 0, 3], [0, 1, 2, 3]),
new Swizzle('reverse_src_y', [0, 3, 2, 1], [0, 1, 2, 3]),
new Swizzle('reverse_dst_x', [0, 1, 2, 3], [2, 1, 0, 3]),
new Swizzle('reverse_dst_y', [0, 1, 2, 3], [0, 3, 2, 1]),
new Swizzle('reverse_src_dst_x', [2, 1, 0, 3], [2, 1, 0, 3]),
new Swizzle('reverse_src_dst_y', [0, 3, 2, 1], [0, 3, 2, 1])
];
/** @const {Array<number>} */ var srcSize = [127, 119];
/** @const {Array<number>} */ var dstSize = [132, 128];
// Blit rectangle tests.
for (var rectNdx = 0; rectNdx < copyRects.length; rectNdx++) {
/** @type {tcuTestCase.DeqpTest} */ var rectGroup = tcuTestCase.newTest('rect', 'Blit rectangle tests');
this.addChild(rectGroup);
for (var swzNdx = 0; swzNdx < swizzles.length; swzNdx++) {
/** @type {string} */ var name = copyRects[rectNdx].name + (swizzles[swzNdx].name ? ('_' + swizzles[swzNdx].name) : '');
/** @type {Array<number>} */ var srcSwz = swizzles[swzNdx].srcSwizzle;
/** @type {Array<number>} */ var dstSwz = swizzles[swzNdx].dstSwizzle;
/** @type {Array<number>} */ var srcRect = deMath.swizzle(copyRects[rectNdx].srcRect, srcSwz);
/** @type {Array<number>} */ var dstRect = deMath.swizzle(copyRects[rectNdx].dstRect, dstSwz);
rectGroup.addChild(new es3fFramebufferBlitTests.BlitRectCase((name + '_nearest'), '', gl.NEAREST, srcSize, srcRect, dstSize, dstRect));
rectGroup.addChild(new es3fFramebufferBlitTests.BlitRectCase((name + '_linear'), '', gl.LINEAR, srcSize, srcRect, dstSize, dstRect));
}
}
// Nearest filter tests
for (var rectNdx = 0; rectNdx < filterConsistencyRects.length; rectNdx++) {
/** @type {tcuTestCase.DeqpTest} */ var rectGroup = tcuTestCase.newTest('rect', 'Blit rectangle tests');
this.addChild(rectGroup);
for (var swzNdx = 0; swzNdx < swizzles.length; swzNdx++) {
var name = 'nearest_consistency_' + filterConsistencyRects[rectNdx].name + (swizzles[swzNdx].name ? ('_' + swizzles[swzNdx].name) : '');
var srcSwz = swizzles[swzNdx].srcSwizzle;
var dstSwz = swizzles[swzNdx].dstSwizzle;
var srcRect = deMath.swizzle(filterConsistencyRects[rectNdx].srcRect, srcSwz);
var dstRect = deMath.swizzle(filterConsistencyRects[rectNdx].dstRect, dstSwz);
rectGroup.addChild(new es3fFramebufferBlitTests.BlitNearestFilterConsistencyCase(name, 'Test consistency of the nearest filter', srcSize, srcRect, dstSize, dstRect));
}
}
// .conversion
for (var srcFmtNdx = 0; srcFmtNdx < colorFormats.length; srcFmtNdx++) {
/** @type {tcuTestCase.DeqpTest} */ var conversionGroup = tcuTestCase.newTest('conversion', 'Color conversion tests');
this.addChild(conversionGroup);
for (var dstFmtNdx = 0; dstFmtNdx < colorFormats.length; dstFmtNdx++) {
/** @type {number} */ var srcFormat = colorFormats[srcFmtNdx];
/** @type {tcuTexture.TextureFormat} */ var srcTexFmt = gluTextureUtil.mapGLInternalFormat(srcFormat);
/** @type {tcuTexture.TextureChannelClass} */ var srcType = tcuTexture.getTextureChannelClass(srcTexFmt.type);
/** @type {number} */ var dstFormat = colorFormats[dstFmtNdx];
/** @type {tcuTexture.TextureFormat} */ var dstTexFmt = gluTextureUtil.mapGLInternalFormat(dstFormat);
/** @type {tcuTexture.TextureChannelClass} */ var dstType = tcuTexture.getTextureChannelClass(dstTexFmt.type);
if (((srcType == tcuTexture.TextureChannelClass.FLOATING_POINT || srcType == tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT) !=
(dstType == tcuTexture.TextureChannelClass.FLOATING_POINT || dstType == tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT)) ||
((srcType == tcuTexture.TextureChannelClass.SIGNED_INTEGER) != (dstType == tcuTexture.TextureChannelClass.SIGNED_INTEGER)) ||
((srcType == tcuTexture.TextureChannelClass.UNSIGNED_INTEGER) != (dstType == tcuTexture.TextureChannelClass.UNSIGNED_INTEGER)))
continue; // Conversion not supported.
var name = es3fFboTestUtil.getFormatName(srcFormat) + '_to_' + es3fFboTestUtil.getFormatName(dstFormat);
conversionGroup.addChild(new es3fFramebufferBlitTests.BlitColorConversionCase(name, '', srcFormat, dstFormat, [127, 113]));
}
}
// .depth_stencil
/** @type {tcuTestCase.DeqpTest} */ var depthStencilGroup = tcuTestCase.newTest('depth_stencil', 'Depth and stencil blits');
this.addChild(depthStencilGroup);
for (var fmtNdx = 0; fmtNdx < depthStencilFormats.length; fmtNdx++) {
/** @type {number} */ var format = depthStencilFormats[fmtNdx];
/** @type {tcuTexture.TextureFormat} */ var texFmt = gluTextureUtil.mapGLInternalFormat(format);
/** @type {string} */ var fmtName = es3fFboTestUtil.getFormatName(format);
/** @type {boolean} */ var depth = texFmt.order == tcuTexture.ChannelOrder.D || texFmt.order == tcuTexture.ChannelOrder.DS;
/** @type {boolean} */ var stencil = texFmt.order == tcuTexture.ChannelOrder.S || texFmt.order == tcuTexture.ChannelOrder.DS;
/** @type {number} */ var buffers = (depth ? gl.DEPTH_BUFFER_BIT : 0) | (stencil ? gl.STENCIL_BUFFER_BIT : 0);
depthStencilGroup.addChild(new es3fFramebufferBlitTests.BlitDepthStencilCase((fmtName + '_basic'), '', format, buffers, [128, 128], [0, 0, 128, 128], buffers, [128, 128], [0, 0, 128, 128], buffers));
depthStencilGroup.addChild(new es3fFramebufferBlitTests.BlitDepthStencilCase((fmtName + '_scale'), '', format, buffers, [127, 119], [10, 30, 100, 70], buffers, [111, 130], [20, 5, 80, 130], buffers));
if (depth && stencil) {
depthStencilGroup.addChild(new es3fFramebufferBlitTests.BlitDepthStencilCase((fmtName + '_depth_only'), '', format, buffers, [128, 128], [0, 0, 128, 128], buffers, [128, 128], [0, 0, 128, 128], gl.DEPTH_BUFFER_BIT));
depthStencilGroup.addChild(new es3fFramebufferBlitTests.BlitDepthStencilCase((fmtName + '_stencil_only'), '', format, buffers, [128, 128], [0, 0, 128, 128], buffers, [128, 128], [0, 0, 128, 128], gl.STENCIL_BUFFER_BIT));
}
}
// .default_framebuffer
/**
* @constructor
* @param {string} name
* @param {es3fFramebufferBlitTests.BlitArea} area
*/
var Area = function(name, area) {
/** @type {string} name */ this.name = name;
/** @type {es3fFramebufferBlitTests.BlitArea} area */ this.area = area;
};
/** @type {Array<Area>} */ var areas = [
new Area('scale', es3fFramebufferBlitTests.BlitArea.AREA_SCALE),
new Area('out_of_bounds', es3fFramebufferBlitTests.BlitArea.AREA_OUT_OF_BOUNDS)
];
var numDefaultFbSubGroups = 7;
/** @type {Array<tcuTestCase.DeqpTest>} */ var defaultFbGroup = [];
for (var ii = 0; ii < numDefaultFbSubGroups; ++ii) {
defaultFbGroup[ii] = tcuTestCase.newTest('default_framebuffer', 'Blits with default framebuffer');
this.addChild(defaultFbGroup[ii]);
}
for (var fmtNdx = 0; fmtNdx < colorFormats.length; fmtNdx++) {
var format = colorFormats[fmtNdx];
var texFmt = gluTextureUtil.mapGLInternalFormat(format);
var fmtClass = tcuTexture.getTextureChannelClass(texFmt.type);
var filter = gluTextureUtil.isGLInternalColorFormatFilterable(format) ? gl.LINEAR : gl.NEAREST;
var filterable = gluTextureUtil.isGLInternalColorFormatFilterable(format);
if (fmtClass != tcuTexture.TextureChannelClass.FLOATING_POINT &&
fmtClass != tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT &&
fmtClass != tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT)
continue; // Conversion not supported.
defaultFbGroup[fmtNdx % numDefaultFbSubGroups].addChild(new es3fFramebufferBlitTests.BlitDefaultFramebufferCase(es3fFboTestUtil.getFormatName(format), '', format, filter));
for (var areaNdx = 0; areaNdx < areas.length; areaNdx++) {
var name = areas[areaNdx].name;
var addLinear = filterable;
var addNearest = !addLinear || (areas[areaNdx].area != es3fFramebufferBlitTests.BlitArea.AREA_OUT_OF_BOUNDS); // No need to check out-of-bounds with different filtering
if (addNearest) {
defaultFbGroup[fmtNdx % numDefaultFbSubGroups].addChild(new es3fFramebufferBlitTests.DefaultFramebufferBlitCase((es3fFboTestUtil.getFormatName(format) + '_nearest_' + name + '_blit_from_default'), '', format, gl.NEAREST, es3fFramebufferBlitTests.BlitDirection.BLIT_DEFAULT_TO_TARGET, areas[areaNdx].area));
defaultFbGroup[fmtNdx % numDefaultFbSubGroups].addChild(new es3fFramebufferBlitTests.DefaultFramebufferBlitCase((es3fFboTestUtil.getFormatName(format) + '_nearest_' + name + '_blit_to_default'), '', format, gl.NEAREST, es3fFramebufferBlitTests.BlitDirection.BLIT_TO_DEFAULT_FROM_TARGET, areas[areaNdx].area));
}
if (addLinear) {
defaultFbGroup[fmtNdx % numDefaultFbSubGroups].addChild(new es3fFramebufferBlitTests.DefaultFramebufferBlitCase((es3fFboTestUtil.getFormatName(format) + '_linear_' + name + '_blit_from_default'), '', format, gl.LINEAR, es3fFramebufferBlitTests.BlitDirection.BLIT_DEFAULT_TO_TARGET, areas[areaNdx].area));
defaultFbGroup[fmtNdx % numDefaultFbSubGroups].addChild(new es3fFramebufferBlitTests.DefaultFramebufferBlitCase((es3fFboTestUtil.getFormatName(format) + '_linear_' + name + '_blit_to_default'), '', format, gl.LINEAR, es3fFramebufferBlitTests.BlitDirection.BLIT_TO_DEFAULT_FROM_TARGET, areas[areaNdx].area));
}
}
}
};
/**
* @param {?tcuTexture.ChannelOrder} order
* @return {Array<boolean>}
*/
es3fFramebufferBlitTests.getChannelMask = function(order) {
switch (order) {
case tcuTexture.ChannelOrder.R: return [true, false, false, false];
case tcuTexture.ChannelOrder.RG: return [true, true, false, false];
case tcuTexture.ChannelOrder.RGB: return [true, true, true, false];
case tcuTexture.ChannelOrder.RGBA: return [true, true, true, true];
case tcuTexture.ChannelOrder.sRGB: return [true, true, true, false];
case tcuTexture.ChannelOrder.sRGBA: return [true, true, true, true];
default:
DE_ASSERT(false);
return [false, false, false, false];
}
};
/**
* es3fFramebufferBlitTests.BlitColorConversionCase class, inherits from FboTestCase
* @constructor
* @extends {es3fFboTestCase.FboTestCase}
* @param {string} name
* @param {string} desc
* @param {number} srcFormat
* @param {number} dstFormat
* @param {Array<number>} size
*/
es3fFramebufferBlitTests.BlitColorConversionCase = function(name, desc, srcFormat, dstFormat, size) {
es3fFboTestCase.FboTestCase.call(this, name, desc);
/** @type {number} */ this.m_srcFormat = srcFormat;
/** @type {number} */ this.m_dstFormat = dstFormat;
/** @type {Array<number>} */ this.m_size = size;
};
es3fFramebufferBlitTests.BlitColorConversionCase.prototype = Object.create(es3fFboTestCase.FboTestCase.prototype);
es3fFramebufferBlitTests.BlitColorConversionCase.prototype.constructor = es3fFramebufferBlitTests.BlitColorConversionCase;
es3fFramebufferBlitTests.BlitColorConversionCase.prototype.preCheck = function() {
this.checkFormatSupport(this.m_srcFormat);
this.checkFormatSupport(this.m_dstFormat);
return true; // No exception thrown
};
/**
* @param {tcuSurface.Surface} dst
*/
es3fFramebufferBlitTests.BlitColorConversionCase.prototype.render = function(dst) {
var ctx = this.getCurrentContext();
/** @type {tcuTexture.TextureFormat} */ var srcFormat = gluTextureUtil.mapGLInternalFormat(this.m_srcFormat);
/** @type {tcuTexture.TextureFormat} */ var dstFormat = gluTextureUtil.mapGLInternalFormat(this.m_dstFormat);
/** @type {gluShaderUtil.DataType} */ var srcOutputType = es3fFboTestUtil.getFragmentOutputType(srcFormat);
/** @type {gluShaderUtil.DataType} */ var dstOutputType = es3fFboTestUtil.getFragmentOutputType(dstFormat);
// Compute ranges \note Doesn't handle case where src or dest is not subset of the another!
/** @type {tcuTextureUtil.TextureFormatInfo} */ var srcFmtRangeInfo = tcuTextureUtil.getTextureFormatInfo(srcFormat);
/** @type {tcuTextureUtil.TextureFormatInfo} */ var dstFmtRangeInfo = tcuTextureUtil.getTextureFormatInfo(dstFormat);
/** @type {Array<boolean>} */ var copyMask = deMath.logicalAndBool(es3fFramebufferBlitTests.getChannelMask(srcFormat.order), es3fFramebufferBlitTests.getChannelMask(dstFormat.order));
/** @type {Array<boolean>} */ var srcIsGreater = deMath.greaterThan(deMath.subtract(srcFmtRangeInfo.valueMax, srcFmtRangeInfo.valueMin), deMath.subtract(dstFmtRangeInfo.valueMax, dstFmtRangeInfo.valueMin));
/** @type {tcuTextureUtil.TextureFormatInfo} */ var srcRangeInfo = new tcuTextureUtil.TextureFormatInfo(
tcuTextureUtil.select(dstFmtRangeInfo.valueMin, srcFmtRangeInfo.valueMin, deMath.logicalAndBool(copyMask, srcIsGreater)),
tcuTextureUtil.select(dstFmtRangeInfo.valueMax, srcFmtRangeInfo.valueMax, deMath.logicalAndBool(copyMask, srcIsGreater)),
tcuTextureUtil.select(dstFmtRangeInfo.lookupScale, srcFmtRangeInfo.lookupScale, deMath.logicalAndBool(copyMask, srcIsGreater)),
tcuTextureUtil.select(dstFmtRangeInfo.lookupBias, srcFmtRangeInfo.lookupBias, deMath.logicalAndBool(copyMask, srcIsGreater)));
/** @type {tcuTextureUtil.TextureFormatInfo} */ var dstRangeInfo = new tcuTextureUtil.TextureFormatInfo(
tcuTextureUtil.select(dstFmtRangeInfo.valueMin, srcFmtRangeInfo.valueMin, deMath.logicalOrBool(deMath.logicalNotBool(copyMask), srcIsGreater)),
tcuTextureUtil.select(dstFmtRangeInfo.valueMax, srcFmtRangeInfo.valueMax, deMath.logicalOrBool(deMath.logicalNotBool(copyMask), srcIsGreater)),
tcuTextureUtil.select(dstFmtRangeInfo.lookupScale, srcFmtRangeInfo.lookupScale, deMath.logicalOrBool(deMath.logicalNotBool(copyMask), srcIsGreater)),
tcuTextureUtil.select(dstFmtRangeInfo.lookupBias, srcFmtRangeInfo.lookupBias, deMath.logicalOrBool(deMath.logicalNotBool(copyMask), srcIsGreater)));
// Shaders.
/** @type {es3fFboTestUtil.GradientShader} */
var gradientToSrcShader = new es3fFboTestUtil.GradientShader(srcOutputType);
/** @type {es3fFboTestUtil.GradientShader} */
var gradientToDstShader = new es3fFboTestUtil.GradientShader(dstOutputType);
var gradShaderSrcID = ctx.createProgram(gradientToSrcShader);
var gradShaderDstID = ctx.createProgram(gradientToDstShader);
var srcFbo;
var dstFbo;
var srcRbo;
var dstRbo;
// Create framebuffers.
// Source framebuffers
srcFbo = ctx.createFramebuffer();
srcRbo = ctx.createRenderbuffer();
ctx.bindRenderbuffer(gl.RENDERBUFFER, srcRbo);
ctx.renderbufferStorage(gl.RENDERBUFFER, this.m_srcFormat, this.m_size[0], this.m_size[1]);
ctx.bindFramebuffer(gl.FRAMEBUFFER, srcFbo);
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, srcRbo);
this.checkError();
this.checkFramebufferStatus(gl.FRAMEBUFFER);
// Destination framebuffers
dstFbo = ctx.createFramebuffer();
dstRbo = ctx.createRenderbuffer();
ctx.bindRenderbuffer(gl.RENDERBUFFER, dstRbo);
ctx.renderbufferStorage(gl.RENDERBUFFER, this.m_dstFormat, this.m_size[0], this.m_size[1]);
ctx.bindFramebuffer(gl.FRAMEBUFFER, dstFbo);
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, dstRbo);
this.checkError();
this.checkFramebufferStatus(gl.FRAMEBUFFER);
ctx.viewport(0, 0, this.m_size[0], this.m_size[1]);
// Render gradients.
for (var ndx = 0; ndx < 2; ndx++) {
ctx.bindFramebuffer(gl.FRAMEBUFFER, ndx ? dstFbo : srcFbo);
if (ndx) {
gradientToDstShader.setGradient(ctx, gradShaderDstID, dstRangeInfo.valueMax, dstRangeInfo.valueMin);
rrUtil.drawQuad(ctx, gradShaderDstID, [-1, -1, 0], [1, 1, 0]);
} else {
gradientToSrcShader.setGradient(ctx, gradShaderSrcID, srcRangeInfo.valueMin, srcRangeInfo.valueMax);
rrUtil.drawQuad(ctx, gradShaderSrcID, [-1, -1, 0], [1, 1, 0]);
}
}
// Execute copy.
ctx.bindFramebuffer(gl.READ_FRAMEBUFFER, srcFbo);
ctx.bindFramebuffer(gl.DRAW_FRAMEBUFFER, dstFbo);
ctx.blitFramebuffer(0, 0, this.m_size[0], this.m_size[1], 0, 0, this.m_size[0], this.m_size[1], gl.COLOR_BUFFER_BIT, gl.NEAREST);
this.checkError();
// Read results.
ctx.bindFramebuffer(gl.READ_FRAMEBUFFER, dstFbo);
this.readPixelsUsingFormat(dst, 0, 0, this.m_size[0], this.m_size[1], dstFormat, dstRangeInfo.lookupScale, dstRangeInfo.lookupBias);
};
/**
* @param {tcuSurface.Surface} reference
* @param {tcuSurface.Surface} result
*/
es3fFramebufferBlitTests.BlitColorConversionCase.prototype.compare = function(reference, result) {
/** @const {tcuTexture.TextureFormat} */ var srcFormat = gluTextureUtil.mapGLInternalFormat(this.m_srcFormat);
/** @const {tcuTexture.TextureFormat} */ var dstFormat = gluTextureUtil.mapGLInternalFormat(this.m_dstFormat);
/** @const {boolean} */ var srcIsSRGB = (srcFormat.order == tcuTexture.ChannelOrder.sRGBA);
/** @const {boolean} */ var dstIsSRGB = (dstFormat.order == tcuTexture.ChannelOrder.sRGBA);
/** @type {tcuRGBA.RGBA} */ var threshold = new tcuRGBA.RGBA();
if (dstIsSRGB)
threshold = es3fFboTestUtil.getToSRGBConversionThreshold(srcFormat, dstFormat);
else {
/** @type {tcuRGBA.RGBA} */ var srcMaxDiff = es3fFboTestUtil.getThresholdFromTextureFormat(srcFormat);
/** @type {tcuRGBA.RGBA} */ var dstMaxDiff = es3fFboTestUtil.getThresholdFromTextureFormat(dstFormat);
if (srcIsSRGB)
srcMaxDiff = tcuRGBA.multiply(srcMaxDiff, 2);
threshold = tcuRGBA.max(srcMaxDiff, dstMaxDiff);
}
// m_testCtx.getLog() << tcu::TestLog::Message << 'threshold = ' << threshold << tcu::TestLog::EndMessage;
return tcuImageCompare.pixelThresholdCompare('Result', 'Image comparison result', reference, result, threshold.toIVec());
};
/**
* @constructor
* @extends {es3fFboTestCase.FboTestCase}
* @param {string} name
* @param {string} desc
* @param {number} format deUint32
* @param {number} srcBuffers deUint32
* @param {Array<number>} srcSize IVec2
* @param {Array<number>} srcRect IVec4
* @param {number} dstBuffers deUint32
* @param {Array<number>} dstSize IVec2
* @param {Array<number>} dstRect IVec4
* @param {number} copyBuffers deUint32
*/
es3fFramebufferBlitTests.BlitDepthStencilCase = function(name, desc, format, srcBuffers, srcSize, srcRect, dstBuffers, dstSize, dstRect, copyBuffers) {
es3fFboTestCase.FboTestCase.call(this, name, desc);
/** @type {number} */ this.m_format = format;
/** @type {number} */ this.m_srcBuffers = srcBuffers;
/** @type {Array<number>} */ this.m_srcSize = srcSize;
/** @type {Array<number>} */ this.m_srcRect = srcRect;
/** @type {number} */ this.m_dstBuffers = dstBuffers;
/** @type {Array<number>} */ this.m_dstSize = dstSize;
/** @type {Array<number>} */ this.m_dstRect = dstRect;
/** @type {number} */ this.m_copyBuffers = copyBuffers;
};
es3fFramebufferBlitTests.BlitDepthStencilCase.prototype = Object.create(es3fFboTestCase.FboTestCase.prototype);
es3fFramebufferBlitTests.BlitDepthStencilCase.prototype.constructor = es3fFramebufferBlitTests.BlitDepthStencilCase;
/**
* @protected
*/
es3fFramebufferBlitTests.BlitDepthStencilCase.prototype.preCheck = function() {
this.checkFormatSupport(this.m_format);
return true; // No exception thrown
};
/**
* @protected
* @param {tcuSurface.Surface} dst
*/
es3fFramebufferBlitTests.BlitDepthStencilCase.prototype.render = function(dst) {
var ctx = this.getCurrentContext();
/** @const {number} */ var colorFormat = gl.RGBA8;
var gradShader = new es3fFboTestUtil.GradientShader(gluShaderUtil.DataType.FLOAT_VEC4);
var texShader = new es3fFboTestUtil.Texture2DShader(
[gluShaderUtil.DataType.SAMPLER_2D] ,
gluShaderUtil.DataType.FLOAT_VEC4);
var flatShader = new es3fFboTestUtil.FlatColorShader(gluShaderUtil.DataType.FLOAT_VEC4);
var flatShaderID = ctx.createProgram(flatShader);
var texShaderID = ctx.createProgram(texShader);
var gradShaderID = ctx.createProgram(gradShader);
var srcFbo;
var dstFbo;
var srcColorRbo;
var dstColorRbo;
var srcDepthStencilRbo;
var dstDepthStencilRbo;
// setup shaders
gradShader.setGradient(ctx, gradShaderID, [0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]);
texShader.setUniforms(ctx, texShaderID);
// Create framebuffers
// Source framebuffers
srcFbo = ctx.createFramebuffer();
srcColorRbo = ctx.createRenderbuffer();
srcDepthStencilRbo = ctx.createRenderbuffer();
ctx.bindRenderbuffer(gl.RENDERBUFFER, srcColorRbo);
ctx.renderbufferStorage(gl.RENDERBUFFER, colorFormat, this.m_srcSize[0], this.m_srcSize[1]);
ctx.bindRenderbuffer(gl.RENDERBUFFER, srcDepthStencilRbo);
ctx.renderbufferStorage(gl.RENDERBUFFER, this.m_format, this.m_srcSize[0], this.m_srcSize[1]);
ctx.bindFramebuffer(gl.FRAMEBUFFER, srcFbo);
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, srcColorRbo);
if (this.m_srcBuffers & gl.DEPTH_BUFFER_BIT)
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, srcDepthStencilRbo);
if (this.m_srcBuffers & gl.STENCIL_BUFFER_BIT)
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.RENDERBUFFER, srcDepthStencilRbo);
this.checkError();
this.checkFramebufferStatus(gl.FRAMEBUFFER);
// Clear depth to 1 and stencil to 0.
ctx.clearBufferfi(gl.DEPTH_STENCIL, 0, 1.0, 0);
// Destination framebuffers
dstFbo = ctx.createFramebuffer();
dstColorRbo = ctx.createRenderbuffer();
dstDepthStencilRbo = ctx.createRenderbuffer();
ctx.bindRenderbuffer(gl.RENDERBUFFER, dstColorRbo);
ctx.renderbufferStorage(gl.RENDERBUFFER, colorFormat, this.m_dstSize[0], this.m_dstSize[1]);
ctx.bindRenderbuffer(gl.RENDERBUFFER, dstDepthStencilRbo);
ctx.renderbufferStorage(gl.RENDERBUFFER, this.m_format, this.m_dstSize[0], this.m_dstSize[1]);
ctx.bindFramebuffer(gl.FRAMEBUFFER, dstFbo);
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, dstColorRbo);
if (this.m_dstBuffers & gl.DEPTH_BUFFER_BIT)
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, dstDepthStencilRbo);
if (this.m_dstBuffers & gl.STENCIL_BUFFER_BIT)
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.RENDERBUFFER, dstDepthStencilRbo);
this.checkError();
this.checkFramebufferStatus(gl.FRAMEBUFFER);
// Clear depth to 1 and stencil to 0.
ctx.clearBufferfi(gl.DEPTH_STENCIL, 0, 1.0, 0);
// Fill source with gradient, depth = [-1..1], stencil = 7
ctx.bindFramebuffer(gl.FRAMEBUFFER, srcFbo);
ctx.viewport(0, 0, this.m_srcSize[0], this.m_srcSize[1]);
ctx.enable(gl.DEPTH_TEST);
ctx.enable(gl.STENCIL_TEST);
ctx.stencilOp(gl.KEEP, gl.KEEP, gl.REPLACE);
ctx.stencilFunc(gl.ALWAYS, 7, 0xff);
rrUtil.drawQuad(ctx, gradShaderID, [-1, -1, -1], [1, 1, 1]);
// Fill destination with grid pattern, depth = 0 and stencil = 1
/** @const {number} */ var format = gl.RGBA;
/** @const {number} */ var dataType = gl.UNSIGNED_BYTE;
/** @const {number} */ var texW = this.m_srcSize[0];
/** @const {number} */ var texH = this.m_srcSize[1];
/** @type {WebGLTexture|sglrReferenceContext.TextureContainer} */ var gridTex = null;
/** @type {tcuTexture.TextureLevel} */ var data = new tcuTexture.TextureLevel(gluTextureUtil.mapGLTransferFormat(format, dataType), texW, texH, 1);
tcuTextureUtil.fillWithGrid(data.getAccess(), 8, [0.2, 0.7, 0.1, 1.0], [0.7, 0.1, 0.5, 0.8]);
gridTex = ctx.createTexture();
ctx.bindTexture(gl.TEXTURE_2D, gridTex);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
ctx.texImage2D(gl.TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr());
ctx.bindFramebuffer(gl.FRAMEBUFFER, dstFbo);
ctx.viewport(0, 0, this.m_dstSize[0], this.m_dstSize[1]);
ctx.stencilFunc(gl.ALWAYS, 1, 0xff);
rrUtil.drawQuad(ctx, texShaderID, [-1, -1, 0], [1, 1, 0]);
// Perform copy.
ctx.bindFramebuffer(gl.READ_FRAMEBUFFER, srcFbo);
ctx.bindFramebuffer(gl.DRAW_FRAMEBUFFER, dstFbo);
ctx.blitFramebuffer(this.m_srcRect[0], this.m_srcRect[1], this.m_srcRect[2], this.m_srcRect[3], this.m_dstRect[0], this.m_dstRect[1], this.m_dstRect[2], this.m_dstRect[3], this.m_copyBuffers, gl.NEAREST);
// Render blue color where depth < 0, decrement on depth failure.
ctx.bindFramebuffer(gl.FRAMEBUFFER, dstFbo);
ctx.viewport(0, 0, this.m_dstSize[0], this.m_dstSize[1]);
ctx.stencilOp(gl.KEEP, gl.DECR, gl.KEEP);
ctx.stencilFunc(gl.ALWAYS, 0, 0xff);
flatShader.setColor(this.getCurrentContext(), flatShaderID, [0.0, 0.0, 1.0, 1.0]);
rrUtil.drawQuad(ctx, flatShaderID, [-1, -1, 0], [1, 1, 0]);
if (this.m_dstBuffers & gl.STENCIL_BUFFER_BIT) {
// Render green color where stencil == 6.
ctx.disable(gl.DEPTH_TEST);
ctx.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
ctx.stencilFunc(gl.EQUAL, 6, 0xff);
flatShader.setColor(this.getCurrentContext(), flatShaderID, [0.0, 1.0, 0.0, 1.0]);
rrUtil.drawQuad(ctx, flatShaderID, [-1, -1, 0], [1, 1, 0]);
}
this.readPixelsUsingFormat(dst, 0, 0, this.m_dstSize[0], this.m_dstSize[1], gluTextureUtil.mapGLInternalFormat(colorFormat), [1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]);
};
/**
* @constructor
* @extends {es3fFboTestCase.FboTestCase}
* @param {string} name
* @param {string} desc
* @param {number} format
* @param {number} filter
*/
es3fFramebufferBlitTests.BlitDefaultFramebufferCase = function(name, desc, format, filter) {
es3fFboTestCase.FboTestCase.call(this, name, desc);
/** @const {number} */ this.m_format = format;
/** @const {number} */ this.m_filter = filter;
};
es3fFramebufferBlitTests.BlitDefaultFramebufferCase.prototype = Object.create(es3fFboTestCase.FboTestCase.prototype);
es3fFramebufferBlitTests.BlitDefaultFramebufferCase.prototype.constructor = es3fFramebufferBlitTests.BlitDefaultFramebufferCase;
/**
* @protected
*/
es3fFramebufferBlitTests.BlitDefaultFramebufferCase.prototype.preCheck = function() {
this.checkFormatSupport(this.m_format);
return true; // No exception thrown
};
/**
* @protected
* @param {tcuSurface.Surface} dst
*/
es3fFramebufferBlitTests.BlitDefaultFramebufferCase.prototype.render = function(dst) {
var ctx = this.getCurrentContext();
/** @type {tcuTexture.TextureFormat} */ var colorFormat = gluTextureUtil.mapGLInternalFormat(this.m_format);
/** @type {gluTextureUtil.TransferFormat} */ var transferFmt = gluTextureUtil.getTransferFormat(colorFormat);
/** @type {es3fFboTestUtil.GradientShader} */ var gradShader = new es3fFboTestUtil.GradientShader(gluShaderUtil.DataType.FLOAT_VEC4);
/** @type {es3fFboTestUtil.Texture2DShader} */ var texShader = new es3fFboTestUtil.Texture2DShader([gluTextureUtil.getSampler2DType(colorFormat)], gluShaderUtil.DataType.FLOAT_VEC4);
var gradShaderID = ctx.createProgram(gradShader);
var texShaderID = ctx.createProgram(texShader);
var fbo;
var tex;
/** @const {number} */ var texW = 128;
/** @const {number} */ var texH = 128;
// Setup shaders
gradShader.setGradient(ctx, gradShaderID, [0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]);
texShader.setUniforms(ctx, texShaderID);
// FBO
fbo = ctx.createFramebuffer();
tex = ctx.createTexture();
ctx.bindTexture(gl.TEXTURE_2D, tex);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, this.m_filter);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, this.m_filter);
ctx.texImage2D(gl.TEXTURE_2D, 0, this.m_format, texW, texH, 0, transferFmt.format, transferFmt.dataType, null);
ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo);
ctx.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0);
this.checkError();
this.checkFramebufferStatus(gl.FRAMEBUFFER);
// Render gradient to screen.
ctx.bindFramebuffer(gl.FRAMEBUFFER, null);
rrUtil.drawQuad(ctx, gradShaderID, [-1, -1, 0], [1, 1, 0]);
// Blit gradient from screen to fbo.
ctx.bindFramebuffer(gl.DRAW_FRAMEBUFFER, fbo);
ctx.blitFramebuffer(0, 0, ctx.getWidth(), ctx.getHeight(), 0, 0, texW, texH, gl.COLOR_BUFFER_BIT, this.m_filter);
// Fill left half of viewport with quad that uses texture.
ctx.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
ctx.clearBufferfv(gl.COLOR, 0, [1.0, 0.0, 0.0, 1.0]);
rrUtil.drawQuad(ctx, texShaderID, [-1, -1, 0], [1, 1, 0]);
// Blit fbo to right half.
ctx.bindFramebuffer(gl.READ_FRAMEBUFFER, fbo);
ctx.blitFramebuffer(0, 0, texW, texH, Math.floor(ctx.getWidth() / 2), 0, ctx.getWidth(), ctx.getHeight(), gl.COLOR_BUFFER_BIT, this.m_filter);
ctx.bindFramebuffer(gl.READ_FRAMEBUFFER, null);
this.readPixels(dst, 0, 0, ctx.getWidth(), ctx.getHeight());
};
/**
* @protected
* @param {tcuSurface.Surface} reference
* @param {tcuSurface.Surface} result
*/
es3fFramebufferBlitTests.BlitDefaultFramebufferCase.prototype.compare = function(reference, result) {
/** @const {tcuRGBA.RGBA} */
var threshold = tcuRGBA.max(es3fFboTestUtil.getFormatThreshold(this.m_format), tcuRGBA.newRGBAComponents(12, 12, 12, 12));
//m_testCtx.getLog() << TestLog::Message << 'Comparing images, threshold: ' << threshold << TestLog::EndMessage;
return tcuImageCompare.bilinearCompare('Result', 'Image comparison result', reference.getAccess(), result.getAccess(), threshold);
};
/** @enum */
es3fFramebufferBlitTests.BlitDirection = {
BLIT_DEFAULT_TO_TARGET: 0,
BLIT_TO_DEFAULT_FROM_TARGET: 1
};
/** @enum */
es3fFramebufferBlitTests.BlitArea = {
AREA_SCALE: 0,
AREA_OUT_OF_BOUNDS: 1
};
/**
* @constructor
* @extends {es3fFramebufferBlitTests.BlitDefaultFramebufferCase}
* @param {string} name
* @param {string} desc
* @param {number} format
* @param {number} filter
* @param {es3fFramebufferBlitTests.BlitDirection} dir
* @param {es3fFramebufferBlitTests.BlitArea} area
*/
es3fFramebufferBlitTests.DefaultFramebufferBlitCase = function(name, desc, format, filter, dir, area) {
es3fFramebufferBlitTests.BlitDefaultFramebufferCase.call(this, name, desc, format, filter);
/** @const {es3fFramebufferBlitTests.BlitDirection} */ this.m_blitDir = dir;
/** @const {es3fFramebufferBlitTests.BlitArea} */ this.m_blitArea = area;
/** @type {Array<number>} */ this.m_srcRect = [-1, -1, -1, -1];
/** @type {Array<number>} */ this.m_dstRect = [-1, -1, -1, -1];
/** @type {Array<number>} */ this.m_interestingArea = [-1, -1, -1, -1];
};
es3fFramebufferBlitTests.DefaultFramebufferBlitCase.prototype = Object.create(es3fFramebufferBlitTests.BlitDefaultFramebufferCase.prototype);
es3fFramebufferBlitTests.DefaultFramebufferBlitCase.prototype.constructor = es3fFramebufferBlitTests.DefaultFramebufferBlitCase;
es3fFramebufferBlitTests.DefaultFramebufferBlitCase.prototype.init = function() {
// requirements
/** @const {number} */ var minViewportSize = 128;
if (gl.drawingBufferWidth < minViewportSize ||
gl.drawingBufferHeight < minViewportSize)
throw new Error('Viewport size ' + minViewportSize + 'x' + minViewportSize + ' required');
// prevent viewport randoming
this.m_viewportWidth = gl.drawingBufferWidth;
this.m_viewportHeight = gl.drawingBufferHeight;
// set proper areas
if (this.m_blitArea == es3fFramebufferBlitTests.BlitArea.AREA_SCALE) {
this.m_srcRect = [10, 20, 65, 100];
this.m_dstRect = [25, 30, 125, 94];
this.m_interestingArea = [0, 0, 128, 128];
} else if (this.m_blitArea == es3fFramebufferBlitTests.BlitArea.AREA_OUT_OF_BOUNDS) {
/** @const {Array<number>} */
var ubound = (this.m_blitDir == es3fFramebufferBlitTests.BlitDirection.BLIT_DEFAULT_TO_TARGET) ?
([128, 128]) :
([gl.drawingBufferWidth, gl.drawingBufferHeight]);
this.m_srcRect = [-10, -15, 100, 63];
this.m_dstRect = deMath.add(deMath.swizzle(ubound, [0, 1, 0, 1]), [-75, -99, 8, 16]);
this.m_interestingArea = [ubound[0] - 128, ubound[1] - 128, ubound[0], ubound[1]];
}
};
/**
* @param {tcuSurface.Surface} dst
*/
es3fFramebufferBlitTests.DefaultFramebufferBlitCase.prototype.render = function(dst) {
/** @type {es3fFboTestCase.Context} */
var ctx = this.getCurrentContext();
// TOOD: implement
/** @type {tcuTexture.TextureFormat} */ var colorFormat = gluTextureUtil.mapGLInternalFormat(this.m_format);
/** @type {gluTextureUtil.TransferFormat} */ var transferFmt = gluTextureUtil.getTransferFormat(colorFormat);
/** @const {tcuTexture.TextureChannelClass} */
var targetClass = (this.m_blitDir == es3fFramebufferBlitTests.BlitDirection.BLIT_DEFAULT_TO_TARGET) ?
(tcuTexture.getTextureChannelClass(colorFormat.type)) :
(tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT);
var fbo;
var fboTex;
/** @const {number} */ var fboTexW = 128;
/** @const {number} */ var fboTexH = 128;
/** @const {number} */ var sourceWidth = (this.m_blitDir == es3fFramebufferBlitTests.BlitDirection.BLIT_DEFAULT_TO_TARGET) ? (ctx.getWidth()) : (fboTexW);
/** @const {number} */ var sourceHeight = (this.m_blitDir == es3fFramebufferBlitTests.BlitDirection.BLIT_DEFAULT_TO_TARGET) ? (ctx.getHeight()) : (fboTexH);
/** @const {number} */ var gridRenderWidth = Math.min(256, sourceWidth);
/** @const {number} */ var gridRenderHeight = Math.min(256, sourceHeight);
var targetFbo;
var sourceFbo;
// FBO
fbo = ctx.createFramebuffer();
fboTex = ctx.createTexture();
ctx.bindTexture(gl.TEXTURE_2D, fboTex);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, this.m_filter);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, this.m_filter);
ctx.texImage2D(gl.TEXTURE_2D, 0, this.m_format, fboTexW, fboTexH, 0, transferFmt.format, transferFmt.dataType, null);
ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo);
ctx.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, fboTex, 0);
this.checkError();
this.checkFramebufferStatus(gl.FRAMEBUFFER);
targetFbo = (this.m_blitDir == es3fFramebufferBlitTests.BlitDirection.BLIT_DEFAULT_TO_TARGET) ? (fbo) : (null);
sourceFbo = (this.m_blitDir == es3fFramebufferBlitTests.BlitDirection.BLIT_DEFAULT_TO_TARGET) ? (null) : (fbo);
// Render grid to source framebuffer
/** @type {es3fFboTestUtil.Texture2DShader} */
var texShader = new es3fFboTestUtil.Texture2DShader(
[gluShaderUtil.DataType.SAMPLER_2D],
gluShaderUtil.DataType.FLOAT_VEC4);
var texShaderID = this.getCurrentContext().createProgram(texShader);
/** @const {number} */ var internalFormat = gl.RGBA8;
/** @const {number} */ var format = gl.RGBA;
/** @const {number} */ var dataType = gl.UNSIGNED_BYTE;
/** @const {number} */ var gridTexW = 128;
/** @const {number} */ var gridTexH = 128;
/** @type {WebGLTexture|framework.opengl.simplereference.sglrReferenceContext.TextureContainer|null} */
var gridTex = null;
/** @type {tcuTexture.TextureLevel} */ var data = new tcuTexture.TextureLevel(gluTextureUtil.mapGLTransferFormat(format, dataType), gridTexW, gridTexH, 1);
tcuTextureUtil.fillWithGrid(data.getAccess(), 9, [0.9, 0.5, 0.1, 0.9], [0.2, 0.8, 0.2, 0.7]);
gridTex = ctx.createTexture();
ctx.bindTexture(gl.TEXTURE_2D, gridTex);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
ctx.texImage2D(gl.TEXTURE_2D, 0, internalFormat, gridTexW, gridTexH, 0, format, dataType, data.getAccess().getDataPtr());
ctx.bindFramebuffer(gl.FRAMEBUFFER, sourceFbo);
ctx.viewport(0, 0, gridRenderWidth, gridRenderHeight);
ctx.clearBufferfv(gl.COLOR, 0, [1.0, 0.0, 0.0, 1.0]);
texShader.setUniforms(this.getCurrentContext(), texShaderID);
rrUtil.drawQuad(ctx, texShaderID, [-1, -1, 0], [1, 1, 0]);
ctx.useProgram(null);
// Blit source framebuffer to destination
ctx.bindFramebuffer(gl.READ_FRAMEBUFFER, sourceFbo);
ctx.bindFramebuffer(gl.DRAW_FRAMEBUFFER, targetFbo);
this.checkError();
if (targetClass == tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT ||
targetClass == tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT ||
targetClass == tcuTexture.TextureChannelClass.FLOATING_POINT)
ctx.clearBufferfv(gl.COLOR, 0, [1.0, 1.0, 0.0, 1.0]);
else if (targetClass == tcuTexture.TextureChannelClass.SIGNED_INTEGER)
ctx.clearBufferiv(gl.COLOR, 0, [0, 0, 0, 0]);
else if (targetClass == tcuTexture.TextureChannelClass.UNSIGNED_INTEGER)
ctx.clearBufferuiv(gl.COLOR, 0, [0, 0, 0, 0]);
else
DE_ASSERT(false);
ctx.blitFramebuffer(this.m_srcRect[0], this.m_srcRect[1], this.m_srcRect[2], this.m_srcRect[3], this.m_dstRect[0], this.m_dstRect[1], this.m_dstRect[2], this.m_dstRect[3], gl.COLOR_BUFFER_BIT, this.m_filter);
this.checkError();
// Read target
ctx.bindFramebuffer(gl.FRAMEBUFFER, targetFbo);
if (this.m_blitDir == es3fFramebufferBlitTests.BlitDirection.BLIT_TO_DEFAULT_FROM_TARGET)
this.readPixels(dst, this.m_interestingArea[0], this.m_interestingArea[1], this.m_interestingArea[2] - this.m_interestingArea[0], this.m_interestingArea[3] - this.m_interestingArea[1]);
else
this.readPixelsUsingFormat(dst, this.m_interestingArea[0], this.m_interestingArea[1], this.m_interestingArea[2] - this.m_interestingArea[0], this.m_interestingArea[3] - this.m_interestingArea[1], colorFormat, [1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]);
this.checkError();
};
es3fFramebufferBlitTests.run = function(context, range) {
gl = context;
//Set up root Test
var state = tcuTestCase.runner;
var test = new es3fFramebufferBlitTests.FramebufferBlitTests();
var testName = test.fullName();
var testDescription = test.getDescription() || '';
state.testName = testName;
state.setRoot(test);
//Set up name and description of this test series.
setCurrentTestName(testName);
description(testDescription);
try {
//Create test cases
test.init();
if (range)
state.setRange(range);
//Run test cases
tcuTestCase.runTestCases();
}
catch (err) {
bufferedLogToConsole(err);
testFailedOptions('Failed to es3fFramebufferBlitTests.run tests', false);
tcuTestCase.runner.terminate();
}
};
});