diff options
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fLifetimeTests.js')
-rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fLifetimeTests.js | 471 |
1 files changed, 471 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fLifetimeTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fLifetimeTests.js new file mode 100644 index 0000000000..b179022bfd --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fLifetimeTests.js @@ -0,0 +1,471 @@ +/*------------------------------------------------------------------------- + * 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.es3fLifetimeTests'); +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.glsLifetimeTests'); +goog.require('modules.shared.glsTextureTestUtil'); + +goog.scope(function() { +var es3fLifetimeTests = functional.gles3.es3fLifetimeTests; +var glsLifetimeTests = modules.shared.glsLifetimeTests; +var gluShaderProgram = framework.opengl.gluShaderProgram; +var deRandom = framework.delibs.debase.deRandom; +var tcuSurface = framework.common.tcuSurface; +var glsTextureTestUtil = modules.shared.glsTextureTestUtil; +var tcuTestCase = framework.common.tcuTestCase; + +/** @const */ var VIEWPORT_SIZE = 128; +/** @const */ var NUM_COMPONENTS = 4; +/** @const */ var NUM_VERTICES = 3; + +/** @type {WebGL2RenderingContext} */ var gl; + +var setParentClass = function(child, parent) { + child.prototype = Object.create(parent.prototype); + child.prototype.constructor = child; +}; + +/** + * @constructor + * @extends {gluShaderProgram.ShaderProgram} + */ +es3fLifetimeTests.ScaleProgram = function() { + gluShaderProgram.ShaderProgram.call(this, gl, this.getSources()); + assertMsgOptions(this.isOk(), 'Program creation failed', false, true); + this.m_scaleLoc = gl.getUniformLocation(this.getProgram(), 'scale'); + this.m_posLoc = gl.getAttribLocation(this.getProgram(), 'pos'); +}; + +setParentClass(es3fLifetimeTests.ScaleProgram, gluShaderProgram.ShaderProgram); + +/** + * @param {WebGLVertexArrayObject} vao + * @param {number} scale + * @param {boolean} tf + * @param {tcuSurface.Surface} dst + */ +es3fLifetimeTests.ScaleProgram.prototype.draw = function(vao, scale, tf, dst) { + es3fLifetimeTests.ScaleProgram.seed = es3fLifetimeTests.ScaleProgram.seed || 0; + ++es3fLifetimeTests.ScaleProgram.seed; + + var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), VIEWPORT_SIZE, VIEWPORT_SIZE, es3fLifetimeTests.ScaleProgram.seed); + gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); + gl.clearColor(0, 0, 0, 1); + gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); + + gl.bindVertexArray(vao); + gl.enableVertexAttribArray(this.m_posLoc); + gl.useProgram(this.getProgram()); + + gl.uniform1f(this.m_scaleLoc, scale); + + if (tf) + gl.beginTransformFeedback(gl.TRIANGLES); + gl.drawArrays(gl.TRIANGLES, 0, 3); + if (tf) + gl.endTransformFeedback(); + + if (dst) + glsLifetimeTests.readRectangle(viewport, dst); + + gl.bindVertexArray(null); + +}; + +/** + * @param {WebGLBuffer} buffer + * @param {WebGLVertexArrayObject} vao + */ +es3fLifetimeTests.ScaleProgram.prototype.setPos = function(buffer, vao) { + gl.bindBuffer(gl.ARRAY_BUFFER, buffer); + gl.bindVertexArray(vao); + gl.vertexAttribPointer(this.m_posLoc, NUM_COMPONENTS, gl.FLOAT, false, 0, 0); + gl.bindVertexArray(null); + gl.bindBuffer(gl.ARRAY_BUFFER, null); +}; + +/** + * @private + */ +es3fLifetimeTests.ScaleProgram.prototype.getSources = function() { +/** @const */ var s_vertexShaderSrc = + '#version 100\n' + + 'attribute vec4 pos;\n' + + 'uniform float scale;\n' + + 'void main ()\n' + + '{\n' + + ' gl_Position = vec4(scale * pos.xy, pos.zw);\n' + + '}'; + +/** @const */ var s_fragmentShaderSrc = + '#version 100\n' + + 'void main ()\n' + + '{\n' + + ' gl_FragColor = vec4(1.0, 0.0, 1.0, 1.0);\n' + + '}'; + var sources = new gluShaderProgram.ProgramSources(); + sources.add(new gluShaderProgram.VertexSource(s_vertexShaderSrc)); + sources.add(new gluShaderProgram.FragmentSource(s_fragmentShaderSrc)); + sources.add(new gluShaderProgram.TransformFeedbackMode(gl.INTERLEAVED_ATTRIBS)); + sources.add(new gluShaderProgram.TransformFeedbackVarying('gl_Position')); + return sources; +}; + +/** + * @constructor + * @extends {glsLifetimeTests.SimpleBinder} + */ +es3fLifetimeTests.VertexArrayBinder = function() { + glsLifetimeTests.SimpleBinder.call(this, null, gl.NONE, gl.VERTEX_ARRAY_BINDING); +}; + +setParentClass(es3fLifetimeTests.VertexArrayBinder, glsLifetimeTests.SimpleBinder); + +es3fLifetimeTests.VertexArrayBinder.prototype.bind = function(obj) { + var vao = /** @type {WebGLVertexArrayObject} */ (obj); + gl.bindVertexArray(vao); +}; + +/** + * @constructor + * @extends {glsLifetimeTests.Binder} + */ +es3fLifetimeTests.SamplerBinder = function() { + glsLifetimeTests.Binder.call(this); +}; + +setParentClass(es3fLifetimeTests.SamplerBinder, glsLifetimeTests.Binder); + +es3fLifetimeTests.SamplerBinder.prototype.bind = function(obj) { + var sampler = /** @type {WebGLSampler} */ (obj); + gl.bindSampler(0, sampler); +}; +es3fLifetimeTests.SamplerBinder.prototype.getBinding = function() { return /** @type {WebGLSampler} */ (gl.getParameter(gl.SAMPLER_BINDING)); }; + +/** + * @constructor + * @extends {glsLifetimeTests.Binder} + */ +es3fLifetimeTests.QueryBinder = function() { + glsLifetimeTests.Binder.call(this); +}; + +setParentClass(es3fLifetimeTests.QueryBinder, glsLifetimeTests.Binder); + +es3fLifetimeTests.QueryBinder.prototype.bind = function(obj) { + var query = /** @type {WebGLQuery} */ (obj); + if (query) + gl.beginQuery(gl.ANY_SAMPLES_PASSED, query); + else + gl.endQuery(gl.ANY_SAMPLES_PASSED); +}; + +es3fLifetimeTests.QueryBinder.prototype.getBinding = function() { return null; }; + +/** + * @constructor + * @extends {glsLifetimeTests.Attacher} + * @param {glsLifetimeTests.Type} elementType + * @param {glsLifetimeTests.Type} varrType + * @param {es3fLifetimeTests.ScaleProgram} program + */ +es3fLifetimeTests.BufferVAOAttacher = function(elementType, varrType, program) { + glsLifetimeTests.Attacher.call(this, elementType, varrType); + this.m_program = program; +}; + +setParentClass(es3fLifetimeTests.BufferVAOAttacher, glsLifetimeTests.Attacher); + +/** + * @return {es3fLifetimeTests.ScaleProgram} + */ +es3fLifetimeTests.BufferVAOAttacher.prototype.getProgram = function() { return this.m_program; }; + +/** + * @param {number} seed + * @param {number} usage + * @param {WebGLBuffer} buffer + */ +es3fLifetimeTests.initBuffer = function(seed, usage, buffer) { + /** @const */ var s_varrData = [ + -1.0, 0.0, 0.0, 1.0, + 1.0, 1.0, 0.0, 1.0, + 0.0, -1.0, 0.0, 1.0 + ]; + gl.bindBuffer(gl.ARRAY_BUFFER, buffer); + if (seed == 0) + gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(s_varrData), usage); + else { + var rnd = new deRandom.Random(seed); + var data = []; + + for (var ndx = 0; ndx < NUM_VERTICES; ndx++) { + data.push(2 * (rnd.getFloat() - 0.5)); + data.push(2 * (rnd.getFloat() - 0.5)); + data.push(0); + data.push(1); + } + gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(data), usage); + } + gl.bindBuffer(gl.ARRAY_BUFFER, null); +}; + +es3fLifetimeTests.BufferVAOAttacher.prototype.initAttachment = function(seed, obj) { + var buffer = /** @type {WebGLBuffer} */ (obj); + es3fLifetimeTests.initBuffer(seed, gl.STATIC_DRAW, buffer); + bufferedLogToConsole('Initialized buffer ' + buffer + ' from seed ' + seed); +}; + +es3fLifetimeTests.BufferVAOAttacher.prototype.attach = function(element, target) { + var buffer = /** @type {WebGLBuffer} */ (element); + var vao = /** @type {WebGLVertexArrayObject} */ (target); + + this.m_program.setPos(buffer, vao); + bufferedLogToConsole('Set the `pos` attribute in VAO ' + vao + ' to buffer ' + buffer); +}; + +es3fLifetimeTests.BufferVAOAttacher.prototype.detach = function(element, target) { + var vao = /** @type {WebGLVertexArrayObject} */ (target); + this.attach(null, vao); +}; + +es3fLifetimeTests.BufferVAOAttacher.prototype.getAttachment = function(target) { + var vao = /** @type {WebGLVertexArrayObject} */ (target); + gl.bindVertexArray(vao); + var name = gl.getVertexAttrib(this.m_posLoc, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING); + gl.bindVertexArray(null); + return name; +}; + +/** + * @constructor + * @extends {glsLifetimeTests.InputAttacher} + * @param {es3fLifetimeTests.BufferVAOAttacher} attacher + */ +es3fLifetimeTests.BufferVAOInputAttacher = function(attacher) { + glsLifetimeTests.InputAttacher.call(this, attacher); + this.m_program = attacher.getProgram(); +}; + +setParentClass(es3fLifetimeTests.BufferVAOInputAttacher, glsLifetimeTests.InputAttacher); + +es3fLifetimeTests.BufferVAOInputAttacher.prototype.drawContainer = function(obj, dst) { + var vao = /** @type {WebGLVertexArrayObject} */ (obj); + this.m_program.draw(vao, 1.0, false, dst); + bufferedLogToConsole('Drew an output image with VAO ' + vao); +}; + +/** + * @constructor + * @extends {glsLifetimeTests.Attacher} + * @param {glsLifetimeTests.Type} elementType + * @param {glsLifetimeTests.Type} tfType +*/ +es3fLifetimeTests.BufferTfAttacher = function(elementType, tfType) { + glsLifetimeTests.Attacher.call(this, elementType, tfType); +}; + +setParentClass(es3fLifetimeTests.BufferTfAttacher, glsLifetimeTests.Attacher); + +es3fLifetimeTests.BufferTfAttacher.prototype.initAttachment = function(seed, obj) { + var buffer = /** @type {WebGLBuffer} */ (obj); + es3fLifetimeTests.initBuffer(seed, gl.DYNAMIC_READ, buffer); + bufferedLogToConsole('Initialized buffer ' + buffer + ' from seed ' + seed); +}; + +es3fLifetimeTests.BufferTfAttacher.prototype.attach = function(element, target) { + var buffer = /** @type {WebGLBuffer} */ (element); + var tf = /** @type {WebGLTransformFeedback} */ (target); + gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tf); + gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buffer); + gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null); +}; + +es3fLifetimeTests.BufferTfAttacher.prototype.detach = function(element, target) { + var buffer = /** @type {WebGLBuffer} */ (element); + var tf = /** @type {WebGLTransformFeedback} */ (target); + gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tf); + gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, null); + gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null); + +}; + +es3fLifetimeTests.BufferTfAttacher.prototype.getAttachment = function(target) { + var tf = /** @type {WebGLTransformFeedback} */ (target); + gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tf); + var name = gl.getIndexedParameter(gl.TRANSFORM_FEEDBACK_BUFFER_BINDING, 0); + gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null); + return name; +}; + +/** + * @constructor + * @extends {glsLifetimeTests.OutputAttacher} + */ +es3fLifetimeTests.BufferTfOutputAttacher = function(attacher, program) { + glsLifetimeTests.OutputAttacher.call(this, attacher); + this.m_program = program; +}; + +setParentClass(es3fLifetimeTests.BufferTfOutputAttacher, glsLifetimeTests.OutputAttacher); + +es3fLifetimeTests.BufferTfOutputAttacher.prototype.setupContainer = function(seed, obj) { + var tf = /** @type {WebGLTransformFeedback} */ (obj); + var posBuf = gl.createBuffer(); + var vao = gl.createVertexArray(); + + es3fLifetimeTests.initBuffer(seed, gl.STATIC_DRAW, posBuf); + this.m_program.setPos(posBuf, vao); + + gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tf); + this.m_program.draw(vao, -1.0, true, null); + bufferedLogToConsole('Drew an image with seed ' + seed + ' with transform feedback to ' + tf); + gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null); + gl.deleteVertexArray(vao); + gl.deleteBuffer(posBuf); +}; + +es3fLifetimeTests.BufferTfOutputAttacher.prototype.drawAttachment = function(buffer, dst) { + var vao = gl.createVertexArray(); + + this.m_program.setPos(buffer, vao); + this.m_program.draw(vao, 1.0, false, dst); + bufferedLogToConsole('Drew output image with vertices from buffer ' + buffer); + gl.deleteVertexArray(vao); +}; + +/** + * @constructor + * @extends {glsLifetimeTests.ES2Types} + */ +es3fLifetimeTests.ES3Types = function() { + glsLifetimeTests.ES2Types.call(this); + this.m_program = new es3fLifetimeTests.ScaleProgram(); + this.m_queryBind = new es3fLifetimeTests.QueryBinder(); + this.m_queryType = new glsLifetimeTests.SimpleType('query', gl.createQuery, gl.deleteQuery, gl.isQuery, this.m_queryBind); + this.m_tfBind = new glsLifetimeTests.SimpleBinder(gl.bindTransformFeedback, gl.TRANSFORM_FEEDBACK, + gl.TRANSFORM_FEEDBACK_BINDING); + this.m_tfType = new glsLifetimeTests.SimpleType('transform_feedback', gl.createTransformFeedback, gl.deleteTransformFeedback, gl.isTransformFeedback, this.m_tfBind); + this.m_varrBind = new es3fLifetimeTests.VertexArrayBinder(); + this.m_varrType = new glsLifetimeTests.SimpleType('vertex_array', gl.createVertexArray, gl.deleteVertexArray, gl.isVertexArray, this.m_varrBind); + this.m_samplerBind = new es3fLifetimeTests.SamplerBinder(); + this.m_samplerType = new glsLifetimeTests.SimpleType('sampler', gl.createSampler, gl.deleteSampler, gl.isSampler, this.m_samplerBind, true); + this.m_bufVarrAtt = new es3fLifetimeTests.BufferVAOAttacher(this.m_bufferType, this.m_varrType, this.m_program); + this.m_bufVarrInAtt = new es3fLifetimeTests.BufferVAOInputAttacher(this.m_bufVarrAtt); + this.m_bufTfAtt = new es3fLifetimeTests.BufferTfAttacher(this.m_bufferType, this.m_tfType); + this.m_bufTfOutAtt = new es3fLifetimeTests.BufferTfOutputAttacher(this.m_bufTfAtt, this.m_program); + + this.m_types.push(this.m_queryType, this.m_tfType, this.m_varrType, this.m_samplerType); + this.m_attachers.push(this.m_bufVarrAtt, this.m_bufTfAtt); + this.m_inAttachers.push(this.m_bufVarrInAtt); + this.m_outAttachers.push(this.m_bufTfOutAtt); +}; + +setParentClass(es3fLifetimeTests.ES3Types, glsLifetimeTests.ES2Types); + +/** + * @constructor + * @extends {tcuTestCase.DeqpTest} + */ +es3fLifetimeTests.TfDeleteActiveTest = function(name, description) { + tcuTestCase.DeqpTest.call(this, name, description); +}; + +setParentClass(es3fLifetimeTests.TfDeleteActiveTest, tcuTestCase.DeqpTest); + +es3fLifetimeTests.TfDeleteActiveTest.prototype.iterate = function() { +/** @const */ var s_xfbVertexSource = + '#version 300 es\n' + + 'void main ()\n' + + '{\n' + + ' gl_Position = vec4(float(gl_VertexID) / 2.0, float(gl_VertexID % 2) / 2.0, 0.0, 1.0);\n' + + '}\n'; + +/** @const */ var s_xfbFragmentSource = + '#version 300 es\n' + + 'layout(location=0) out mediump vec4 dEQP_FragColor;\n' + + 'void main (void)\n' + + '{\n' + + ' dEQP_FragColor = vec4(1.0, 1.0, 0.0, 1.0);\n' + + '}\n'; + var buf = gl.createBuffer(); + + var sources = new gluShaderProgram.ProgramSources(); + sources.add(new gluShaderProgram.VertexSource(s_xfbVertexSource)); + sources.add(new gluShaderProgram.FragmentSource(s_xfbFragmentSource)); + sources.add(new gluShaderProgram.TransformFeedbackMode(gl.SEPARATE_ATTRIBS)); + sources.add(new gluShaderProgram.TransformFeedbackVarying('gl_Position')); + var program = new gluShaderProgram.ShaderProgram(gl, sources); + if (!program.isOk()) { + bufferedLogToConsole(program.getProgramInfo().infoLog); + testFailedOptions('failed to build program', true); + } + gl.useProgram(program.getProgram()); + + var tf = gl.createTransformFeedback(); + gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tf); + gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buf); + gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, 48, gl.STATIC_DRAW); + + gl.beginTransformFeedback(gl.TRIANGLES); + var errCode = gl.NONE; + gl.deleteTransformFeedback(tf); + errCode = gl.getError(); + assertMsgOptions(errCode == gl.INVALID_OPERATION, + 'Deleting active transform feedback must produce INVALID_OPERATION', false, true); + gl.endTransformFeedback(); + gl.deleteTransformFeedback(tf); + testPassed(); + return tcuTestCase.IterateResult.STOP; +}; + +es3fLifetimeTests.genTestCases = function() { + var state = tcuTestCase.runner; + state.setRoot(tcuTestCase.newTest('lifetime', 'Top level')); + + var types = new es3fLifetimeTests.ES3Types(); + glsLifetimeTests.addTestCases(state.testCases, types); + /* TODO: Add TfDeleteActiveTest test */ + var deleteActiveGroup = tcuTestCase.newTest('delete_active', 'Delete active object'); + state.testCases.addChild(deleteActiveGroup); + deleteActiveGroup.addChild( + new es3fLifetimeTests.TfDeleteActiveTest('transform_feedback', 'Transform Feedback')); +}; + +/** + * Create and execute the test cases + */ +es3fLifetimeTests.run = function(context) { + gl = context; + try { + es3fLifetimeTests.genTestCases(); + tcuTestCase.runner.runCallback(tcuTestCase.runTestCases); + } catch (err) { + bufferedLogToConsole(err); + tcuTestCase.runner.terminate(); + } + +}; + +}); |