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('modules.shared.glsLifetimeTests');
goog.require('framework.common.tcuImageCompare');
goog.require('framework.common.tcuStringTemplate');
goog.require('framework.common.tcuSurface');
goog.require('framework.common.tcuTestCase');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.opengl.gluShaderProgram');
goog.require('modules.shared.glsTextureTestUtil');
goog.scope(function() {
var glsLifetimeTests = modules.shared.glsLifetimeTests;
var tcuStringTemplate = framework.common.tcuStringTemplate;
var tcuSurface = framework.common.tcuSurface;
var deRandom = framework.delibs.debase.deRandom;
var glsTextureTestUtil = modules.shared.glsTextureTestUtil;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var tcuTestCase = framework.common.tcuTestCase;
var tcuImageCompare = framework.common.tcuImageCompare;
/** @const */ var VIEWPORT_SIZE = 128;
/** @const */ var FRAMEBUFFER_SIZE = 128;
var setParentClass = function(child, parent) {
child.prototype = Object.create(parent.prototype);
child.prototype.constructor = child;
};
/** @const */ var s_vertexShaderSrc =
'#version 100\n' +
'attribute vec2 pos;\n' +
'void main()\n' +
'{\n' +
' gl_Position = vec4(pos.xy, 0.0, 1.0);\n' +
'}\n';
/** @const */ var s_fragmentShaderSrc =
'#version 100\n' +
'void main()\n' +
'{\n' +
' gl_FragColor = vec4(1.0);\n' +
'}\n';
/**
* @constructor
* @extends {gluShaderProgram.Shader}
* @param {gluShaderProgram.shaderType} type
* @param {string} src
*/
glsLifetimeTests.CheckedShader = function(type, src) {
gluShaderProgram.Shader.call(this, gl, type);
this.setSources(src);
this.compile();
assertMsgOptions(this.getCompileStatus() === true, 'Failed to compile shader', false, true);
};
setParentClass(glsLifetimeTests.CheckedShader, gluShaderProgram.Shader);
/**
* @constructor
* @extends {gluShaderProgram.Program}
* @param {WebGLShader} vtxShader
* @param {WebGLShader} fragShader
*/
glsLifetimeTests.CheckedProgram = function(vtxShader, fragShader) {
gluShaderProgram.Program.call(this, gl);
this.attachShader(vtxShader);
this.attachShader(fragShader);
this.link();
assertMsgOptions(this.info.linkOk === true, 'Failed to link program', false, true);
};
setParentClass(glsLifetimeTests.CheckedProgram, gluShaderProgram.Program);
/**
* @constructor
*/
glsLifetimeTests.Binder = function() {
};
/**
* @param {WebGLObject} obj
*/
glsLifetimeTests.Binder.prototype.bind = function(obj) { throw new Error('Virtual function'); };
/**
* @return {WebGLObject}
*/
glsLifetimeTests.Binder.prototype.getBinding = function() { throw new Error('Virtual function'); };
/**
* @constructor
* @extends {glsLifetimeTests.Binder}
* @param {?function(number, ?)} bindFunc
* @param {number} bindTarget
* @param {number} bindingParam
*/
glsLifetimeTests.SimpleBinder = function(bindFunc, bindTarget, bindingParam) {
glsLifetimeTests.Binder.call(this);
this.m_bindFunc = bindFunc;
this.m_bindTarget = bindTarget;
this.m_bindingParam = bindingParam;
};
setParentClass(glsLifetimeTests.SimpleBinder, glsLifetimeTests.Binder);
glsLifetimeTests.SimpleBinder.prototype.bind = function(obj) {
this.m_bindFunc.call(gl, this.m_bindTarget, obj);
};
glsLifetimeTests.SimpleBinder.prototype.getBinding = function() {
return /** @type {WebGLObject} */ (gl.getParameter(this.m_bindingParam));
};
/**
* @constructor
*/
glsLifetimeTests.Type = function() {
};
/**
* Create a type
* @return {WebGLObject}
*/
glsLifetimeTests.Type.prototype.gen = function() { throw new Error('Virtual function'); };
/**
* Destroy a type
* @param {WebGLObject} obj
*/
glsLifetimeTests.Type.prototype.release = function(obj) { throw new Error('Virtual function'); };
/**
* Is object valid
* @param {WebGLObject} obj
*/
glsLifetimeTests.Type.prototype.exists = function(obj) { throw new Error('Virtual function'); };
/**
* Is object flagged for deletion
* @param {WebGLObject} obj
*/
glsLifetimeTests.Type.prototype.isDeleteFlagged = function(obj) { return false; };
/**
* @return {glsLifetimeTests.Binder}
*/
glsLifetimeTests.Type.prototype.binder = function() { return null; };
/**
* @return {string}
*/
glsLifetimeTests.Type.prototype.getName = function() { throw new Error('Virtual function'); };
/**
* Is the object unbound automatically when it is deleted?
* @return {boolean}
*/
glsLifetimeTests.Type.prototype.nameLingers = function() { return false; };
/**
* Does 'create' creates the object fully?
* If not, the object is created at bound time
* @return {boolean}
*/
glsLifetimeTests.Type.prototype.genCreates = function() { return false; };
/**
* @constructor
* @extends {glsLifetimeTests.Type}
* @param {string} name
* @param {function(): WebGLObject} genFunc
* @param {function(?)} deleteFunc
* @param {function(?): boolean} existsFunc
* @param {glsLifetimeTests.Binder} binder
* @param {boolean=} genCreates
*/
glsLifetimeTests.SimpleType = function(name, genFunc, deleteFunc, existsFunc, binder, genCreates) {
glsLifetimeTests.Type.call(this);
this.m_getName = name;
this.m_genFunc = genFunc;
this.m_deleteFunc = deleteFunc;
this.m_existsFunc = existsFunc;
this.m_binder = binder;
this.m_genCreates = genCreates || false;
};
setParentClass(glsLifetimeTests.SimpleType, glsLifetimeTests.Type);
glsLifetimeTests.SimpleType.prototype.gen = function() { return this.m_genFunc.call(gl); };
glsLifetimeTests.SimpleType.prototype.release = function(obj) { return this.m_deleteFunc.call(gl, obj); };
glsLifetimeTests.SimpleType.prototype.exists = function(obj) { return this.m_existsFunc.call(gl, obj); };
glsLifetimeTests.SimpleType.prototype.binder = function() { return this.m_binder; };
glsLifetimeTests.SimpleType.prototype.getName = function() { return this.m_getName; };
glsLifetimeTests.SimpleType.prototype.genCreates = function() { return this.m_genCreates; };
/**
* @constructor
* @extends {glsLifetimeTests.Type}
*/
glsLifetimeTests.ProgramType = function() {
glsLifetimeTests.Type.call(this);
};
setParentClass(glsLifetimeTests.ProgramType, glsLifetimeTests.Type);
glsLifetimeTests.ProgramType.prototype.gen = function() { return gl.createProgram(); };
glsLifetimeTests.ProgramType.prototype.release = function(obj) { return gl.deleteProgram(/** @type {WebGLProgram} */ (obj)); };
glsLifetimeTests.ProgramType.prototype.exists = function(obj) { return gl.isProgram(/** @type {WebGLProgram} */ (obj)); };
glsLifetimeTests.ProgramType.prototype.getName = function() { return 'program'; };
glsLifetimeTests.ProgramType.prototype.genCreates = function() { return true; };
glsLifetimeTests.ProgramType.prototype.nameLingers = function() { return true; };
glsLifetimeTests.ProgramType.prototype.isDeleteFlagged = function(obj) { return gl.getProgramParameter(/** @type {WebGLProgram} */ (obj), gl.DELETE_STATUS); };
/**
* @constructor
* @extends {glsLifetimeTests.Type}
*/
glsLifetimeTests.ShaderType = function() {
glsLifetimeTests.Type.call(this);
};
setParentClass(glsLifetimeTests.ShaderType, glsLifetimeTests.Type);
glsLifetimeTests.ShaderType.prototype.gen = function() { return gl.createShader(gl.FRAGMENT_SHADER); };
glsLifetimeTests.ShaderType.prototype.release = function(obj) { return gl.deleteShader(/** @type {WebGLShader} */ (obj)); };
glsLifetimeTests.ShaderType.prototype.exists = function(obj) { return gl.isShader(/** @type {WebGLShader} */ (obj)); };
glsLifetimeTests.ShaderType.prototype.getName = function() { return 'shader'; };
glsLifetimeTests.ShaderType.prototype.genCreates = function() { return true; };
glsLifetimeTests.ShaderType.prototype.nameLingers = function() { return true; };
glsLifetimeTests.ShaderType.prototype.isDeleteFlagged = function(obj) { return gl.getShaderParameter(/** @type {WebGLShader} */ (obj), gl.DELETE_STATUS); };
/**
* @constructor
* @param {glsLifetimeTests.Type} elementType
* @param {glsLifetimeTests.Type} containerType
*/
glsLifetimeTests.Attacher = function(elementType, containerType) {
this.m_elementType = elementType;
this.m_containerType = containerType;
};
/**
* @param {number} seed
* @param {WebGLObject} obj
*/
glsLifetimeTests.Attacher.prototype.initAttachment = function(seed, obj) { throw new Error('Virtual function'); };
/**
* @param {WebGLObject} element
* @param {WebGLObject} target
*/
glsLifetimeTests.Attacher.prototype.attach = function(element, target) { throw new Error('Virtual function'); };
/**
* @param {WebGLObject} element
* @param {WebGLObject} target
*/
glsLifetimeTests.Attacher.prototype.detach = function(element, target) { throw new Error('Virtual function'); };
glsLifetimeTests.Attacher.prototype.canAttachDeleted = function() { return true; };
/**
* @return {glsLifetimeTests.Type}
*/
glsLifetimeTests.Attacher.prototype.getElementType = function() { return this.m_elementType; };
/**
* @return {glsLifetimeTests.Type}
*/
glsLifetimeTests.Attacher.prototype.getContainerType = function() { return this.m_containerType; };
/**
* @constructor
*/
glsLifetimeTests.InputAttacher = function(attacher) {
this.m_attacher = attacher;
};
glsLifetimeTests.InputAttacher.prototype.getAttacher = function() { return this.m_attacher; };
/**
* @param {WebGLObject} container
* @param {tcuSurface.Surface} dst
*/
glsLifetimeTests.InputAttacher.prototype.drawContainer = function(container, dst) { throw new Error('Virtual function'); };
/**
* @constructor
*/
glsLifetimeTests.OutputAttacher = function(attacher) {
this.m_attacher = attacher;
};
glsLifetimeTests.OutputAttacher.prototype.getAttacher = function() { return this.m_attacher; };
/**
* @param {number} seed
* @param {WebGLObject} container
*/
glsLifetimeTests.OutputAttacher.prototype.setupContainer = function(seed, container) { throw new Error('Virtual function'); };
/**
* @param {WebGLObject} attachment
* @param {tcuSurface.Surface} dst
*/
glsLifetimeTests.OutputAttacher.prototype.drawAttachment = function(attachment, dst) { throw new Error('Virtual function'); };
/**
* @constructor
*/
glsLifetimeTests.Types = function() {
/** @type {Array<glsLifetimeTests.Type>} */ this.m_types = [];
/** @type {Array<glsLifetimeTests.Attacher>} */ this.m_attachers = [];
/** @type {Array<glsLifetimeTests.InputAttacher>} */ this.m_inAttachers = [];
/** @type {Array<glsLifetimeTests.OutputAttacher>} */ this.m_outAttachers = [];
};
/**
* @return {glsLifetimeTests.ProgramType}
*/
glsLifetimeTests.Types.prototype.getProgramType = function() { throw new Error('Virtual function'); };
glsLifetimeTests.Types.prototype.getTypes = function() { return this.m_types; };
glsLifetimeTests.Types.prototype.getAttachers = function() { return this.m_attachers; };
glsLifetimeTests.Types.prototype.getInputAttachers = function() { return this.m_inAttachers; };
glsLifetimeTests.Types.prototype.getOutputAttachers = function() { return this.m_outAttachers; };
/**
* @param {number} seed
* @param {WebGLFramebuffer} fbo
*/
glsLifetimeTests.setupFbo = function(seed, fbo) {
gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
if (seed == 0) {
gl.clearColor(0.0, 0.0, 0.0, 1.0);
gl.clear(gl.COLOR_BUFFER_BIT);
} else {
var rnd = new deRandom.Random(seed);
var width = rnd.getInt(0, FRAMEBUFFER_SIZE);
var height = rnd.getInt(0, FRAMEBUFFER_SIZE);
var x = rnd.getInt(0, FRAMEBUFFER_SIZE - width);
var y = rnd.getInt(0, FRAMEBUFFER_SIZE - height);
var r1 = rnd.getFloat();
var g1 = rnd.getFloat();
var b1 = rnd.getFloat();
var a1 = rnd.getFloat();
var r2 = rnd.getFloat();
var g2 = rnd.getFloat();
var b2 = rnd.getFloat();
var a2 = rnd.getFloat();
gl.clearColor(r1, g1, b1, a1);
gl.clear(gl.COLOR_BUFFER_BIT);
gl.scissor(x, y, width, height);
gl.enable(gl.SCISSOR_TEST);
gl.clearColor(r2, g2, b2, a2);
gl.clear(gl.COLOR_BUFFER_BIT);
gl.disable(gl.SCISSOR_TEST);
}
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
};
/**
* @param {{x: number, y:number, width: number, height: number}} rect
* @param {tcuSurface.Surface} dst
*/
glsLifetimeTests.readRectangle = function(rect, dst) {
dst.readViewport(gl, rect);
};
/**
* @param {WebGLFramebuffer} fbo
* @param {tcuSurface.Surface} dst
*/
glsLifetimeTests.drawFbo = function(fbo, dst) {
gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
dst.readViewport(gl, [0, 0, FRAMEBUFFER_SIZE, FRAMEBUFFER_SIZE]);
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
};
/**
* @constructor
* @extends {glsLifetimeTests.Attacher}
*/
glsLifetimeTests.FboAttacher = function(elementType, containerType) {
glsLifetimeTests.Attacher.call(this, elementType, containerType);
};
setParentClass(glsLifetimeTests.FboAttacher, glsLifetimeTests.Attacher);
glsLifetimeTests.FboAttacher.prototype.initStorage = function() { throw new Error('Virtual function'); };
glsLifetimeTests.FboAttacher.prototype.initAttachment = function(seed, element) {
var binder = this.getElementType().binder();
var fbo = gl.createFramebuffer();
binder.bind(element);
this.initStorage();
binder.bind(null);
this.attach(element, fbo);
glsLifetimeTests.setupFbo(seed, fbo);
this.detach(element, fbo);
gl.deleteFramebuffer(fbo);
bufferedLogToConsole('Drew to ' + this.getElementType().getName() + ' ' + element + ' with seed ' + seed + '.');
};
/**
* @constructor
* @extends {glsLifetimeTests.InputAttacher}
*/
glsLifetimeTests.FboInputAttacher = function(attacher) {
glsLifetimeTests.InputAttacher.call(this, attacher);
};
setParentClass(glsLifetimeTests.FboInputAttacher, glsLifetimeTests.InputAttacher);
glsLifetimeTests.FboInputAttacher.prototype.drawContainer = function(obj, dst) {
var fbo = /** @type {WebGLFramebuffer} */ (obj);
glsLifetimeTests.drawFbo(fbo, dst);
bufferedLogToConsole('Read pixels from framebuffer ' + fbo + ' to output image.');
};
/**
* @constructor
* @extends {glsLifetimeTests.OutputAttacher}
*/
glsLifetimeTests.FboOutputAttacher = function(attacher) {
glsLifetimeTests.OutputAttacher.call(this, attacher);
};
setParentClass(glsLifetimeTests.FboOutputAttacher, glsLifetimeTests.OutputAttacher);
glsLifetimeTests.FboOutputAttacher.prototype.setupContainer = function(seed, fbo) {
glsLifetimeTests.setupFbo(seed, /** @type {WebGLFramebuffer} */ (fbo));
bufferedLogToConsole('Drew to framebuffer ' + fbo + ' with seed ' + seed + '.');
};
glsLifetimeTests.FboOutputAttacher.prototype.drawAttachment = function(element, dst) {
var fbo = gl.createFramebuffer();
this.m_attacher.attach(element, fbo);
glsLifetimeTests.drawFbo(fbo, dst);
this.m_attacher.detach(element, fbo);
gl.deleteFramebuffer(fbo);
bufferedLogToConsole('Read pixels from ' + this.m_attacher.getElementType().getName() + ' ' + element + ' to output image.');
};
/**
* @constructor
* @extends {glsLifetimeTests.FboAttacher}
*/
glsLifetimeTests.TextureFboAttacher = function(elementType, containerType) {
glsLifetimeTests.FboAttacher.call(this, elementType, containerType);
};
setParentClass(glsLifetimeTests.TextureFboAttacher, glsLifetimeTests.FboAttacher);
glsLifetimeTests.TextureFboAttacher.prototype.initStorage = function() {
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, FRAMEBUFFER_SIZE, FRAMEBUFFER_SIZE, 0,
gl.RGBA, gl.UNSIGNED_SHORT_4_4_4_4, null);
};
glsLifetimeTests.TextureFboAttacher.prototype.attach = function(element, target) {
var texture = /** @type {WebGLTexture} */ (element);
var fbo = /** @type {WebGLFramebuffer} */ (target);
gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
gl.TEXTURE_2D, texture, 0);
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
};
glsLifetimeTests.TextureFboAttacher.prototype.detach = function(texture, target) {
var fbo = /** @type {WebGLFramebuffer} */ (target);
this.attach(null, fbo);
};
glsLifetimeTests.getFboAttachment = function(fbo, requiredType) {
gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
var type = gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE);
var name = gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME);
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
var ret = type == requiredType ? name : null;
return ret;
};
glsLifetimeTests.TextureFboAttacher.prototype.getAttachment = function(fbo) {
return glsLifetimeTests.getFboAttachment(fbo, gl.TEXTURE);
};
/**
* @constructor
* @extends {glsLifetimeTests.FboAttacher}
*/
glsLifetimeTests.RboFboAttacher = function(elementType, containerType) {
glsLifetimeTests.FboAttacher.call(this, elementType, containerType);
};
setParentClass(glsLifetimeTests.RboFboAttacher, glsLifetimeTests.FboAttacher);
glsLifetimeTests.RboFboAttacher.prototype.initStorage = function() {
gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA4, FRAMEBUFFER_SIZE, FRAMEBUFFER_SIZE);
};
glsLifetimeTests.RboFboAttacher.prototype.attach = function(element, target) {
var rbo = /** @type {WebGLRenderbuffer} */ (element);
var fbo = /** @type {WebGLFramebuffer} */ (target);
gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo);
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
};
glsLifetimeTests.RboFboAttacher.prototype.detach = function(rbo, target) {
var fbo = /** @type {WebGLFramebuffer} */ (target);
this.attach(null, fbo);
};
glsLifetimeTests.RboFboAttacher.prototype.getAttachment = function(fbo) {
return glsLifetimeTests.getFboAttachment(fbo, gl.RENDERBUFFER);
};
/**
* @constructor
* @extends {glsLifetimeTests.Attacher}
*/
glsLifetimeTests.ShaderProgramAttacher = function(elementType, containerType) {
glsLifetimeTests.Attacher.call(this, elementType, containerType);
};
setParentClass(glsLifetimeTests.ShaderProgramAttacher, glsLifetimeTests.Attacher);
glsLifetimeTests.ShaderProgramAttacher.prototype.initAttachment = function(seed, obj) {
var shader = /** @type {WebGLShader} */ (obj);
var s_fragmentShaderTemplate =
'#version 100\n' +
'void main()\n' +
'{\n' +
' gl_FragColor = vec4(${RED}, ${GREEN}, ${BLUE}, 1.0);\n' +
'}';
var rnd = new deRandom.Random(seed);
var params = [];
params['RED'] = rnd.getFloat().toString(10);
params['GREEN'] = rnd.getFloat().toString(10);
params['BLUE'] = rnd.getFloat().toString(10);
var source = tcuStringTemplate.specialize(s_fragmentShaderTemplate, params);
gl.shaderSource(shader, source);
gl.compileShader(shader);
var compileStatus = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
assertMsgOptions(compileStatus === true, 'Failed to compile shader: ' + source, false, true);
};
glsLifetimeTests.ShaderProgramAttacher.prototype.attach = function(element, target) {
var shader = /** @type {WebGLShader} */ (element);
var program = /** @type {WebGLProgram} */ (target);
gl.attachShader(program, shader);
};
glsLifetimeTests.ShaderProgramAttacher.prototype.detach = function(element, target) {
var shader = /** @type {WebGLShader} */ (element);
var program = /** @type {WebGLProgram} */ (target);
gl.detachShader(program, shader);
};
glsLifetimeTests.ShaderProgramAttacher.prototype.getAttachment = function(program) {
var shaders = gl.getAttachedShaders(program);
for (var i = 0; i < shaders.length; i++) {
var shader = shaders[i];
var type = gl.getShaderParameter(shader, gl.SHADER_TYPE);
if (type === gl.FRAGMENT_SHADER)
return shader;
}
return null;
};
/**
* @constructor
* @extends {glsLifetimeTests.InputAttacher}
*/
glsLifetimeTests.ShaderProgramInputAttacher = function(attacher) {
glsLifetimeTests.InputAttacher.call(this, attacher);
};
setParentClass(glsLifetimeTests.ShaderProgramInputAttacher, glsLifetimeTests.InputAttacher);
glsLifetimeTests.ShaderProgramInputAttacher.prototype.drawContainer = function(container, dst) {
var program = /** @type {WebGLProgram} */ (container);
var s_vertices = [-1.0, 0.0, 1.0, 1.0, 0.0, -1.0];
glsLifetimeTests.ShaderProgramInputAttacher.seed = glsLifetimeTests.ShaderProgramInputAttacher.seed || 0;
var vtxShader = new glsLifetimeTests.CheckedShader(gluShaderProgram.shaderType.VERTEX, s_vertexShaderSrc);
var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), VIEWPORT_SIZE, VIEWPORT_SIZE, glsLifetimeTests.ShaderProgramInputAttacher.seed);
gl.attachShader(program, vtxShader.getShader());
gl.linkProgram(program);
var linkStatus = gl.getProgramParameter(program, gl.LINK_STATUS);
assertMsgOptions(linkStatus === true, 'Program link failed', false, true);
bufferedLogToConsole('Attached a temporary vertex shader and linked program ' + program);
gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
bufferedLogToConsole('Positioned viewport randomly');
gl.useProgram(program);
var posLoc = gl.getAttribLocation(program, 'pos');
assertMsgOptions(posLoc >= 0, 'Could not find pos attribute', false, true);
var buf = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, buf);
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(s_vertices), gl.STATIC_DRAW);
gl.enableVertexAttribArray(posLoc);
gl.vertexAttribPointer(posLoc, 2, gl.FLOAT, false, 0, 0);
gl.bindBuffer(gl.ARRAY_BUFFER, null);
gl.clearColor(0, 0, 0, 1);
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
gl.drawArrays(gl.TRIANGLES, 0, 3);
gl.disableVertexAttribArray(posLoc);
gl.deleteBuffer(buf);
bufferedLogToConsole('Drew a fixed triangle');
gl.useProgram(null);
glsLifetimeTests.readRectangle(viewport, dst);
bufferedLogToConsole('Copied viewport to output image');
gl.detachShader(program, vtxShader.getShader());
bufferedLogToConsole('Removed temporary vertex shader');
};
/**
* @constructor
* @extends {glsLifetimeTests.Types}
*/
glsLifetimeTests.ES2Types = function() {
glsLifetimeTests.Types.call(this);
this.m_bufferBind = new glsLifetimeTests.SimpleBinder(gl.bindBuffer, gl.ARRAY_BUFFER, gl.ARRAY_BUFFER_BINDING);
this.m_bufferType = new glsLifetimeTests.SimpleType('buffer', gl.createBuffer, gl.deleteBuffer, gl.isBuffer, this.m_bufferBind);
this.m_textureBind = new glsLifetimeTests.SimpleBinder(gl.bindTexture, gl.TEXTURE_2D, gl.TEXTURE_BINDING_2D);
this.m_textureType = new glsLifetimeTests.SimpleType('texture', gl.createTexture, gl.deleteTexture, gl.isTexture, this.m_textureBind);
this.m_rboBind = new glsLifetimeTests.SimpleBinder(gl.bindRenderbuffer, gl.RENDERBUFFER, gl.RENDERBUFFER_BINDING);
this.m_rboType = new glsLifetimeTests.SimpleType('renderbuffer', gl.createRenderbuffer, gl.deleteRenderbuffer, gl.isRenderbuffer, this.m_rboBind);
this.m_fboBind = new glsLifetimeTests.SimpleBinder(gl.bindFramebuffer, gl.FRAMEBUFFER, gl.FRAMEBUFFER_BINDING);
this.m_fboType = new glsLifetimeTests.SimpleType('framebuffer', gl.createFramebuffer, gl.deleteFramebuffer, gl.isFramebuffer, this.m_fboBind);
this.m_shaderType = new glsLifetimeTests.ShaderType();
this.m_programType = new glsLifetimeTests.ProgramType();
this.m_texFboAtt = new glsLifetimeTests.TextureFboAttacher(this.m_textureType, this.m_fboType);
this.m_texFboInAtt = new glsLifetimeTests.FboInputAttacher(this.m_texFboAtt);
this.m_texFboOutAtt = new glsLifetimeTests.FboOutputAttacher(this.m_texFboAtt);
this.m_rboFboAtt = new glsLifetimeTests.RboFboAttacher(this.m_rboType, this.m_fboType);
this.m_rboFboInAtt = new glsLifetimeTests.FboInputAttacher(this.m_rboFboAtt);
this.m_rboFboOutAtt = new glsLifetimeTests.FboOutputAttacher(this.m_rboFboAtt);
this.m_shaderAtt = new glsLifetimeTests.ShaderProgramAttacher(this.m_shaderType, this.m_programType);
this.m_shaderInAtt = new glsLifetimeTests.ShaderProgramInputAttacher(this.m_shaderAtt);
this.m_types.push(this.m_bufferType, this.m_textureType, this.m_rboType, this.m_fboType, this.m_shaderType, this.m_programType);
this.m_attachers.push(this.m_texFboAtt, this.m_rboFboAtt, this.m_shaderAtt);
this.m_inAttachers.push(this.m_texFboInAtt, this.m_rboFboInAtt, this.m_shaderInAtt);
this.m_outAttachers.push(this.m_texFboOutAtt, this.m_rboFboOutAtt);
};
setParentClass(glsLifetimeTests.ES2Types, glsLifetimeTests.Types);
glsLifetimeTests.ES2Types.prototype.getProgramType = function() { return this.m_programType; };
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} description
* @param {glsLifetimeTests.Type} type
* @param {function()} test
*/
glsLifetimeTests.LifeTest = function(name, description, type, test) {
tcuTestCase.DeqpTest.call(this, name, description);
this.m_type = type;
this.m_test = test;
};
setParentClass(glsLifetimeTests.LifeTest, tcuTestCase.DeqpTest);
glsLifetimeTests.LifeTest.prototype.iterate = function() {
this.m_test();
return tcuTestCase.IterateResult.STOP;
};
/**
* @this {glsLifetimeTests.LifeTest}
*/
glsLifetimeTests.LifeTest.testGen = function() {
var obj = this.m_type.gen();
if (this.m_type.genCreates())
assertMsgOptions(this.m_type.exists(obj), "create* should have created an object, but didn't", false, true);
else
assertMsgOptions(!this.m_type.exists(obj), 'create* should not have created an object, but did', false, true);
this.m_type.release(obj);
testPassed();
};
/**
* @this {glsLifetimeTests.LifeTest}
*/
glsLifetimeTests.LifeTest.testDelete = function() {
var obj = this.m_type.gen();
this.m_type.release(obj);
assertMsgOptions(!this.m_type.exists(obj), 'Object still exists after deletion', false, true);
testPassed();
};
/**
* @this {glsLifetimeTests.LifeTest}
*/
glsLifetimeTests.LifeTest.testBind = function() {
var obj = this.m_type.gen();
this.m_type.binder().bind(obj);
var err = gl.getError();
assertMsgOptions(err == gl.NONE, 'Bind failed', false, true);
assertMsgOptions(this.m_type.exists(obj), 'Object does not exist after binding', false, true);
this.m_type.binder().bind(null);
this.m_type.release(obj);
testPassed();
};
/**
* @this {glsLifetimeTests.LifeTest}
*/
glsLifetimeTests.LifeTest.testDeleteBound = function() {
var obj = this.m_type.gen();
this.m_type.binder().bind(obj);
this.m_type.release(obj);
if (this.m_type.nameLingers()) {
assertMsgOptions(gl.getError() == gl.NONE, 'Deleting bound object failed', false, true);
assertMsgOptions(this.m_type.binder().getBinding() === obj, 'Deleting bound object did not retain binding', false, true);
assertMsgOptions(this.m_type.exists(obj), 'Deleting bound object made its name invalid', false, true);
assertMsgOptions(this.m_type.isDeleteFlagged(obj), 'Deleting bound object did not flag the object for deletion', false, true);
this.m_type.binder().bind(null);
} else {
assertMsgOptions(gl.getError() == gl.NONE, 'Deleting bound object failed', false, true);
assertMsgOptions(this.m_type.binder().getBinding() === null, 'Deleting bound object did not remove binding', false, true);
assertMsgOptions(!this.m_type.exists(obj), 'Deleting bound object did not make its name invalid', false, true);
}
assertMsgOptions(this.m_type.binder().getBinding() === null, "Unbinding didn't remove binding", false, true);
assertMsgOptions(!this.m_type.exists(obj), 'Name is still valid after deleting and unbinding', false, true);
testPassed();
};
/**
* @this {glsLifetimeTests.LifeTest}
*/
glsLifetimeTests.LifeTest.testDeleteUsed = function() {
var vtxShader = new glsLifetimeTests.CheckedShader(gluShaderProgram.shaderType.VERTEX, s_vertexShaderSrc);
var fragShader = new glsLifetimeTests.CheckedShader(gluShaderProgram.shaderType.FRAGMENT, s_fragmentShaderSrc);
var program = new glsLifetimeTests.CheckedProgram(vtxShader.getShader(), fragShader.getShader());
var programId = program.getProgram();
bufferedLogToConsole('Created and linked program ' + programId);
gl.useProgram(programId);
gl.deleteProgram(programId);
bufferedLogToConsole('Deleted program ' + programId);
assertMsgOptions(gl.isProgram(programId), 'Deleted current program', false, true);
var deleteFlagged = gl.getProgramParameter(programId, gl.DELETE_STATUS);
assertMsgOptions(deleteFlagged == true, 'Program object was not flagged as deleted', false, true);
gl.useProgram(null);
assertMsgOptions(!gl.isProgram(programId), 'Deleted program name still valid after being made non-current', false, true);
testPassed();
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} description
* @param {glsLifetimeTests.Attacher} attacher
* @param {function()} test
*/
glsLifetimeTests.AttachmentTest = function(name, description, attacher, test) {
tcuTestCase.DeqpTest.call(this, name, description);
this.m_attacher = attacher;
this.m_test = test;
};
setParentClass(glsLifetimeTests.AttachmentTest, tcuTestCase.DeqpTest);
glsLifetimeTests.AttachmentTest.prototype.iterate = function() {
this.m_test();
return tcuTestCase.IterateResult.STOP;
};
/**
* @this {glsLifetimeTests.AttachmentTest}
*/
glsLifetimeTests.AttachmentTest.testDeletedNames = function() {
var getAttachment = function(attacher, container) {
var queriedAttachment = attacher.getAttachment(container);
bufferedLogToConsole('Result of query for ' + attacher.getElementType().getName() +
' attached to ' + attacher.getContainerType().getName() + ' ' +
container + ': ' + queriedAttachment);
return queriedAttachment;
};
var elemType = this.m_attacher.getElementType();
var containerType = this.m_attacher.getContainerType();
var container = containerType.gen();
var element = elemType.gen();
this.m_attacher.initAttachment(0, element);
this.m_attacher.attach(element, container);
assertMsgOptions(getAttachment(this.m_attacher, container) == element,
'Attachment not returned by query even before deletion.', false, true);
elemType.release(element);
// "Such a container or other context may continue using the object, and
// may still contain state identifying its name as being currently bound"
//
// We here interpret "may" to mean that whenever the container has a
// deleted object attached to it, a query will return that object's former
// name.
assertMsgOptions(getAttachment(this.m_attacher, container) == element,
'Attachment name not returned by query after attachment was deleted.', false, true);
if (elemType.nameLingers())
assertMsgOptions(elemType.exists(element),
'Attached object name no longer valid after deletion.', false, true);
else
assertMsgOptions(!elemType.exists(element),
'Attached object name still valid after deletion.', false, true);
this.m_attacher.detach(element, container);
assertMsgOptions(getAttachment(this.m_attacher, container) == null,
'Attachment name returned by query even after detachment.', false, true);
assertMsgOptions(!elemType.exists(element),
'Deleted attached object name still usable after detachment.', false, true);
testPassed();
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} description
* @param {glsLifetimeTests.InputAttacher} attacher
*/
glsLifetimeTests.InputAttachmentTest = function(name, description, attacher) {
tcuTestCase.DeqpTest.call(this, name, description);
this.m_inputAttacher = attacher;
};
setParentClass(glsLifetimeTests.InputAttachmentTest, tcuTestCase.DeqpTest);
glsLifetimeTests.InputAttachmentTest.prototype.iterate = function() {
var attacher = this.m_inputAttacher.getAttacher();
var containerType = attacher.getContainerType();
var elementType = attacher.getElementType();
var container = containerType.gen();
glsLifetimeTests.InputAttachmentTest.seed = glsLifetimeTests.InputAttachmentTest.seed || 0;
++glsLifetimeTests.InputAttachmentTest.seed;
var rnd = new deRandom.Random(glsLifetimeTests.InputAttachmentTest.seed);
var refSeed = rnd.getInt();
var newSeed = rnd.getInt();
var refSurface = new tcuSurface.Surface(VIEWPORT_SIZE, VIEWPORT_SIZE); // Surface from drawing with refSeed-seeded attachment
var delSurface = new tcuSurface.Surface(VIEWPORT_SIZE, VIEWPORT_SIZE); // Surface from drawing with deleted refSeed attachment
var newSurface = new tcuSurface.Surface(VIEWPORT_SIZE, VIEWPORT_SIZE); // Surface from drawing with newSeed-seeded attachment
bufferedLogToConsole('Testing if writing to a newly created object modifies a deleted attachment');
bufferedLogToConsole('Writing to an original attachment');
var element = elementType.gen();
attacher.initAttachment(refSeed, element);
attacher.attach(element, container);
this.m_inputAttacher.drawContainer(container, refSurface);
// element gets deleted here
bufferedLogToConsole('Deleting attachment');
elementType.release(element);
bufferedLogToConsole('Writing to a new attachment after deleting the original');
var newElement = elementType.gen();
attacher.initAttachment(newSeed, newElement);
this.m_inputAttacher.drawContainer(container, delSurface);
attacher.detach(element, container);
attacher.attach(newElement, container);
this.m_inputAttacher.drawContainer(container, newSurface);
attacher.detach(newElement, container);
var surfacesMatch = tcuImageCompare.pixelThresholdCompare(
'Reading from deleted',
'Comparison result from reading from a container with a deleted attachment ' +
'before and after writing to a fresh object.',
refSurface, delSurface, [0, 0, 0, 0]);
/* TODO: Add logging images */
// if (!surfacesMatch)
// log() << TestLog::Image("New attachment",
// "Container state after attached to the fresh object",
// newSurface);
assertMsgOptions(surfacesMatch,
'Writing to a fresh object modified the container with a deleted attachment.', false, true);
testPassed();
return tcuTestCase.IterateResult.STOP;
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} description
* @param {glsLifetimeTests.OutputAttacher} attacher
*/
glsLifetimeTests.OutputAttachmentTest = function(name, description, attacher) {
tcuTestCase.DeqpTest.call(this, name, description);
this.m_outputAttacher = attacher;
};
setParentClass(glsLifetimeTests.OutputAttachmentTest, tcuTestCase.DeqpTest);
glsLifetimeTests.OutputAttachmentTest.prototype.iterate = function() {
var attacher = this.m_outputAttacher.getAttacher();
var containerType = attacher.getContainerType();
var elementType = attacher.getElementType();
var container = containerType.gen();
glsLifetimeTests.InputAttachmentTest.seed = glsLifetimeTests.InputAttachmentTest.seed || 0;
++glsLifetimeTests.InputAttachmentTest.seed;
var rnd = new deRandom.Random(glsLifetimeTests.InputAttachmentTest.seed);
var refSeed = rnd.getInt();
var newSeed = rnd.getInt();
var refSurface = new tcuSurface.Surface(VIEWPORT_SIZE, VIEWPORT_SIZE); // Surface from drawing with refSeed-seeded attachment
var delSurface = new tcuSurface.Surface(VIEWPORT_SIZE, VIEWPORT_SIZE); // Surface from drawing with deleted refSeed attachment
var newSurface = new tcuSurface.Surface(VIEWPORT_SIZE, VIEWPORT_SIZE); // Surface from drawing with newSeed-seeded attachment
bufferedLogToConsole('Testing if writing to a container with a deleted attachment ' +
'modifies a newly created object');
bufferedLogToConsole('Writing to a container with an existing attachment');
var element = elementType.gen();
attacher.initAttachment(0, element);
attacher.attach(element, container);
// For reference purposes, make note of what refSeed looks like.
this.m_outputAttacher.setupContainer(refSeed, container);
// Since in WebGL, buffer bound to TRANSFORM_FEEDBACK_BUFFER can not be bound to other targets.
// Unfortunately, element will be bound again in drawAttachment() for drawing.
// Detach element from container before drawing, then reattach it after drawing.
attacher.detach(element, container);
this.m_outputAttacher.drawAttachment(element, refSurface);
attacher.attach(element, container);
elementType.release(element);
bufferedLogToConsole('Writing to a container after deletion of attachment');
var newElement = elementType.gen();
bufferedLogToConsole('Creating a new object ');
bufferedLogToConsole('Recording state of new object before writing to container');
attacher.initAttachment(newSeed, newElement);
this.m_outputAttacher.drawAttachment(newElement, newSurface);
bufferedLogToConsole('Writing to container');
// Now re-write refSeed to the container.
this.m_outputAttacher.setupContainer(refSeed, container);
// Does it affect the newly created attachment object?
this.m_outputAttacher.drawAttachment(newElement, delSurface);
attacher.detach(element, container);
var surfacesMatch = tcuImageCompare.pixelThresholdCompare(
'Writing to deleted',
'Comparison result from reading from a fresh object before and after ' +
'writing to a container with a deleted attachment',
newSurface, delSurface, [0, 0, 0, 0]);
/* TODO: Add logging images */
// if (!surfacesMatch)
// log() << TestLog::Image(
// "Original attachment",
// "Result of container modification on original attachment before deletion.",
// refSurface);
assertMsgOptions(surfacesMatch,
'Writing to container with deleted attachment modified a new object.', false, true);
testPassed();
return tcuTestCase.IterateResult.STOP;
};
glsLifetimeTests.createLifeTestGroup = function(spec, types) {
var group = tcuTestCase.newTest(spec.name, spec.name);
for (var i = 0; i < types.length; i++) {
var type = types[i];
var name = type.getName();
if (!spec.needBind || type.binder() != null)
group.addChild(new glsLifetimeTests.LifeTest(name, name, type, spec.func));
}
return group;
};
/**
* @param {tcuTestCase.DeqpTest} group
* @param {glsLifetimeTests.Types} types
*/
glsLifetimeTests.addTestCases = function(group, types) {
var attacherName = function(attacher) {
return attacher.getElementType().getName() + '_' + attacher.getContainerType().getName();
};
var s_lifeTests = [
/* Create */ { name: 'gen', func: glsLifetimeTests.LifeTest.testGen, needBind: false },
/* Delete */ { name: 'delete', func: glsLifetimeTests.LifeTest.testDelete, needBind: false },
/* Bind */ { name: 'bind', func: glsLifetimeTests.LifeTest.testBind, needBind: true },
/* Delete bound */ { name: 'delete_bound', func: glsLifetimeTests.LifeTest.testDeleteBound, needBind: true }
];
s_lifeTests.forEach(function(spec) {
group.addChild(glsLifetimeTests.createLifeTestGroup(spec, types.getTypes()));
});
var delUsedGroup = tcuTestCase.newTest('delete_used', 'Delete current program');
group.addChild(delUsedGroup);
delUsedGroup.addChild(new glsLifetimeTests.LifeTest('program', 'program', types.getProgramType(),
glsLifetimeTests.LifeTest.testDeleteUsed));
var attGroup = tcuTestCase.newTest('attach', 'Attachment tests');
group.addChild(attGroup);
var nameGroup = tcuTestCase.newTest('deleted_name', 'Name of deleted attachment');
attGroup.addChild(nameGroup);
var atts = types.getAttachers();
for (var i = 0; i < atts.length; i++) {
var att = atts[i];
var name = attacherName(att);
nameGroup.addChild(new glsLifetimeTests.AttachmentTest(name, name, att,
glsLifetimeTests.AttachmentTest.testDeletedNames));
}
var inputGroup = tcuTestCase.newTest('deleted_input', 'Input from deleted attachment');
attGroup.addChild(inputGroup);
var inAtts = types.getInputAttachers();
for (var i = 0; i < inAtts.length; i++) {
var att = inAtts[i];
var name = attacherName(att.getAttacher());
inputGroup.addChild(new glsLifetimeTests.InputAttachmentTest(name, name, att));
}
var outputGroup = tcuTestCase.newTest('deleted_output', 'Output to deleted attachment');
attGroup.addChild(outputGroup);
var outAtts = types.getOutputAttachers();
for (var i = 0; i < outAtts.length; i++) {
var att = outAtts[i];
var name = attacherName(att.getAttacher());
outputGroup.addChild(new glsLifetimeTests.OutputAttachmentTest(name, name, att));
}
};
});