1090 lines
54 KiB
JavaScript
1090 lines
54 KiB
JavaScript
/*
|
|
Copyright (c) 2019 The Khronos Group Inc.
|
|
Use of this source code is governed by an MIT-style license that can be
|
|
found in the LICENSE.txt file.
|
|
*/
|
|
|
|
// This test relies on the surrounding web page defining a variable
|
|
// "contextVersion" which indicates what version of WebGL it's running
|
|
// on -- 1 for WebGL 1.0, 2 for WebGL 2.0, etc.
|
|
|
|
"use strict";
|
|
const wtu = WebGLTestUtils;
|
|
description("Test of get calls against GL objects like getBufferParameter, etc.");
|
|
|
|
let gl = wtu.create3DContext(undefined, undefined, contextVersion);
|
|
|
|
async function testInvalidArgument(funcName, argumentName, validArgumentArray, func) {
|
|
let validArguments = {};
|
|
for (let ii = 0; ii < validArgumentArray.length; ++ii) {
|
|
validArguments[validArgumentArray[ii]] = true;
|
|
}
|
|
let success = true;
|
|
const MAX = 0x10000;
|
|
const STEP = Math.ceil(MAX / 10);
|
|
for (let ii = 0; ii < MAX; ii += 1) {
|
|
if (ii && ii % STEP == 0) {
|
|
debug(`(${ii} of ${MAX}: ${(ii/MAX*100).toFixed(1)}%)`);
|
|
await wtu.dispatchPromise(); // Spin the event loop.
|
|
}
|
|
if (!validArguments[ii]) {
|
|
let result = func(ii);
|
|
if (result !== null) {
|
|
success = false;
|
|
testFailed(funcName + " returned " + result + " instead of null for invalid " + argumentName + " enum: " + wtu.glEnumToString(gl, ii));
|
|
break;
|
|
}
|
|
let err = gl.getError();
|
|
if (err != gl.INVALID_ENUM) {
|
|
success = false;
|
|
testFailed(funcName + " did not generate INVALID_ENUM for invalid " + argumentName + " enum: " + wtu.glEnumToString(gl, ii));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (success) {
|
|
testPassed(funcName + " correctly handled invalid " + argumentName + " enums");
|
|
}
|
|
}
|
|
|
|
(async () => {
|
|
debug("");
|
|
debug("test getBufferParameter");
|
|
// Test getBufferParameter
|
|
let bufferTypes = [gl.ARRAY_BUFFER, gl.ELEMENT_ARRAY_BUFFER];
|
|
if (contextVersion > 1) {
|
|
bufferTypes = bufferTypes.concat([gl.COPY_READ_BUFFER, gl.COPY_WRITE_BUFFER, gl.PIXEL_PACK_BUFFER, gl.PIXEL_UNPACK_BUFFER, gl.TRANSFORM_FEEDBACK_BUFFER, gl.UNIFORM_BUFFER]);
|
|
}
|
|
for (let bb = 0; bb < bufferTypes.length; ++bb) {
|
|
let bufferType = bufferTypes[bb];
|
|
let buffer = gl.createBuffer();
|
|
gl.bindBuffer(bufferType, buffer);
|
|
gl.bufferData(bufferType, 16, gl.DYNAMIC_DRAW);
|
|
let expression1 = "gl.getBufferParameter(" + bufferType + ", gl.BUFFER_SIZE)";
|
|
let expression2 = "gl.getBufferParameter(" + bufferType + ", gl.BUFFER_USAGE)";
|
|
shouldBe(expression1, '16');
|
|
shouldBe(expression2, 'gl.DYNAMIC_DRAW');
|
|
await testInvalidArgument("getBufferParameter", "parameter", [gl.BUFFER_SIZE, gl.BUFFER_USAGE], function(bufferType) {
|
|
return function(parameter) {
|
|
return gl.getBufferParameter(bufferType, parameter);
|
|
};
|
|
}(bufferType));
|
|
gl.bindBuffer(bufferType, null);
|
|
}
|
|
await testInvalidArgument(
|
|
"getBufferParameter",
|
|
"target",
|
|
bufferTypes,
|
|
function(target) {
|
|
return gl.getBufferParameter(target, gl.BUFFER_SIZE);
|
|
}
|
|
);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
let testCases = [
|
|
{ contextStencil: true},
|
|
{ contextStencil: false}
|
|
];
|
|
|
|
for (let run = 0; run < testCases.length; ++run) {
|
|
debug("");
|
|
debug("Test getFramebufferAttachmentParameter with stencil " + testCases[run].contextStencil);
|
|
|
|
if (testCases[run].contextStencil) {
|
|
gl = wtu.create3DContext(null, {stencil: true}, contextVersion);
|
|
} else {
|
|
gl = wtu.create3DContext(null, {stencil: false}, contextVersion);
|
|
}
|
|
|
|
window.texture = gl.createTexture();
|
|
window.anotherTexture = gl.createTexture();
|
|
gl.bindTexture(gl.TEXTURE_2D, texture);
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 2, 2, 0, gl.RGBA, gl.UNSIGNED_BYTE,
|
|
new Uint8Array([
|
|
0, 0, 0, 255,
|
|
255, 255, 255, 255,
|
|
255, 255, 255, 255,
|
|
0, 0, 0, 255]));
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
|
|
gl.bindTexture(gl.TEXTURE_2D, null);
|
|
window.framebuffer = gl.createFramebuffer();
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
|
|
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
|
|
let colorAttachmentsNum = 1;
|
|
if (contextVersion > 1) {
|
|
gl.bindTexture(gl.TEXTURE_2D, anotherTexture);
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 2, 2, 0, gl.RGBA, gl.UNSIGNED_BYTE,
|
|
new Uint8Array([
|
|
0, 0, 0, 255,
|
|
255, 255, 255, 255,
|
|
255, 255, 255, 255,
|
|
0, 0, 0, 255]));
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
|
|
gl.bindTexture(gl.TEXTURE_2D, null);
|
|
colorAttachmentsNum = gl.getParameter(gl.MAX_COLOR_ATTACHMENTS);
|
|
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + colorAttachmentsNum - 1, gl.TEXTURE_2D, anotherTexture, 0);
|
|
}
|
|
window.renderbuffer = gl.createRenderbuffer();
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
if (contextVersion == 1)
|
|
gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, 2, 2);
|
|
else
|
|
gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH24_STENCIL8, 2, 2);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, renderbuffer);
|
|
if (contextVersion > 1)
|
|
gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.RENDERBUFFER, renderbuffer);
|
|
shouldBe('gl.checkFramebufferStatus(gl.FRAMEBUFFER)', 'gl.FRAMEBUFFER_COMPLETE');
|
|
// The for loop tests two color attachments for WebGL 2: the first one (gl.COLOR_ATTACHMENT0)
|
|
// and the last one (gl.COLOR_ATTACHMENT0 + gl.MAX_COLOR_ATTACHMENTS - 1).
|
|
for (let ii = 0; ii < colorAttachmentsNum; ii += (colorAttachmentsNum > 1 ? colorAttachmentsNum - 1 : 1)) {
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.TEXTURE');
|
|
if (ii == 0)
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'texture');
|
|
else
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'anotherTexture');
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL)', '0');
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE)', '0');
|
|
if (contextVersion > 1) {
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_RED_SIZE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)');
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER)', '0');
|
|
}
|
|
}
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.RENDERBUFFER');
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'renderbuffer');
|
|
if (contextVersion > 1) {
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.RENDERBUFFER');
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'renderbuffer');
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.RENDERBUFFER');
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'renderbuffer');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)');
|
|
wtu.shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)');
|
|
}
|
|
let validParametersForFBAttachment =
|
|
[ gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
|
|
gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
|
|
gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL,
|
|
gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE
|
|
];
|
|
if (contextVersion > 1) {
|
|
validParametersForFBAttachment = validParametersForFBAttachment.concat([
|
|
gl.FRAMEBUFFER_ATTACHMENT_RED_SIZE,
|
|
gl.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE,
|
|
gl.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE,
|
|
gl.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE,
|
|
gl.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE,
|
|
gl.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE,
|
|
gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE,
|
|
gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING,
|
|
gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER
|
|
]);
|
|
}
|
|
await testInvalidArgument(
|
|
"getFramebufferAttachmentParameter",
|
|
"parameter",
|
|
validParametersForFBAttachment,
|
|
function(parameter) {
|
|
return gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT, parameter);
|
|
}
|
|
);
|
|
let validTargetsForFBAttachment = [gl.FRAMEBUFFER];
|
|
if (contextVersion > 1) {
|
|
validTargetsForFBAttachment = validTargetsForFBAttachment.concat([gl.READ_FRAMEBUFFER, gl.DRAW_FRAMEBUFFER]);
|
|
}
|
|
await testInvalidArgument(
|
|
"getFramebufferAttachmentParameter",
|
|
"target",
|
|
validTargetsForFBAttachment,
|
|
function(target) {
|
|
return gl.getFramebufferAttachmentParameter(target, gl.COLOR_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE);
|
|
}
|
|
);
|
|
let validAttachmentsForFBAttachment = new Array(
|
|
gl.COLOR_ATTACHMENT0,
|
|
gl.DEPTH_ATTACHMENT,
|
|
gl.STENCIL_ATTACHMENT,
|
|
gl.DEPTH_STENCIL_ATTACHMENT
|
|
);
|
|
if (contextVersion > 1) {
|
|
for (let ii = 1; ii < gl.getParameter(gl.MAX_COLOR_ATTACHMENTS); ++ii) {
|
|
validAttachmentsForFBAttachment[validAttachmentsForFBAttachment.length] = gl.COLOR_ATTACHMENT0 + ii;
|
|
}
|
|
}
|
|
await testInvalidArgument(
|
|
"getFramebufferAttachmentParameter",
|
|
"attachment",
|
|
validAttachmentsForFBAttachment,
|
|
function(attachment) {
|
|
return gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, attachment, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE);
|
|
}
|
|
);
|
|
if (contextVersion > 1) {
|
|
// test default framebuffer
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
|
|
shouldBe('gl.checkFramebufferStatus(gl.FRAMEBUFFER)', 'gl.FRAMEBUFFER_COMPLETE');
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.FRAMEBUFFER_DEFAULT');
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.FRAMEBUFFER_DEFAULT');
|
|
if (testCases[run].contextStencil)
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.FRAMEBUFFER_DEFAULT');
|
|
else
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_RED_SIZE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH, gl.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)');
|
|
if (testCases[run].contextStencil) {
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)');
|
|
shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
} else {
|
|
wtu.shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE)');
|
|
wtu.shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)');
|
|
wtu.shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)');
|
|
}
|
|
await testInvalidArgument(
|
|
"getFramebufferAttachmentParameter",
|
|
"parameter",
|
|
validParametersForFBAttachment,
|
|
function(parameter) {
|
|
return gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, parameter);
|
|
}
|
|
);
|
|
await testInvalidArgument(
|
|
"getFramebufferAttachmentParameter",
|
|
"target",
|
|
validTargetsForFBAttachment,
|
|
function(target) {
|
|
return gl.getFramebufferAttachmentParameter(target, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE);
|
|
}
|
|
);
|
|
await testInvalidArgument(
|
|
"getFramebufferAttachmentParameter",
|
|
"attachment",
|
|
[ gl.BACK,
|
|
gl.DEPTH,
|
|
gl.STENCIL
|
|
],
|
|
function(attachment) {
|
|
return gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, attachment, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE);
|
|
}
|
|
);
|
|
}
|
|
}
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
debug("");
|
|
debug("test getAttachedShaders");
|
|
window.standardVert = wtu.loadStandardVertexShader(gl);
|
|
window.standardFrag = wtu.loadStandardFragmentShader(gl);
|
|
window.standardProgram = gl.createProgram();
|
|
gl.attachShader(standardProgram, standardVert);
|
|
gl.attachShader(standardProgram, standardFrag);
|
|
gl.linkProgram(standardProgram);
|
|
window.shaders = gl.getAttachedShaders(standardProgram);
|
|
shouldBe('shaders.length', '2');
|
|
shouldBeTrue('shaders[0] == standardVert && shaders[1] == standardFrag || shaders[1] == standardVert && shaders[0] == standardFrag');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
shouldThrow('gl.getAttachedShaders(null)');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
shouldThrow('gl.getAttachedShaders(standardVert)');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
debug("");
|
|
debug("Test getProgramParameter");
|
|
shouldBe('gl.getProgramParameter(standardProgram, gl.DELETE_STATUS)', 'false');
|
|
shouldBe('gl.getProgramParameter(standardProgram, gl.LINK_STATUS)', 'true');
|
|
shouldBe('typeof gl.getProgramParameter(standardProgram, gl.VALIDATE_STATUS)', '"boolean"');
|
|
shouldBe('gl.getProgramParameter(standardProgram, gl.ATTACHED_SHADERS)', '2');
|
|
shouldBe('gl.getProgramParameter(standardProgram, gl.ACTIVE_ATTRIBUTES)', '2');
|
|
shouldBe('gl.getProgramParameter(standardProgram, gl.ACTIVE_UNIFORMS)', '1');
|
|
if (contextVersion > 1) {
|
|
let buffer = gl.createBuffer();
|
|
gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buffer);
|
|
gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, 1024, gl.DYNAMIC_DRAW);
|
|
window.uniformBlockProgram = wtu.loadUniformBlockProgram(gl);
|
|
let transformFeedbackVars = ["normal", "ecPosition"];
|
|
gl.transformFeedbackVaryings(uniformBlockProgram, transformFeedbackVars, gl.INTERLEAVED_ATTRIBS);
|
|
gl.linkProgram(uniformBlockProgram);
|
|
shouldBe('gl.getProgramParameter(uniformBlockProgram, gl.LINK_STATUS)', 'true');
|
|
shouldBe('gl.getError()', 'gl.NO_ERROR');
|
|
shouldBe('gl.getProgramParameter(uniformBlockProgram, gl.ACTIVE_UNIFORM_BLOCKS)', '1');
|
|
shouldBe('gl.getProgramParameter(uniformBlockProgram, gl.TRANSFORM_FEEDBACK_VARYINGS)', '2');
|
|
shouldBe('gl.getProgramParameter(uniformBlockProgram, gl.TRANSFORM_FEEDBACK_BUFFER_MODE)', 'gl.INTERLEAVED_ATTRIBS');
|
|
}
|
|
window.program = standardProgram;
|
|
let validArrayForProgramParameter = [
|
|
gl.DELETE_STATUS,
|
|
gl.LINK_STATUS,
|
|
gl.VALIDATE_STATUS,
|
|
gl.ATTACHED_SHADERS,
|
|
gl.ACTIVE_ATTRIBUTES,
|
|
gl.ACTIVE_UNIFORMS
|
|
];
|
|
if (contextVersion > 1) {
|
|
validArrayForProgramParameter = validArrayForProgramParameter.concat([
|
|
gl.ACTIVE_UNIFORM_BLOCKS,
|
|
gl.TRANSFORM_FEEDBACK_VARYINGS,
|
|
gl.TRANSFORM_FEEDBACK_BUFFER_MODE
|
|
]);
|
|
program = uniformBlockProgram;
|
|
}
|
|
await testInvalidArgument(
|
|
"getProgramParameter",
|
|
"parameter",
|
|
validArrayForProgramParameter,
|
|
function(parameter) {
|
|
return gl.getProgramParameter(program, parameter);
|
|
}
|
|
);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
debug("");
|
|
debug("Test getRenderbufferParameter");
|
|
shouldBe('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_WIDTH)', '2');
|
|
shouldBe('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_HEIGHT)', '2');
|
|
// Note: we can't test the actual value of the internal format since
|
|
// the implementation is allowed to change it.
|
|
shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_INTERNAL_FORMAT)');
|
|
shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_DEPTH_SIZE)');
|
|
let colorbuffer = gl.createRenderbuffer();
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA4, 2, 2);
|
|
shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_RED_SIZE)');
|
|
shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_GREEN_SIZE)');
|
|
shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_BLUE_SIZE)');
|
|
shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_ALPHA_SIZE)');
|
|
if (contextVersion > 1) {
|
|
gl.renderbufferStorageMultisample(gl.RENDERBUFFER, 4, gl.RGBA4, 2, 2);
|
|
shouldBe('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_SAMPLES)', '4');
|
|
}
|
|
let validArrayForRenderbuffer = new Array(
|
|
gl.RENDERBUFFER_WIDTH,
|
|
gl.RENDERBUFFER_HEIGHT,
|
|
gl.RENDERBUFFER_INTERNAL_FORMAT,
|
|
gl.RENDERBUFFER_RED_SIZE,
|
|
gl.RENDERBUFFER_GREEN_SIZE,
|
|
gl.RENDERBUFFER_BLUE_SIZE,
|
|
gl.RENDERBUFFER_ALPHA_SIZE,
|
|
gl.RENDERBUFFER_DEPTH_SIZE,
|
|
gl.RENDERBUFFER_STENCIL_SIZE
|
|
);
|
|
if (contextVersion > 1) {
|
|
validArrayForRenderbuffer[validArrayForRenderbuffer.length] = gl.RENDERBUFFER_SAMPLES;
|
|
}
|
|
await testInvalidArgument(
|
|
"getRenderbufferParameter",
|
|
"parameter",
|
|
validArrayForRenderbuffer,
|
|
function(parameter) {
|
|
return gl.getRenderbufferParameter(gl.RENDERBUFFER, parameter);
|
|
});
|
|
await testInvalidArgument(
|
|
"getRenderbufferParameter",
|
|
"target",
|
|
[ gl.RENDERBUFFER ],
|
|
function(target) {
|
|
return gl.getRenderbufferParameter(target, gl.RENDERBUFFER_WIDTH);
|
|
}
|
|
);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
debug("");
|
|
debug("Test getShaderParameter");
|
|
shouldBe('gl.getShaderParameter(standardVert, gl.SHADER_TYPE)', 'gl.VERTEX_SHADER');
|
|
shouldBe('gl.getShaderParameter(standardVert, gl.DELETE_STATUS)', 'false');
|
|
shouldBe('gl.getShaderParameter(standardVert, gl.COMPILE_STATUS)', 'true');
|
|
await testInvalidArgument(
|
|
"getShaderParameter",
|
|
"parameter",
|
|
[ gl.DELETE_STATUS,
|
|
gl.COMPILE_STATUS,
|
|
gl.SHADER_TYPE
|
|
],
|
|
function(parameter) {
|
|
return gl.getShaderParameter(standardVert, parameter);
|
|
}
|
|
);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
debug("");
|
|
debug("Test getTexParameter");
|
|
gl.bindTexture(gl.TEXTURE_2D, texture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER)', 'gl.NEAREST');
|
|
shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER)', 'gl.NEAREST');
|
|
shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S)', 'gl.CLAMP_TO_EDGE');
|
|
shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T)', 'gl.CLAMP_TO_EDGE');
|
|
if (contextVersion > 1) {
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_BASE_LEVEL, 0);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_FUNC, gl.LEQUAL);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAX_LEVEL, 10);
|
|
gl.texParameterf(gl.TEXTURE_2D, gl.TEXTURE_MAX_LOD, 10);
|
|
gl.texParameterf(gl.TEXTURE_2D, gl.TEXTURE_MIN_LOD, 0);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE);
|
|
shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_BASE_LEVEL)', '0');
|
|
shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_FUNC)', 'gl.LEQUAL');
|
|
shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_MODE)', 'gl.COMPARE_REF_TO_TEXTURE');
|
|
shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MAX_LEVEL)', '10');
|
|
shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MAX_LOD)', '10');
|
|
shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MIN_LOD)', '0');
|
|
shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_R)', 'gl.CLAMP_TO_EDGE');
|
|
shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_IMMUTABLE_FORMAT)', 'false');
|
|
shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_IMMUTABLE_LEVELS)', '0');
|
|
}
|
|
let validParametersForTexture = [
|
|
gl.TEXTURE_MAG_FILTER,
|
|
gl.TEXTURE_MIN_FILTER,
|
|
gl.TEXTURE_WRAP_S,
|
|
gl.TEXTURE_WRAP_T,
|
|
];
|
|
if (contextVersion > 1) {
|
|
validParametersForTexture = validParametersForTexture.concat([
|
|
gl.TEXTURE_BASE_LEVEL,
|
|
gl.TEXTURE_COMPARE_FUNC,
|
|
gl.TEXTURE_COMPARE_MODE,
|
|
gl.TEXTURE_MAX_LEVEL,
|
|
gl.TEXTURE_MAX_LOD,
|
|
gl.TEXTURE_MIN_LOD,
|
|
gl.TEXTURE_WRAP_R,
|
|
gl.TEXTURE_IMMUTABLE_FORMAT,
|
|
gl.TEXTURE_IMMUTABLE_LEVELS,
|
|
]);
|
|
}
|
|
await testInvalidArgument(
|
|
"getTexParameter",
|
|
"parameter",
|
|
validParametersForTexture,
|
|
function(parameter) {
|
|
return gl.getTexParameter(gl.TEXTURE_2D, parameter);
|
|
}
|
|
);
|
|
let validTargetsForTexture = [ gl.TEXTURE_2D, gl.TEXTURE_CUBE_MAP];
|
|
if (contextVersion > 1) {
|
|
validTargetsForTexture = validTargetsForTexture.concat([ gl.TEXTURE_3D, gl.TEXTURE_2D_ARRAY]);
|
|
}
|
|
await testInvalidArgument(
|
|
"getTexParameter",
|
|
"target",
|
|
validTargetsForTexture,
|
|
function(target) {
|
|
return gl.getTexParameter(target, gl.TEXTURE_MAG_FILTER);
|
|
}
|
|
);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
debug("");
|
|
debug("Test getUniform with all variants of data types");
|
|
debug("Boolean uniform variables");
|
|
window.boolProgram = wtu.loadProgramFromFile(gl, "../../resources/boolUniformShader.vert", "../../resources/noopUniformShader.frag");
|
|
shouldBe('gl.getProgramParameter(boolProgram, gl.LINK_STATUS)', 'true');
|
|
window.bvalLoc = gl.getUniformLocation(boolProgram, "bval");
|
|
window.bval2Loc = gl.getUniformLocation(boolProgram, "bval2");
|
|
window.bval3Loc = gl.getUniformLocation(boolProgram, "bval3");
|
|
window.bval4Loc = gl.getUniformLocation(boolProgram, "bval4");
|
|
gl.useProgram(boolProgram);
|
|
gl.uniform1i(bvalLoc, 1);
|
|
gl.uniform2i(bval2Loc, 1, 0);
|
|
gl.uniform3i(bval3Loc, 1, 0, 1);
|
|
gl.uniform4i(bval4Loc, 1, 0, 1, 0);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
shouldBe('gl.getUniform(boolProgram, bvalLoc)', 'true');
|
|
shouldBe('gl.getUniform(boolProgram, bval2Loc)', '[true, false]');
|
|
shouldBe('gl.getUniform(boolProgram, bval3Loc)', '[true, false, true]');
|
|
shouldBe('gl.getUniform(boolProgram, bval4Loc)', '[true, false, true, false]');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
debug("Integer uniform variables");
|
|
window.intProgram = wtu.loadProgramFromFile(gl, "../../resources/intUniformShader.vert", "../../resources/noopUniformShader.frag");
|
|
shouldBe('gl.getProgramParameter(intProgram, gl.LINK_STATUS)', 'true');
|
|
window.ivalLoc = gl.getUniformLocation(intProgram, "ival");
|
|
window.ival2Loc = gl.getUniformLocation(intProgram, "ival2");
|
|
window.ival3Loc = gl.getUniformLocation(intProgram, "ival3");
|
|
window.ival4Loc = gl.getUniformLocation(intProgram, "ival4");
|
|
gl.useProgram(intProgram);
|
|
gl.uniform1i(ivalLoc, 1);
|
|
gl.uniform2i(ival2Loc, 2, 3);
|
|
gl.uniform3i(ival3Loc, 4, 5, 6);
|
|
gl.uniform4i(ival4Loc, 7, 8, 9, 10);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
shouldBe('gl.getUniform(intProgram, ivalLoc)', '1');
|
|
shouldBe('gl.getUniform(intProgram, ival2Loc)', '[2, 3]');
|
|
shouldBe('gl.getUniform(intProgram, ival3Loc)', '[4, 5, 6]');
|
|
shouldBe('gl.getUniform(intProgram, ival4Loc)', '[7, 8, 9, 10]');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
debug("Float uniform variables");
|
|
window.floatProgram = wtu.loadProgramFromFile(gl, "../../resources/floatUniformShader.vert", "../../resources/noopUniformShader.frag");
|
|
shouldBe('gl.getProgramParameter(floatProgram, gl.LINK_STATUS)', 'true');
|
|
window.fvalLoc = gl.getUniformLocation(floatProgram, "fval");
|
|
window.fval2Loc = gl.getUniformLocation(floatProgram, "fval2");
|
|
window.fval3Loc = gl.getUniformLocation(floatProgram, "fval3");
|
|
window.fval4Loc = gl.getUniformLocation(floatProgram, "fval4");
|
|
gl.useProgram(floatProgram);
|
|
gl.uniform1f(fvalLoc, 11);
|
|
gl.uniform2f(fval2Loc, 12, 13);
|
|
gl.uniform3f(fval3Loc, 14, 15, 16);
|
|
gl.uniform4f(fval4Loc, 17, 18, 19, 20);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
shouldBe('gl.getUniform(floatProgram, fvalLoc)', '11');
|
|
shouldBe('gl.getUniform(floatProgram, fval2Loc)', '[12, 13]');
|
|
shouldBe('gl.getUniform(floatProgram, fval3Loc)', '[14, 15, 16]');
|
|
shouldBe('gl.getUniform(floatProgram, fval4Loc)', '[17, 18, 19, 20]');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
debug("Sampler uniform variables");
|
|
window.samplerProgram = wtu.loadProgramFromFile(gl, "../../resources/noopUniformShader.vert", "../../resources/samplerUniformShader.frag");
|
|
shouldBe('gl.getProgramParameter(samplerProgram, gl.LINK_STATUS)', 'true');
|
|
window.s2DValLoc = gl.getUniformLocation(samplerProgram, "s2D");
|
|
window.sCubeValLoc = gl.getUniformLocation(samplerProgram, "sCube");
|
|
gl.useProgram(samplerProgram);
|
|
gl.uniform1i(s2DValLoc, 0);
|
|
gl.uniform1i(sCubeValLoc, 1);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
shouldBe('gl.getUniform(samplerProgram, s2DValLoc)', '0');
|
|
shouldBe('gl.getUniform(samplerProgram, sCubeValLoc)', '1');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
debug("Matrix uniform variables");
|
|
window.matProgram = wtu.loadProgramFromFile(gl, "../../resources/matUniformShader.vert", "../../resources/noopUniformShader.frag");
|
|
shouldBe('gl.getProgramParameter(matProgram, gl.LINK_STATUS)', 'true');
|
|
window.mval2Loc = gl.getUniformLocation(matProgram, "mval2");
|
|
window.mval3Loc = gl.getUniformLocation(matProgram, "mval3");
|
|
window.mval4Loc = gl.getUniformLocation(matProgram, "mval4");
|
|
gl.useProgram(matProgram);
|
|
gl.uniformMatrix2fv(mval2Loc, false, [1, 2, 3, 4]);
|
|
gl.uniformMatrix3fv(mval3Loc, false, [5, 6, 7, 8, 9, 10, 11, 12, 13]);
|
|
gl.uniformMatrix4fv(mval4Loc, false, [14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
shouldBe('gl.getUniform(matProgram, mval2Loc)', '[1, 2, 3, 4]');
|
|
shouldBe('gl.getUniform(matProgram, mval3Loc)', '[5, 6, 7, 8, 9, 10, 11, 12, 13]');
|
|
shouldBe('gl.getUniform(matProgram, mval4Loc)', '[14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
if (contextVersion > 1) {
|
|
debug("Unsigned Integer uniform variables");
|
|
window.uintProgram = wtu.loadProgramFromFile(gl, "../../resources/uintUniformShader.vert", "../../resources/noopUniformShaderES3.frag");
|
|
shouldBe('gl.getProgramParameter(uintProgram, gl.LINK_STATUS)', 'true');
|
|
window.uvalLoc = gl.getUniformLocation(uintProgram, "uval");
|
|
window.uval2Loc = gl.getUniformLocation(uintProgram, "uval2");
|
|
window.uval3Loc = gl.getUniformLocation(uintProgram, "uval3");
|
|
window.uval4Loc = gl.getUniformLocation(uintProgram, "uval4");
|
|
gl.useProgram(uintProgram);
|
|
gl.uniform1ui(uvalLoc, 1);
|
|
gl.uniform2ui(uval2Loc, 2, 3);
|
|
gl.uniform3ui(uval3Loc, 4, 5, 6);
|
|
gl.uniform4ui(uval4Loc, 7, 8, 9, 10);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
shouldBe('gl.getUniform(uintProgram, uvalLoc)', '1');
|
|
shouldBe('gl.getUniform(uintProgram, uval2Loc)', '[2, 3]');
|
|
shouldBe('gl.getUniform(uintProgram, uval3Loc)', '[4, 5, 6]');
|
|
shouldBe('gl.getUniform(uintProgram, uval4Loc)', '[7, 8, 9, 10]');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
debug("Matrix uniform variables for WebGL 2");
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
window.matForWebGL2Program = wtu.loadProgramFromFile(gl, "../../resources/matForWebGL2UniformShader.vert", "../../resources/noopUniformShaderES3.frag");
|
|
shouldBe('gl.getProgramParameter(matForWebGL2Program, gl.LINK_STATUS)', 'true');
|
|
window.mval2x3Loc = gl.getUniformLocation(matForWebGL2Program, "mval2x3");
|
|
window.mval2x4Loc = gl.getUniformLocation(matForWebGL2Program, "mval2x4");
|
|
window.mval3x2Loc = gl.getUniformLocation(matForWebGL2Program, "mval3x2");
|
|
window.mval3x4Loc = gl.getUniformLocation(matForWebGL2Program, "mval3x4");
|
|
window.mval4x2Loc = gl.getUniformLocation(matForWebGL2Program, "mval4x2");
|
|
window.mval4x3Loc = gl.getUniformLocation(matForWebGL2Program, "mval4x3");
|
|
gl.useProgram(matForWebGL2Program);
|
|
gl.uniformMatrix2x3fv(mval2x3Loc, false, [1, 2, 3, 4, 5, 6]);
|
|
gl.uniformMatrix2x4fv(mval2x4Loc, false, [7, 8, 9, 10, 11, 12, 13, 14]);
|
|
gl.uniformMatrix3x2fv(mval3x2Loc, false, [15, 16, 17, 18, 19, 20]);
|
|
gl.uniformMatrix3x4fv(mval3x4Loc, false, [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]);
|
|
gl.uniformMatrix4x2fv(mval4x2Loc, false, [33, 34, 35, 36, 37, 38, 39, 40]);
|
|
gl.uniformMatrix4x3fv(mval4x3Loc, false, [41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52]);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
shouldBe('gl.getUniform(matForWebGL2Program, mval2x3Loc)', '[1, 2, 3, 4, 5, 6]');
|
|
shouldBe('gl.getUniform(matForWebGL2Program, mval2x4Loc)', '[7, 8, 9, 10, 11, 12, 13, 14]');
|
|
shouldBe('gl.getUniform(matForWebGL2Program, mval3x2Loc)', '[15, 16, 17, 18, 19, 20]');
|
|
shouldBe('gl.getUniform(matForWebGL2Program, mval3x4Loc)', '[21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]');
|
|
shouldBe('gl.getUniform(matForWebGL2Program, mval4x2Loc)', '[33, 34, 35, 36, 37, 38, 39, 40]');
|
|
shouldBe('gl.getUniform(matForWebGL2Program, mval4x3Loc)', '[41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52]');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
debug("Sampler uniform variables for WebGL2");
|
|
window.samplerForWebGL2Program = wtu.loadProgramFromFile(gl, "../../resources/noopUniformShaderES3.vert", "../../resources/samplerForWebGL2UniformShader.frag");
|
|
shouldBe('gl.getProgramParameter(samplerForWebGL2Program, gl.LINK_STATUS)', 'true');
|
|
window.s3DValLoc = gl.getUniformLocation(samplerForWebGL2Program, "s3D");
|
|
window.s2DArrayValLoc = gl.getUniformLocation(samplerForWebGL2Program, "s2DArray");
|
|
gl.useProgram(samplerForWebGL2Program);
|
|
gl.uniform1i(s3DValLoc, 0);
|
|
gl.uniform1i(s2DArrayValLoc, 1);
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
shouldBe('gl.getUniform(samplerForWebGL2Program, s3DValLoc)', '0');
|
|
shouldBe('gl.getUniform(samplerForWebGL2Program, s2DArrayValLoc)', '1');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
}
|
|
|
|
debug("");
|
|
debug("test getVertexAttrib");
|
|
let array = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
|
|
window.buffer = gl.createBuffer();
|
|
gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
|
|
gl.bufferData(gl.ARRAY_BUFFER, array, gl.DYNAMIC_DRAW);
|
|
// Vertex attribute 0 is special in that it has no current state, so
|
|
// fetching GL_CURRENT_VERTEX_ATTRIB generates an error. Use attribute
|
|
// 1 for these tests instead.
|
|
gl.enableVertexAttribArray(1);
|
|
gl.vertexAttribPointer(1, 4, gl.FLOAT, false, 0, 0);
|
|
shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)', 'buffer');
|
|
shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_ENABLED)', 'true');
|
|
shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_SIZE)', '4');
|
|
// Stride MUST be the value the user put in.
|
|
shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_STRIDE)', '0');
|
|
shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_TYPE)', 'gl.FLOAT');
|
|
shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED)', 'false');
|
|
if (contextVersion > 1) {
|
|
shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_DIVISOR)', '0');
|
|
shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_INTEGER)', 'false');
|
|
gl.vertexAttribDivisor(1, 2);
|
|
shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_DIVISOR)', '2');
|
|
}
|
|
gl.vertexAttribPointer(1, 4, gl.FLOAT, false, 36, 12);
|
|
shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_STRIDE)', '36');
|
|
shouldBe('gl.getVertexAttribOffset(1, gl.VERTEX_ATTRIB_ARRAY_POINTER)', '12');
|
|
gl.disableVertexAttribArray(1);
|
|
shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_ENABLED)', 'false');
|
|
gl.vertexAttrib4f(1, 5, 6, 7, 8);
|
|
shouldBe('gl.getVertexAttrib(1, gl.CURRENT_VERTEX_ATTRIB)', '[5, 6, 7, 8]');
|
|
if (contextVersion > 1) {
|
|
let intArray = new Int32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
|
|
gl.bufferData(gl.ARRAY_BUFFER, intArray, gl.DYNAMIC_DRAW);
|
|
gl.enableVertexAttribArray(1);
|
|
// feed fixed-point data to buffer
|
|
gl.vertexAttribIPointer(1, 4, gl.INT, false, 0, 0);
|
|
shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_TYPE)', 'gl.INT');
|
|
shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_INTEGER)', 'true');
|
|
}
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
let validArrayForVertexAttrib = new Array(
|
|
gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING,
|
|
gl.VERTEX_ATTRIB_ARRAY_ENABLED,
|
|
gl.VERTEX_ATTRIB_ARRAY_SIZE,
|
|
gl.VERTEX_ATTRIB_ARRAY_STRIDE,
|
|
gl.VERTEX_ATTRIB_ARRAY_TYPE,
|
|
gl.VERTEX_ATTRIB_ARRAY_NORMALIZED,
|
|
gl.CURRENT_VERTEX_ATTRIB
|
|
);
|
|
if (contextVersion > 1) {
|
|
validArrayForVertexAttrib[validArrayForVertexAttrib.length] = gl.VERTEX_ATTRIB_ARRAY_DIVISOR;
|
|
validArrayForVertexAttrib[validArrayForVertexAttrib.length] = gl.VERTEX_ATTRIB_ARRAY_INTEGER;
|
|
}
|
|
await testInvalidArgument(
|
|
"getVertexAttrib",
|
|
"parameter",
|
|
validArrayForVertexAttrib,
|
|
function(parameter) {
|
|
return gl.getVertexAttrib(1, parameter);
|
|
}
|
|
);
|
|
let numVertexAttribs = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
|
|
wtu.shouldGenerateGLError(gl, gl.INVALID_VALUE, 'gl.getVertexAttrib(' + numVertexAttribs + ', gl.CURRENT_VERTEX_ATTRIB)');
|
|
|
|
debug("");
|
|
debug("Test cases where name == 0");
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
|
|
|
|
shouldNotBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE');
|
|
gl.deleteTexture(texture);
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
shouldNotBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE');
|
|
gl.deleteRenderbuffer(renderbuffer);
|
|
shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
gl.deleteBuffer(buffer);
|
|
shouldBeNull('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
if (contextVersion > 1) {
|
|
debug("");
|
|
debug("Test getInternalformatParameter")
|
|
|
|
shouldBeNonNull('gl.getInternalformatParameter(gl.RENDERBUFFER, gl.R32I, gl.SAMPLES)');
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
await testInvalidArgument(
|
|
"getInternalformatParameter",
|
|
"target",
|
|
[ gl.RENDERBUFFER ],
|
|
function(target) {
|
|
return gl.getInternalformatParameter(target, gl.R32I, gl.SAMPLES);
|
|
});
|
|
|
|
await testInvalidArgument(
|
|
"getInternalformatParameter",
|
|
"pname",
|
|
[ gl.SAMPLES ],
|
|
function(pname) {
|
|
return gl.getInternalformatParameter(gl.RENDERBUFFER, gl.RGBA4, pname);
|
|
});
|
|
|
|
let validArrayForInterformat = new Array(
|
|
gl.R8, gl.R8_SNORM, gl.RG8, gl.RG8_SNORM,
|
|
gl.RGB8, gl.RGB8_SNORM, gl.RGB565, gl.RGBA4,
|
|
gl.RGB5_A1, gl.RGBA8, gl.RGBA8_SNORM, gl.RGB10_A2,
|
|
gl.RGB10_A2UI, gl.SRGB8, gl.SRGB8_ALPHA8, gl.R16F,
|
|
gl.RG16F, gl.RGB16F, gl.RGBA16F, gl.R32F,
|
|
gl.RG32F, gl.RGB32F, gl.RGBA32F, gl.R11F_G11F_B10F,
|
|
gl.RGB9_E5, gl.R8I, gl.R8UI, gl.R16I,
|
|
gl.R16UI, gl.R32I, gl.R32UI, gl.RG8I,
|
|
gl.RG8UI, gl.RG16I, gl.RG16UI, gl.RG32I,
|
|
gl.RG32UI, gl.RGB8I, gl.RGB8UI, gl.RGB16I,
|
|
gl.RGB16UI, gl.RGB32I, gl.RGB32UI, gl.RGBA8I,
|
|
gl.RGBA8UI, gl.RGBA16I, gl.RGBA16UI, gl.RGBA32I,
|
|
gl.RGBA32UI, gl.RGB, gl.RGBA, gl.DEPTH_STENCIL, gl.DEPTH_COMPONENT16,
|
|
gl.DEPTH_COMPONENT24, gl.DEPTH_COMPONENT32F, gl.DEPTH24_STENCIL8,
|
|
gl.DEPTH32F_STENCIL8, gl.STENCIL_INDEX8
|
|
);
|
|
await testInvalidArgument(
|
|
"getInternalformatParameter",
|
|
"internalformat",
|
|
validArrayForInterformat,
|
|
function(internalformat) {
|
|
return gl.getInternalformatParameter(gl.RENDERBUFFER, internalformat, gl.SAMPLES);
|
|
});
|
|
|
|
|
|
debug("");
|
|
debug("Test getIndexedParameter");
|
|
window.buffer = gl.createBuffer();
|
|
gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buffer);
|
|
gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, 64, gl.DYNAMIC_DRAW);
|
|
gl.bindBufferRange(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buffer, 4, 8);
|
|
shouldBe('gl.getIndexedParameter(gl.TRANSFORM_FEEDBACK_BUFFER_BINDING, 0)', 'buffer');
|
|
shouldBe('gl.getIndexedParameter(gl.TRANSFORM_FEEDBACK_BUFFER_SIZE, 0)', '8');
|
|
shouldBe('gl.getIndexedParameter(gl.TRANSFORM_FEEDBACK_BUFFER_START, 0)', '4');
|
|
window.buffer1 = gl.createBuffer();
|
|
gl.bindBuffer(gl.UNIFORM_BUFFER, buffer1);
|
|
gl.bufferData(gl.UNIFORM_BUFFER, 64, gl.DYNAMIC_DRAW);
|
|
window.offsetUniform = gl.getParameter(gl.UNIFORM_BUFFER_OFFSET_ALIGNMENT);
|
|
gl.bindBufferRange(gl.UNIFORM_BUFFER, 1, buffer1, offsetUniform, 8);
|
|
shouldBe('gl.getIndexedParameter(gl.UNIFORM_BUFFER_BINDING, 1)', 'buffer1');
|
|
shouldBe('gl.getIndexedParameter(gl.UNIFORM_BUFFER_SIZE, 1)', '8');
|
|
shouldBe('gl.getIndexedParameter(gl.UNIFORM_BUFFER_START, 1)', 'offsetUniform');
|
|
|
|
gl.bindBufferBase(gl.UNIFORM_BUFFER, 1, null);
|
|
shouldBe('gl.getIndexedParameter(gl.UNIFORM_BUFFER_BINDING, 1)', 'null');
|
|
|
|
let validArrayForTarget = new Array(
|
|
gl.TRANSFORM_FEEDBACK_BUFFER_BINDING,
|
|
gl.TRANSFORM_FEEDBACK_BUFFER_SIZE,
|
|
gl.TRANSFORM_FEEDBACK_BUFFER_START,
|
|
gl.UNIFORM_BUFFER_BINDING,
|
|
gl.UNIFORM_BUFFER_SIZE,
|
|
gl.UNIFORM_BUFFER_START
|
|
);
|
|
await testInvalidArgument(
|
|
"getIndexedParameter",
|
|
"target",
|
|
validArrayForTarget,
|
|
function(target) {
|
|
return gl.getIndexedParameter(target, 0);
|
|
});
|
|
|
|
debug("");
|
|
debug("Test getSamplerParameter");
|
|
window.sampler = gl.createSampler();
|
|
gl.samplerParameteri(sampler, gl.TEXTURE_COMPARE_FUNC, gl.LEQUAL);
|
|
gl.samplerParameteri(sampler, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);
|
|
gl.samplerParameteri(sampler, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
gl.samplerParameterf(sampler, gl.TEXTURE_MAX_LOD, 10);
|
|
gl.samplerParameteri(sampler, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.samplerParameterf(sampler, gl.TEXTURE_MIN_LOD, 0);
|
|
gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE);
|
|
gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_COMPARE_FUNC)', 'gl.LEQUAL');
|
|
shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_COMPARE_MODE)', 'gl.COMPARE_REF_TO_TEXTURE');
|
|
shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_MAG_FILTER)', 'gl.NEAREST');
|
|
shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_MAX_LOD)', '10');
|
|
shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_MIN_FILTER)', 'gl.NEAREST');
|
|
shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_MIN_LOD)', '0');
|
|
shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_WRAP_R)', 'gl.CLAMP_TO_EDGE');
|
|
shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_WRAP_S)', 'gl.CLAMP_TO_EDGE');
|
|
shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_WRAP_T)', 'gl.CLAMP_TO_EDGE');
|
|
let validArrayForSamplerParameter = new Array(
|
|
gl.TEXTURE_COMPARE_FUNC,
|
|
gl.TEXTURE_COMPARE_MODE,
|
|
gl.TEXTURE_MAG_FILTER,
|
|
gl.TEXTURE_MAX_LOD,
|
|
gl.TEXTURE_MIN_FILTER,
|
|
gl.TEXTURE_MIN_LOD,
|
|
gl.TEXTURE_WRAP_R,
|
|
gl.TEXTURE_WRAP_S,
|
|
gl.TEXTURE_WRAP_T
|
|
);
|
|
await testInvalidArgument(
|
|
"getSamplerParameter",
|
|
"pname",
|
|
validArrayForSamplerParameter,
|
|
function(pname) {
|
|
return gl.getSamplerParameter(sampler, pname);
|
|
});
|
|
|
|
debug("");
|
|
debug("Test getSyncParameter");
|
|
window.sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
|
|
shouldBe('gl.getSyncParameter(sync, gl.OBJECT_TYPE)', 'gl.SYNC_FENCE');
|
|
let sync_status = gl.getSyncParameter(sync, gl.SYNC_STATUS);
|
|
switch (sync_status) {
|
|
case gl.UNSIGNALED:
|
|
testPassed('gl.getSyncParameter(sync, gl.SYNC_CONDITION) is gl.UNSIGNALED');
|
|
break;
|
|
case gl.SIGNALED:
|
|
testPassed('gl.getSyncParameter(sync, gl.SYNC_CONDITION) is gl.SIGNALED');
|
|
break;
|
|
default:
|
|
testFailed('gl.getSyncParameter(sync, gl.SYNC_CONDITION) was ' + sync_status +
|
|
', expected gl.UNSIGNALED or gl.SIGNALED');
|
|
break;
|
|
}
|
|
shouldBe('gl.getSyncParameter(sync, gl.SYNC_CONDITION)', 'gl.SYNC_GPU_COMMANDS_COMPLETE');
|
|
shouldBe('gl.getSyncParameter(sync, gl.SYNC_FLAGS)', '0');
|
|
let validArrayForSyncParameter = new Array(
|
|
gl.OBJECT_TYPE,
|
|
gl.SYNC_STATUS,
|
|
gl.SYNC_CONDITION,
|
|
gl.SYNC_FLAGS
|
|
);
|
|
await testInvalidArgument(
|
|
"getSyncParameter",
|
|
"pname",
|
|
validArrayForSyncParameter,
|
|
function(pname) {
|
|
return gl.getSyncParameter(sync, pname);
|
|
});
|
|
|
|
debug("");
|
|
debug("Test getQueryParameter");
|
|
window.query = gl.createQuery();
|
|
gl.beginQuery(gl.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, query);
|
|
gl.endQuery(gl.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
|
|
shouldBe('gl.getQueryParameter(query, gl.QUERY_RESULT_AVAILABLE)', 'false');
|
|
// Queries' results are tested elsewhere in the conformance suite. It's complicated
|
|
// to wait for this query's result to become available and verify it.
|
|
let validArrayForPname = new Array(
|
|
gl.QUERY_RESULT,
|
|
gl.QUERY_RESULT_AVAILABLE
|
|
);
|
|
await testInvalidArgument(
|
|
"getQueryParameter",
|
|
"pname",
|
|
validArrayForPname,
|
|
function(pname) {
|
|
return gl.getQueryParameter(query, pname);
|
|
}
|
|
);
|
|
|
|
debug("");
|
|
debug("Test getFragDataLocation");
|
|
let baseVertShader = '' +
|
|
'#version 300 es\n' +
|
|
'uniform mat4 modelViewMatrix;\n' +
|
|
'uniform mat4 projectionMatrix;\n' +
|
|
'in vec4 vertex;\n' +
|
|
'out vec4 position;\n' +
|
|
'void main (void)\n' +
|
|
'{\n' +
|
|
' position = modelViewMatrix * vertex;\n' +
|
|
' gl_Position = projectionMatrix * position;\n' +
|
|
'}\n';
|
|
let baseFragShader = '' +
|
|
'#version 300 es\n' +
|
|
'in lowp vec4 position;\n' +
|
|
'layout(location = 0) out mediump vec4 fragColor;\n' +
|
|
'void main (void)\n' +
|
|
'{\n' +
|
|
' fragColor = position;\n' +
|
|
'}\n';
|
|
window.vertShader = gl.createShader(gl.VERTEX_SHADER);
|
|
gl.shaderSource(vertShader, baseVertShader);
|
|
gl.compileShader(vertShader);
|
|
shouldBe('gl.getShaderParameter(vertShader, gl.COMPILE_STATUS)', 'true');
|
|
window.fragShader = gl.createShader(gl.FRAGMENT_SHADER);
|
|
gl.shaderSource(fragShader, baseFragShader);
|
|
gl.compileShader(fragShader);
|
|
shouldBe('gl.getShaderParameter(fragShader, gl.COMPILE_STATUS)', 'true');
|
|
window.program = gl.createProgram();
|
|
gl.attachShader(program, vertShader);
|
|
gl.attachShader(program, fragShader);
|
|
gl.linkProgram(program);
|
|
shouldBe('gl.getProgramParameter(program, gl.LINK_STATUS)','true');
|
|
shouldBe('gl.getFragDataLocation(program, "vertexColor")', '-1');
|
|
shouldBe('gl.getFragDataLocation(program, "modelViewMatrix")', '-1');
|
|
shouldBe('gl.getFragDataLocation(program, "projectionMatrix")', '-1');
|
|
shouldBe('gl.getFragDataLocation(program, "position")', '-1');
|
|
shouldBe('gl.getFragDataLocation(program, "fragColor")', '0');
|
|
|
|
debug("");
|
|
debug("Test getActiveUniforms");
|
|
program = wtu.loadUniformBlockProgram(gl);
|
|
gl.linkProgram(program);
|
|
shouldBe('gl.getProgramParameter(program, gl.LINK_STATUS)', 'true');
|
|
shouldBe('gl.getError()', 'gl.NO_ERROR');
|
|
|
|
let numActiveUniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
|
|
let blockIndex = gl.getUniformBlockIndex(program, "Transform");
|
|
let uniformIndices = [];
|
|
for (let i = 0; i < numActiveUniforms; i++)
|
|
uniformIndices.push(i);
|
|
let types = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_TYPE);
|
|
let sizes = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_SIZE);
|
|
let blockIndices = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_BLOCK_INDEX);
|
|
let offsets = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_OFFSET);
|
|
let arrayStrides = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_ARRAY_STRIDE);
|
|
let matrixStrides = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_MATRIX_STRIDE);
|
|
let rowMajors = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_IS_ROW_MAJOR);
|
|
for (let i = 0; i < numActiveUniforms; i++) {
|
|
if (types[i] != gl.FLOAT_MAT4 && types[i] != gl.FLOAT_MAT3)
|
|
testFailed("expected value: GL_FLOAT_MAT4 or GL_FLOAT_MAT3" + " actual value for UNIFORM_TYPE for uniform index[" + i + "]:" + wtu.glEnumToString(gl, types[i]));
|
|
if (sizes[i] != 1)
|
|
testFailed("expected value: 1" + " actual value for UNIFORM_SIZE for uniform index[" + i + "]:" + sizes[i]);
|
|
if (blockIndices[i] != blockIndex)
|
|
testFailed("expected value: 0" + " actual value for UNIFORM_BLOCK_INDEX for uniform index[" + i + "]:" + blockIndices[i]);
|
|
if (offsets[i] < 0)
|
|
testFailed("expected value >= 0" + " actual value for UNIFORM_OFFSET for uniform index[" + i + "]:" + offsets[i]);
|
|
if (arrayStrides[i] != 0)
|
|
testFailed("expected value: 0" + " actual value for UNIFORM_ARRAY_STRIDE for uniform index[" + i + "]:" + arrayStrides[i]);
|
|
if (matrixStrides[i] < 0)
|
|
testFailed("expected value >= 0" + " actual value for UNIFORM_MATRIX_STRIDE for uniform index[" + i + "]:" + matrixStrides[i]);
|
|
shouldBe(`"${typeof rowMajors[i]}"`, '"boolean"');
|
|
if (rowMajors[i] != false)
|
|
testFailed("expected value: 0" + " actual value for UNIFORM_IS_ROW_MAJOR for uniform index[" + i + "]:" + rowMajors[i]);
|
|
}
|
|
|
|
validArrayForPname = new Array(
|
|
gl.UNIFORM_TYPE,
|
|
gl.UNIFORM_SIZE,
|
|
gl.UNIFORM_BLOCK_INDEX,
|
|
gl.UNIFORM_OFFSET,
|
|
gl.UNIFORM_ARRAY_STRIDE,
|
|
gl.UNIFORM_MATRIX_STRIDE,
|
|
gl.UNIFORM_IS_ROW_MAJOR
|
|
);
|
|
await testInvalidArgument(
|
|
"getActiveUniforms",
|
|
"pname",
|
|
validArrayForPname,
|
|
function(pname) {
|
|
return gl.getActiveUniforms(program, uniformIndices, pname);
|
|
}
|
|
);
|
|
|
|
debug("");
|
|
debug("Test getUniformBlockIndex");
|
|
program = wtu.loadUniformBlockProgram(gl);
|
|
gl.linkProgram(program);
|
|
shouldBeTrue('gl.getProgramParameter(program, gl.LINK_STATUS)');
|
|
shouldBe('gl.getUniformBlockIndex(program, "Transform")', '0');
|
|
shouldBe('gl.getUniformBlockIndex(program, "u_modelViewMatrix")', 'gl.INVALID_INDEX');
|
|
shouldBe('gl.getUniformBlockIndex(program, "normal")', 'gl.INVALID_INDEX');
|
|
shouldBe('gl.getUniformBlockIndex(program, "u_normal")', 'gl.INVALID_INDEX');
|
|
window.noUniformProgram = wtu.loadStandardProgram(gl);
|
|
gl.linkProgram(noUniformProgram);
|
|
shouldBeTrue('gl.getProgramParameter(noUniformProgram, gl.LINK_STATUS)');
|
|
shouldBe('gl.getUniformBlockIndex(noUniformProgram, "u_modelViewProjMatrix")', 'gl.INVALID_INDEX');
|
|
shouldBe('gl.getUniformBlockIndex(noUniformProgram, "u_normal")', 'gl.INVALID_INDEX');
|
|
|
|
debug("");
|
|
debug("Test getActiveUniformBlockName");
|
|
program = wtu.loadUniformBlockProgram(gl);
|
|
gl.linkProgram(program);
|
|
shouldBeTrue('gl.getProgramParameter(program, gl.LINK_STATUS)');
|
|
shouldBeEqualToString('gl.getActiveUniformBlockName(program, 0)', 'Transform');
|
|
shouldBeNull('gl.getActiveUniformBlockName(program, -1)');
|
|
wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
|
|
shouldBeNull('gl.getActiveUniformBlockName(program, 1)');
|
|
wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
|
|
shouldBeNull('gl.getActiveUniformBlockName(program, gl.INVALID_INDEX)');
|
|
wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
|
|
window.noLinkProgram = gl.createProgram();
|
|
shouldBeFalse('gl.getProgramParameter(noLinkProgram, gl.LINK_STATUS)');
|
|
wtu.shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.getActiveUniformBlockName(noLinkProgram, 0)');
|
|
noUniformProgram = wtu.loadStandardProgram(gl);
|
|
gl.linkProgram(noUniformProgram);
|
|
shouldBeTrue('gl.getProgramParameter(noUniformProgram, gl.LINK_STATUS)');
|
|
shouldBeNull('gl.getActiveUniformBlockName(noUniformProgram, -1)');
|
|
wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
|
|
shouldBeNull('gl.getActiveUniformBlockName(noUniformProgram, 0)');
|
|
wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
|
|
shouldBeNull('gl.getActiveUniformBlockName(noUniformProgram, gl.INVALID_INDEX)');
|
|
wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
|
|
|
|
debug("");
|
|
debug("Test getActiveUniformBlockParameter");
|
|
program = wtu.loadUniformBlockProgram(gl);
|
|
gl.linkProgram(program);
|
|
shouldBeTrue('gl.getProgramParameter(program, gl.LINK_STATUS)');
|
|
shouldBe('gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_BINDING)', '0');
|
|
gl.uniformBlockBinding(program, 0, 1);
|
|
shouldBe('gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_BINDING)', '1');
|
|
// The actual block data size can be bigger than 164, depending on the uniform block layout.
|
|
shouldBeTrue('gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_DATA_SIZE) >= 164');
|
|
shouldBe('gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS)', '3');
|
|
shouldBeTrue('gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER)');
|
|
shouldBeFalse('gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER)');
|
|
let indices = gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES);
|
|
for (let i = 0; i < 3; i++) {
|
|
if (indices[i] < 0)
|
|
testFailed("expected value >= 0" + " actual value for UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES for uniform index[" + i + "]:" + indices[i]);
|
|
}
|
|
validArrayForPname = new Array(
|
|
gl.UNIFORM_BLOCK_BINDING,
|
|
gl.UNIFORM_BLOCK_DATA_SIZE,
|
|
gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS,
|
|
gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES,
|
|
gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER,
|
|
gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER
|
|
);
|
|
await testInvalidArgument(
|
|
"getActiveUniformBlockParameter",
|
|
"pname",
|
|
validArrayForPname,
|
|
function(pname) {
|
|
return gl.getActiveUniformBlockParameter(program, 0, pname);
|
|
}
|
|
);
|
|
}
|
|
|
|
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
|
|
|
|
finishTest();
|
|
})();
|
|
|
|
let successfullyParsed = true;
|