mozilla-central/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFboRenderTest.js (file symbol)

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.es3fFboRenderTest');
goog.require('framework.common.tcuImageCompare');
goog.require('framework.common.tcuLogImage');
goog.require('framework.common.tcuPixelFormat');
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.delibs.debase.deString');
goog.require('framework.delibs.debase.deUtil');
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.es3fFboTestUtil');
goog.scope(function() {
var es3fFboRenderTest = functional.gles3.es3fFboRenderTest;
var es3fFboTestUtil = functional.gles3.es3fFboTestUtil;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var gluTextureUtil = framework.opengl.gluTextureUtil;
var tcuImageCompare = framework.common.tcuImageCompare;
var tcuLogImage = framework.common.tcuLogImage;
var tcuPixelFormat = framework.common.tcuPixelFormat;
var tcuRGBA = framework.common.tcuRGBA;
var tcuTestCase = framework.common.tcuTestCase;
var tcuSurface = framework.common.tcuSurface;
var tcuTexture = framework.common.tcuTexture;
var tcuTextureUtil = framework.common.tcuTextureUtil;
var deMath = framework.delibs.debase.deMath;
var deRandom = framework.delibs.debase.deRandom;
var deString = framework.delibs.debase.deString;
var deUtil = framework.delibs.debase.deUtil;
var sglrGLContext = framework.opengl.simplereference.sglrGLContext;
var sglrReferenceContext =
framework.opengl.simplereference.sglrReferenceContext;
var rrUtil = framework.referencerenderer.rrUtil;
/** @type {WebGL2RenderingContext} */ var gl;
/**
* @constructor
* @param {number=} buffers_
* @param {number=} colorType_
* @param {number=} colorFormat_
* @param {number=} depthStencilType_
* @param {number=} depthStencilFormat_
* @param {number=} width_
* @param {number=} height_
* @param {number=} samples_
*/
es3fFboRenderTest.FboConfig = function(
buffers_, colorType_, colorFormat_, depthStencilType_,
depthStencilFormat_, width_, height_, samples_
) {
// Buffer bit mask (gl.COLOR_BUFFER_BIT|gl.DEPTH_BUFFER_BIT|...)
this.buffers = buffers_ ? buffers_ : 0;
// gl.TEXTURE_2D, gl.TEXTURE_CUBE_MAP, gl.RENDERBUFFER
this.colorType = colorType_ ? colorType_ : gl.NONE;
// Internal format for color buffer texture or renderbuffer
this.colorFormat = colorFormat_ ? colorFormat_ : gl.NONE;
this.depthStencilType = depthStencilType_?
depthStencilType_ : gl.NONE;
this.depthStencilFormat = depthStencilFormat_ ?
depthStencilFormat_ : gl.NONE;
this.width = width_ ? width_ : 0;
this.height = height_ ? height_ : 0;
this.samples = samples_? samples_ : 0;
};
/**
* @param {number} type
* @return {string}
*/
es3fFboRenderTest.getTypeName = function(type) {
switch (type) {
case gl.TEXTURE_2D: return 'tex2d';
case gl.RENDERBUFFER: return 'rbo';
default:
testFailed('Unknown type');
}
return 'Should not get to this point';
};
/**
* @return {string}
*/
es3fFboRenderTest.FboConfig.prototype.getName = function() {
var name = '';
assertMsgOptions((this.buffers & gl.COLOR_BUFFER_BIT) != 0,
'Color buffer is not specified', false, true);
name += es3fFboRenderTest.getTypeName(this.colorType) + '_' +
es3fFboTestUtil.getFormatName(this.colorFormat);
if (this.buffers & gl.DEPTH_BUFFER_BIT)
name += '_depth';
if (this.buffers & gl.STENCIL_BUFFER_BIT)
name += '_stencil';
if (this.buffers & (gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT))
name += '_' + es3fFboRenderTest.getTypeName(this.depthStencilType) +
'_' + es3fFboTestUtil.getFormatName(this.depthStencilFormat);
return name;
};
/**
* @param {number} format
* @return {Array<string>}
*/
es3fFboRenderTest.getEnablingExtensions = function(format) {
/** @type {Array<string>} */ var out = [];
switch (format) {
case gl.RGB16F:
assertMsgOptions(false, "Not part of the tested formats", false, true);
break;
case gl.RGBA16F:
case gl.RG16F:
case gl.R16F:
case gl.RGBA32F:
case gl.RGB32F:
case gl.R11F_G11F_B10F:
case gl.RG32F:
case gl.R32F:
out.push('EXT_color_buffer_float');
default:
break;
}
return out;
};
/**
* @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
* context
* @param {string} name
* @return {*}
*/
es3fFboRenderTest.isExtensionSupported = function(context, name) {
return context.getExtension(name);
};
/**
* @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
* context
* @param {Array<string>} requiredExts
* @return {boolean}
*/
es3fFboRenderTest.isAnyExtensionSupported = function(
context, requiredExts) {
if (!requiredExts || requiredExts.length == 0)
return true;
for (var extNdx = 0; extNdx < requiredExts.length; extNdx++) {
var extension = requiredExts[extNdx];
if (es3fFboRenderTest.isExtensionSupported(context, extension))
return true;
}
return false;
};
/**
* @param {Array} list
* @param {string} sep
* @return {string}
*/
es3fFboRenderTest.join = function(list, sep) {
var out = '';
for (var elemNdx = 0; elemNdx < list.length; elemNdx++) {
if (elemNdx != 0)
out += sep;
out += list[elemNdx];
}
return out;
};
/**
* @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
* context
* @param {number} sizedFormat
*/
es3fFboRenderTest.checkColorFormatSupport = function(context, sizedFormat) {
/** @type {Array<string>} */ var requiredExts =
es3fFboRenderTest.getEnablingExtensions(sizedFormat);
if (!es3fFboRenderTest.isAnyExtensionSupported(context, requiredExts)) {
var errMsg = 'Format not supported, requires ' + (
(requiredExts.length == 1) ? requiredExts[0] :
' one of the following: ' +
requiredExts.join(', ')
);
checkMessage(false, errMsg);
throw new TestFailedException(errMsg);
}
};
/**
* @constructor
* @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
* context
* @param {es3fFboRenderTest.FboConfig} config
* @param {number} width
* @param {number} height
* @param {sglrReferenceContext.AnyFramebuffer=} fbo
* @param {sglrReferenceContext.AnyRenderbuffer=} colorBufferName
* @param {sglrReferenceContext.AnyRenderbuffer=} depthStencilBufferName
*/
es3fFboRenderTest.Framebuffer = function(
context, config, width, height, fbo,
colorBufferName, depthStencilBufferName) {
this.m_config = config;
this.m_context = context;
this.m_framebuffer = fbo ? fbo : null;
this.m_colorBuffer = colorBufferName ? colorBufferName : null;
this.m_depthStencilBuffer = depthStencilBufferName ?
depthStencilBufferName : null;
// Verify that color format is supported
es3fFboRenderTest.checkColorFormatSupport(context, config.colorFormat);
if (!this.m_framebuffer)
this.m_framebuffer = context.createFramebuffer();
context.bindFramebuffer(gl.FRAMEBUFFER, this.m_framebuffer);
if (this.m_config.buffers & (gl.COLOR_BUFFER_BIT)) {
switch (this.m_config.colorType) {
case gl.TEXTURE_2D:
this.m_colorBuffer = this.createTex2D(
/** @type {WebGLTexture} */ (colorBufferName),
this.m_config.colorFormat, width, height
);
context.framebufferTexture2D(
gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
gl.TEXTURE_2D, this.m_colorBuffer, 0
);
break;
case gl.RENDERBUFFER:
this.m_colorBuffer = this.createRbo(
/** @type {WebGLRenderbuffer} */ (colorBufferName),
this.m_config.colorFormat, width, height
);
context.framebufferRenderbuffer(
gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
gl.RENDERBUFFER, this.m_colorBuffer
);
break;
default:
testFailed('Unsupported type');
}
}
if (this.m_config.buffers &
(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT)) {
switch (this.m_config.depthStencilType) {
case gl.TEXTURE_2D:
this.m_depthStencilBuffer = this.createTex2D(
/** @type {WebGLTexture} */
(depthStencilBufferName),
this.m_config.depthStencilFormat, width, height
);
break;
case gl.RENDERBUFFER:
this.m_depthStencilBuffer = this.createRbo(
/** @type {WebGLRenderbuffer} */
(depthStencilBufferName),
this.m_config.depthStencilFormat, width, height
);
break;
default:
testFailed('Unsupported type');
}
}
for (var ndx = 0; ndx < 2; ndx++) {
var bit = ndx ? gl.STENCIL_BUFFER_BIT : gl.DEPTH_BUFFER_BIT;
var point = ndx ? gl.STENCIL_ATTACHMENT : gl.DEPTH_ATTACHMENT;
if ((this.m_config.buffers & bit) == 0)
continue; /* Not used. */
switch (this.m_config.depthStencilType) {
case gl.TEXTURE_2D:
context.framebufferTexture2D(
gl.FRAMEBUFFER, point, gl.TEXTURE_2D,
this.m_depthStencilBuffer, 0
);
break;
case gl.RENDERBUFFER:
context.framebufferRenderbuffer(
gl.FRAMEBUFFER, point,
gl.RENDERBUFFER, this.m_depthStencilBuffer
);
break;
default:
throw new Error('Invalid depth stencil type');
}
}
context.bindFramebuffer(gl.FRAMEBUFFER, null);
};
/**
* @return {es3fFboRenderTest.FboConfig}
*/
es3fFboRenderTest.Framebuffer.prototype.getConfig = function() {
return this.m_config;
};
/**
* @return {?sglrReferenceContext.AnyFramebuffer}
*/
es3fFboRenderTest.Framebuffer.prototype.getFramebuffer = function() {
return this.m_framebuffer;
};
/**
* @return {?sglrReferenceContext.AnyRenderbuffer}
*/
es3fFboRenderTest.Framebuffer.prototype.getColorBuffer = function() {
return this.m_colorBuffer;
};
/**
* @return {?sglrReferenceContext.AnyRenderbuffer}
*/
es3fFboRenderTest.Framebuffer.prototype.getDepthStencilBuffer = function() {
return this.m_depthStencilBuffer;
};
/**
* deinit
*/
es3fFboRenderTest.Framebuffer.prototype.deinit = function() {
this.m_context.deleteFramebuffer(
/** @type {WebGLFramebuffer} */ (this.m_framebuffer)
);
this.destroyBuffer(this.m_colorBuffer, this.m_config.colorType);
this.destroyBuffer(
this.m_depthStencilBuffer, this.m_config.depthStencilType
);
};
/**
* checkCompleteness
*/
es3fFboRenderTest.Framebuffer.prototype.checkCompleteness = function() {
this.m_context.bindFramebuffer(gl.FRAMEBUFFER, this.m_framebuffer);
var status = this.m_context.checkFramebufferStatus(gl.FRAMEBUFFER);
this.m_context.bindFramebuffer(gl.FRAMEBUFFER, null);
if (status != gl.FRAMEBUFFER_COMPLETE)
throw new es3fFboTestUtil.FboIncompleteException(status);
};
/**
* @param {?WebGLTexture|sglrReferenceContext.TextureContainer} name
* @param {number} format
* @param {number} width
* @param {number} height
* @return {?WebGLTexture|sglrReferenceContext.TextureContainer}
*/
es3fFboRenderTest.Framebuffer.prototype.createTex2D = function(
name, format, width, height) {
if (!name)
name = this.m_context.createTexture();
this.m_context.bindTexture(gl.TEXTURE_2D, name);
this.m_context.texImage2DDelegate(
gl.TEXTURE_2D, 0, format, width, height
);
if (!deMath.deIsPowerOfTwo32(width) ||
!deMath.deIsPowerOfTwo32(height)) {
// Set wrap mode to clamp for NPOT FBOs
this.m_context.texParameteri(
gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE
);
this.m_context.texParameteri(
gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE
);
}
this.m_context.texParameteri(
gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST
);
this.m_context.texParameteri(
gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST
);
return name;
};
/**
* @param {?WebGLRenderbuffer|sglrReferenceContext.Renderbuffer} name
* @param {number} format
* @param {number} width
* @param {number} height
* @return {?WebGLRenderbuffer|sglrReferenceContext.Renderbuffer}
*/
es3fFboRenderTest.Framebuffer.prototype.createRbo = function(
name, format, width, height) {
if (!name)
name = this.m_context.createRenderbuffer();
this.m_context.bindRenderbuffer(gl.RENDERBUFFER, name);
this.m_context.renderbufferStorage(
gl.RENDERBUFFER, format, width, height
);
return name;
};
/**
* @param {?sglrReferenceContext.AnyRenderbuffer} name
* @param {number} type
*/
es3fFboRenderTest.Framebuffer.prototype.destroyBuffer = function(
name, type) {
if (type == gl.TEXTURE_2D || type == gl.TEXTURE_CUBE_MAP)
this.m_context.deleteTexture(/** @type {?WebGLTexture} */ (name));
else if (type == gl.RENDERBUFFER)
this.m_context.deleteRenderbuffer(
/** @type {?WebGLRenderbuffer} */ (name)
);
else
assertMsgOptions(
type == gl.NONE, 'Invalid buffer type', false, true
);
};
/**
* @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
* context
* @param {WebGLTexture|sglrReferenceContext.TextureContainer} name
* @param {number} format
* @param {number} dataType
* @param {number} width
* @param {number} height
*/
es3fFboRenderTest.createMetaballsTex2D = function(
context, name, format, dataType, width, height) {
/** @type {tcuTexture.TextureFormat} */ var texFormat =
gluTextureUtil.mapGLTransferFormat(format, dataType);
/** @type {tcuTexture.TextureLevel} */ var level =
new tcuTexture.TextureLevel(texFormat, width, height);
tcuTextureUtil.fillWithMetaballs(
level.getAccess(), 5, /*name ^*/ width ^ height
);
context.bindTexture(gl.TEXTURE_2D, name);
context.texImage2D(
gl.TEXTURE_2D, 0, format, width, height, 0, format,
dataType, level.getAccess().getDataPtr()
);
context.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
};
/**
* @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
* context
* @param {WebGLTexture|sglrReferenceContext.TextureContainer} name
* @param {number} format
* @param {number} dataType
* @param {number} width
* @param {number} height
*/
es3fFboRenderTest.createQuadsTex2D = function(
context, name, format, dataType, width, height) {
/** @type {tcuTexture.TextureFormat} */
var texFormat = gluTextureUtil.mapGLTransferFormat(format, dataType);
/** @type {tcuTexture.TextureLevel} */
var level = new tcuTexture.TextureLevel(texFormat, width, height);
tcuTextureUtil.fillWithRGBAQuads(level.getAccess());
context.bindTexture(gl.TEXTURE_2D, name);
context.texImage2D(
gl.TEXTURE_2D, 0, format, width, height, 0,
format, dataType, level.getAccess().getDataPtr()
);
context.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} description
* @param {es3fFboRenderTest.FboConfig} config
*/
es3fFboRenderTest.FboRenderCase = function(name, description, config) {
tcuTestCase.DeqpTest.call(this, name, description);
this.m_config = config;
};
es3fFboRenderTest.FboRenderCase.prototype =
Object.create(tcuTestCase.DeqpTest.prototype);
es3fFboRenderTest.FboRenderCase.prototype.constructor =
es3fFboRenderTest.FboRenderCase;
/**
* Must be overridden
* @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
* fboContext
* @param {tcuSurface.Surface} dst
*/
es3fFboRenderTest.FboRenderCase.prototype.render = function(
fboContext, dst) {
throw new Error('Must override');
};
/**
* @return {tcuTestCase.IterateResult}
*/
es3fFboRenderTest.FboRenderCase.prototype.iterate = function() {
var clearColor = [0.125, 0.25, 0.5, 1.0];
/** @type {?string} */ var failReason = "";
// Position & size for context
var rnd = new deRandom.deRandom();
deRandom.deRandom_init(rnd, deString.deStringHash(this.fullName()));
var width = Math.min(gl.canvas.width, 128);
var height = Math.min(gl.canvas.height, 128);
var xMax = gl.canvas.width - width + 1;
var yMax = gl.canvas.height - height + 1;
var x = Math.abs(deRandom.deRandom_getInt(rnd)) % xMax;
var y = Math.abs(deRandom.deRandom_getInt(rnd)) % yMax;
/** @type {tcuSurface.Surface} */
var gles3Frame = new tcuSurface.Surface(width, height);
/** @type {tcuSurface.Surface} */
var refFrame = new tcuSurface.Surface(width, height);
/** @type {number} */ var gles3Error = 0;
/** @type {number} */ var refError = 0;
// Render using GLES3
/**
* @type {sglrGLContext.GLContext|
* sglrReferenceContext.ReferenceContext}
*/
var context;
try {
context = new sglrGLContext.GLContext(gl, [x, y, width, height]);
context.clearColor(
clearColor[0], clearColor[1], clearColor[2], clearColor[3]
);
context.clear(
gl.COLOR_BUFFER_BIT |
gl.DEPTH_BUFFER_BIT |
gl.STENCIL_BUFFER_BIT
);
this.render(context, gles3Frame); // Call actual render func
gles3Error = context.getError();
}
catch (e) {
if (e instanceof es3fFboTestUtil.FboIncompleteException) {
e.message = WebGLTestUtils.glEnumToString(gl, e.getReason());
if(e.getReason() == gl.FRAMEBUFFER_UNSUPPORTED) {
// Mark test case as unsupported
bufferedLogToConsole(e + ': ' + e.message);
testFailed('Not supported');
return tcuTestCase.IterateResult.STOP;
}
}
// Propagate error
throw e;
}
// Render reference image
/** @type {sglrReferenceContext.ReferenceContextBuffers} */
var buffers = new sglrReferenceContext.ReferenceContextBuffers(
new tcuPixelFormat.PixelFormat(
8, 8, 8,
gl.getParameter(gl.ALPHA_BITS) ? 8 : 0
),
/** @type {number} */ (gl.getParameter(gl.DEPTH_BITS)),
/** @type {number} */ (gl.getParameter(gl.STENCIL_BITS)),
width,
height
);
context = new sglrReferenceContext.ReferenceContext(
new sglrReferenceContext.ReferenceContextLimits(gl),
buffers.getColorbuffer(),
buffers.getDepthbuffer(),
buffers.getStencilbuffer()
);
context.clearColor(
clearColor[0], clearColor[1], clearColor[2], clearColor[3]
);
context.clear(
gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT
);
this.render(context, refFrame);
refError = context.getError();
// Compare error codes
var errorCodesOk = (gles3Error == refError);
if (!errorCodesOk) {
bufferedLogToConsole (
'Error code mismatch: got ' +
WebGLTestUtils.glEnumToString(gl, gles3Error) + ', expected ' +
WebGLTestUtils.glEnumToString(gl, refError)
);
failReason = 'Got unexpected error';
}
// Compare images
var imagesOk = this.compare(refFrame, gles3Frame);
if (!imagesOk && !failReason)
failReason = 'Image comparison failed';
// Store test result
var isOk = errorCodesOk && imagesOk;
assertMsgOptions(isOk, failReason, true, true);
return tcuTestCase.IterateResult.STOP;
};
/**
* @param {tcuSurface.Surface} reference
* @param {tcuSurface.Surface} result
* @return {boolean}
*/
es3fFboRenderTest.FboRenderCase.prototype.compare = function(
reference, result) {
var threshold = new tcuRGBA.RGBA(
/* TODO: tcu::max(getFormatThreshold(this.m_config.colorFormat),*/
[12, 12, 12, 12]
);
return tcuImageCompare.bilinearCompare(
'ComparisonResult', 'Image comparison result',
reference.getAccess(), result.getAccess(),
threshold, tcuImageCompare.CompareLogMode.RESULT
);
};
/**
* deinit
*/
es3fFboRenderTest.FboRenderCase.prototype.deinit = function() {
gl.clearColor(0.0, 0.0, 0.0, 0.0);
gl.clearDepth(1.0);
gl.clearStencil(0);
gl.disable(gl.STENCIL_TEST);
gl.disable(gl.DEPTH_TEST);
gl.disable(gl.BLEND);
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
gl.bindRenderbuffer(gl.RENDERBUFFER, null);
};
// FboCases
/**
* @constructor
* @extends {es3fFboRenderTest.FboRenderCase}
* @param {es3fFboRenderTest.FboConfig} config
*/
es3fFboRenderTest.StencilClearsTest = function(config) {
es3fFboRenderTest.FboRenderCase.call(
this, config.getName(), 'Stencil clears', config
);
};
es3fFboRenderTest.StencilClearsTest.prototype =
Object.create(es3fFboRenderTest.FboRenderCase.prototype);
es3fFboRenderTest.StencilClearsTest.prototype.constructor =
es3fFboRenderTest.StencilClearsTest;
/**
* @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
* context
* @param {tcuSurface.Surface} dst
*/
es3fFboRenderTest.StencilClearsTest.prototype.render = function(
context, dst) {
/** @type {tcuTexture.TextureFormat} */
var colorFormat = gluTextureUtil.mapGLInternalFormat(
this.m_config.colorFormat
);
/** @type {gluShaderUtil.DataType} */
var fboSamplerType = /** @type {gluShaderUtil.DataType} */ (
gluTextureUtil.getSampler2DType(colorFormat)
);
/** @type {gluShaderUtil.DataType} */
var fboOutputType = es3fFboTestUtil.getFragmentOutputType(colorFormat);
/** @type {tcuTextureUtil.TextureFormatInfo} */
var fboRangeInfo = tcuTextureUtil.getTextureFormatInfo(colorFormat);
var fboOutScale = deMath.subtract(
fboRangeInfo.valueMax, fboRangeInfo.valueMin
);
var fboOutBias = fboRangeInfo.valueMin;
/** @type {es3fFboTestUtil.Texture2DShader} */
var texToFboShader = new es3fFboTestUtil.Texture2DShader(
[gluShaderUtil.DataType.SAMPLER_2D], fboOutputType
);
/** @type {es3fFboTestUtil.Texture2DShader} */
var texFromFboShader = new es3fFboTestUtil.Texture2DShader(
[fboSamplerType], gluShaderUtil.DataType.FLOAT_VEC4);
/** @type {number} */ var texToFboShaderID =
context.createProgram(texToFboShader);
/** @type {number} */ var texFromFboShaderID =
context.createProgram(texFromFboShader);
/** @type {?WebGLTexture|sglrReferenceContext.TextureContainer} */
var metaballsTex = context.createTexture();
/** @type {?WebGLTexture|sglrReferenceContext.TextureContainer} */
var quadsTex = context.createTexture();
/** @type {number} */ var width = 128;
/** @type {number} */ var height = 128;
texToFboShader.setOutScaleBias(fboOutScale, fboOutBias);
texFromFboShader.setTexScaleBias(
0, fboRangeInfo.lookupScale, fboRangeInfo.lookupBias
);
es3fFboRenderTest.createQuadsTex2D(
context, quadsTex, gl.RGBA, gl.UNSIGNED_BYTE, width, height
);
es3fFboRenderTest.createMetaballsTex2D(
context, metaballsTex, gl.RGBA, gl.UNSIGNED_BYTE, width, height
);
/** @type {es3fFboRenderTest.Framebuffer} */
var fbo = new es3fFboRenderTest.Framebuffer(
context, this.m_config, width, height
);
fbo.checkCompleteness();
// Bind framebuffer and clear
context.bindFramebuffer(gl.FRAMEBUFFER, fbo.getFramebuffer());
context.viewport(0, 0, width, height);
context.clearColor(0.0, 0.0, 0.0, 1.0);
context.clear(
gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT
);
// Do stencil clears
context.enable(gl.SCISSOR_TEST);
context.scissor(10, 16, 32, 120);
context.clearStencil(1);
context.clear(gl.STENCIL_BUFFER_BIT);
context.scissor(16, 32, 100, 64);
context.clearStencil(2);
context.clear(gl.STENCIL_BUFFER_BIT);
context.disable(gl.SCISSOR_TEST);
// Draw 2 textures with stecil tests
context.enable(gl.STENCIL_TEST);
context.bindTexture(gl.TEXTURE_2D, quadsTex);
context.stencilFunc(gl.EQUAL, 1, 0xff);
texToFboShader.setUniforms(context, texToFboShaderID);
rrUtil.drawQuad(
context, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
context.bindTexture(gl.TEXTURE_2D, metaballsTex);
context.stencilFunc(gl.EQUAL, 2, 0xff);
texToFboShader.setUniforms(context, texToFboShaderID);
rrUtil.drawQuad(
context, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
context.disable(gl.STENCIL_TEST);
if (fbo.getConfig().colorType == gl.TEXTURE_2D) {
context.bindFramebuffer(gl.FRAMEBUFFER, null);
context.bindTexture(gl.TEXTURE_2D, fbo.getColorBuffer());
context.viewport(0, 0, context.getWidth(), context.getHeight());
texFromFboShader.setUniforms(context, texFromFboShaderID);
rrUtil.drawQuad(
context, texFromFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
dst.readViewport(
context, [0, 0, context.getWidth(), context.getHeight()]
);
} else
es3fFboTestUtil.readPixels(
context, dst, 0, 0, width, height, colorFormat,
fboRangeInfo.lookupScale, fboRangeInfo.lookupBias
);
};
/**
* @constructor
* @extends {es3fFboRenderTest.FboRenderCase}
* @param {es3fFboRenderTest.FboConfig} config
*/
es3fFboRenderTest.SharedColorbufferTest = function(config) {
es3fFboRenderTest.FboRenderCase.call(
this, config.getName(), 'Shared colorbuffer', config
);
};
es3fFboRenderTest.SharedColorbufferTest.prototype =
Object.create(es3fFboRenderTest.FboRenderCase.prototype);
es3fFboRenderTest.SharedColorbufferTest.prototype.constructor =
es3fFboRenderTest.SharedColorbufferTest;
/**
* @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
* context
* @param {tcuSurface.Surface} dst
*/
es3fFboRenderTest.SharedColorbufferTest.prototype.render = function(
context, dst) {
/** @type {es3fFboTestUtil.Texture2DShader} */
var texShader = new es3fFboTestUtil.Texture2DShader(
[gluShaderUtil.DataType.SAMPLER_2D],
gluShaderUtil.DataType.FLOAT_VEC4
);
/** @type {es3fFboTestUtil.FlatColorShader} */
var flatShader = new es3fFboTestUtil.FlatColorShader(
gluShaderUtil.DataType.FLOAT_VEC4
);
/** @type {number} */
var texShaderID = context.createProgram(texShader);
/** @type {number} */
var flatShaderID = context.createProgram(flatShader);
/** @type {number} */ var width = 128;
/** @type {number} */ var height = 128;
/** @type {?WebGLTexture|sglrReferenceContext.TextureContainer} */
var quadsTex = context.createTexture();
/** @type {?WebGLTexture|sglrReferenceContext.TextureContainer} */
var metaballsTex = context.createTexture();
/** @type {boolean} */ var stencil =
(this.m_config.buffers & gl.STENCIL_BUFFER_BIT) != 0;
context.disable(gl.DITHER);
// Textures
es3fFboRenderTest.createQuadsTex2D(
context, quadsTex, gl.RGB, gl.UNSIGNED_BYTE, 64, 64
);
es3fFboRenderTest.createMetaballsTex2D(
context, metaballsTex, gl.RGBA, gl.UNSIGNED_BYTE, 64, 64
);
context.viewport(0, 0, width, height);
// Fbo A
/** @type {es3fFboRenderTest.Framebuffer} */
var fboA = new es3fFboRenderTest.Framebuffer(
context, this.m_config, width, height
);
fboA.checkCompleteness();
// Fbo B - don't create colorbuffer
/** @type {es3fFboRenderTest.FboConfig} */
var cfg = /** @type {es3fFboRenderTest.FboConfig} */
(deUtil.clone(this.m_config));
cfg.buffers = deMath.binaryOp(
cfg.buffers,
deMath.binaryNot(gl.COLOR_BUFFER_BIT),
deMath.BinaryOp.AND
);
cfg.colorType = gl.NONE;
cfg.colorFormat = gl.NONE;
/** @type {es3fFboRenderTest.Framebuffer} */
var fboB = new es3fFboRenderTest.Framebuffer(
context, cfg, width, height
);
// Attach color buffer from fbo A
context.bindFramebuffer(gl.FRAMEBUFFER, fboB.getFramebuffer());
switch (this.m_config.colorType) {
case gl.TEXTURE_2D:
context.framebufferTexture2D(
gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
gl.TEXTURE_2D, fboA.getColorBuffer(), 0
);
break;
case gl.RENDERBUFFER:
context.framebufferRenderbuffer(
gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
gl.RENDERBUFFER, fboA.getColorBuffer()
);
break;
default:
throw new Error('Invalid color type');
}
// Clear depth and stencil in fbo B
context.clear(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
// Render quads to fbo 1, with depth 0.0
context.bindFramebuffer(gl.FRAMEBUFFER, fboA.getFramebuffer());
context.bindTexture(gl.TEXTURE_2D, quadsTex);
context.clearColor(0.0, 0.0, 0.0, 1.0);
context.clear(
gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT
);
if (stencil) {
// Stencil to 1 in fbo A
context.clearStencil(1);
context.clear(gl.STENCIL_BUFFER_BIT);
}
texShader.setUniforms(context, texShaderID);
context.enable(gl.DEPTH_TEST);
rrUtil.drawQuad(
context, texShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
context.disable(gl.DEPTH_TEST);
// Blend metaballs to fbo 2
context.bindFramebuffer(gl.FRAMEBUFFER, fboB.getFramebuffer());
context.bindTexture(gl.TEXTURE_2D, metaballsTex);
context.enable(gl.BLEND);
context.blendFuncSeparate(
gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ZERO, gl.ONE
);
rrUtil.drawQuad(
context, texShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
// Render small quad that is only visible if depth buffer
// is not shared with fbo A - or there is no depth bits
context.bindTexture(gl.TEXTURE_2D, quadsTex);
context.enable(gl.DEPTH_TEST);
rrUtil.drawQuad(context, texShaderID, [0.5, 0.5, 0.5], [1.0, 1.0, 0.5]);
context.disable(gl.DEPTH_TEST);
if (stencil) {
flatShader.setColor(context, flatShaderID, [0.0, 1.0, 0.0, 1.0]);
// Clear subset of stencil buffer to 1
context.enable(gl.SCISSOR_TEST);
context.scissor(10, 10, 12, 25);
context.clearStencil(1);
context.clear(gl.STENCIL_BUFFER_BIT);
context.disable(gl.SCISSOR_TEST);
// Render quad with stencil mask == 1
context.enable(gl.STENCIL_TEST);
context.stencilFunc(gl.EQUAL, 1, 0xff);
rrUtil.drawQuad(
context, flatShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
context.disable(gl.STENCIL_TEST);
}
// Get results
if (fboA.getConfig().colorType == gl.TEXTURE_2D) {
texShader.setUniforms(context, texShaderID);
context.bindFramebuffer(gl.FRAMEBUFFER, null);
context.bindTexture(gl.TEXTURE_2D, fboA.getColorBuffer());
context.viewport(0, 0, context.getWidth(), context.getHeight());
rrUtil.drawQuad(
context, texShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
dst.readViewport(
context, [0, 0, context.getWidth(), context.getHeight()]
);
} else
es3fFboTestUtil.readPixels(
context, dst, 0, 0, width, height,
gluTextureUtil.mapGLInternalFormat(
fboA.getConfig().colorFormat
), [1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]
);
};
/**
* @constructor
* @extends {es3fFboRenderTest.FboRenderCase}
* @param {es3fFboRenderTest.FboConfig} config
*/
es3fFboRenderTest.SharedColorbufferClearsTest = function(config) {
es3fFboRenderTest.FboRenderCase.call(
this, config.getName(), 'Shared colorbuffer clears', config
);
};
es3fFboRenderTest.SharedColorbufferClearsTest.prototype =
Object.create(es3fFboRenderTest.FboRenderCase.prototype);
es3fFboRenderTest.SharedColorbufferClearsTest.prototype.constructor =
es3fFboRenderTest.SharedColorbufferClearsTest;
/**
* @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
* context
* @param {tcuSurface.Surface} dst
*/
es3fFboRenderTest.SharedColorbufferClearsTest.prototype.render = function(
context, dst) {
/** @type {tcuTexture.TextureFormat} */
var colorFormat = gluTextureUtil.mapGLInternalFormat(
this.m_config.colorFormat
);
/** @type {gluShaderUtil.DataType} */
var fboSamplerType = gluTextureUtil.getSampler2DType(colorFormat);
var width = 128;
var height = 128;
var colorbuffer = this.m_config.colorType == gl.TEXTURE_2D?
context.createTexture() :
context.createRenderbuffer();
// Check for format support.
es3fFboRenderTest.checkColorFormatSupport(
context, this.m_config.colorFormat
);
// Single colorbuffer
if (this.m_config.colorType == gl.TEXTURE_2D) {
context.bindTexture(gl.TEXTURE_2D, colorbuffer);
context.texImage2DDelegate(
gl.TEXTURE_2D, 0, this.m_config.colorFormat, width, height
);
context.texParameteri(
gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST
);
context.texParameteri(
gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST
);
} else {
assertMsgOptions(
this.m_config.colorType == gl.RENDERBUFFER,
'Not a render buffer type', false, true
);
context.bindRenderbuffer(gl.RENDERBUFFER, colorbuffer);
context.renderbufferStorage(
gl.RENDERBUFFER, this.m_config.colorFormat, width, height
);
}
// Multiple framebuffers sharing the colorbuffer
var fbo = [
context.createFramebuffer(),
context.createFramebuffer(),
context.createFramebuffer()
];
for (var fboi = 0; fboi < fbo.length; fboi++) {
context.bindFramebuffer(gl.FRAMEBUFFER, fbo[fboi]);
if (this.m_config.colorType == gl.TEXTURE_2D)
context.framebufferTexture2D(
gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
gl.TEXTURE_2D, colorbuffer, 0
);
else
context.framebufferRenderbuffer(
gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
gl.RENDERBUFFER, colorbuffer
);
}
context.bindFramebuffer(gl.FRAMEBUFFER, fbo[0]);
// Check completeness
var status = context.checkFramebufferStatus(gl.FRAMEBUFFER);
if (status != gl.FRAMEBUFFER_COMPLETE)
throw new es3fFboTestUtil.FboIncompleteException(status);
// Render to them
context.viewport(0, 0, width, height);
context.clearColor(0.0, 0.0, 1.0, 1.0);
context.clear(gl.COLOR_BUFFER_BIT);
context.enable(gl.SCISSOR_TEST);
context.bindFramebuffer(gl.FRAMEBUFFER, fbo[1]);
context.clearColor(0.6, 0.0, 0.0, 1.0);
context.scissor(10, 10, 64, 64);
context.clear(gl.COLOR_BUFFER_BIT);
context.clearColor(0.0, 0.6, 0.0, 1.0);
context.scissor(60, 60, 40, 20);
context.clear(gl.COLOR_BUFFER_BIT);
context.bindFramebuffer(gl.FRAMEBUFFER, fbo[2]);
context.clearColor(0.0, 0.0, 0.6, 1.0);
context.scissor(20, 20, 100, 10);
context.clear(gl.COLOR_BUFFER_BIT);
context.bindFramebuffer(gl.FRAMEBUFFER, fbo[0]);
context.clearColor(0.6, 0.0, 0.6, 1.0);
context.scissor(20, 20, 5, 100);
context.clear(gl.COLOR_BUFFER_BIT);
context.disable(gl.SCISSOR_TEST);
if (this.m_config.colorType == gl.TEXTURE_2D) {
/** @type {es3fFboTestUtil.Texture2DShader} */
var shader = new es3fFboTestUtil.Texture2DShader(
[fboSamplerType], gluShaderUtil.DataType.FLOAT_VEC4
);
var shaderID = context.createProgram(shader);
shader.setUniforms(context, shaderID);
context.bindFramebuffer(gl.FRAMEBUFFER, null);
context.viewport(0, 0, context.getWidth(), context.getHeight());
rrUtil.drawQuad(
context, shaderID, [-0.9, -0.9, 0.0], [0.9, 0.9, 0.0]
);
dst.readViewport(
context, [0, 0, context.getWidth(), context.getHeight()]
);
} else
es3fFboTestUtil.readPixels(
context, dst, 0, 0, width, height, colorFormat,
[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]
);
//delete FBOs
for (fboi = 0; fboi < fbo.length; fboi++)
context.deleteFramebuffer(fbo[fboi]);
//delete Texture/Renderbuffer
if (this.m_config.colorType == gl.TEXTURE_2D)
context.deleteTexture(colorbuffer);
else
context.deleteRenderbuffer(colorbuffer);
};
/**
* @constructor
* @extends {es3fFboRenderTest.FboRenderCase}
* @param {es3fFboRenderTest.FboConfig} config
*/
es3fFboRenderTest.SharedDepthStencilTest = function(config) {
es3fFboRenderTest.FboRenderCase.call(
this, config.getName(), 'Shared depth/stencilbuffer', config
);
};
es3fFboRenderTest.SharedDepthStencilTest.prototype =
Object.create(es3fFboRenderTest.FboRenderCase.prototype);
es3fFboRenderTest.SharedDepthStencilTest.prototype.constructor =
es3fFboRenderTest.SharedDepthStencilTest;
/**
* @param {es3fFboRenderTest.FboConfig} config
* @return {boolean}
*/
es3fFboRenderTest.SharedDepthStencilTest.prototype.isConfigSupported =
function(config) {
return deMath.binaryOp(
config.buffers,
deMath.binaryOp(
gl.DEPTH_BUFFER_BIT, gl.STENCIL_BUFFER_BIT, deMath.BinaryOp.OR
), deMath.BinaryOp.AND
) != 0;
};
/**
* @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
* context
* @param {tcuSurface.Surface} dst
*/
es3fFboRenderTest.SharedDepthStencilTest.prototype.render = function(
context, dst) {
/** @type {es3fFboTestUtil.Texture2DShader} */
var texShader = new es3fFboTestUtil.Texture2DShader(
[gluShaderUtil.DataType.SAMPLER_2D],
gluShaderUtil.DataType.FLOAT_VEC4
);
/** @type {es3fFboTestUtil.FlatColorShader} */
var flatShader = new es3fFboTestUtil.FlatColorShader(
gluShaderUtil.DataType.FLOAT_VEC4
);
var texShaderID = context.createProgram(texShader);
var flatShaderID = context.createProgram(flatShader);
var width = 128;
var height = 128;
// bool depth = (this.m_config.buffers & gl.DEPTH_BUFFER_BIT) != 0;
/**@type {boolean} */ var stencil =
(this.m_config.buffers & gl.STENCIL_BUFFER_BIT) != 0;
// Textures
var metaballsTex = context.createTexture();
var quadsTex = context.createTexture();
es3fFboRenderTest.createMetaballsTex2D(
context, metaballsTex, gl.RGB, gl.UNSIGNED_BYTE, 64, 64
);
es3fFboRenderTest.createQuadsTex2D(
context, quadsTex, gl.RGB, gl.UNSIGNED_BYTE, 64, 64
);
context.viewport(0, 0, width, height);
// Fbo A
/** @type {es3fFboRenderTest.Framebuffer} */
var fboA = new es3fFboRenderTest.Framebuffer(
context, this.m_config, width, height
);
fboA.checkCompleteness();
// Fbo B
/** @type {es3fFboRenderTest.FboConfig} */
var cfg = /** @type {es3fFboRenderTest.FboConfig} */
(deUtil.clone(this.m_config));
cfg.buffers = deMath.binaryOp(
cfg.buffers,
deMath.binaryNot(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT),
deMath.BinaryOp.AND
);
cfg.depthStencilType = gl.NONE;
cfg.depthStencilFormat = gl.NONE;
/** @type {es3fFboRenderTest.Framebuffer} */
var fboB = new es3fFboRenderTest.Framebuffer(
context, cfg, width, height
);
// Bind depth/stencil buffers from fbo A to fbo B
context.bindFramebuffer(gl.FRAMEBUFFER, fboB.getFramebuffer());
for (var ndx = 0; ndx < 2; ndx++) {
var bit = ndx ? gl.STENCIL_BUFFER_BIT : gl.DEPTH_BUFFER_BIT;
var point = ndx ? gl.STENCIL_ATTACHMENT : gl.DEPTH_ATTACHMENT;
if (
deMath.binaryOp(
this.m_config.buffers, bit, deMath.BinaryOp.AND
) == 0
)
continue;
switch (this.m_config.depthStencilType) {
case gl.TEXTURE_2D:
context.framebufferTexture2D(
gl.FRAMEBUFFER, point, gl.TEXTURE_2D,
fboA.getDepthStencilBuffer(), 0
);
break;
case gl.RENDERBUFFER:
context.framebufferRenderbuffer(
gl.FRAMEBUFFER, point, gl.RENDERBUFFER,
fboA.getDepthStencilBuffer()
);
break;
default:
testFailed('Not implemented');
}
}
// Setup uniforms
texShader.setUniforms(context, texShaderID);
// Clear color to red and stencil to 1 in fbo B.
context.clearColor(1.0, 0.0, 0.0, 1.0);
context.clearStencil(1);
context.clear(
gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT
);
context.enable(gl.DEPTH_TEST);
// Render quad to fbo A
context.bindFramebuffer(gl.FRAMEBUFFER, fboA.getFramebuffer());
context.bindTexture(gl.TEXTURE_2D, quadsTex);
rrUtil.drawQuad(
context, texShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
if (stencil) {
// Clear subset of stencil buffer to 0 in fbo A
context.enable(gl.SCISSOR_TEST);
context.scissor(10, 10, 12, 25);
context.clearStencil(0);
context.clear(gl.STENCIL_BUFFER_BIT);
context.disable(gl.SCISSOR_TEST);
}
// Render metaballs to fbo B
context.bindFramebuffer(gl.FRAMEBUFFER, fboB.getFramebuffer());
context.bindTexture(gl.TEXTURE_2D, metaballsTex);
rrUtil.drawQuad(
context, texShaderID, [-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]
);
context.disable(gl.DEPTH_TEST);
if (stencil) {
// Render quad with stencil mask == 0
context.enable(gl.STENCIL_TEST);
context.stencilFunc(gl.EQUAL, 0, 0xff);
context.useProgram(flatShaderID);
flatShader.setColor(context, flatShaderID, [0.0, 1.0, 0.0, 1.0]);
rrUtil.drawQuad(
context, flatShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
context.disable(gl.STENCIL_TEST);
}
if (this.m_config.colorType == gl.TEXTURE_2D) {
// Render both to screen
context.bindFramebuffer(gl.FRAMEBUFFER, null);
context.viewport(0, 0, context.getWidth(), context.getHeight());
context.bindTexture(gl.TEXTURE_2D, fboA.getColorBuffer());
rrUtil.drawQuad(
context, texShaderID, [-1.0, -1.0, 0.0], [0.0, 1.0, 0.0]
);
context.bindTexture(gl.TEXTURE_2D, fboB.getColorBuffer());
rrUtil.drawQuad(
context, texShaderID, [0.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
dst.readViewport(
context, [0, 0, context.getWidth(), context.getHeight()]
);
} else {
// Read results from fbo B
es3fFboTestUtil.readPixels(
context, dst, 0, 0, width, height,
gluTextureUtil.mapGLInternalFormat(this.m_config.colorFormat),
[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]
);
}
};
/**
* @constructor
* @extends {es3fFboRenderTest.FboRenderCase}
* @param {es3fFboRenderTest.FboConfig} config
*/
es3fFboRenderTest.ResizeTest = function(config) {
es3fFboRenderTest.FboRenderCase.call(
this, config.getName(), 'Resize framebuffer', config
);
};
es3fFboRenderTest.ResizeTest.prototype =
Object.create(es3fFboRenderTest.FboRenderCase.prototype);
es3fFboRenderTest.ResizeTest.prototype.constructor =
es3fFboRenderTest.ResizeTest;
/**
* @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
* context
* @param {tcuSurface.Surface} dst
*/
es3fFboRenderTest.ResizeTest.prototype.render = function(context, dst) {
/** @type {tcuTexture.TextureFormat} */
var colorFormat = gluTextureUtil.mapGLInternalFormat(
this.m_config.colorFormat
);
/** @type {gluShaderUtil.DataType} */
var fboSamplerType = gluTextureUtil.getSampler2DType(colorFormat);
/** @type {gluShaderUtil.DataType} */
var fboOutputType = es3fFboTestUtil.getFragmentOutputType(colorFormat);
/** @type {tcuTextureUtil.TextureFormatInfo} */
var fboRangeInfo = tcuTextureUtil.getTextureFormatInfo(colorFormat);
var fboOutScale = deMath.subtract(
fboRangeInfo.valueMax, fboRangeInfo.valueMin
);
var fboOutBias = fboRangeInfo.valueMin;
/** @type {es3fFboTestUtil.Texture2DShader} */
var texToFboShader = new es3fFboTestUtil.Texture2DShader(
[gluShaderUtil.DataType.SAMPLER_2D], fboOutputType
);
/** @type {es3fFboTestUtil.Texture2DShader} */
var texFromFboShader = new es3fFboTestUtil.Texture2DShader(
[fboSamplerType], gluShaderUtil.DataType.FLOAT_VEC4
);
/** @type {es3fFboTestUtil.FlatColorShader} */
var flatShader = new es3fFboTestUtil.FlatColorShader(fboOutputType);
/** @type {WebGLProgram} */
var texToFboShaderID = context.createProgram(texToFboShader);
/** @type {WebGLProgram} */
var texFromFboShaderID = context.createProgram(texFromFboShader);
/** @type {WebGLProgram} */
var flatShaderID = context.createProgram(flatShader);
var quadsTex = context.createTexture();
var metaballsTex = context.createTexture();
var depth = deMath.binaryOp(
this.m_config.buffers, gl.DEPTH_BUFFER_BIT, deMath.BinaryOp.AND
) != 0;
var stencil = deMath.binaryOp(
this.m_config.buffers, gl.STENCIL_BUFFER_BIT, deMath.BinaryOp.AND
) != 0;
var initialWidth = 128;
var initialHeight = 128;
var newWidth = 64;
var newHeight = 32;
texToFboShader.setOutScaleBias(fboOutScale, fboOutBias);
texFromFboShader.setTexScaleBias(
0, fboRangeInfo.lookupScale, fboRangeInfo.lookupBias
);
es3fFboRenderTest.createQuadsTex2D(
context, quadsTex, gl.RGB, gl.UNSIGNED_BYTE, 64, 64
);
es3fFboRenderTest.createMetaballsTex2D(
context, metaballsTex, gl.RGB, gl.UNSIGNED_BYTE, 32, 32
);
/** @type {es3fFboRenderTest.Framebuffer} */
var fbo = new es3fFboRenderTest.Framebuffer(
context, this.m_config, initialWidth, initialHeight
);
fbo.checkCompleteness();
// Setup shaders
texToFboShader.setUniforms(context, texToFboShaderID);
texFromFboShader.setUniforms(context, texFromFboShaderID);
flatShader.setColor(
context, flatShaderID, deMath.add(
deMath.multiply([0.0, 1.0, 0.0, 1.0], fboOutScale), fboOutBias
)
);
// Render quads
context.bindFramebuffer(gl.FRAMEBUFFER, fbo.getFramebuffer());
context.viewport(0, 0, initialWidth, initialHeight);
es3fFboTestUtil.clearColorBuffer(
context, colorFormat, [0.0, 0.0, 0.0, 1.0]
);
context.clear(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
context.bindTexture(gl.TEXTURE_2D, quadsTex);
rrUtil.drawQuad(
context, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
if (fbo.getConfig().colorType == gl.TEXTURE_2D) {
// Render fbo to screen
context.bindFramebuffer(gl.FRAMEBUFFER, null);
context.viewport(0, 0, context.getWidth(), context.getHeight());
context.bindTexture(gl.TEXTURE_2D, fbo.getColorBuffer());
rrUtil.drawQuad(
context, texFromFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
// Restore binding
context.bindFramebuffer(gl.FRAMEBUFFER, fbo.getFramebuffer());
}
// Resize buffers
switch (fbo.getConfig().colorType) {
case gl.TEXTURE_2D:
context.bindTexture(gl.TEXTURE_2D, fbo.getColorBuffer());
context.texImage2DDelegate(
gl.TEXTURE_2D, 0, fbo.getConfig().colorFormat,
newWidth, newHeight
);
break;
case gl.RENDERBUFFER:
context.bindRenderbuffer(gl.RENDERBUFFER, fbo.getColorBuffer());
context.renderbufferStorage(
gl.RENDERBUFFER, fbo.getConfig().colorFormat,
newWidth, newHeight
);
break;
default:
throw new Error('Color type unsupported');
}
if (depth || stencil) {
switch (fbo.getConfig().depthStencilType) {
case gl.TEXTURE_2D:
context.bindTexture(
gl.TEXTURE_2D, fbo.getDepthStencilBuffer()
);
context.texImage2DDelegate(
gl.TEXTURE_2D, 0, fbo.getConfig().depthStencilFormat,
newWidth, newHeight
);
break;
case gl.RENDERBUFFER:
context.bindRenderbuffer(
gl.RENDERBUFFER, fbo.getDepthStencilBuffer()
);
context.renderbufferStorage(
gl.RENDERBUFFER, fbo.getConfig().depthStencilFormat,
newWidth, newHeight
);
break;
default:
throw new Error('Depth / stencil type unsupported');
}
}
// Render to resized fbo
context.viewport(0, 0, newWidth, newHeight);
es3fFboTestUtil.clearColorBuffer(
context, colorFormat, [1.0, 0.0, 0.0, 1.0]
);
context.clear(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
context.enable(gl.DEPTH_TEST);
context.bindTexture(gl.TEXTURE_2D, metaballsTex);
rrUtil.drawQuad(
context, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
context.bindTexture(gl.TEXTURE_2D, quadsTex);
rrUtil.drawQuad(
context, texToFboShaderID, [0.0, 0.0, -1.0], [1.0, 1.0, 1.0]
);
context.disable(gl.DEPTH_TEST);
if (stencil) {
context.enable(gl.SCISSOR_TEST);
context.clearStencil(1);
context.scissor(10, 10, 5, 15);
context.clear(gl.STENCIL_BUFFER_BIT);
context.disable(gl.SCISSOR_TEST);
context.enable(gl.STENCIL_TEST);
context.stencilFunc(gl.EQUAL, 1, 0xff);
rrUtil.drawQuad(
context, flatShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
context.disable(gl.STENCIL_TEST);
}
if (this.m_config.colorType == gl.TEXTURE_2D) {
context.bindFramebuffer(gl.FRAMEBUFFER, null);
context.viewport(0, 0, context.getWidth(), context.getHeight());
context.bindTexture(gl.TEXTURE_2D, fbo.getColorBuffer());
rrUtil.drawQuad(
context, texFromFboShaderID, [-0.5, -0.5, 0.0], [0.5, 0.5, 0.0]
);
dst.readViewport(
context, [0, 0, context.getWidth(), context.getHeight()]
);
} else
es3fFboTestUtil.readPixels(
context, dst, 0, 0, newWidth, newHeight, colorFormat,
fboRangeInfo.lookupScale, fboRangeInfo.lookupBias
);
};
/**
* @constructor
* @extends {es3fFboRenderTest.FboRenderCase}
* @param {es3fFboRenderTest.FboConfig} config
* @param {number} buffers
* @param {boolean} rebind
*/
es3fFboRenderTest.RecreateBuffersTest = function(config, buffers, rebind) {
es3fFboRenderTest.FboRenderCase.call(
this, config.getName() +
(rebind ? '' : '_no_rebind'),
'Recreate buffers', config
);
this.m_buffers = buffers;
this.m_rebind = rebind;
};
es3fFboRenderTest.RecreateBuffersTest.prototype =
Object.create(es3fFboRenderTest.FboRenderCase.prototype);
es3fFboRenderTest.RecreateBuffersTest.prototype.construtor =
es3fFboRenderTest.RecreateBuffersTest;
/**
* @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
* ctx
* @param {tcuSurface.Surface} dst
*/
es3fFboRenderTest.RecreateBuffersTest.prototype.render = function(
ctx, dst) {
/** @type {tcuTexture.TextureFormat} */
var colorFormat = gluTextureUtil.mapGLInternalFormat(
this.m_config.colorFormat
);
/** @type {gluShaderUtil.DataType} */
var fboSamplerType = gluTextureUtil.getSampler2DType(colorFormat);
/** @type {gluShaderUtil.DataType} */
var fboOutputType = es3fFboTestUtil.getFragmentOutputType(colorFormat);
/** @type {tcuTextureUtil.TextureFormatInfo} */
var fboRangeInfo = tcuTextureUtil.getTextureFormatInfo(colorFormat);
var fboOutScale = deMath.subtract(
fboRangeInfo.valueMax, fboRangeInfo.valueMin
);
var fboOutBias = fboRangeInfo.valueMin;
/** @type {es3fFboTestUtil.Texture2DShader} */
var texToFboShader = new es3fFboTestUtil.Texture2DShader(
[gluShaderUtil.DataType.SAMPLER_2D], fboOutputType
);
/** @type {es3fFboTestUtil.Texture2DShader} */
var texFromFboShader = new es3fFboTestUtil.Texture2DShader(
[fboSamplerType], gluShaderUtil.DataType.FLOAT_VEC4
);
/** @type {es3fFboTestUtil.FlatColorShader} */
var flatShader = new es3fFboTestUtil.FlatColorShader(fboOutputType);
/** @type {number} */
var texToFboShaderID = ctx.createProgram(texToFboShader);
/** @type {number} */
var texFromFboShaderID = ctx.createProgram(texFromFboShader);
/** @type {number} */
var flatShaderID = ctx.createProgram(flatShader);
var width = 128;
var height = 128;
var metaballsTex = ctx.createTexture();
var quadsTex = ctx.createTexture();
var stencil = deMath.binaryOp(
this.m_config.buffers, gl.STENCIL_BUFFER_BIT, deMath.BinaryOp.AND
) != 0;
es3fFboRenderTest.createQuadsTex2D(
ctx, quadsTex, gl.RGB, gl.UNSIGNED_BYTE, 64, 64
);
es3fFboRenderTest.createMetaballsTex2D(
ctx, metaballsTex, gl.RGB, gl.UNSIGNED_BYTE, 64, 64
);
/** @type {es3fFboRenderTest.Framebuffer} */
var fbo = new es3fFboRenderTest.Framebuffer(
ctx, this.m_config, width, height
);
fbo.checkCompleteness();
// Setup shaders
texToFboShader.setOutScaleBias(fboOutScale, fboOutBias);
texFromFboShader.setTexScaleBias(
0, fboRangeInfo.lookupScale, fboRangeInfo.lookupBias
);
texToFboShader.setUniforms(ctx, texToFboShaderID);
texFromFboShader.setUniforms(ctx, texFromFboShaderID);
flatShader.setColor(
ctx, flatShaderID, deMath.add(
deMath.multiply([0.0, 0.0, 1.0, 1.0], fboOutScale
), fboOutBias)
);
// Draw scene
ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo.getFramebuffer());
ctx.viewport(0, 0, width, height);
es3fFboTestUtil.clearColorBuffer(
ctx, colorFormat, [1.0, 0.0, 0.0, 1.0]
);
ctx.clear(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
ctx.enable(gl.DEPTH_TEST);
ctx.bindTexture(gl.TEXTURE_2D, quadsTex);
rrUtil.drawQuad(
ctx, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
ctx.disable(gl.DEPTH_TEST);
if (stencil) {
ctx.enable(gl.SCISSOR_TEST);
ctx.scissor(
Math.floor(width / 4), Math.floor(height / 4),
Math.floor(width / 2), Math.floor(height / 2)
);
ctx.clearStencil(1);
ctx.clear(gl.STENCIL_BUFFER_BIT);
ctx.disable(gl.SCISSOR_TEST);
}
// Recreate buffers
if (!this.m_rebind)
ctx.bindFramebuffer(gl.FRAMEBUFFER, null);
assertMsgOptions(
deMath.binaryOp(
this.m_buffers, deMath.binaryOp(
gl.DEPTH_BUFFER_BIT,
gl.STENCIL_BUFFER_BIT,
deMath.BinaryOp.OR
), deMath.BinaryOp.AND
) == 0 || deMath.binaryOp(
this.m_buffers, deMath.binaryOp(
gl.DEPTH_BUFFER_BIT,
gl.STENCIL_BUFFER_BIT,
deMath.BinaryOp.OR
), deMath.BinaryOp.AND
) == deMath.binaryOp(
this.m_config.buffers, deMath.binaryOp(
gl.DEPTH_BUFFER_BIT,
gl.STENCIL_BUFFER_BIT,
deMath.BinaryOp.OR
), deMath.BinaryOp.AND
), 'Depth/stencil buffers are not disabled or not ' +
'equal to the config\'s depth/stencil buffer state',
false, true
);
// Recreate.
for (var ndx = 0; ndx < 2; ndx++) {
var bit = ndx == 0 ? gl.COLOR_BUFFER_BIT :
(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
var type = ndx == 0 ? fbo.getConfig().colorType :
fbo.getConfig().depthStencilType;
var format = ndx == 0 ? fbo.getConfig().colorFormat :
fbo.getConfig().depthStencilFormat;
var buf = ndx == 0 ? fbo.getColorBuffer() :
fbo.getDepthStencilBuffer();
if (deMath.binaryOp(this.m_buffers, bit, deMath.BinaryOp.AND) == 0)
continue;
switch (type) {
case gl.TEXTURE_2D:
ctx.deleteTexture(/** @type {WebGLTexture} */ (buf));
buf = ctx.createTexture();
ctx.bindTexture(gl.TEXTURE_2D, buf);
ctx.texImage2DDelegate(
gl.TEXTURE_2D, 0, format, width, height
);
ctx.texParameteri(
gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST
);
ctx.texParameteri(
gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST
);
break;
case gl.RENDERBUFFER:
ctx.deleteRenderbuffer(
/** @type {WebGLRenderbuffer} */ (buf)
);
buf = ctx.createRenderbuffer();
ctx.bindRenderbuffer(gl.RENDERBUFFER, buf);
ctx.renderbufferStorage(
gl.RENDERBUFFER, format, width, height
);
break;
default:
throw new Error('Unsupported buffer type');
}
if (ndx == 0) {
fbo.m_colorBuffer = buf;
} else {
fbo.m_depthStencilBuffer = buf;
}
}
// Rebind.
if (this.m_rebind) {
for (var ndx = 0; ndx < 3; ndx++) {
var bit = ndx == 0 ? gl.COLOR_BUFFER_BIT :
ndx == 1 ? gl.DEPTH_BUFFER_BIT :
ndx == 2 ? gl.STENCIL_BUFFER_BIT : 0;
var point = ndx == 0 ? gl.COLOR_ATTACHMENT0 :
ndx == 1 ? gl.DEPTH_ATTACHMENT :
ndx == 2 ? gl.STENCIL_ATTACHMENT : 0;
var type = ndx == 0 ? fbo.getConfig().colorType :
fbo.getConfig().depthStencilType;
var buf = ndx == 0 ? fbo.getColorBuffer() :
fbo.getDepthStencilBuffer();
if (deMath.binaryOp(
this.m_buffers, bit, deMath.BinaryOp.AND) == 0)
continue;
switch (type) {
case gl.TEXTURE_2D:
ctx.framebufferTexture2D(
gl.FRAMEBUFFER, point, gl.TEXTURE_2D, buf, 0
);
break;
case gl.RENDERBUFFER:
ctx.framebufferRenderbuffer(
gl.FRAMEBUFFER, point, gl.RENDERBUFFER, buf
);
break;
default:
throw new Error('Invalid buffer type');
}
}
}
if (!this.m_rebind)
ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo.getFramebuffer());
ctx.clearStencil(0);
// \note Clear only buffers that were re-created
ctx.clear(
deMath.binaryOp(
this.m_buffers,
deMath.binaryOp(
gl.DEPTH_BUFFER_BIT,
gl.STENCIL_BUFFER_BIT,
deMath.BinaryOp.OR
), deMath.BinaryOp.AND
)
);
if (deMath.binaryOp(
this.m_buffers, gl.COLOR_BUFFER_BIT, deMath.BinaryOp.AND)) {
// Clearing of integer buffers is undefined
// so do clearing by rendering flat color.
rrUtil.drawQuad(
ctx, flatShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
}
ctx.enable(gl.DEPTH_TEST);
if (stencil) {
// \note Stencil test enabled only if we have stencil buffer
ctx.enable(gl.STENCIL_TEST);
ctx.stencilFunc(gl.EQUAL, 0, 0xff);
}
ctx.bindTexture(gl.TEXTURE_2D, metaballsTex);
rrUtil.drawQuad(
ctx, texToFboShaderID, [-1.0, -1.0, 1.0], [1.0, 1.0, -1.0]
);
if (stencil)
ctx.disable(gl.STENCIL_TEST);
ctx.disable(gl.DEPTH_TEST);
if (fbo.getConfig().colorType == gl.TEXTURE_2D) {
// Unbind fbo
ctx.bindFramebuffer(gl.FRAMEBUFFER, null);
// Draw to screen
ctx.bindTexture(gl.TEXTURE_2D, fbo.getColorBuffer());
ctx.viewport(0, 0, ctx.getWidth(), ctx.getHeight());
rrUtil.drawQuad(
ctx, texFromFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
);
// Read from screen
dst.readViewport(ctx, [0, 0, ctx.getWidth(), ctx.getHeight()]);
} else {
// Read from fbo
es3fFboTestUtil.readPixels(
ctx, dst, 0, 0, width, height, colorFormat,
fboRangeInfo.lookupScale, fboRangeInfo.lookupBias
);
}
};
// FboGroups
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fFboRenderTest.FboRenderTestGroup = function() {
tcuTestCase.DeqpTest.call(this, 'render', 'Rendering Tests');
};
es3fFboRenderTest.FboRenderTestGroup.prototype =
Object.create(tcuTestCase.DeqpTest.prototype);
es3fFboRenderTest.FboRenderTestGroup.prototype.constructor =
es3fFboRenderTest.FboRenderTestGroup;
/**
* @enum {number}
*/
var FormatType = {
FLOAT: 0,
INT: 1,
UINT: 2
};
// Required by specification.
/**
* @typedef {{format: number, type: FormatType}}
*/
var ColorFormatStruct;
/**
* @typedef {{format: number, depth: boolean, stencil: boolean}}
*/
var DepthStencilFormatStruct;
/**
* init
*/
es3fFboRenderTest.FboRenderTestGroup.prototype.init = function() {
var objectTypes = [
gl.TEXTURE_2D,
gl.RENDERBUFFER
];
/** @type {Array<ColorFormatStruct>} */ var colorFormats = [{
format: gl.RGBA32F, type: FormatType.FLOAT
},{
format: gl.RGBA32I, type: FormatType.INT
},{
format: gl.RGBA32UI, type: FormatType.UINT
},{
format: gl.RGBA16F, type: FormatType.FLOAT
},{
format: gl.RGBA16I, type: FormatType.INT
},{
format: gl.RGBA16UI, type: FormatType.UINT
},/*{
// RGB16F isn't made color-renderable through WebGL's EXT_color_buffer_float
format: gl.RGB16F, type: FormatType.FLOAT
},*/{
format: gl.RGBA8I, type: FormatType.INT
},{
format: gl.RGBA8UI, type: FormatType.UINT
},{
format: gl.RGB10_A2UI, type: FormatType.UINT
},{
format: gl.R11F_G11F_B10F, type: FormatType.FLOAT
},{
format: gl.RG32F, type: FormatType.FLOAT
},{
format: gl.RG32I, type: FormatType.INT
},{
format: gl.RG32UI, type: FormatType.UINT
},{
format: gl.RG16F, type: FormatType.FLOAT
},{
format: gl.RG16I, type: FormatType.INT
},{
format: gl.RG16UI, type: FormatType.UINT
},{
format: gl.RG8, type: FormatType.FLOAT
},{
format: gl.RG8I, type: FormatType.INT
},{
format: gl.RG8UI, type: FormatType.UINT
},{
format: gl.R32F, type: FormatType.FLOAT
},{
format: gl.R32I, type: FormatType.INT
},{
format: gl.R32UI, type: FormatType.UINT
},{
format: gl.R16F, type: FormatType.FLOAT
},{
format: gl.R16I, type: FormatType.INT
},{
format: gl.R16UI, type: FormatType.UINT
},{
format: gl.R8, type: FormatType.FLOAT
},{
format: gl.R8I, type: FormatType.INT
},{
format: gl.R8UI, type: FormatType.UINT
}];
/** @type {Array<DepthStencilFormatStruct>} */
var depthStencilFormats = [{
format: gl.DEPTH_COMPONENT32F, depth: true, stencil: false
},{
format: gl.DEPTH_COMPONENT24, depth: true, stencil: false
},{
format: gl.DEPTH_COMPONENT16, depth: true, stencil: false
},{
format: gl.DEPTH32F_STENCIL8, depth: true, stencil: true
},{
format: gl.DEPTH24_STENCIL8, depth: true, stencil: true
},{
format: gl.STENCIL_INDEX8, depth: false, stencil: true
}];
/** @type {es3fFboRenderTest.FboConfig} */ var config;
var colorType;
var stencilType;
var colorFmt;
var depth;
var stencil;
var depthStencilType;
var depthStencilFormat;
// .stencil_clear
/** @type {tcuTestCase.DeqpTest} */
var stencilClearGroup = new tcuTestCase.DeqpTest(
'stencil_clear', 'Stencil buffer clears'
);
this.addChild(stencilClearGroup);
for (var fmtNdx = 0; fmtNdx < depthStencilFormats.length; fmtNdx++) {
colorType = gl.TEXTURE_2D;
stencilType = gl.RENDERBUFFER;
colorFmt = gl.RGBA8;
if (!depthStencilFormats[fmtNdx].stencil)
continue;
config = new es3fFboRenderTest.FboConfig(
gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT,
colorType, colorFmt, stencilType,
depthStencilFormats[fmtNdx].format
);
stencilClearGroup.addChild(
new es3fFboRenderTest.StencilClearsTest(config)
);
}
// .shared_colorbuffer_clear
/** @type {tcuTestCase.DeqpTest} */
var sharedColorbufferClearGroup = new tcuTestCase.DeqpTest(
'shared_colorbuffer_clear', 'Shader colorbuffer clears'
);
this.addChild(sharedColorbufferClearGroup);
for (var colorFmtNdx = 0;
colorFmtNdx < colorFormats.length;
colorFmtNdx++) {
// Clearing of integer buffers is undefined.
if (colorFormats[colorFmtNdx].type == FormatType.INT ||
colorFormats[colorFmtNdx].type == FormatType.UINT)
continue;
for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
config = new es3fFboRenderTest.FboConfig(
gl.COLOR_BUFFER_BIT, objectTypes[typeNdx],
colorFormats[colorFmtNdx].format, gl.NONE, gl.NONE
);
sharedColorbufferClearGroup.addChild(
new es3fFboRenderTest.SharedColorbufferClearsTest(config)
);
}
}
// .shared_colorbuffer
/** @type {Array<tcuTestCase.DeqpTest>} */ var sharedColorbufferGroup = [];
var numSharedColorbufferGroups = 3;
for (var ii = 0; ii < numSharedColorbufferGroups; ++ii) {
sharedColorbufferGroup[ii] = new tcuTestCase.DeqpTest(
'shared_colorbuffer', 'Shared colorbuffer tests'
);
this.addChild(sharedColorbufferGroup[ii]);
}
for (var colorFmtNdx = 0; colorFmtNdx < colorFormats.length; colorFmtNdx++) {
depthStencilType = gl.RENDERBUFFER;
depthStencilFormat = gl.DEPTH24_STENCIL8;
// Blending with integer buffers and fp32 targets is not supported.
if (colorFormats[colorFmtNdx].type == FormatType.INT ||
colorFormats[colorFmtNdx].type == FormatType.UINT ||
colorFormats[colorFmtNdx].format == gl.RGBA32F ||
colorFormats[colorFmtNdx].format == gl.RGB32F ||
colorFormats[colorFmtNdx].format == gl.RG32F ||
colorFormats[colorFmtNdx].format == gl.R32F)
continue;
for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
/** @type {es3fFboRenderTest.FboConfig} */
var colorOnlyConfig = new es3fFboRenderTest.FboConfig(
gl.COLOR_BUFFER_BIT, objectTypes[typeNdx],
colorFormats[colorFmtNdx].format, gl.NONE, gl.NONE
);
/** @type {es3fFboRenderTest.FboConfig} */
var colorDepthConfig = new es3fFboRenderTest.FboConfig(
gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT,
objectTypes[typeNdx], colorFormats[colorFmtNdx].format,
depthStencilType, depthStencilFormat
);
/** @type {es3fFboRenderTest.FboConfig} */
var colorDepthStencilConfig =
new es3fFboRenderTest.FboConfig(
gl.COLOR_BUFFER_BIT |
gl.DEPTH_BUFFER_BIT |
gl.STENCIL_BUFFER_BIT,
objectTypes[typeNdx], colorFormats[colorFmtNdx].format,
depthStencilType, depthStencilFormat
);
sharedColorbufferGroup[0].addChild(
new es3fFboRenderTest.SharedColorbufferTest(colorOnlyConfig)
);
sharedColorbufferGroup[1].addChild(
new es3fFboRenderTest.SharedColorbufferTest(
colorDepthConfig
)
);
sharedColorbufferGroup[2].addChild(
new es3fFboRenderTest.SharedColorbufferTest(
colorDepthStencilConfig
)
);
}
}
// .shared_depth_stencil
/** @type {tcuTestCase.DeqpTest} */
var sharedDepthStencilGroup = new tcuTestCase.DeqpTest(
'shared_depth_stencil', 'Shared depth and stencil buffers'
);
this.addChild(sharedDepthStencilGroup);
for (var fmtNdx = 0; fmtNdx < depthStencilFormats.length; fmtNdx++) {
colorType = gl.TEXTURE_2D;
colorFmt = gl.RGBA8;
depth = depthStencilFormats[fmtNdx].depth;
stencil = depthStencilFormats[fmtNdx].stencil;
if (!depth)
continue; // Not verified.
// Depth and stencil: both rbo and textures
for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
config = new es3fFboRenderTest.FboConfig(
gl.COLOR_BUFFER_BIT |
(depth ? gl.DEPTH_BUFFER_BIT : 0) |
(stencil ? gl.STENCIL_BUFFER_BIT : 0),
colorType, colorFmt, objectTypes[typeNdx],
depthStencilFormats[fmtNdx].format
);
sharedDepthStencilGroup.addChild(
new es3fFboRenderTest.SharedDepthStencilTest(config)
);
}
}
// .resize
/** @type {Array<tcuTestCase.DeqpTest>} */ var resizeGroup = [];
var numResizeGroups = 4;
for (var ii = 0; ii < numResizeGroups; ++ii) {
resizeGroup[ii] = new tcuTestCase.DeqpTest('resize', 'FBO resize tests');
this.addChild(resizeGroup[ii]);
}
for (var colorFmtNdx = 0; colorFmtNdx < colorFormats.length; colorFmtNdx++) {
var colorFormat = colorFormats[colorFmtNdx].format;
// Color-only.
for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
config = new es3fFboRenderTest.FboConfig(
gl.COLOR_BUFFER_BIT, objectTypes[typeNdx],
colorFormat, gl.NONE, gl.NONE
);
resizeGroup[colorFmtNdx % numResizeGroups].addChild(new es3fFboRenderTest.ResizeTest(config));
}
// For selected color formats tests depth & stencil variants.
if (colorFormat == gl.RGBA8 || colorFormat == gl.RGBA16F) {
for (var depthStencilFmtNdx = 0; depthStencilFmtNdx < depthStencilFormats.length; depthStencilFmtNdx++) {
colorType = gl.TEXTURE_2D;
depth = depthStencilFormats[depthStencilFmtNdx].depth;
stencil = depthStencilFormats[depthStencilFmtNdx].stencil;
// Depth and stencil: both rbo and textures
for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
if (!depth && objectTypes[typeNdx] != gl.RENDERBUFFER)
continue; // Not supported.
config = new es3fFboRenderTest.FboConfig(
gl.COLOR_BUFFER_BIT |
(depth ? gl.DEPTH_BUFFER_BIT : 0) |
(stencil ? gl.STENCIL_BUFFER_BIT : 0),
colorType, colorFormat, objectTypes[typeNdx],
depthStencilFormats[depthStencilFmtNdx].format
);
resizeGroup[colorFmtNdx % numResizeGroups].addChild(
new es3fFboRenderTest.ResizeTest(config)
);
}
}
}
}
// .recreate_color
/** @type {Array<tcuTestCase.DeqpTest>} */ var recreateColorGroup = [];
var numRecreateColorGroups = 7;
for (var ii = 0; ii < numRecreateColorGroups; ++ii) {
recreateColorGroup[ii] = new tcuTestCase.DeqpTest('recreate_color', 'Recreate colorbuffer tests');
this.addChild(recreateColorGroup[ii]);
}
for (var colorFmtNdx = 0; colorFmtNdx < colorFormats.length; colorFmtNdx++) {
colorFormat = colorFormats[colorFmtNdx].format;
depthStencilFormat = gl.DEPTH24_STENCIL8;
depthStencilType = gl.RENDERBUFFER;
// Color-only.
for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
config = new es3fFboRenderTest.FboConfig(
gl.COLOR_BUFFER_BIT |
gl.DEPTH_BUFFER_BIT |
gl.STENCIL_BUFFER_BIT,
objectTypes[typeNdx], colorFormat,
depthStencilType, depthStencilFormat
);
recreateColorGroup[colorFmtNdx % numRecreateColorGroups].addChild(
new es3fFboRenderTest.RecreateBuffersTest(
config, gl.COLOR_BUFFER_BIT, true /* rebind */
)
);
}
}
// .recreate_depth_stencil
/** @type {tcuTestCase.DeqpTest} */
var recreateDepthStencilGroup = new tcuTestCase.DeqpTest(
'recreate_depth_stencil', 'Recreate depth and stencil buffers'
);
this.addChild(recreateDepthStencilGroup);
for (var fmtNdx = 0; fmtNdx < depthStencilFormats.length; fmtNdx++) {
colorType = gl.TEXTURE_2D;
colorFmt = gl.RGBA8;
depth = depthStencilFormats[fmtNdx].depth;
stencil = depthStencilFormats[fmtNdx].stencil;
// Depth and stencil: both rbo and textures
for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
if (!depth && objectTypes[typeNdx] != gl.RENDERBUFFER)
continue;
config = new es3fFboRenderTest.FboConfig(
gl.COLOR_BUFFER_BIT |
(depth ? gl.DEPTH_BUFFER_BIT : 0) |
(stencil ? gl.STENCIL_BUFFER_BIT : 0),
colorType, colorFmt, objectTypes[typeNdx],
depthStencilFormats[fmtNdx].format
);
recreateDepthStencilGroup.addChild(
new es3fFboRenderTest.RecreateBuffersTest(
config,
(depth ? gl.DEPTH_BUFFER_BIT : 0) |
(stencil ? gl.STENCIL_BUFFER_BIT : 0),
true /* rebind */
)
);
}
}
};
/**
* Create and execute the test cases
* @param {WebGL2RenderingContext} context
*/
es3fFboRenderTest.run = function(context, range) {
gl = context;
//Set up Test Root parameters
var state = tcuTestCase.runner;
state.setRoot(new es3fFboRenderTest.FboRenderTestGroup());
//Set up name and description of this test series.
setCurrentTestName(state.testCases.fullName());
description(state.testCases.getDescription());
try {
if (range)
state.setRange(range);
//Run test cases
tcuTestCase.runTestCases();
}
catch (err) {
testFailedOptions('Failed to run tests', false);
tcuTestCase.runner.terminate();
}
};
});