| /*------------------------------------------------------------------------- |
| * 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('modules.shared.glsBufferTestUtil'); |
| goog.require('framework.common.tcuImageCompare'); |
| goog.require('framework.common.tcuRGBA'); |
| goog.require('framework.common.tcuSurface'); |
| goog.require('framework.common.tcuTestCase'); |
| goog.require('framework.common.tcuTexture'); |
| goog.require('framework.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.gluDrawUtil'); |
| goog.require('framework.opengl.gluShaderProgram'); |
| goog.require('framework.opengl.gluShaderUtil'); |
| |
| goog.scope(function() { |
| |
| var glsBufferTestUtil = modules.shared.glsBufferTestUtil; |
| var tcuImageCompare = framework.common.tcuImageCompare; |
| var tcuRGBA = framework.common.tcuRGBA; |
| var tcuSurface = framework.common.tcuSurface; |
| var tcuTestCase = framework.common.tcuTestCase; |
| var tcuTexture = framework.common.tcuTexture; |
| var gluShaderProgram = framework.opengl.gluShaderProgram; |
| var gluShaderUtil = framework.opengl.gluShaderUtil; |
| var gluDrawUtil = framework.opengl.gluDrawUtil; |
| var deUtil = framework.delibs.debase.deUtil; |
| var deMath = framework.delibs.debase.deMath; |
| var deRandom = framework.delibs.debase.deRandom; |
| var deString = framework.delibs.debase.deString; |
| |
| glsBufferTestUtil.VERIFY_QUAD_SIZE = 8; //!< Quad size in VertexArrayVerifier |
| glsBufferTestUtil.MAX_LINES_PER_INDEX_ARRAY_DRAW = 128; //!< Maximum number of lines per one draw in IndexArrayVerifier |
| glsBufferTestUtil.INDEX_ARRAY_DRAW_VIEWPORT_WIDTH = 128; |
| glsBufferTestUtil.INDEX_ARRAY_DRAW_VIEWPORT_HEIGHT = 128; |
| |
| // Helper functions. |
| |
| /** |
| * @param {Uint8Array} ptr |
| * @param {number} numBytes |
| * @param {number} seed |
| */ |
| glsBufferTestUtil.fillWithRandomBytes = function(ptr, numBytes, seed) { |
| var rnd = new deRandom.Random(seed); |
| for (var left = numBytes; left > 0; left--) |
| ptr[left - 1] = rnd.getInt(); |
| }; |
| |
| /** |
| * @param {Uint8Array} resPtr |
| * @param {Uint8Array} refPtr |
| * @param {number} numBytes |
| * @return {boolean} |
| */ |
| glsBufferTestUtil.compareByteArrays = function(resPtr, refPtr, numBytes) { |
| var isOk = true; |
| var maxSpanLen = 8; |
| var maxDiffSpans = 4; |
| var numDiffSpans = 0; |
| var diffSpanStart = -1; |
| var ndx = 0; |
| |
| var log = 'Verification result: '; |
| |
| for (; ndx < numBytes; ndx++) { |
| if (resPtr[ndx] != refPtr[ndx]) { |
| if (diffSpanStart < 0) |
| diffSpanStart = ndx; |
| |
| isOk = false; |
| } else if (diffSpanStart >= 0) { |
| if (numDiffSpans < maxDiffSpans) { |
| var len = ndx - diffSpanStart; |
| var printLen = Math.min(len, maxSpanLen); |
| |
| log += len + ' byte difference at offset ' + diffSpanStart + '\n' + |
| ' expected ' + refPtr.subarray(diffSpanStart, diffSpanStart + printLen) + |
| ' got ' + resPtr.subarray(diffSpanStart, diffSpanStart + printLen); |
| } else |
| log += '(output too long, truncated)'; |
| |
| numDiffSpans += 1; |
| diffSpanStart = -1; |
| } |
| } |
| |
| if (diffSpanStart >= 0) { |
| if (numDiffSpans < maxDiffSpans) { |
| var len = ndx - diffSpanStart; |
| var printLen = Math.min(len, maxSpanLen); |
| |
| log += len + ' byte difference at offset ' + diffSpanStart + '\n' + |
| ' expected ' + refPtr.subarray(diffSpanStart, diffSpanStart + printLen) + |
| ' got ' + resPtr.subarray(diffSpanStart, diffSpanStart + printLen); |
| } else |
| log += '(output too long, truncated)'; |
| } |
| |
| log += (isOk ? 'Verification passed.' : 'Verification FAILED!'); |
| |
| bufferedLogToConsole(log); |
| |
| return isOk; |
| }; |
| |
| /** |
| * @param {number} target |
| * @return {string} |
| */ |
| glsBufferTestUtil.getBufferTargetName = function(target) { |
| switch (target) { |
| case gl.ARRAY_BUFFER: return 'array'; |
| case gl.COPY_READ_BUFFER: return 'copy_read'; |
| case gl.COPY_WRITE_BUFFER: return 'copy_write'; |
| case gl.ELEMENT_ARRAY_BUFFER: return 'element_array'; |
| case gl.PIXEL_PACK_BUFFER: return 'pixel_pack'; |
| case gl.PIXEL_UNPACK_BUFFER: return 'pixel_unpack'; |
| //case gl.TEXTURE_BUFFER: return "texture"; //TODO: Unimplemented in WebGL 2. Remove? |
| case gl.TRANSFORM_FEEDBACK_BUFFER: return 'transform_feedback'; |
| case gl.UNIFORM_BUFFER: return 'uniform'; |
| default: |
| throw new Error('Invalid buffer target'); |
| } |
| }; |
| |
| /** |
| * @param {number} hint |
| * @return {string} |
| */ |
| glsBufferTestUtil.getUsageHintName = function(hint) { |
| switch (hint) { |
| case gl.STREAM_DRAW: return 'stream_draw'; |
| case gl.STREAM_READ: return 'stream_read'; |
| case gl.STREAM_COPY: return 'stream_copy'; |
| case gl.STATIC_DRAW: return 'static_draw'; |
| case gl.STATIC_READ: return 'static_read'; |
| case gl.STATIC_COPY: return 'static_copy'; |
| case gl.DYNAMIC_DRAW: return 'dynamic_draw'; |
| case gl.DYNAMIC_READ: return 'dynamic_read'; |
| case gl.DYNAMIC_COPY: return 'dynamic_copy'; |
| default: |
| throw new Error('Invalid buffer usage hint'); |
| } |
| }; |
| |
| // Base class for buffer cases. |
| // BufferCase |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| * @param {string} name |
| * @param {string} description |
| */ |
| glsBufferTestUtil.BufferCase = function(name, description) { |
| tcuTestCase.DeqpTest.call(this, name, description); |
| /** @type {Array<WebGLBuffer>} */ this.m_allocatedBuffers = []; |
| }; |
| |
| glsBufferTestUtil.BufferCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| glsBufferTestUtil.BufferCase.prototype.constructor = glsBufferTestUtil.BufferCase; |
| |
| /** |
| * init |
| */ |
| glsBufferTestUtil.BufferCase.prototype.init = function() {}; |
| |
| /** |
| * deinit |
| */ |
| glsBufferTestUtil.BufferCase.prototype.deinit = function() { |
| for (var ndx = 0; ndx < this.m_allocatedBuffers.length; ndx++) |
| this.deleteBuffer(this.m_allocatedBuffers[ndx]); |
| }; |
| |
| /** |
| * @return {WebGLBuffer} |
| */ |
| glsBufferTestUtil.BufferCase.prototype.genBuffer = function() { |
| var buf = 0; |
| buf = gl.createBuffer(); |
| if (buf != 0) { |
| try { |
| deUtil.dePushUniqueToArray(this.m_allocatedBuffers, buf); |
| } |
| catch (err) { |
| gl.deleteBuffer(buf); |
| throw err; |
| } |
| } |
| return buf; |
| }; |
| |
| /** |
| * @param {WebGLBuffer} buffer |
| */ |
| glsBufferTestUtil.BufferCase.prototype.deleteBuffer = function(buffer) { |
| gl.deleteBuffer(buffer); |
| this.m_allocatedBuffers.splice(this.m_allocatedBuffers.indexOf(buffer), 1); |
| }; |
| |
| glsBufferTestUtil.BufferCase.prototype.checkError = function() { |
| /** @type {number} */ var err = gl.getError(); |
| if (err != gl.NO_ERROR) |
| throw new TestFailedException('Got ' + WebGLTestUtils.glEnumToString(gl, err)); |
| }; |
| |
| // Reference buffer. |
| |
| /** |
| * @constructor |
| */ |
| glsBufferTestUtil.ReferenceBuffer = function() { |
| /** @type {ArrayBuffer} */ this.m_data; |
| }; |
| |
| /** |
| * @param {number=} offset |
| * @return {Uint8Array} |
| */ |
| glsBufferTestUtil.ReferenceBuffer.prototype.getPtr = function(offset) { |
| offset = offset ? offset : 0; return new Uint8Array(this.m_data, offset); |
| }; |
| |
| /** |
| * @param {number} numBytes |
| */ |
| glsBufferTestUtil.ReferenceBuffer.prototype.setSize = function(numBytes) { |
| this.m_data = new ArrayBuffer(numBytes); |
| }; |
| |
| /** |
| * @param {number} numBytes |
| * @param {Uint8Array} bytes |
| */ |
| glsBufferTestUtil.ReferenceBuffer.prototype.setData = function(numBytes, bytes) { |
| this.setSize(numBytes); |
| var dst = new Uint8Array(this.m_data); |
| dst.set(bytes.subarray(numBytes)); |
| }; |
| |
| /** |
| * @param {number} offset |
| * @param {number} numBytes |
| * @param {Uint8Array} bytes |
| */ |
| glsBufferTestUtil.ReferenceBuffer.prototype.setSubData = function(offset, numBytes, bytes) { |
| assertMsgOptions(deMath.deInBounds32(offset, 0, this.m_data.byteLength) && deMath.deInRange32(offset + numBytes, offset, this.m_data.byteLength), |
| 'Parameters not in buffer bounds or range', false, true); |
| var dst = new Uint8Array(this.m_data, offset); |
| dst.set(bytes.subarray(offset, offset + numBytes)); |
| }; |
| |
| // Buffer writer system. |
| |
| /** |
| * @enum {number} |
| */ |
| glsBufferTestUtil.WriteType = { |
| BUFFER_SUB_DATA: 0, |
| BUFFER_WRITE_MAP: 1, |
| TRANSFORM_FEEDBACK: 2, |
| PIXEL_PACK: 3 |
| }; |
| |
| /** |
| * @param {glsBufferTestUtil.WriteType} write |
| * @return {string} |
| */ |
| glsBufferTestUtil.getWriteTypeDescription = function(write) { |
| /** @type {Array<string>} */ var s_desc = [ |
| 'gl.bufferSubData()', |
| 'gl.mapBufferRange()', |
| 'transform feedback', |
| 'gl.readPixels() into PBO binding' |
| ]; |
| return /** @type {string} */ (deUtil.getArrayElement(s_desc, write)); |
| }; |
| |
| // BufferWriterBase |
| |
| /** |
| * @constructor |
| */ |
| glsBufferTestUtil.BufferWriterBase = function() {}; |
| |
| /** |
| * //Meant to be overriden |
| * @return {number} |
| */ |
| glsBufferTestUtil.BufferWriterBase.prototype.getMinSize = function() { throw new Error('Must be overriden'); }; |
| |
| /** |
| * //Meant to be overriden |
| * @return {number} |
| */ |
| glsBufferTestUtil.BufferWriterBase.prototype.getAlignment = function() { throw new Error('Must be overriden'); }; |
| |
| /** |
| * //Meant to be overriden |
| * @param {WebGLBuffer} buffer |
| * @param {number} offset |
| * @param {number} numBytes |
| * @param {Uint8Array} bytes |
| */ |
| glsBufferTestUtil.BufferWriterBase.prototype.writeNoTarget = function(buffer, offset, numBytes, bytes) { throw new Error('Must be overriden'); }; |
| |
| /** |
| * @param {WebGLBuffer} buffer |
| * @param {number} offset |
| * @param {number} numBytes |
| * @param {Uint8Array} bytes |
| * @param {number} targetHint |
| */ |
| glsBufferTestUtil.BufferWriterBase.prototype.write = function(buffer, offset, numBytes, bytes, targetHint) { |
| this.writeNoTarget(buffer, offset, numBytes, bytes); |
| }; |
| |
| // BufferWriter |
| |
| /** |
| * @constructor |
| * @param {glsBufferTestUtil.WriteType} writeType |
| */ |
| glsBufferTestUtil.BufferWriter = function(writeType) { |
| /** @type {glsBufferTestUtil.BufferWriterBase} */ this.m_writer = null; |
| switch (writeType) { |
| case glsBufferTestUtil.WriteType.BUFFER_SUB_DATA: this.m_writer = new glsBufferTestUtil.BufferSubDataWriter(); break; |
| default: |
| testFailed('Unsupported writer'); |
| } |
| }; |
| |
| /** |
| * @return {number} |
| */ |
| glsBufferTestUtil.BufferWriter.prototype.getMinSize = function() {return this.m_writer.getMinSize();}; |
| |
| /** |
| * @return {number} |
| */ |
| glsBufferTestUtil.BufferWriter.prototype.getAlignment = function() {return this.m_writer.getAlignment();}; |
| |
| /** |
| * @param {WebGLBuffer} buffer |
| * @param {number} offset |
| * @param {number} numBytes |
| * @param {Uint8Array} bytes |
| */ |
| glsBufferTestUtil.BufferWriter.prototype.writeNoTarget = function(buffer, offset, numBytes, bytes) { |
| assertMsgOptions(numBytes >= this.getMinSize(), 'Number of bytes to write is smaller than the minimum size.', false, true); |
| assertMsgOptions(offset % this.getAlignment() == 0, 'Offset is not aligned.', false, true); |
| assertMsgOptions((offset + numBytes) % this.getAlignment() == 0, 'Buffer segment is not aligned', false, true); |
| return this.m_writer.writeNoTarget(buffer, offset, numBytes, bytes); |
| }; |
| |
| /** |
| * @param {WebGLBuffer} buffer |
| * @param {number} offset |
| * @param {number} numBytes |
| * @param {Uint8Array} bytes |
| * @param {number} targetHint |
| */ |
| glsBufferTestUtil.BufferWriter.prototype.write = function(buffer, offset, numBytes, bytes, targetHint) { |
| assertMsgOptions(numBytes >= this.getMinSize(), 'Number of bytes to write is smaller than the minimum size.', false, true); |
| assertMsgOptions(offset % this.getAlignment() == 0, 'Offset is not aligned.', false, true); |
| assertMsgOptions((offset + numBytes) % this.getAlignment() == 0, 'Buffer segment is not aligned', false, true); |
| return this.m_writer.write(buffer, offset, numBytes, bytes, targetHint); |
| }; |
| |
| // BufferSubDataWriter |
| |
| /** |
| * @constructor |
| * @extends {glsBufferTestUtil.BufferWriterBase} |
| */ |
| glsBufferTestUtil.BufferSubDataWriter = function() { |
| glsBufferTestUtil.BufferWriterBase.call(this); |
| }; |
| |
| glsBufferTestUtil.BufferSubDataWriter.prototype = Object.create(glsBufferTestUtil.BufferWriterBase.prototype); |
| glsBufferTestUtil.BufferSubDataWriter.prototype.constructor = glsBufferTestUtil.BufferSubDataWriter; |
| |
| /** |
| * @return {number} |
| */ |
| glsBufferTestUtil.BufferSubDataWriter.prototype.getMinSize = function() { return 1; }; |
| |
| /** |
| * @return {number} |
| */ |
| glsBufferTestUtil.BufferSubDataWriter.prototype.getAlignment = function() { return 1; }; |
| |
| /** |
| * @param {WebGLBuffer} buffer |
| * @param {number} offset |
| * @param {number} numBytes |
| * @param {Uint8Array} bytes |
| */ |
| glsBufferTestUtil.BufferSubDataWriter.prototype.writeNoTarget = function(buffer, offset, numBytes, bytes) { |
| this.write(buffer, offset, numBytes, bytes, gl.ARRAY_BUFFER); |
| }; |
| |
| /** |
| * @param {WebGLBuffer} buffer |
| * @param {number} offset |
| * @param {number} numBytes |
| * @param {Uint8Array} bytes |
| * @param {number} target |
| */ |
| glsBufferTestUtil.BufferSubDataWriter.prototype.write = function(buffer, offset, numBytes, bytes, target) { |
| gl.bindBuffer(target, buffer); |
| gl.bufferSubData(target, offset, bytes); |
| gl.bindBuffer(target, null); |
| }; |
| |
| // Buffer verifier system. |
| |
| /** |
| * @enum {number} |
| */ |
| glsBufferTestUtil.VerifyType = { |
| AS_VERTEX_ARRAY: 0, |
| AS_INDEX_ARRAY: 1, |
| AS_UNIFORM_BUFFER: 2, |
| AS_PIXEL_UNPACK_BUFFER: 3, |
| BUFFER_READ_MAP: 4 |
| }; |
| |
| /** |
| * @param {glsBufferTestUtil.VerifyType} verify |
| * @return {string} |
| */ |
| glsBufferTestUtil.getVerifyTypeDescription = function(verify) { |
| /** @type {Array<string>} */ var s_desc = |
| [ |
| 'rendering as vertex data', |
| 'rendering as index data', |
| 'reading in shader as uniform buffer data', |
| 'using as PBO and uploading to texture', |
| 'reading back using glMapBufferRange()' |
| ]; |
| |
| return /** @type {string} */ (deUtil.getArrayElement(s_desc, verify)); |
| }; |
| |
| /** |
| * @constructor |
| */ |
| glsBufferTestUtil.BufferVerifierBase = function() {}; |
| |
| /** |
| * //Meant to be overriden |
| * @return {number} |
| */ |
| glsBufferTestUtil.BufferVerifierBase.prototype.getMinSize = function() { throw new Error('Must be overriden'); }; |
| |
| /** |
| * //Meant to be overriden |
| * @return {number} |
| */ |
| glsBufferTestUtil.BufferVerifierBase.prototype.getAlignment = function() { throw new Error('Must be overriden'); }; |
| |
| /** |
| * @param {WebGLBuffer} buffer |
| * @param {Uint8Array} reference |
| * @param {number} offset |
| * @param {number} numBytes |
| * @return {boolean} |
| */ |
| glsBufferTestUtil.BufferVerifierBase.prototype.verifyNoTarget = function(buffer, reference, offset, numBytes) { |
| throw new Error('Must be overriden'); |
| }; |
| |
| /** |
| * //Meant to be overriden |
| * @param {WebGLBuffer} buffer |
| * @param {Uint8Array} reference |
| * @param {number} offset |
| * @param {number} numBytes |
| * @param {number} targetHint |
| * @return {boolean} |
| */ |
| glsBufferTestUtil.BufferVerifierBase.prototype.verify = function(buffer, reference, offset, numBytes, targetHint) { |
| //In WebGL 2, ELEMENT_ARRAY_BUFFER and TRANSFORM_FEEDBACK_BUFFER cannot be rebound to a different |
| //type of buffer, so, let's copy their data to an ARRAY BUFFER and pass that one instead to be verified. |
| var wasReadBufferCreated = false; |
| try { |
| if (targetHint == gl.ELEMENT_ARRAY_BUFFER || targetHint == gl.TRANSFORM_FEEDBACK_BUFFER) { |
| var readBuffer = new Uint8Array(offset + numBytes); |
| gl.getBufferSubData(targetHint, 0, readBuffer); |
| buffer = gl.createBuffer(); |
| |
| wasReadBufferCreated = true; |
| |
| gl.bindBuffer(gl.ARRAY_BUFFER, buffer); |
| gl.bufferData(gl.ARRAY_BUFFER, readBuffer, gl.STATIC_DRAW); |
| } |
| |
| var result = this.verifyNoTarget(buffer, reference, offset, numBytes); |
| |
| if (wasReadBufferCreated) |
| gl.deleteBuffer(buffer); |
| |
| return result; |
| } catch (err) { |
| if (wasReadBufferCreated) |
| gl.deleteBuffer(buffer); |
| throw err; |
| } |
| }; |
| |
| // BufferVerifier |
| |
| /** |
| * @constructor |
| * @param {glsBufferTestUtil.VerifyType} verifyType |
| */ |
| glsBufferTestUtil.BufferVerifier = function(verifyType) { |
| /** @type {glsBufferTestUtil.BufferVerifierBase} */ this.m_verifier = null; |
| switch (verifyType) { |
| case glsBufferTestUtil.VerifyType.AS_VERTEX_ARRAY: this.m_verifier = new glsBufferTestUtil.VertexArrayVerifier(); break; |
| case glsBufferTestUtil.VerifyType.AS_INDEX_ARRAY: this.m_verifier = new glsBufferTestUtil.IndexArrayVerifier(); break; |
| default: |
| testFailed('Unsupported verifier type'); |
| } |
| }; |
| |
| /** |
| * @return {number} |
| */ |
| glsBufferTestUtil.BufferVerifier.prototype.getMinSize = function() { return this.m_verifier.getMinSize(); }; |
| |
| /** |
| * @return {number} |
| */ |
| glsBufferTestUtil.BufferVerifier.prototype.getAlignment = function() { return this.m_verifier.getAlignment(); }; |
| |
| /** |
| * @param {WebGLBuffer} buffer |
| * @param {Uint8Array} reference |
| * @param {number} numBytes |
| * @return {boolean} |
| */ |
| glsBufferTestUtil.BufferVerifier.prototype.verifyNoTarget = function(buffer, reference, offset, numBytes) { |
| assertMsgOptions(numBytes >= this.getMinSize(), 'Number of bytes to write is smaller than the minimum size.', false, true); |
| assertMsgOptions(offset % this.getAlignment() == 0, 'Offset is not aligned.', false, true); |
| assertMsgOptions((offset + numBytes) % this.getAlignment() == 0, 'Buffer segment is not aligned', false, true); |
| return this.m_verifier.verifyNoTarget(buffer, reference, offset, numBytes); |
| }; |
| |
| /** |
| * @param {WebGLBuffer} buffer |
| * @param {Uint8Array} reference |
| * @param {number} offset |
| * @param {number} numBytes |
| * @param {number} targetHint |
| * @return {boolean} |
| */ |
| glsBufferTestUtil.BufferVerifier.prototype.verify = function(buffer, reference, offset, numBytes, targetHint) { |
| assertMsgOptions(numBytes >= this.getMinSize(), 'Number of bytes to write is smaller than the minimum size.', false, true); |
| assertMsgOptions(offset % this.getAlignment() == 0, 'Offset is not aligned.', false, true); |
| assertMsgOptions((offset + numBytes) % this.getAlignment() == 0, 'Buffer segment is not aligned', false, true); |
| return this.m_verifier.verify(buffer, reference, offset, numBytes, targetHint); |
| }; |
| |
| // VertexArrayVerifier |
| |
| /** |
| * @constructor |
| * @extends {glsBufferTestUtil.BufferVerifierBase} |
| */ |
| glsBufferTestUtil.VertexArrayVerifier = function() { |
| glsBufferTestUtil.BufferVerifierBase.call(this); |
| /** @type {gluShaderProgram.ShaderProgram} */ this.m_program = null; |
| this.m_posLoc = 0; |
| this.m_byteVecLoc = 0; |
| /** @type {WebGLVertexArrayObject} */ this.m_vao = null; |
| |
| /** @type {gluShaderUtil.GLSLVersion} */ var glslVersion = gluShaderUtil.getGLSLVersion(gl); |
| |
| assertMsgOptions(gluShaderUtil.isGLSLVersionSupported(gl, glslVersion), 'Unsupported GLSL version', false, true); |
| |
| this.m_program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources( |
| gluShaderUtil.getGLSLVersionDeclaration(glslVersion) + '\n' + |
| 'in highp vec2 a_position;\n' + |
| 'in mediump vec3 a_byteVec;\n' + |
| 'out mediump vec3 v_byteVec;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' gl_Position = vec4(a_position, 0.0, 1.0);\n' + |
| ' v_byteVec = a_byteVec;\n' + |
| '}\n', |
| |
| gluShaderUtil.getGLSLVersionDeclaration(glslVersion) + '\n' + |
| 'in mediump vec3 v_byteVec;\n' + |
| 'layout(location = 0) out mediump vec4 o_color;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' o_color = vec4(v_byteVec, 1.0);\n' + |
| '}\n' |
| )); |
| |
| if (!this.m_program.isOk()) { |
| testFailed('Compile failed'); |
| } |
| |
| this.m_posLoc = gl.getAttribLocation(this.m_program.getProgram(), 'a_position'); |
| this.m_byteVecLoc = gl.getAttribLocation(this.m_program.getProgram(), 'a_byteVec'); |
| |
| this.m_vao = gl.createVertexArray(); |
| this.m_positionBuf = gl.createBuffer(); |
| this.m_indexBuf = gl.createBuffer(); |
| }; |
| |
| glsBufferTestUtil.VertexArrayVerifier.prototype = Object.create(glsBufferTestUtil.BufferVerifierBase.prototype); |
| glsBufferTestUtil.VertexArrayVerifier.prototype.constructor = glsBufferTestUtil.VertexArrayVerifier; |
| |
| /** |
| * @return {number} |
| */ |
| glsBufferTestUtil.VertexArrayVerifier.prototype.getMinSize = function() { return 3 * 4; }; |
| |
| /** |
| * @return {number} |
| */ |
| glsBufferTestUtil.VertexArrayVerifier.prototype.getAlignment = function() { return 1; }; |
| |
| /** |
| * deinit |
| */ |
| glsBufferTestUtil.VertexArrayVerifier.prototype.deinit = function() { |
| if (this.m_vao) gl.deleteVertexArray(this.m_vao); |
| if (this.m_positionBuf) gl.deleteBuffer(this.m_positionBuf); |
| if (this.m_indexBuf) gl.deleteBuffer(this.m_indexBuf); |
| }; |
| |
| /** |
| * @param {number} gridSizeX |
| * @param {number} gridSizeY |
| * @return {Array<number>} |
| */ |
| glsBufferTestUtil.computePositions = function(gridSizeX, gridSizeY) { |
| var positions = []; |
| |
| for (var y = 0; y < gridSizeY; y++) |
| for (var x = 0; x < gridSizeX; x++) { |
| /** @type {number} */ var sx0 = (x + 0) / gridSizeX; |
| /** @type {number} */ var sy0 = (y + 0) / gridSizeY; |
| /** @type {number} */ var sx1 = (x + 1) / gridSizeX; |
| /** @type {number} */ var sy1 = (y + 1) / gridSizeY; |
| /** @type {number} */ var fx0 = 2.0 * sx0 - 1.0; |
| /** @type {number} */ var fy0 = 2.0 * sy0 - 1.0; |
| /** @type {number} */ var fx1 = 2.0 * sx1 - 1.0; |
| /** @type {number} */ var fy1 = 2.0 * sy1 - 1.0; |
| /** @type {number} */ var baseNdx = (y * gridSizeX + x) * 8; |
| |
| positions[baseNdx + 0] = fx0; positions[baseNdx + 1] = fy0; |
| positions[baseNdx + 2] = fx0; positions[baseNdx + 3] = fy1; |
| positions[baseNdx + 4] = fx1; positions[baseNdx + 5] = fy0; |
| positions[baseNdx + 6] = fx1; positions[baseNdx + 7] = fy1; |
| } |
| |
| return positions; |
| }; |
| |
| /** |
| * @param {number} gridSizeX |
| * @param {number} gridSizeY |
| * @return {Uint16Array} |
| */ |
| glsBufferTestUtil.computeIndices = function(gridSizeX, gridSizeY) { |
| var indices = new Uint16Array(3 * 2 * gridSizeX * gridSizeY); |
| |
| for (var quadNdx = 0; quadNdx < gridSizeX * gridSizeY; quadNdx++) { |
| /** @type {number} */ var v00 = quadNdx * 4 + 0; |
| /** @type {number} */ var v01 = quadNdx * 4 + 1; |
| /** @type {number} */ var v10 = quadNdx * 4 + 2; |
| /** @type {number} */ var v11 = quadNdx * 4 + 3; |
| |
| assertMsgOptions(v11 < (1 << 16), 'Vertex index value won\'t fit into a 16-bit number', false, true); |
| |
| indices[quadNdx * 6 + 0] = v10; |
| indices[quadNdx * 6 + 1] = v00; |
| indices[quadNdx * 6 + 2] = v01; |
| |
| indices[quadNdx * 6 + 3] = v10; |
| indices[quadNdx * 6 + 4] = v01; |
| indices[quadNdx * 6 + 5] = v11; |
| } |
| |
| return indices; |
| }; |
| |
| /** |
| * @param {Uint8Array} ptr |
| * @param {number} vtxNdx |
| * @return {Array<number>} |
| */ |
| glsBufferTestUtil.fetchVtxColor = function(ptr, vtxNdx) { |
| return new tcuRGBA.RGBA([ |
| ptr[vtxNdx * 3 + 0], |
| ptr[vtxNdx * 3 + 1], |
| ptr[vtxNdx * 3 + 2], |
| 255]).toVec(); |
| }; |
| |
| /** |
| * @param {tcuSurface.Surface} dst |
| * @param {number} numQuads |
| * @param {number} rowLength |
| * @param {Uint8Array} inPtr |
| */ |
| glsBufferTestUtil.renderQuadGridReference = function(dst, numQuads, rowLength, inPtr) { |
| dst.setSize(rowLength * glsBufferTestUtil.VERIFY_QUAD_SIZE, (Math.floor(numQuads / rowLength) + (numQuads % rowLength != 0 ? 1 : 0)) * glsBufferTestUtil.VERIFY_QUAD_SIZE); |
| |
| /** @type {tcuTexture.PixelBufferAccess} */ var dstAccess = dst.getAccess(); |
| dstAccess.clear([0, 0, 0, 1.0]); |
| |
| for (var quadNdx = 0; quadNdx < numQuads; quadNdx++) { |
| /** @type {number} */ var x0 = (quadNdx % rowLength) * glsBufferTestUtil.VERIFY_QUAD_SIZE; |
| /** @type {number} */ var y0 = Math.floor(quadNdx / rowLength) * glsBufferTestUtil.VERIFY_QUAD_SIZE; |
| /** @type {Array<number>} */ var v00 = glsBufferTestUtil.fetchVtxColor(inPtr, quadNdx * 4 + 0); |
| /** @type {Array<number>} */ var v10 = glsBufferTestUtil.fetchVtxColor(inPtr, quadNdx * 4 + 1); |
| /** @type {Array<number>} */ var v01 = glsBufferTestUtil.fetchVtxColor(inPtr, quadNdx * 4 + 2); |
| /** @type {Array<number>} */ var v11 = glsBufferTestUtil.fetchVtxColor(inPtr, quadNdx * 4 + 3); |
| |
| for (var y = 0; y < glsBufferTestUtil.VERIFY_QUAD_SIZE; y++) |
| for (var x = 0; x < glsBufferTestUtil.VERIFY_QUAD_SIZE; x++) { |
| /** @type {number} */ var fx = (x + 0.5) / glsBufferTestUtil.VERIFY_QUAD_SIZE; |
| /** @type {number} */ var fy = (y + 0.5) / glsBufferTestUtil.VERIFY_QUAD_SIZE; |
| |
| /** @type {boolean} */ var tri = fx + fy <= 1.0; |
| /** @type {number} */ var tx = tri ? fx : (1.0 - fx); |
| /** @type {number} */ var ty = tri ? fy : (1.0 - fy); |
| /** @type {Array<number>} */ var t0 = tri ? v00 : v11; |
| /** @type {Array<number>} */ var t1 = tri ? v01 : v10; |
| /** @type {Array<number>} */ var t2 = tri ? v10 : v01; |
| /** @type {Array<number>} */ var color = deMath.add( |
| deMath.add(t0, deMath.scale(deMath.subtract(t1, t0), tx)), |
| deMath.scale(deMath.subtract(t2, t0), ty) |
| ); |
| |
| dstAccess.setPixel(color, x0 + x, y0 + y); |
| } |
| } |
| }; |
| |
| /** |
| * @param {WebGLBuffer} buffer |
| * @param {Uint8Array} refPtr |
| * @param {number} offset |
| * @param {number} numBytes |
| * @return {boolean} |
| */ |
| glsBufferTestUtil.VertexArrayVerifier.prototype.verifyNoTarget = function(buffer, refPtr, offset, numBytes) { |
| var numBytesInVtx = 3; |
| var numBytesInQuad = numBytesInVtx * 4; |
| var maxQuadsX = Math.min(128, Math.floor(gl.drawingBufferWidth / glsBufferTestUtil.VERIFY_QUAD_SIZE)); |
| var maxQuadsY = Math.min(128, Math.floor(gl.drawingBufferHeight / glsBufferTestUtil.VERIFY_QUAD_SIZE)); |
| var maxQuadsPerBatch = maxQuadsX * maxQuadsY; |
| var numVerified = 0; |
| var program = this.m_program.getProgram(); |
| /** @type {tcuRGBA.RGBA} */ var threshold = /*TODO: renderTarget.getPixelFormat().getColorThreshold() + tcu::RGBA(3,3,3,3);*/ new tcuRGBA.RGBA([3, 3, 3, 3]); |
| var isOk = true; |
| |
| /** @type {Array<number>} */ var positions = []; |
| /** @type {Uint16Array} */var indices; |
| |
| /** @type {tcuSurface.Surface} */ var rendered = new tcuSurface.Surface(); |
| /** @type {tcuSurface.Surface} */ var reference = new tcuSurface.Surface(); |
| |
| // Can't render full quad with smaller buffers. |
| assertMsgOptions(numBytes >= numBytesInQuad, 'Number of bytes must be bigger than number of bytes per quad', false, true); |
| |
| positions = glsBufferTestUtil.computePositions(maxQuadsX, maxQuadsY); |
| indices = glsBufferTestUtil.computeIndices(maxQuadsX, maxQuadsY); |
| |
| // Reset buffer bindings. |
| gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null); |
| |
| // Setup rendering state. |
| gl.viewport(0, 0, maxQuadsX * glsBufferTestUtil.VERIFY_QUAD_SIZE, maxQuadsY * glsBufferTestUtil.VERIFY_QUAD_SIZE); |
| gl.clearColor(0.0, 0.0, 0.0, 1.0); |
| gl.useProgram(program); |
| gl.bindVertexArray(this.m_vao); |
| |
| // Upload positions |
| gl.bindBuffer(gl.ARRAY_BUFFER, this.m_positionBuf); |
| gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STATIC_DRAW); |
| gl.enableVertexAttribArray(this.m_posLoc); |
| gl.vertexAttribPointer(this.m_posLoc, 2, gl.FLOAT, false, 0, 0); |
| |
| // Upload indices |
| gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.m_indexBuf); |
| gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW); |
| |
| gl.enableVertexAttribArray(this.m_byteVecLoc); |
| |
| gl.bindBuffer(gl.ARRAY_BUFFER, buffer); |
| |
| while (numVerified < numBytes) { |
| /** @type {number} */ var numRemaining = numBytes - numVerified; |
| var isLeftoverBatch = numRemaining < numBytesInQuad; |
| /** @type {number} */ var numBytesToVerify = isLeftoverBatch ? numBytesInQuad : Math.min(maxQuadsPerBatch * numBytesInQuad, numRemaining - numRemaining % numBytesInQuad); |
| /** @type {number} */ var curOffset = isLeftoverBatch ? (numBytes - numBytesInQuad) : numVerified; |
| /** @type {number} */ var numQuads = Math.floor(numBytesToVerify / numBytesInQuad); |
| /** @type {number} */ var numCols = Math.min(maxQuadsX, numQuads); |
| /** @type {number} */ var numRows = Math.floor(numQuads / maxQuadsX) + (numQuads % maxQuadsX != 0 ? 1 : 0); |
| /** @type {string} */ var imageSetDesc = 'Bytes ' + (offset + curOffset) + ' to ' + (offset + curOffset + numBytesToVerify - 1); |
| |
| assertMsgOptions(numBytesToVerify > 0 && numBytesToVerify % numBytesInQuad == 0, 'Bytes to verify must be greater than zero and must be a multiple of the bytes per quad', false, true); |
| assertMsgOptions(deMath.deInBounds32(curOffset, 0, numBytes), 'Offset out of bounds', false, true); |
| assertMsgOptions(deMath.deInRange32(curOffset + numBytesToVerify, curOffset, numBytes), 'Range of bytes to verify outside of bounds', false, true); |
| |
| // Render batch. |
| gl.clear(gl.COLOR_BUFFER_BIT); |
| gl.vertexAttribPointer(this.m_byteVecLoc, 3, gl.UNSIGNED_BYTE, true, 0, offset + curOffset); |
| gl.drawElements(gl.TRIANGLES, numQuads * 6, gl.UNSIGNED_SHORT, 0); |
| |
| glsBufferTestUtil.renderQuadGridReference(reference, numQuads, numCols, refPtr.subarray(offset + curOffset)); |
| |
| rendered.setSize(numCols * glsBufferTestUtil.VERIFY_QUAD_SIZE, numRows * glsBufferTestUtil.VERIFY_QUAD_SIZE); |
| rendered.readViewport(gl, [0, 0, numCols * glsBufferTestUtil.VERIFY_QUAD_SIZE, numRows * glsBufferTestUtil.VERIFY_QUAD_SIZE]); |
| |
| if (!tcuImageCompare.pixelThresholdCompare('RenderResult', imageSetDesc, reference, rendered, threshold.toIVec(), tcuImageCompare.CompareLogMode.RESULT)) { |
| isOk = false; |
| break; |
| } |
| |
| numVerified += isLeftoverBatch ? numRemaining : numBytesToVerify; |
| } |
| |
| gl.bindVertexArray(null); |
| |
| return isOk; |
| }; |
| |
| // IndexArrayVerifier |
| |
| /** |
| * @constructor |
| * @extends {glsBufferTestUtil.BufferVerifierBase} |
| */ |
| glsBufferTestUtil.IndexArrayVerifier = function() { |
| glsBufferTestUtil.BufferVerifierBase.call(this); |
| |
| this.m_program = null; |
| this.m_posLoc = 0; |
| this.m_colorLoc = 0; |
| |
| /** @type {gluShaderUtil.GLSLVersion} */ var glslVersion = gluShaderUtil.GLSLVersion.V300_ES; |
| |
| assertMsgOptions(gluShaderUtil.isGLSLVersionSupported(gl, glslVersion), 'GLSL version not supported', false, true); |
| |
| this.m_program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources( |
| gluShaderUtil.getGLSLVersionDeclaration(glslVersion) + '\n' + |
| 'in highp vec2 a_position;\n' + |
| 'in mediump vec3 a_color;\n' + |
| 'out mediump vec3 v_color;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' gl_Position = vec4(a_position, 0.0, 1.0);\n' + |
| ' v_color = a_color;\n' + |
| '}\n', |
| |
| gluShaderUtil.getGLSLVersionDeclaration(glslVersion) + '\n' + |
| 'in mediump vec3 v_color;\n' + |
| 'layout(location = 0) out mediump vec4 o_color;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' o_color = vec4(v_color, 1.0);\n' + |
| '}\n')); |
| |
| if (!this.m_program.isOk()) { |
| testFailed('Compile failed'); |
| } |
| |
| this.m_posLoc = gl.getAttribLocation(this.m_program.getProgram(), 'a_position'); |
| this.m_colorLoc = gl.getAttribLocation(this.m_program.getProgram(), 'a_color'); |
| |
| this.m_vao = gl.createVertexArray(); |
| this.m_positionBuf = gl.createBuffer(); |
| this.m_colorBuf = gl.createBuffer(); |
| }; |
| |
| glsBufferTestUtil.IndexArrayVerifier.prototype = Object.create(glsBufferTestUtil.BufferVerifierBase.prototype); |
| glsBufferTestUtil.IndexArrayVerifier.prototype.constructor = glsBufferTestUtil.IndexArrayVerifier; |
| |
| /** |
| * deinit |
| */ |
| glsBufferTestUtil.IndexArrayVerifier.prototype.deinit = function() { |
| if (this.m_vao) gl.deleteVertexArray(this.m_vao); |
| if (this.m_positionBuf) gl.deleteBuffer(this.m_positionBuf); |
| if (this.m_colorBuf) gl.deleteBuffer(this.m_colorBuf); |
| }; |
| |
| /** |
| * @return {Array<number>} |
| */ |
| glsBufferTestUtil.computeIndexVerifierPositions = function() { |
| var numPosX = 16; |
| var numPosY = 16; |
| |
| var dst = []; |
| |
| for (var y = 0; y < numPosY; y++) { |
| for (var x = 0; x < numPosX; x++) { |
| var xf = x / (numPosX - 1); |
| var yf = y / (numPosY - 1); |
| |
| var offset = 2 * (y * numPosX + x); |
| dst[offset] = 2.0 * xf - 1.0; |
| dst[offset + 1] = 2.0 * yf - 1.0; |
| } |
| } |
| |
| return dst; |
| }; |
| |
| /** |
| * @return {Array<number>} |
| */ |
| glsBufferTestUtil.computeIndexVerifierColors = function() { |
| /** @type {number} */ var numColors = 256; |
| /** @type {number} */ var minVal = 0.1; |
| /** @type {number} */ var maxVal = 0.5; |
| var rnd = new deRandom.Random(0xabc231); |
| |
| var dst = []; |
| |
| for (var i = 0; i < numColors; ++i) { |
| dst[3 * i] = rnd.getFloat(minVal, maxVal); |
| dst[3 * i + 1] = rnd.getFloat(minVal, maxVal); |
| dst[3 * i + 2] = rnd.getFloat(minVal, maxVal); |
| } |
| |
| return dst; |
| }; |
| |
| /** |
| * @param {Array<number>} dst |
| * @param {Array<number>} src |
| * @param {Uint8Array} indices |
| * @param {number} numIndices |
| */ |
| glsBufferTestUtil.execVertexFetch = function(dst, src, indices, numIndices) { |
| for (var i = 0; i < numIndices; ++i) |
| dst[i] = src[indices[i]]; |
| }; |
| |
| /** |
| * @param {WebGLBuffer} buffer |
| * @param {Uint8Array} refPtr |
| * @param {number} offset |
| * @param {number} numBytes |
| * @return {boolean} |
| */ |
| glsBufferTestUtil.IndexArrayVerifier.prototype.verify = function(buffer, refPtr, offset, numBytes) { |
| var viewportW = Math.min(glsBufferTestUtil.INDEX_ARRAY_DRAW_VIEWPORT_WIDTH, gl.drawingBufferWidth); |
| var viewportH = Math.min(glsBufferTestUtil.INDEX_ARRAY_DRAW_VIEWPORT_HEIGHT, gl.drawingBufferHeight); |
| var minBytesPerBatch = 2; |
| /** @type {tcuRGBA.RGBA} */ var threshold = new tcuRGBA.RGBA([0, 0, 0, 0]); |
| |
| var positions = []; |
| var colors = []; |
| |
| var fetchedPos = []; |
| var fetchedColor = []; |
| |
| /** @type {tcuSurface.Surface} */ var indexBufferImg = new tcuSurface.Surface(viewportW, viewportH); |
| /** @type {tcuSurface.Surface} */ var referenceImg = new tcuSurface.Surface(viewportW, viewportH); |
| |
| var numVerified = 0; |
| var isOk = true; |
| |
| positions = glsBufferTestUtil.computeIndexVerifierPositions(); |
| colors = glsBufferTestUtil.computeIndexVerifierColors(); |
| |
| // Reset buffer bindings. |
| gl.bindVertexArray(this.m_vao); |
| gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null); |
| gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer); |
| |
| // Setup rendering state. |
| gl.viewport(0, 0, viewportW, viewportH); |
| gl.clearColor(0.0, 0.0, 0.0, 1.0); |
| gl.useProgram(this.m_program.getProgram()); |
| gl.enableVertexAttribArray(this.m_posLoc); |
| gl.enableVertexAttribArray(this.m_colorLoc); |
| gl.enable(gl.BLEND); |
| gl.blendFunc(gl.ONE, gl.ONE); |
| gl.blendEquation(gl.FUNC_ADD); |
| |
| while (numVerified < numBytes) { |
| var numRemaining = numBytes - numVerified; |
| var isLeftoverBatch = numRemaining < minBytesPerBatch; |
| var numBytesToVerify = isLeftoverBatch ? minBytesPerBatch : Math.min(glsBufferTestUtil.MAX_LINES_PER_INDEX_ARRAY_DRAW + 1, numRemaining); |
| var curOffset = isLeftoverBatch ? (numBytes - minBytesPerBatch) : numVerified; |
| /** @type {string} */ var imageSetDesc = 'Bytes ' + (offset + curOffset) + ' to ' + (offset + curOffset + numBytesToVerify - 1); |
| |
| // Step 1: Render using index buffer. |
| gl.clear(gl.COLOR_BUFFER_BIT); |
| |
| gl.bindBuffer(gl.ARRAY_BUFFER, this.m_positionBuf); |
| gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STREAM_DRAW); |
| gl.vertexAttribPointer(this.m_posLoc, 2, gl.FLOAT, false, 0, 0); |
| |
| gl.bindBuffer(gl.ARRAY_BUFFER, this.m_colorBuf); |
| gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(colors), gl.STREAM_DRAW); |
| gl.vertexAttribPointer(this.m_colorLoc, 3, gl.FLOAT, false, 0, 0); |
| |
| gl.drawElements(gl.LINE_STRIP, numBytesToVerify, gl.UNSIGNED_BYTE, offset + curOffset); |
| indexBufferImg.readViewport(gl); |
| |
| // Step 2: Do manual fetch and render without index buffer. |
| glsBufferTestUtil.execVertexFetch(fetchedPos, positions, refPtr.subarray(offset + curOffset), numBytesToVerify); |
| glsBufferTestUtil.execVertexFetch(fetchedColor, colors, refPtr.subarray(offset + curOffset), numBytesToVerify); |
| |
| gl.clear(gl.COLOR_BUFFER_BIT); |
| |
| gl.bindBuffer(gl.ARRAY_BUFFER, this.m_positionBuf); |
| gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(fetchedPos), gl.STREAM_DRAW); |
| gl.vertexAttribPointer(this.m_posLoc, 2, gl.FLOAT, false, 0, 0); |
| |
| gl.bindBuffer(gl.ARRAY_BUFFER, this.m_colorBuf); |
| gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(fetchedColor), gl.STREAM_DRAW); |
| gl.vertexAttribPointer(this.m_colorLoc, 3, gl.FLOAT, false, 0, 0); |
| |
| gl.drawArrays(gl.LINE_STRIP, 0, numBytesToVerify); |
| referenceImg.readViewport(gl, [0, 0, viewportW, viewportH]); |
| |
| if (!tcuImageCompare.pixelThresholdCompare('RenderResult', imageSetDesc, referenceImg, indexBufferImg, threshold.toIVec(), tcuImageCompare.CompareLogMode.RESULT)) { |
| isOk = false; |
| break; |
| } |
| |
| numVerified += isLeftoverBatch ? numRemaining : numBytesToVerify; |
| } |
| |
| gl.bindVertexArray(null); |
| |
| return isOk; |
| }; |
| |
| }); |
