<!DOCTYPE HTML>
<title>WebGL test: Drawing without attrib arrays</title>
<script src="/tests/SimpleTest/SimpleTest.js"></script>
<link rel="stylesheet" href="/tests/SimpleTest/test.css">
<script src="driver-info.js"></script>
<script src="webgl-util.js"></script>
<script id="vs-no-attrib" type="x-shader/x-vertex">
void main(void) {
gl_PointSize = 64.0;
gl_Position = vec4(vec3(0.0), 1.0);
}
</script>
<script id="vs-attrib" type="x-shader/x-vertex">
attribute vec3 aPosition;
void main(void) {
gl_PointSize = 64.0;
gl_Position = vec4(aPosition, 1.0);
}
</script>
<script id="fs" type="x-shader/x-fragment">
precision mediump float;
void main(void) {
gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
}
</script>
<body>
<canvas id="c" width="64" height="64"></canvas>
<script>
// Give ourselves a scope to return early from:
(function() {
var gl = WebGLUtil.getWebGL('c');
if (!gl) {
todo(false, 'WebGL is unavailable.');
return;
}
function errorFunc(str) {
ok(false, 'Error: ' + str);
}
WebGLUtil.setErrorFunc(errorFunc);
WebGLUtil.setWarningFunc(errorFunc);
var attribProg = WebGLUtil.createProgramByIds(gl, 'vs-attrib', 'fs');
var noAttribProg = WebGLUtil.createProgramByIds(gl, 'vs-no-attrib', 'fs');
if (!attribProg || !noAttribProg) {
ok(false, 'Program linking should succeed.');
return;
}
attribProg.aPosition = gl.getAttribLocation(attribProg, "aPosition");
ok(attribProg.aPosition >= 0, '`aPosition` should be valid.');
function isScreenBlack() {
var pixels = gl.drawingBufferWidth * gl.drawingBufferHeight;
var data = new Uint8Array(4 * pixels);
gl.readPixels(0, 0,
gl.drawingBufferWidth, gl.drawingBufferHeight,
gl.RGBA, gl.UNSIGNED_BYTE,
data);
var accum = 0;
for (var i = 0; i < pixels; i++) {
accum += data[4*i + 0];
accum += data[4*i + 1];
accum += data[4*i + 2];
}
return accum == 0;
}
function checkGLError(func, info) {
var error = gl.getError();
func(!error, '[' + info + '] gl.getError should be 0, was 0x' + error.toString(16) + '.');
}
function testDrawing(info) {
var cruelNumber = 1024*1024;
// Really, we should test for INT32_MAX-1 here, but we don't gracefully chunk these calls,
// and so try to create a VBO of size INT32_MAX-1 to pretend that vert attrib 0 is an array.
// (INT32_MAX-1 because we check that `first+count` is a valid GLsizei, which is int32_t)
var UINT16_MAX = 0xffff;
var INT32_MAX = 0x7fffffff;
var UINT32_MAX = 0xffffffff;
// `first` needs room for `first+count` <= sizeof(GLsizei) == INT32_MAX
var hugeFirst = Math.min(cruelNumber, INT32_MAX-1);
var hugeIndex = Math.min(cruelNumber, UINT32_MAX);
var indexType = gl.UNSIGNED_SHORT;
var indexStride = 2;
var indexArr = new Uint16Array([0, 1, Math.min(hugeIndex, UINT16_MAX)]);
if (gl.getExtension('OES_element_index_uint')) {
indexType = gl.UNSIGNED_INT;
indexStride = 4;
indexArr = new Uint32Array([0, 1, hugeIndex]);
}
gl.clear(gl.COLOR_BUFFER_BIT);
gl.drawArrays(gl.POINTS, 0, 1);
ok(!isScreenBlack(), '[' + info + '] drawArrays should color pixels.');
gl.clear(gl.COLOR_BUFFER_BIT);
gl.drawArrays(gl.POINTS, hugeFirst, 1);
ok(!isScreenBlack(), '[' + info + '] drawArrays[huge first] should color pixels.');
checkGLError(ok, info);
var elemTestFunc = todo; // We fail on most implementations.
var checkGLTestFunc = todo;
if (DriverInfo.getDriver() == DriverInfo.DRIVER.ANGLE ||
DriverInfo.getOS() == DriverInfo.OS.ANDROID)
{
// ANGLE and Android slaves seem to work fine.
elemTestFunc = ok;
checkGLTestFunc = ok;
}
if (DriverInfo.getDriver() == DriverInfo.DRIVER.ANDROID_X86_EMULATOR ||
DriverInfo.getOS() == DriverInfo.OS.B2G)
{
// ...but the Android 4.2 x86 emulator environment is different
elemTestFunc = todo;
checkGLTestFunc = ok;
}
// Now for drawElements:
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, gl.createBuffer());
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indexArr, gl.STATIC_DRAW);
gl.clear(gl.COLOR_BUFFER_BIT);
gl.drawElements(gl.POINTS, 1, indexType, 0);
elemTestFunc(!isScreenBlack(), '[' + info + '] drawElements[0] should color pixels.');
gl.clear(gl.COLOR_BUFFER_BIT);
gl.drawElements(gl.POINTS, 1, indexType, 1*indexStride);
elemTestFunc(!isScreenBlack(), '[' + info + '] drawElements[1] should color pixels.');
gl.clear(gl.COLOR_BUFFER_BIT);
gl.drawElements(gl.POINTS, 1, indexType, 2*indexStride);
elemTestFunc(!isScreenBlack(), '[' + info + '] drawElements[huge offset] should color pixels.');
checkGLError(checkGLTestFunc, info);
}
// Begin drawing
gl.clearColor(0.0, 0.0, 0.0, 1.0);
gl.disable(gl.DEPTH_TEST);
// No-attrib prog:
gl.useProgram(noAttribProg);
testDrawing('no-attrib');
// One-attrib, no-array prog:
gl.useProgram(attribProg);
gl.disableVertexAttribArray(attribProg.aPosition);
gl.vertexAttrib3fv(attribProg.aPosition, [0.0, 0.0, 0.0]);
testDrawing('one-attrib, no-array');
})();
</script>