對有DX/OpenGL基礎的人,通過下面的代碼可以快速有一個WebGL概念
示例有兩個文件組成
webgl.html
<html>
<head>
<!--
Date: 2018-3-16
Author: kagula
Prologue:
对已经有DirectX/OpenGL基础的，通过这里的代码快速对WebGl有个概念!
Description:
用兩個三角形拼出一個彩色的正方形.
Original:
[1]https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/Tutorial/Using_shaders_to_apply_color_in_WebGL
測試環境
[1]Chrome 65.0.3325.162
[2]nginx 1.12.2
-->
<title>第一个Webgl程序</title>
<meta charset="utf-8">
<!-- gl-matrix version 2.4.0 from http://glmatrix.net/ -->
<script type="text/javascript" src="/gl-matrix-min.js"></script>
<script type="text/javascript" src="/kagula/webgl_helper.js"></script>
</head>
<body>
<canvas id="glCanvas" width="640" height="480"></canvas>
</body>
</html>
<script>
main();
//弄4个顶点, 4個顔色, 用来演示render流程!
function initBuffers(gl) {
// Create a buffer for the square's positions.
const positionBuffer = gl.createBuffer();
// Select the positionBuffer as the one to apply buffer
// operations to from here out.
gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
// Now create an array of positions for the square.
const positions = [
1.0, 1.0,
-1.0, 1.0,
1.0, -1.0,
-1.0, -1.0,
];
// Now pass the list of positions into WebGL to build the
// shape. We do this by creating a Float32Array from the
// JavaScript array, then use it to fill the current buffer.
gl.bufferData(gl.ARRAY_BUFFER,
new Float32Array(positions),
gl.STATIC_DRAW);
//給每個頂點弄一個顔色
const colors = [
1.0, 1.0, 1.0, 1.0, // white
1.0, 0.0, 0.0, 1.0, // red
0.0, 1.0, 0.0, 1.0, // green
0.0, 0.0, 1.0, 1.0, // blue
];
const colorBuffer = gl.createBuffer();//创建gl缓存，但是不指定缓存类型.
gl.bindBuffer(gl.ARRAY_BUFFER, colorBuffer);//指定olorBuffer的类型为gl.ARRAY_BUFFER
//缓冲区对象中的数据只指定1次，但是常常使用。这种模式下，OpenGL会将数据放在能够快速渲染的地方。
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(colors), gl.STATIC_DRAW);
return {
position: positionBuffer,
color: colorBuffer,
};
}
function main() {
//选择器的使用
//http://www.runoob.com/jsref/met-document-queryselector.html
const canvas = document.querySelector("#glCanvas");
// Initialize the GL context
const gl = canvas.getContext("webgl");
// Only continue if WebGL is available and working
if (!gl) {
alert("Unable to initialize WebGL. Your browser or machine may not support it.");
return;
}
// Vertex shader program
const vsSource = `
attribute vec4 aVertexPosition;
attribute vec4 aVertexColor;//从外部拿到颜色，不做任何处理，丢给vColor.
uniform mat4 uModelViewMatrix;
uniform mat4 uProjectionMatrix;
//从aVertexColor拿到的颜色直接给vColor,
//由vColor传给Fragment Shader.
varying lowp vec4 vColor;
void main() {
gl_Position = uProjectionMatrix * uModelViewMatrix * aVertexPosition;
vColor = aVertexColor;//什么都不做，只是为了把从外部得到的color传递给Fragment Shader.
}
`;
// Fragment shader, 相当于pixel shader
const fsSource = `
varying lowp vec4 vColor;//从vertex shader得到的颜色放在这里。
void main() {
//gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
gl_FragColor = vColor;//直接使用从vertex shader传过来的数据。
}
`;
//装配shader到shaderProgram中去
const shaderProgram = initShaderProgram(gl, vsSource, fsSource);
//为了让外部的数据能统一传到shanderProgram中去，新建programInfo对象。
//vertexPosition => aVertexPosition位置
//projectionMatrix => uProjectionMatrix位置
//modelViewMatrix => uModelViewMatrix位置
//...
const programInfo = {
program: shaderProgram,
attribLocations: {
vertexPosition: gl.getAttribLocation(shaderProgram, 'aVertexPosition'),
vertexColor: gl.getAttribLocation(shaderProgram, 'aVertexColor'),
},
uniformLocations: {
projectionMatrix: gl.getUniformLocation(shaderProgram, 'uProjectionMatrix'),
modelViewMatrix: gl.getUniformLocation(shaderProgram, 'uModelViewMatrix'),
},
};
//initBuffers(gl)返回要render的vertex.
drawScene(gl, programInfo, initBuffers(gl));
}//main
</script>
webgl_helper.js
// Initialize a shader program, so WebGL knows how to draw our data
function initShaderProgram(gl, vsSource, fsSource) {
const vertexShader = loadShader(gl, gl.VERTEX_SHADER, vsSource);
const fragmentShader = loadShader(gl, gl.FRAGMENT_SHADER, fsSource);
// Create the shader program
const shaderProgram = gl.createProgram();
gl.attachShader(shaderProgram, vertexShader);
gl.attachShader(shaderProgram, fragmentShader);
gl.linkProgram(shaderProgram);
// If creating the shader program failed, alert
if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {
alert('Unable to initialize the shader program: ' + gl.getProgramInfoLog(shaderProgram));
return null;
}
return shaderProgram;
}
// creates a shader of the given type, uploads the source and
// compiles it.
function loadShader(gl, type, source) {
const shader = gl.createShader(type);
// Send the source to the shader object
gl.shaderSource(shader, source);
// Compile the shader program
gl.compileShader(shader);
// See if it compiled successfully
if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
alert('An error occurred compiling the shaders: ' + gl.getShaderInfoLog(shader));
gl.deleteShader(shader);
return null;
}
return shader;
}
function drawScene(gl, programInfo, buffers) {
gl.clearColor(0.0, 0.0, 0.0, 1.0); // Clear to black, fully opaque
gl.clearDepth(1.0); // Clear everything
gl.enable(gl.DEPTH_TEST); // Enable depth testing
gl.depthFunc(gl.LEQUAL); // Near things obscure far things
// Clear the canvas before we start drawing on it.
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
// Create a perspective matrix, a special matrix that is
// used to simulate the distortion of perspective in a camera.
// Our field of view is 45 degrees, with a width/height
// ratio that matches the display size of the canvas
// and we only want to see objects between 0.1 units
// and 100 units away from the camera.
const fieldOfView = 45 * Math.PI / 180; // in radians
const aspect = gl.canvas.clientWidth / gl.canvas.clientHeight;
const zNear = 0.1;
const zFar = 100.0;
const projectionMatrix = mat4.create();
// note: glmatrix.js always has the first argument
// as the destination to receive the result.
mat4.perspective(projectionMatrix,
fieldOfView,
aspect,
zNear,
zFar);
// Set the drawing position to the "identity" point, which is
// the center of the scene.
const modelViewMatrix = mat4.create();
// Now move the drawing position a bit to where we want to
// start drawing the square.
mat4.translate(modelViewMatrix, // destination matrix
modelViewMatrix, // matrix to translate
[-0.0, 0.0, -6.0]); // amount to translate
// Tell WebGL how to pull out the positions from the position
// buffer into the vertexPosition attribute.
{
// gl.ARRAY_BUFFER => 指向 => buffers.position
gl.bindBuffer(gl.ARRAY_BUFFER, buffers.position);
//指定源数据格式.
//https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/vertexAttribPointer
gl.vertexAttribPointer(
programInfo.attribLocations.vertexPosition,
2,// pull out 2 values per iteration //Must be 1, 2, 3, or 4. 比如说顶点{x,y}要选2，{x,y,z}要选3，颜色{r,g,b,a}要选4
gl.FLOAT,// the data in the buffer is 32bit floats
false,// don't normalize
0,//stride, how many bytes to get from one set of values to the next
0);//how many bytes inside the buffer to start from
//源数据填充到gl
//tell WebGL that this attribute should be filled with data from our array buffer.
//gl.ARRAY_BUFFER => 数据传到 => programInfo.attribLocations.vertexPosition
gl.enableVertexAttribArray(
programInfo.attribLocations.vertexPosition);
}
// Tell WebGL how to pull out the colors from the color buffer
// into the vertexColor attribute.
{
//buffers.color => 数据传到 => gl.ARRAY_BUFFER
gl.bindBuffer(gl.ARRAY_BUFFER, buffers.color);
//设置programInfo.attribLocations.vertexColor格式
gl.vertexAttribPointer(
programInfo.attribLocations.vertexColor,
4,//size of {r g b a} = 4.
gl.FLOAT,
false,//normalize
0,//stride
0);//offset
//gl.ARRAY_BUFFER => 数据传到 => programInfo.attribLocations.vertexColor
gl.enableVertexAttribArray(
programInfo.attribLocations.vertexColor);
}
// Tell WebGL to use our program when drawing
gl.useProgram(programInfo.program);
// Set the shader uniforms
//projectionMatrix => programInfo.uniformLocations.projectionMatrix
gl.uniformMatrix4fv(
programInfo.uniformLocations.projectionMatrix,
false,//A GLboolean specifying whether to transpose the matrix. Must be false.
projectionMatrix);
//modelViewMatrix => programInfo.uniformLocations.modelViewMatrix
gl.uniformMatrix4fv(
programInfo.uniformLocations.modelViewMatrix,
false,
modelViewMatrix);
//數據準備好后可以draw了.
{
const offset = 0;
const vertexCount = 4;
//开始处理已经在gl中的顶点数据
//gl.TRIANGLE_STRIP模式復用前面兩個頂點, 所以這裏告訴gl, render兩個三角形.
gl.drawArrays(gl.TRIANGLE_STRIP, offset, vertexCount);
}
}