// Copyright 2011 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
WebGLTestUtils = (function() {
/**
* Converts a WebGL enum to a string
* @param {!WebGLContext} gl The WebGLContext to use.
* @param {number} value The enum value.
* @return {string} The enum as a string.
*/
var glEnumToString = function(gl, value) {
for (var p in gl) {
if (gl[p] == value) {
return p;
}
}
return '0x' + value.toString(16);
};
var lastError = '';
/**
* Returns the last compiler/linker error.
* @return {string} The last compiler/linker error.
*/
var getLastError = function() {
return lastError;
};
// clang-format off
/**
* A vertex shader for a single texture.
* @type {string}
*/
var simpleTextureVertexShader = [
'attribute vec4 vPosition;', //
'attribute vec2 texCoord0;',
'varying vec2 texCoord;',
'void main() {',
' gl_Position = vPosition;',
' texCoord = texCoord0;',
'}'
].join('\n');
/**
* A fragment shader for a single texture.
* @type {string}
*/
var simpleTextureFragmentShader = [
'precision mediump float;',
'uniform sampler2D tex;',
'varying vec2 texCoord;',
'void main() {',
' gl_FragData[0] = texture2D(tex, texCoord);',
'}'
].join('\n');
// clang-format on
/**
* Creates a simple texture vertex shader.
* @param {!WebGLContext} gl The WebGLContext to use.
* @return {!WebGLShader}
*/
var setupSimpleTextureVertexShader = function(gl) {
return loadShader(gl, simpleTextureVertexShader, gl.VERTEX_SHADER);
};
/**
* Creates a simple texture fragment shader.
* @param {!WebGLContext} gl The WebGLContext to use.
* @return {!WebGLShader}
*/
var setupSimpleTextureFragmentShader = function(gl) {
return loadShader(gl, simpleTextureFragmentShader, gl.FRAGMENT_SHADER);
};
/**
* Creates a program, attaches shaders, binds attrib locations, links the
* program and calls useProgram.
* @param {!Array.<!WebGLShader>} shaders The shaders to attach .
* @param {!Array.<string>} opt_attribs The attribs names.
* @param {!Array.<number>} opt_locations The locations for the attribs.
*/
var setupProgram = function(gl, shaders, opt_attribs, opt_locations) {
var realShaders = [];
var program = gl.createProgram();
for (var ii = 0; ii < shaders.length; ++ii) {
var shader = shaders[ii];
if (typeof shader == 'string') {
var element = document.getElementById(shader);
if (element) {
shader = loadShaderFromScript(gl, shader);
} else {
shader = loadShader(
gl, shader, ii ? gl.FRAGMENT_SHADER : gl.VERTEX_SHADER);
}
}
gl.attachShader(program, shader);
}
if (opt_attribs) {
for (var ii = 0; ii < opt_attribs.length; ++ii) {
gl.bindAttribLocation(
program, opt_locations ? opt_locations[ii] : ii, opt_attribs[ii]);
}
}
gl.linkProgram(program);
// Check the link status
var linked = gl.getProgramParameter(program, gl.LINK_STATUS);
if (!linked) {
gl.deleteProgram(program);
return null;
}
gl.useProgram(program);
return program;
};
/**
* Creates a simple texture program.
* @param {!WebGLContext} gl The WebGLContext to use.
* @param {number} opt_positionLocation The attrib location for position.
* @param {number} opt_texcoordLocation The attrib location for texture
* coords.
* @return {WebGLProgram}
*/
var setupSimpleTextureProgram = function(
gl, opt_positionLocation, opt_texcoordLocation) {
opt_positionLocation = opt_positionLocation || 0;
opt_texcoordLocation = opt_texcoordLocation || 1;
var vs = setupSimpleTextureVertexShader(gl);
var fs = setupSimpleTextureFragmentShader(gl);
if (!vs || !fs) {
return null;
}
var program = setupProgram(
gl, [vs, fs], ['vPosition', 'texCoord0'],
[opt_positionLocation, opt_texcoordLocation]);
if (!program) {
gl.deleteShader(fs);
gl.deleteShader(vs);
}
gl.useProgram(program);
return program;
};
/**
* Creates buffers for a textured unit quad and attaches them to vertex
* attribs.
* @param {!WebGLContext} gl The WebGLContext to use.
* @param {number} opt_positionLocation The attrib location for position.
* @param {number} opt_texcoordLocation The attrib location for texture
* coords.
* @return {!Array.<WebGLBuffer>} The buffer objects that were
* created.
*/
var setupUnitQuad = function(gl, opt_positionLocation, opt_texcoordLocation) {
opt_positionLocation = opt_positionLocation || 0;
opt_texcoordLocation = opt_texcoordLocation || 1;
var objects = [];
var vertexObject = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, vertexObject);
gl.bufferData(
gl.ARRAY_BUFFER, new Float32Array([
1.0, 1.0, 0.0, -1.0, 1.0, 0.0, -1.0, -1.0, 0.0, 1.0, 1.0, 0.0, -1.0,
-1.0, 0.0, 1.0, -1.0, 0.0
]),
gl.STATIC_DRAW);
gl.enableVertexAttribArray(opt_positionLocation);
gl.vertexAttribPointer(opt_positionLocation, 3, gl.FLOAT, false, 0, 0);
objects.push(vertexObject);
var vertexObject = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, vertexObject);
gl.bufferData(
gl.ARRAY_BUFFER,
new Float32Array(
[1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0]),
gl.STATIC_DRAW);
gl.enableVertexAttribArray(opt_texcoordLocation);
gl.vertexAttribPointer(opt_texcoordLocation, 2, gl.FLOAT, false, 0, 0);
objects.push(vertexObject);
return objects;
};
/**
* Creates a program and buffers for rendering a textured quad.
* @param {!WebGLContext} gl The WebGLContext to use.
* @param {number} opt_positionLocation The attrib location for position.
* @param {number} opt_texcoordLocation The attrib location for texture
* coords.
* @return {!WebGLProgram}
*/
var setupTexturedQuad = function(
gl, opt_positionLocation, opt_texcoordLocation) {
var program = setupSimpleTextureProgram(
gl, opt_positionLocation, opt_texcoordLocation);
setupUnitQuad(gl, opt_positionLocation, opt_texcoordLocation);
return program;
};
/**
* Draws a previously setup quad.
* @param {!WebGLContext} gl The WebGLContext to use.
* @param {!Array.<number>} opt_color The color to fill clear with before
* drawing. A 4 element array where each element is in the range 0 to
* 255. Default [255, 255, 255, 255]
*/
var drawQuad = function(gl, opt_color) {
opt_color = opt_color || [255, 255, 255, 255];
gl.clearColor(
opt_color[0] / 255, opt_color[1] / 255, opt_color[2] / 255,
opt_color[3] / 255);
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
gl.drawArrays(gl.TRIANGLES, 0, 6);
};
/**
* Links a WebGL program, throws if there are errors.
* @param {!WebGLContext} gl The WebGLContext to use.
* @param {!WebGLProgram} program The WebGLProgram to link.
* @param {function(string): void) opt_errorCallback callback for errors.
*/
var linkProgram = function(gl, program, opt_errorCallback) {
// Link the program
gl.linkProgram(program);
// Check the link status
var linked = gl.getProgramParameter(program, gl.LINK_STATUS);
if (!linked) {
// something went wrong with the link
gl.deleteProgram(program);
return false;
}
return true;
};
/**
* Loads a shader.
* @param {!WebGLContext} gl The WebGLContext to use.
* @param {string} shaderSource The shader source.
* @param {number} shaderType The type of shader.
* @param {function(string): void) opt_errorCallback callback for errors.
* @return {!WebGLShader} The created shader.
*/
var loadShader =
function(gl, shaderSource, shaderType, opt_errorCallback) {
var errFn = opt_errorCallback || (_ => {});
// Create the shader object
var shader = gl.createShader(shaderType);
if (shader == null) {
errFn('*** Error: unable to create shader \'' + shaderSource + '\'');
return null;
}
// Load the shader source
gl.shaderSource(shader, shaderSource);
var err = gl.getError();
if (err != gl.NO_ERROR) {
errFn(
'*** Error loading shader \'' + shader +
'\':' + glEnumToString(gl, err));
return null;
}
// Compile the shader
gl.compileShader(shader);
// Check the compile status
var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
if (!compiled) {
// Something went wrong during compilation; get the error
lastError = gl.getShaderInfoLog(shader);
errFn('*** Error compiling shader \'' + shader + '\':' + lastError);
gl.deleteShader(shader);
return null;
}
return shader;
}
/**
* Loads shaders from source, creates a program, attaches the shaders and
* links.
* @param {!WebGLContext} gl The WebGLContext to use.
* @param {string} vertexShader The vertex shader.
* @param {string} fragmentShader The fragment shader.
* @param {function(string): void) opt_errorCallback callback for errors.
* @return {!WebGLProgram} The created program.
*/
var loadProgram = function(
gl, vertexShader, fragmentShader, opt_errorCallback) {
var program = gl.createProgram();
gl.attachShader(
program,
loadShader(gl, vertexShader, gl.VERTEX_SHADER, opt_errorCallback));
gl.attachShader(
program,
loadShader(gl, fragmentShader, gl.FRAGMENT_SHADER, opt_errorCallback));
return linkProgram(gl, program, opt_errorCallback) ? program : null;
};
return {
drawQuad: drawQuad,
getLastError: getLastError,
glEnumToString: glEnumToString,
loadProgram: loadProgram,
loadShader: loadShader,
setupProgram: setupProgram,
setupSimpleTextureFragmentShader: setupSimpleTextureFragmentShader,
setupSimpleTextureProgram: setupSimpleTextureProgram,
setupSimpleTextureVertexShader: setupSimpleTextureVertexShader,
setupTexturedQuad: setupTexturedQuad,
setupUnitQuad: setupUnitQuad,
};
}());
Codebase Browser
chromium