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.es3fFboMultisampleTests');
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.delibs.debase.deRandom');
goog.require('framework.opengl.gluTextureUtil');
goog.require('framework.referencerenderer.rrUtil');
goog.require('functional.gles3.es3fFboTestCase');
goog.require('functional.gles3.es3fFboTestUtil');
goog.scope(function() {
var es3fFboMultisampleTests = functional.gles3.es3fFboMultisampleTests;
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 deRandom = framework.delibs.debase.deRandom;
var deMath = framework.delibs.debase.deMath;
var gluTextureUtil = framework.opengl.gluTextureUtil;
var rrUtil = framework.referencerenderer.rrUtil;
/** @type {WebGL2RenderingContext} */ var gl;
var DE_ASSERT = function(x) {
if (!x)
throw new Error('Assert failed');
};
/**
* @constructor
* @extends {es3fFboTestCase.FboTestCase}
* @param {string} name
* @param {string} desc
* @param {number} colorFormat
* @param {number} depthStencilFormat
* @param {Array<number>} size
* @param {number} numSamples
*/
es3fFboMultisampleTests.BasicFboMultisampleCase = function(name, desc, colorFormat, depthStencilFormat, size, numSamples) {
es3fFboTestCase.FboTestCase.call(this, name, desc);
/** @type {number} */ this.m_colorFormat = colorFormat;
/** @type {number} */ this.m_depthStencilFormat = depthStencilFormat;
/** @type {Array<number>} */ this.m_size = size;
/** @type {number} */ this.m_numSamples = numSamples;
};
es3fFboMultisampleTests.BasicFboMultisampleCase.prototype = Object.create(es3fFboTestCase.FboTestCase.prototype);
es3fFboMultisampleTests.BasicFboMultisampleCase.prototype.constructor = es3fFboMultisampleTests.BasicFboMultisampleCase;
es3fFboMultisampleTests.BasicFboMultisampleCase.prototype.preCheck = function() {
this.checkFormatSupport(this.m_colorFormat);
if (!this.checkSampleCount(this.m_colorFormat, this.m_numSamples))
return false;
if (this.m_depthStencilFormat != gl.NONE) {
this.checkFormatSupport(this.m_depthStencilFormat);
if (!this.checkSampleCount(this.m_depthStencilFormat, this.m_numSamples))
return false;
}
return true; // No exception thrown
};
/**
* @param {tcuSurface.Surface} dst
*/
es3fFboMultisampleTests.BasicFboMultisampleCase.prototype.render = function(dst) {
var ctx = this.getCurrentContext();
/** @type {tcuTexture.TextureFormat} */ var colorFmt = gluTextureUtil.mapGLInternalFormat(this.m_colorFormat);
/** @type {tcuTexture.TextureFormat} */ var depthStencilFmt = this.m_depthStencilFormat != gl.NONE ? gluTextureUtil.mapGLInternalFormat(this.m_depthStencilFormat) : new tcuTexture.TextureFormat(null, null);
/** @type {tcuTextureUtil.TextureFormatInfo} */ var colorFmtInfo = tcuTextureUtil.getTextureFormatInfo(colorFmt);
/** @type {boolean} */ var depth = depthStencilFmt.order == tcuTexture.ChannelOrder.D || depthStencilFmt.order == tcuTexture.ChannelOrder.DS;
/** @type {boolean} */ var stencil = depthStencilFmt.order == tcuTexture.ChannelOrder.S || depthStencilFmt.order == tcuTexture.ChannelOrder.DS;
/** @type {es3fFboTestUtil.GradientShader} */ var gradShader = new es3fFboTestUtil.GradientShader(es3fFboTestUtil.getFragmentOutputType(colorFmt));
/** @type {es3fFboTestUtil.FlatColorShader} */ var flatShader = new es3fFboTestUtil.FlatColorShader(es3fFboTestUtil.getFragmentOutputType(colorFmt));
var gradShaderID = this.getCurrentContext().createProgram(gradShader);
var flatShaderID = this.getCurrentContext().createProgram(flatShader);
var msaaFbo = null;
var resolveFbo = null;
var msaaColorRbo = null;
var resolveColorRbo = null;
var msaaDepthStencilRbo = null;
var resolveDepthStencilRbo = null;
// Create framebuffers.
msaaColorRbo = ctx.createRenderbuffer();
ctx.bindRenderbuffer(gl.RENDERBUFFER, msaaColorRbo);
ctx.renderbufferStorageMultisample(gl.RENDERBUFFER, this.m_numSamples, this.m_colorFormat, this.m_size[0], this.m_size[1]);
if (depth || stencil) {
msaaDepthStencilRbo = ctx.createRenderbuffer();
ctx.bindRenderbuffer(gl.RENDERBUFFER, msaaDepthStencilRbo);
ctx.renderbufferStorageMultisample(gl.RENDERBUFFER, this.m_numSamples, this.m_depthStencilFormat, this.m_size[0], this.m_size[1]);
}
msaaFbo = ctx.createFramebuffer();
ctx.bindFramebuffer(gl.FRAMEBUFFER, msaaFbo);
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, msaaColorRbo);
if (depth)
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, msaaDepthStencilRbo);
if (stencil)
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.RENDERBUFFER, msaaDepthStencilRbo);
this.checkError();
this.checkFramebufferStatus(gl.FRAMEBUFFER);
resolveColorRbo = ctx.createRenderbuffer();
ctx.bindRenderbuffer(gl.RENDERBUFFER, resolveColorRbo);
ctx.renderbufferStorageMultisample(gl.RENDERBUFFER, 0, this.m_colorFormat, this.m_size[0], this.m_size[1]);
if (depth || stencil) {
resolveDepthStencilRbo = ctx.createRenderbuffer();
ctx.bindRenderbuffer(gl.RENDERBUFFER, resolveDepthStencilRbo);
ctx.renderbufferStorageMultisample(gl.RENDERBUFFER, 0, this.m_depthStencilFormat, this.m_size[0], this.m_size[1]);
}
resolveFbo = ctx.createFramebuffer();
ctx.bindFramebuffer(gl.FRAMEBUFFER, resolveFbo);
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, resolveColorRbo);
if (depth)
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, resolveDepthStencilRbo);
if (stencil)
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.RENDERBUFFER, resolveDepthStencilRbo);
this.checkError();
this.checkFramebufferStatus(gl.FRAMEBUFFER);
ctx.bindFramebuffer(gl.FRAMEBUFFER, msaaFbo);
ctx.viewport(0, 0, this.m_size[0], this.m_size[1]);
// Clear depth and stencil buffers.
ctx.clearBufferfi(gl.DEPTH_STENCIL, 0, 1.0, 0);
// Fill MSAA fbo with gradient, depth = [-1..1]
ctx.enable(gl.DEPTH_TEST);
gradShader.setGradient(this.getCurrentContext(), gradShaderID, colorFmtInfo.valueMin, colorFmtInfo.valueMax);
rrUtil.drawQuad(this.getCurrentContext(), gradShaderID, [-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]);
// Render random-colored quads.
/** @const {number} */ var numQuads = 8;
// The choice of random seed affects the correctness of the tests,
// because there are some boundary conditions which aren't handled
// correctly even in the C++ dEQP tests.
/** @type {deRandom.Random} */ var rnd = new deRandom.Random(7);
ctx.depthFunc(gl.ALWAYS);
ctx.enable(gl.STENCIL_TEST);
ctx.stencilFunc(gl.ALWAYS, 0, 0xff);
ctx.stencilOp(gl.KEEP, gl.KEEP, gl.INCR);
for (var ndx = 0; ndx < numQuads; ndx++) {
/** @type {number} */ var r = rnd.getFloat();
/** @type {number} */ var g = rnd.getFloat();
/** @type {number} */ var b = rnd.getFloat();
/** @type {number} */ var a = rnd.getFloat();
/** @type {number} */ var x0 = rnd.getFloat(-1.0, 1.0);
/** @type {number} */ var y0 = rnd.getFloat(-1.0, 1.0);
/** @type {number} */ var z0 = rnd.getFloat(-1.0, 1.0);
/** @type {number} */ var x1 = rnd.getFloat(-1.0, 1.0);
/** @type {number} */ var y1 = rnd.getFloat(-1.0, 1.0);
/** @type {number} */ var z1 = rnd.getFloat(-1.0, 1.0);
flatShader.setColor(this.getCurrentContext(), flatShaderID, deMath.add(deMath.multiply([r, g, b, a], deMath.subtract(colorFmtInfo.valueMax, colorFmtInfo.valueMin)), colorFmtInfo.valueMin));
rrUtil.drawQuad(this.getCurrentContext(), flatShaderID, [x0, y0, z0], [x1, y1, z1]);
}
ctx.disable(gl.DEPTH_TEST);
ctx.disable(gl.STENCIL_TEST);
this.checkError();
// Resolve using glBlitFramebuffer().
ctx.bindFramebuffer(gl.DRAW_FRAMEBUFFER, resolveFbo);
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 | (depth ? gl.DEPTH_BUFFER_BIT : 0) | (stencil ? gl.STENCIL_BUFFER_BIT : 0), gl.NEAREST);
ctx.bindFramebuffer(gl.READ_FRAMEBUFFER, resolveFbo);
/** @type {number} */ var numSteps;
/** @type {number} */ var step;
/** @type {number} */ var d;
/** @type {number} */ var c;
/** @type {number} */ var s;
if (depth) {
// Visualize depth.
numSteps = 8;
step = 2.0 / numSteps;
ctx.enable(gl.DEPTH_TEST);
ctx.depthFunc(gl.LESS);
ctx.depthMask(false);
ctx.colorMask(false, false, true, false);
for (var ndx = 0; ndx < numSteps; ndx++) {
d = -1.0 + step * ndx;
c = ndx / (numSteps - 1);
flatShader.setColor(this.getCurrentContext(), flatShaderID, deMath.add(deMath.multiply([0.0, 0.0, c, 1.0], deMath.subtract(colorFmtInfo.valueMax, colorFmtInfo.valueMin)), colorFmtInfo.valueMin));
rrUtil.drawQuad(this.getCurrentContext(), flatShaderID, [-1.0, -1.0, d], [1.0, 1.0, d]);
}
ctx.disable(gl.DEPTH_TEST);
}
if (stencil) {
// Visualize stencil.
numSteps = 4;
step = 1;
ctx.enable(gl.STENCIL_TEST);
ctx.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
ctx.colorMask(false, true, false, false);
for (var ndx = 0; ndx < numSteps; ndx++) {
s = step * ndx;
c = ndx / (numSteps - 1);
ctx.stencilFunc(gl.EQUAL, s, 0xff);
flatShader.setColor(this.getCurrentContext(), flatShaderID, deMath.add(deMath.multiply([0.0, c, 0.0, 1.0], deMath.subtract(colorFmtInfo.valueMax, colorFmtInfo.valueMin)), colorFmtInfo.valueMin));
rrUtil.drawQuad(this.getCurrentContext(), flatShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]);
}
ctx.disable(gl.STENCIL_TEST);
}
this.readPixelsUsingFormat(dst, 0, 0, this.m_size[0], this.m_size[1], colorFmt, colorFmtInfo.lookupScale, colorFmtInfo.lookupBias);
};
/**
* @param {tcuSurface.Surface} reference
* @param {tcuSurface.Surface} result
* @return {boolean}
*/
es3fFboMultisampleTests.BasicFboMultisampleCase.prototype.colorCompare = function(reference, result) {
/** @const {tcuRGBA.RGBA} */ var threshold = tcuRGBA.max(es3fFboTestUtil.getFormatThreshold(this.m_colorFormat), tcuRGBA.newRGBAComponents(12, 12, 12, 12));
return tcuImageCompare.bilinearCompare('Result', 'Image comparison result', reference.getAccess(), result.getAccess(), threshold, tcuImageCompare.CompareLogMode.RESULT);
};
/**
* @param {tcuSurface.Surface} reference
* @param {tcuSurface.Surface} result
* @return {boolean}
*/
es3fFboMultisampleTests.BasicFboMultisampleCase.prototype.compare = function(reference, result) {
if (this.m_depthStencilFormat != gl.NONE)
return es3fFboTestCase.FboTestCase.prototype.compare(reference, result); // FboTestCase.compare
else
return this.colorCompare(reference, result);
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fFboMultisampleTests.FboMultisampleTests = function() {
tcuTestCase.DeqpTest.call(this, 'msaa', 'Multisample FBO tests');
};
es3fFboMultisampleTests.FboMultisampleTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fFboMultisampleTests.FboMultisampleTests.prototype.constructor = es3fFboMultisampleTests.FboMultisampleTests;
es3fFboMultisampleTests.FboMultisampleTests.prototype.init = function() {
/** @const {Array<number>} */ var colorFormats = [
// RGBA formats
gl.RGBA8,
gl.SRGB8_ALPHA8,
gl.RGB10_A2,
gl.RGBA4,
gl.RGB5_A1,
// RGB formats
gl.RGB8,
gl.RGB565,
// RG formats
gl.RG8,
// R formats
gl.R8,
// gl.EXT_color_buffer_float
// Multi-sample floating-point color buffers can be optional supported, see https://www.khronos.org/registry/webgl/extensions/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
];
/** @const {Array<number>} */ var sampleCounts = [2, 4, 8];
for (var sampleCntNdx in sampleCounts) {
/** @type {number} */ var samples = sampleCounts[sampleCntNdx];
/** @type {tcuTestCase.DeqpTest} */
var sampleCountGroup = tcuTestCase.newTest(samples + '_samples', '');
this.addChild(sampleCountGroup);
// Color formats.
for (var fmtNdx in colorFormats)
sampleCountGroup.addChild(new es3fFboMultisampleTests.BasicFboMultisampleCase(es3fFboTestUtil.getFormatName(colorFormats[fmtNdx]), '', colorFormats[fmtNdx], gl.NONE, [119, 131], samples));
// Depth/stencil formats.
for (var fmtNdx in depthStencilFormats)
sampleCountGroup.addChild(new es3fFboMultisampleTests.BasicFboMultisampleCase(es3fFboTestUtil.getFormatName(depthStencilFormats[fmtNdx]), '', gl.RGBA8, depthStencilFormats[fmtNdx], [119, 131], samples));
}
};
es3fFboMultisampleTests.run = function(context, range) {
gl = context;
//Set up root Test
var state = tcuTestCase.runner;
var test = new es3fFboMultisampleTests.FboMultisampleTests();
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) {
testFailedOptions('Failed to es3fFboMultisampleTests.run tests', false);
tcuTestCase.runner.terminate();
}
};
});