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('framework.opengl.simplereference.sglrReferenceContextTest');
goog.require('framework.common.tcuLogImage');
goog.require('framework.common.tcuPixelFormat');
goog.require('framework.common.tcuRGBA');
goog.require('framework.common.tcuSurface');
goog.require('framework.common.tcuTestCase');
goog.require('framework.opengl.gluDrawUtil');
goog.require('framework.opengl.simplereference.sglrReferenceContext');
goog.require('framework.opengl.simplereference.sglrShaderProgram');
goog.require('framework.referencerenderer.rrFragmentOperations');
goog.require('framework.referencerenderer.rrGenericVector');
goog.require('framework.referencerenderer.rrShadingContext');
goog.require('framework.referencerenderer.rrVertexAttrib');
goog.require('framework.referencerenderer.rrVertexPacket');
goog.scope(function() {
var sglrReferenceContextTest = framework.opengl.simplereference.sglrReferenceContextTest;
var sglrReferenceContext = framework.opengl.simplereference.sglrReferenceContext;
var tcuTestCase = framework.common.tcuTestCase;
var tcuPixelFormat = framework.common.tcuPixelFormat;
var gluDrawUtil = framework.opengl.gluDrawUtil;
var tcuSurface = framework.common.tcuSurface;
var tcuLogImage = framework.common.tcuLogImage;
var sglrShaderProgram = framework.opengl.simplereference.sglrShaderProgram;
var rrGenericVector = framework.referencerenderer.rrGenericVector;
var rrVertexAttrib = framework.referencerenderer.rrVertexAttrib;
var rrShadingContext = framework.referencerenderer.rrShadingContext;
var rrVertexPacket = framework.referencerenderer.rrVertexPacket;
var rrFragmentOperations = framework.referencerenderer.rrFragmentOperations;
var tcuRGBA = framework.common.tcuRGBA;
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} description
*/
sglrReferenceContextTest.ClearContext = function(name, description) {
tcuTestCase.DeqpTest.call(this, name, description);
};
sglrReferenceContextTest.ClearContext.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
sglrReferenceContextTest.ClearContext.prototype.constructor = sglrReferenceContextTest.ClearContext;
sglrReferenceContextTest.ClearContext.prototype.init = function() {};
sglrReferenceContextTest.ClearContext.prototype.iterate = function() {
var width = 200;
var height = 188;
var samples = 1;
var limits = new sglrReferenceContext.ReferenceContextLimits(gl);
var format = new tcuPixelFormat.PixelFormat(8, 8, 8, 8);
var buffers = new sglrReferenceContext.ReferenceContextBuffers(format, 24, 8, width, height, samples);
var ctx = new sglrReferenceContext.ReferenceContext(limits, buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer());
ctx.clearColor(1, 0, 0, 1);
ctx.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
var pixels = new tcuSurface.Surface(width, height);
ctx.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels.getAccess().getDataPtr());
var numFailedPixels = 0;
var redPixel = new gluDrawUtil.Pixel([255, 0, 0, 255]);
for (var x = 0; x < width; x++)
for (var y = 0; y < height; y++) {
var pixel = new gluDrawUtil.Pixel(pixels.getPixel(x, y));
if (!pixel.equals(redPixel))
numFailedPixels += 1;
}
var access = pixels.getAccess();
tcuLogImage.logImage('Result', '', access);
if (numFailedPixels > 0)
testFailedOptions('Image comparison failed, got ' + numFailedPixels + ' non-equal pixels.', false);
else
testPassedOptions('Image comparison succeed', true);
ctx.scissor(width / 4, height / 4, width / 2, height / 2);
ctx.enable(gl.SCISSOR_TEST);
ctx.clearColor(0, 1, 1, 1);
ctx.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
ctx.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels.getAccess().getDataPtr());
numFailedPixels = 0;
var greenBluePixel = new gluDrawUtil.Pixel([0, 255, 255, 255]);
for (var x = 0; x < width; x++)
for (var y = 0; y < height; y++) {
var pixel = new gluDrawUtil.Pixel(pixels.getPixel(x, y));
if ((x >= width / 4 && x < width - width / 4) && (y >= height / 4 && y < height - height / 4)) {
if (!pixel.equals(greenBluePixel))
numFailedPixels += 1;
} else
if (!pixel.equals(redPixel))
numFailedPixels += 1;
}
access = pixels.getAccess();
tcuLogImage.logImage('Result', '', access);
if (numFailedPixels > 0)
testFailedOptions('Image comparison failed, got ' + numFailedPixels + ' non-equal pixels.', false);
else
testPassedOptions('Image comparison succeed', true);
return tcuTestCase.IterateResult.STOP;
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} description
*/
sglrReferenceContextTest.Framebuffer = function(name, description) {
tcuTestCase.DeqpTest.call(this, name, description);
};
sglrReferenceContextTest.Framebuffer.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
sglrReferenceContextTest.Framebuffer.prototype.constructor = sglrReferenceContextTest.Framebuffer;
sglrReferenceContextTest.Framebuffer.prototype.init = function() {};
sglrReferenceContextTest.Framebuffer.prototype.iterate = function() {
var limits = new sglrReferenceContext.ReferenceContextLimits(gl);
var format = new tcuPixelFormat.PixelFormat(8, 8, 8, 8);
var width = 200;
var height = 188;
var samples = 1;
var buffers = new sglrReferenceContext.ReferenceContextBuffers(format, 24, 8, width, height, samples);
var ctx = new sglrReferenceContext.ReferenceContext(limits, buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer());
ctx.clearColor(0, 0, 1, 1);
ctx.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
var fbo = ctx.createFramebuffer();
var rbo = ctx.createRenderbuffer();
ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo);
ctx.bindRenderbuffer(gl.RENDERBUFFER, rbo);
ctx.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA8, width, height);
ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo);
bufferedLogToConsole('Framebuffer status: ' + (ctx.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_COMPLETE));
ctx.clearColor(1, 0, 0, 1);
ctx.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
var pixels = new tcuSurface.Surface(width, height);
ctx.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels.getAccess().getDataPtr());
var numFailedPixels = 0;
var redPixel = new gluDrawUtil.Pixel([255, 0, 0, 255]);
for (var x = 0; x < width; x++)
for (var y = 0; y < height; y++) {
var pixel = new gluDrawUtil.Pixel(pixels.getPixel(x, y));
if (!pixel.equals(redPixel))
numFailedPixels += 1;
}
var access = pixels.getAccess();
tcuLogImage.logImage('Result', '', access);
if (numFailedPixels > 0)
testFailedOptions('Image comparison failed, got ' + numFailedPixels + ' non-equal pixels.', false);
else
testPassedOptions('Image comparison succeed', true);
ctx.scissor(width / 4, height / 4, width / 2, height / 2);
ctx.enable(gl.SCISSOR_TEST);
ctx.clearColor(0, 1, 1, 1);
ctx.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
ctx.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels.getAccess().getDataPtr());
numFailedPixels = 0;
var greenBluePixel = new gluDrawUtil.Pixel([0, 255, 255, 255]);
for (var x = 0; x < width; x++)
for (var y = 0; y < height; y++) {
var pixel = new gluDrawUtil.Pixel(pixels.getPixel(x, y));
if ((x >= width / 4 && x < width - width / 4) && (y >= height / 4 && y < height - height / 4)) {
if (!pixel.equals(greenBluePixel))
numFailedPixels += 1;
} else
if (!pixel.equals(redPixel))
numFailedPixels += 1;
}
access = pixels.getAccess();
tcuLogImage.logImage('Result', '', access);
if (numFailedPixels > 0)
testFailedOptions('Image comparison failed, got ' + numFailedPixels + ' non-equal pixels.', false);
else
testPassedOptions('Image comparison succeed', true);
ctx.bindFramebuffer(gl.FRAMEBUFFER, null);
ctx.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels.getAccess().getDataPtr());
var bluePixel = new gluDrawUtil.Pixel([0, 0, 255, 255]);
for (var x = 0; x < width; x++)
for (var y = 0; y < height; y++) {
var pixel = new gluDrawUtil.Pixel(pixels.getPixel(x, y));
if (!pixel.equals(bluePixel))
numFailedPixels += 1;
}
access = pixels.getAccess();
tcuLogImage.logImage('Result', '', access);
if (numFailedPixels > 0)
testFailedOptions('Image comparison failed, got ' + numFailedPixels + ' non-equal pixels.', false);
else
testPassedOptions('Image comparison succeed', true);
return tcuTestCase.IterateResult.STOP;
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} description
*/
sglrReferenceContextTest.Shader = function(name, description) {
tcuTestCase.DeqpTest.call(this, name, description);
};
sglrReferenceContextTest.Shader.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
sglrReferenceContextTest.Shader.prototype.constructor = sglrReferenceContextTest.Shader;
sglrReferenceContextTest.Shader.prototype.init = function() {};
sglrReferenceContextTest.Shader.prototype.iterate = function() {
var limits = new sglrReferenceContext.ReferenceContextLimits(gl);
var format = new tcuPixelFormat.PixelFormat(8, 8, 8, 8);
var width = 200;
var height = 188;
var samples = 1;
var buffers = new sglrReferenceContext.ReferenceContextBuffers(format, 24, 8, width, height, samples);
var ctx = new sglrReferenceContext.ReferenceContext(limits, buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer());
ctx.clearColor(0, 0, 1, 1);
ctx.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
var vertices = [
-0.5, 0.5,
0.5, 0.5,
-0.5, -0.5,
0.5, 0.5,
0.5, -0.5,
-0.5, -0.5
];
var vertices32 = new Float32Array(vertices);
var squareVerticesBuffer = ctx.createBuffer();
ctx.bindBuffer(gl.ARRAY_BUFFER, squareVerticesBuffer);
ctx.bufferData(gl.ARRAY_BUFFER, vertices32, gl.STATIC_DRAW);
var colors = [
1, 0, 0, 1,
1, 0, 0, 1,
1, 0, 0, 1,
1, 0, 0, 1,
1, 0, 0, 1,
1, 0, 0, 1
];
var colors32 = new Float32Array(colors);
var squareColorsBuffer = ctx.createBuffer();
ctx.bindBuffer(gl.ARRAY_BUFFER, squareColorsBuffer);
ctx.bufferData(gl.ARRAY_BUFFER, colors32, gl.STATIC_DRAW);
/** @type {sglrShaderProgram.ShaderProgramDeclaration} */ var progDecl = new sglrShaderProgram.ShaderProgramDeclaration();
progDecl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('aVertexPosition', rrGenericVector.GenericVecType.FLOAT));
progDecl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('aVertexColor', rrGenericVector.GenericVecType.FLOAT));
progDecl.pushVertexSource(new sglrShaderProgram.VertexSource(''));
progDecl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(rrGenericVector.GenericVecType.FLOAT));
progDecl.pushFragmentSource(new sglrShaderProgram.FragmentSource(''));
/** @type {sglrReferenceContextTest.ContextShaderProgram} */ var program = new sglrReferenceContextTest.ContextShaderProgram(progDecl);
//Create program
ctx.createProgram(program);
//Use program
ctx.useProgram(program);
var vertexPositionAttribute = ctx.getAttribLocation(program, 'aVertexPosition');
var vertexColorAttribute = ctx.getAttribLocation(program, 'aVertexColor');
ctx.enableVertexAttribArray(vertexPositionAttribute);
ctx.enableVertexAttribArray(vertexColorAttribute);
ctx.bindBuffer(gl.ARRAY_BUFFER, squareVerticesBuffer);
ctx.vertexAttribPointer(vertexPositionAttribute, 2, gl.FLOAT, false, 0, 0);
ctx.bindBuffer(gl.ARRAY_BUFFER, squareColorsBuffer);
ctx.vertexAttribPointer(vertexColorAttribute, 4, gl.FLOAT, false, 0, 0);
ctx.drawQuads(gl.TRIANGLES, 0, 6);
var pixels = new tcuSurface.Surface(width, height);
ctx.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels.getAccess().getDataPtr());
var numFailedPixels = 0;
var redPixel = new gluDrawUtil.Pixel([255, 0, 0, 255]);
var bluePixel = new gluDrawUtil.Pixel([0, 0, 255, 255]);
var pixel = new gluDrawUtil.Pixel(pixels.getPixel(0, 0));
if (!pixel.equals(bluePixel))
numFailedPixels += 1;
pixel = new gluDrawUtil.Pixel(pixels.getPixel(100, 94));
if (!pixel.equals(redPixel))
numFailedPixels += 1;
var access = pixels.getAccess();
tcuLogImage.logImage('Result', '', access);
if (numFailedPixels > 0)
testFailedOptions('Image comparison failed, got ' + numFailedPixels + ' non-equal pixels.', false);
else
testPassedOptions('Image comparison succeed', true);
return tcuTestCase.IterateResult.STOP;
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} description
*/
sglrReferenceContextTest.TriangleStrip = function(name, description) {
tcuTestCase.DeqpTest.call(this, name, description);
};
sglrReferenceContextTest.TriangleStrip.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
sglrReferenceContextTest.TriangleStrip.prototype.constructor = sglrReferenceContextTest.TriangleStrip;
sglrReferenceContextTest.TriangleStrip.prototype.init = function() {};
sglrReferenceContextTest.TriangleStrip.prototype.iterate = function() {
var limits = new sglrReferenceContext.ReferenceContextLimits(gl);
var format = new tcuPixelFormat.PixelFormat(8, 8, 8, 8);
var width = 200;
var height = 188;
var samples = 1;
var buffers = new sglrReferenceContext.ReferenceContextBuffers(format, 24, 8, width, height, samples);
var ctx = new sglrReferenceContext.ReferenceContext(limits, buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer());
ctx.clearColor(0, 0, 1, 1);
ctx.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
var vertices = [
-0.5, 0.5,
0.5, 0.5,
-0.5, 0,
0.5, 0,
-0.5, -0.5,
0.5, -0.5
];
var vertices32 = new Float32Array(vertices);
var squareVerticesBuffer = ctx.createBuffer();
ctx.bindBuffer(gl.ARRAY_BUFFER, squareVerticesBuffer);
ctx.bufferData(gl.ARRAY_BUFFER, vertices32, gl.STATIC_DRAW);
var colors = [
1, 0, 0, 1,
1, 0, 0, 1,
1, 0, 0, 1,
1, 0, 0, 1,
1, 0, 0, 1,
1, 0, 0, 1
];
var colors32 = new Float32Array(colors);
var squareColorsBuffer = ctx.createBuffer();
ctx.bindBuffer(gl.ARRAY_BUFFER, squareColorsBuffer);
ctx.bufferData(gl.ARRAY_BUFFER, colors32, gl.STATIC_DRAW);
/** @type {sglrShaderProgram.ShaderProgramDeclaration} */ var progDecl = new sglrShaderProgram.ShaderProgramDeclaration();
progDecl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('aVertexPosition', rrGenericVector.GenericVecType.FLOAT));
progDecl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('aVertexColor', rrGenericVector.GenericVecType.FLOAT));
progDecl.pushVertexSource(new sglrShaderProgram.VertexSource(''));
progDecl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(rrGenericVector.GenericVecType.FLOAT));
progDecl.pushFragmentSource(new sglrShaderProgram.FragmentSource(''));
/** @type {sglrReferenceContextTest.ContextShaderProgram} */ var program = new sglrReferenceContextTest.ContextShaderProgram(progDecl);
//Create program
ctx.createProgram(program);
//Use program
ctx.useProgram(program);
var vertexPositionAttribute = ctx.getAttribLocation(program, 'aVertexPosition');
var vertexColorAttribute = ctx.getAttribLocation(program, 'aVertexColor');
ctx.enableVertexAttribArray(vertexPositionAttribute);
ctx.enableVertexAttribArray(vertexColorAttribute);
ctx.bindBuffer(gl.ARRAY_BUFFER, squareVerticesBuffer);
ctx.vertexAttribPointer(vertexPositionAttribute, 2, gl.FLOAT, false, 0, 0);
ctx.bindBuffer(gl.ARRAY_BUFFER, squareColorsBuffer);
ctx.vertexAttribPointer(vertexColorAttribute, 4, gl.FLOAT, false, 0, 0);
ctx.drawQuads(gl.TRIANGLE_STRIP, 0, 6);
var pixels = new tcuSurface.Surface(width, height);
ctx.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels.getAccess().getDataPtr());
var numFailedPixels = 0;
var redPixel = new gluDrawUtil.Pixel([255, 0, 0, 255]);
var bluePixel = new gluDrawUtil.Pixel([0, 0, 255, 255]);
var pixel = new gluDrawUtil.Pixel(pixels.getPixel(0, 0));
if (!pixel.equals(bluePixel))
numFailedPixels += 1;
pixel = new gluDrawUtil.Pixel(pixels.getPixel(100, 94));
if (!pixel.equals(redPixel))
numFailedPixels += 1;
var access = pixels.getAccess();
tcuLogImage.logImage('Result', '', access);
if (numFailedPixels > 0)
testFailedOptions('Image comparison failed, got ' + numFailedPixels + ' non-equal pixels.', false);
else
testPassedOptions('Image comparison succeed', true);
return tcuTestCase.IterateResult.STOP;
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} description
*/
sglrReferenceContextTest.TriangleFan = function(name, description) {
tcuTestCase.DeqpTest.call(this, name, description);
};
sglrReferenceContextTest.TriangleFan.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
sglrReferenceContextTest.TriangleFan.prototype.constructor = sglrReferenceContextTest.TriangleFan;
sglrReferenceContextTest.TriangleFan.prototype.init = function() {};
sglrReferenceContextTest.TriangleFan.prototype.iterate = function() {
var limits = new sglrReferenceContext.ReferenceContextLimits(gl);
var format = new tcuPixelFormat.PixelFormat(8, 8, 8, 8);
var width = 200;
var height = 188;
var samples = 1;
var buffers = new sglrReferenceContext.ReferenceContextBuffers(format, 24, 8, width, height, samples);
var ctx = new sglrReferenceContext.ReferenceContext(limits, buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer());
ctx.clearColor(0, 0, 1, 1);
ctx.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
var vertices = [
-0.5, 0,
-0.5, 0.5,
0.5, 0.5,
0.5, 0,
0.5, -0.5,
-0.5, -0.5
];
var vertices32 = new Float32Array(vertices);
var squareVerticesBuffer = ctx.createBuffer();
ctx.bindBuffer(gl.ARRAY_BUFFER, squareVerticesBuffer);
ctx.bufferData(gl.ARRAY_BUFFER, vertices32, gl.STATIC_DRAW);
var colors = [
1, 0, 0, 1,
1, 0, 0, 1,
1, 0, 0, 1,
1, 0, 0, 1,
1, 0, 0, 1,
1, 0, 0, 1
];
var colors32 = new Float32Array(colors);
var squareColorsBuffer = ctx.createBuffer();
ctx.bindBuffer(gl.ARRAY_BUFFER, squareColorsBuffer);
ctx.bufferData(gl.ARRAY_BUFFER, colors32, gl.STATIC_DRAW);
/** @type {sglrShaderProgram.ShaderProgramDeclaration} */ var progDecl = new sglrShaderProgram.ShaderProgramDeclaration();
progDecl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('aVertexPosition', rrGenericVector.GenericVecType.FLOAT));
progDecl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('aVertexColor', rrGenericVector.GenericVecType.FLOAT));
progDecl.pushVertexSource(new sglrShaderProgram.VertexSource(''));
progDecl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(rrGenericVector.GenericVecType.FLOAT));
progDecl.pushFragmentSource(new sglrShaderProgram.FragmentSource(''));
/** @type {sglrReferenceContextTest.ContextShaderProgram} */ var program = new sglrReferenceContextTest.ContextShaderProgram(progDecl);
//Create program
ctx.createProgram(program);
//Use program
ctx.useProgram(program);
var vertexPositionAttribute = ctx.getAttribLocation(program, 'aVertexPosition');
var vertexColorAttribute = ctx.getAttribLocation(program, 'aVertexColor');
ctx.enableVertexAttribArray(vertexPositionAttribute);
ctx.enableVertexAttribArray(vertexColorAttribute);
ctx.bindBuffer(gl.ARRAY_BUFFER, squareVerticesBuffer);
ctx.vertexAttribPointer(vertexPositionAttribute, 2, gl.FLOAT, false, 0, 0);
ctx.bindBuffer(gl.ARRAY_BUFFER, squareColorsBuffer);
ctx.vertexAttribPointer(vertexColorAttribute, 4, gl.FLOAT, false, 0, 0);
ctx.drawQuads(gl.TRIANGLE_FAN, 0, 6);
var pixels = new tcuSurface.Surface(width, height);
ctx.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels.getAccess().getDataPtr());
var numFailedPixels = 0;
var redPixel = new gluDrawUtil.Pixel([255, 0, 0, 255]);
var bluePixel = new gluDrawUtil.Pixel([0, 0, 255, 255]);
var pixel = new gluDrawUtil.Pixel(pixels.getPixel(0, 0));
if (!pixel.equals(bluePixel))
numFailedPixels += 1;
pixel = new gluDrawUtil.Pixel(pixels.getPixel(100, 94));
if (!pixel.equals(redPixel))
numFailedPixels += 1;
var access = pixels.getAccess();
tcuLogImage.logImage('Result', '', access);
if (numFailedPixels > 0)
testFailedOptions('Image comparison failed, got ' + numFailedPixels + ' non-equal pixels.', false);
else
testPassedOptions('Image comparison succeed', true);
return tcuTestCase.IterateResult.STOP;
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} description
*/
sglrReferenceContextTest.DrawElements = function(name, description) {
tcuTestCase.DeqpTest.call(this, name, description);
};
sglrReferenceContextTest.DrawElements.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
sglrReferenceContextTest.DrawElements.prototype.constructor = sglrReferenceContextTest.DrawElements;
sglrReferenceContextTest.DrawElements.prototype.init = function() {};
sglrReferenceContextTest.DrawElements.prototype.iterate = function() {
var limits = new sglrReferenceContext.ReferenceContextLimits(gl);
var format = new tcuPixelFormat.PixelFormat(8, 8, 8, 8);
var width = 200;
var height = 188;
var samples = 1;
var buffers = new sglrReferenceContext.ReferenceContextBuffers(format, 24, 8, width, height, samples);
var ctx = new sglrReferenceContext.ReferenceContext(limits, buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer());
ctx.clearColor(0, 0, 1, 1);
ctx.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
var vertices = [
-0.5, 0.5,
0, 0.5,
0.4, 0.5,
-0.5, 0.1,
0, 0.1,
0.4, 0.1,
-0.5, -0.7,
0, -0.7,
0.4, -0.7
];
var vertices32 = new Float32Array(vertices);
var squareVerticesBuffer = ctx.createBuffer();
ctx.bindBuffer(gl.ARRAY_BUFFER, squareVerticesBuffer);
ctx.bufferData(gl.ARRAY_BUFFER, vertices32, gl.STATIC_DRAW);
var indices = [
0, 1, 3, 1, 3, 4,
1, 2, 4, 2, 4, 5,
3, 4, 6, 4, 6, 7,
4, 5, 7, 5, 7, 8
];
var indicesBuffer = ctx.createBuffer();
ctx.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indicesBuffer);
ctx.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
var colors = [
1, 0, 0, 1,
0, 1, 0, 1,
0, 0, 1, 1,
1, 1, 1, 1,
1, 1, 0, 1,
0, 1, 1, 1,
1, 0, 1, 1,
0.5, 0.5, 0.5, 1,
0, 0, 0, 0
];
var colors32 = new Float32Array(colors);
var squareColorsBuffer = ctx.createBuffer();
ctx.bindBuffer(gl.ARRAY_BUFFER, squareColorsBuffer);
ctx.bufferData(gl.ARRAY_BUFFER, colors32, gl.STATIC_DRAW);
/** @type {sglrShaderProgram.ShaderProgramDeclaration} */ var progDecl = new sglrShaderProgram.ShaderProgramDeclaration();
progDecl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('aVertexPosition', rrGenericVector.GenericVecType.FLOAT));
progDecl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('aVertexColor', rrGenericVector.GenericVecType.FLOAT));
progDecl.pushVertexSource(new sglrShaderProgram.VertexSource(''));
progDecl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(rrGenericVector.GenericVecType.FLOAT));
progDecl.pushFragmentSource(new sglrShaderProgram.FragmentSource(''));
/** @type {sglrReferenceContextTest.ContextShaderProgram} */ var program = new sglrReferenceContextTest.ContextShaderProgram(progDecl);
//Create program
ctx.createProgram(program);
//Use program
ctx.useProgram(program);
var vertexPositionAttribute = ctx.getAttribLocation(program, 'aVertexPosition');
var vertexColorAttribute = ctx.getAttribLocation(program, 'aVertexColor');
ctx.enableVertexAttribArray(vertexPositionAttribute);
ctx.enableVertexAttribArray(vertexColorAttribute);
ctx.bindBuffer(gl.ARRAY_BUFFER, squareVerticesBuffer);
ctx.vertexAttribPointer(vertexPositionAttribute, 2, gl.FLOAT, false, 0, 0);
ctx.bindBuffer(gl.ARRAY_BUFFER, squareColorsBuffer);
ctx.vertexAttribPointer(vertexColorAttribute, 4, gl.FLOAT, false, 0, 0);
ctx.drawElements(gl.TRIANGLES, indices.length, gl.UNSIGNED_SHORT, 0);
var pixels = new tcuSurface.Surface(width, height);
ctx.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels.getAccess().getDataPtr());
var numFailedPixels = 0;
var access = pixels.getAccess();
var pixelsTotest = [
// location, color
[2, 1], [0, 0, 255, 255],
// The red vertex is between 140 and 141 so account for some blending with the white vertex
[50, 140], [255, 5, 5, 255],
[50, 28], [255, 0, 255, 255],
[139, 28], [0, 0, 0, 255],
[50, 102], [255, 255, 255, 255],
[139, 102], [0, 255, 255, 255]
];
var threshold = new tcuRGBA.RGBA([5, 5, 5, 5]);
for (var i = 0; i < pixelsTotest.length; i += 2) {
var location = pixelsTotest[i];
var reference = new tcuRGBA.RGBA(pixelsTotest[i + 1]);
var color = access.getPixelInt(location[0], location[1]);
var pixel = new tcuRGBA.RGBA(color);
if (!tcuRGBA.compareThreshold(pixel, reference, threshold))
numFailedPixels++;
}
tcuLogImage.logImage('Result', '', access);
if (numFailedPixels > 0)
testFailedOptions('Image comparison failed, got ' + numFailedPixels + ' non-equal pixels.', false);
else
testPassedOptions('Image comparison succeed', true);
return tcuTestCase.IterateResult.STOP;
};
/**
* @constructor
* @extends {sglrShaderProgram.ShaderProgram}
* @param {sglrShaderProgram.ShaderProgramDeclaration} progDecl
*/
sglrReferenceContextTest.ContextShaderProgram = function(progDecl) {
sglrShaderProgram.ShaderProgram.call(this, progDecl);
};
sglrReferenceContextTest.ContextShaderProgram.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype);
sglrReferenceContextTest.ContextShaderProgram.prototype.constructor = sglrReferenceContextTest.ContextShaderProgram;
/**
* @param {Array<rrVertexAttrib.VertexAttrib>} inputs
* @param {Array<rrVertexPacket.VertexPacket>} packets
* @param {number} numPackets
*/
sglrReferenceContextTest.ContextShaderProgram.prototype.shadeVertices = function(inputs, packets, numPackets) {
for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) {
/** @type {number} */ var varyingLocColor = 0;
/** @type {rrVertexPacket.VertexPacket} */ var packet = packets[packetNdx];
// Calc output color
/** @type {Array<number>} */ var coord = [1.0, 1.0];
/** @type {Array<number>} */ var color = [1.0, 1.0, 1.0];
for (var attribNdx = 0; attribNdx < this.getVertexShader().getInputs().length; attribNdx++) {
/** @type {number} */ var numComponents = inputs[attribNdx].componentCount;
var attribValue = rrVertexAttrib.readVertexAttrib(inputs[attribNdx], packet.instanceNdx, packet.vertexNdx, this.getVertexShader().getInputs()[attribNdx].type);
if (attribNdx == 0) {
coord[0] = attribValue[0];
coord[1] = attribValue[1];
} else {
color[0] = attribValue[0] * attribValue[3];
color[1] = attribValue[1] * attribValue[3];
color[2] = attribValue[2] * attribValue[3];
}
}
// Transform position
packet.position = [coord[0], coord[1], 1.0, 1.0];
// Pass color to FS
packet.outputs[varyingLocColor] = [color[0], color[1], color[2], 1.0];
}
};
/**
* @param {Array<rrFragmentOperations.Fragment>} packets
* @param {rrShadingContext.FragmentShadingContext} context
*/
sglrReferenceContextTest.ContextShaderProgram.prototype.shadeFragments = function(packets, context) {
var varyingLocColor = 0;
// Normal shading
for (var packetNdx = 0; packetNdx < packets.length; ++packetNdx)
packets[packetNdx].value = rrShadingContext.readTriangleVarying(packets[packetNdx], context, varyingLocColor);
};
sglrReferenceContextTest.init = function() {
var state = tcuTestCase.runner;
/** @type {tcuTestCase.DeqpTest} */ var testGroup = state.testCases;
/** @type {tcuTestCase.DeqpTest} */ var referenceContextGroup = tcuTestCase.newTest('reference_context', 'Test reference context');
referenceContextGroup.addChild(new sglrReferenceContextTest.ClearContext('clear_context', 'Clear Context Test'));
referenceContextGroup.addChild(new sglrReferenceContextTest.Framebuffer('Framebuffer', 'Framebuffer Test'));
referenceContextGroup.addChild(new sglrReferenceContextTest.Shader('Shaders', 'Drawing using TRIANGLES'));
referenceContextGroup.addChild(new sglrReferenceContextTest.TriangleStrip('TriangleStrip', 'Drawing using TRIANGLE_STRIP'));
referenceContextGroup.addChild(new sglrReferenceContextTest.TriangleFan('TriangleFan', 'Drawing using TRIANGLE_FAN'));
referenceContextGroup.addChild(new sglrReferenceContextTest.DrawElements('DrawElements', 'Drawing using DrawElements and TRIANGLES'));
testGroup.addChild(referenceContextGroup);
};
sglrReferenceContextTest.run = function(context) {
gl = context;
//Set up Test Root parameters
var testName = 'single_reference_context';
var testDescription = 'Single Reference Context Tests';
var state = tcuTestCase.runner;
state.testName = testName;
state.testCases = tcuTestCase.newTest(testName, testDescription, null);
//Set up name and description of this test series.
setCurrentTestName(testName);
description(testDescription);
try {
//Create test cases
sglrReferenceContextTest.init();
//Run test cases
tcuTestCase.runTestCases();
}
catch (err) {
bufferedLogToConsole(err);
tcuTestCase.runner.terminate();
}
};
});