| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES Utilities |
| * ------------------------------------------------ |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| 'use strict'; |
| goog.provide('functional.gles3.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(); |
| } |
| }; |
| }); |
