读书笔记,技术储备指南

WebGL技术储备指南

2015/12/22 · HTML5 · 1
评论 ·
WebGL

原稿出处: Tmall前端团队(FED)-
叶斋   

图片 1

WebGL 是 HTML 5 草案的一局地,能够使得 Canvas 渲染三维场景。WebGL
固然还未有广泛应用,但极具潜力和设想空间。本文是自笔者上学 WebGL
时梳理知识系统的产物,花点时间整理出来与我们大饱眼福。

WebGL 是 HTML 5 草案的一有的,能够使得 Canvas 渲染三维场景。WebGL
即使还未有广泛应用,但极具潜力和想象空间。本文是本身就学 WebGL
时梳理知识系统的产物,花点时间整理出来与我们享用。

WebGL 是 HTML 5 草案的一有个别,能够使得 Canvas 渲染三维场景。WebGL
就算还未有广泛应用,但极具潜力和想象空间。本文是小编就学 WebGL
时梳理知识系统的产物,花点时间整理出来与大家分享。

一、前言

示例

WebGL 很酷,有以下 demos 为证:

招来奥兹国
赛车游戏
泛舟的男孩(Goo
Engine Demo)

示例

WebGL 很酷,有以下 demos 为证:

找寻奥兹国
赛车游戏
泛舟的男孩(Goo
Engine Demo)

示例

      前日高歌猛进第6章的读书内容,起首读书复合变换的学问。

正文的指标

读书笔记,技术储备指南。正文的料想读者是:面生图形学,熟稔前端,希望精晓或种类学习 WebGL
的同窗。

本文不是 WebGL 的概述性小说,也不是欧洲经济共同体详细的 WebGL
教程。本文只希望成为一篇供 WebGL 初学者使用的纲要。

正文的指标

正文的预期读者是:不熟悉图形学,纯熟前端,希望掌握或种类学习 WebGL
的同室。

本文不是 WebGL 的概述性小说,也不是全体详细的 WebGL
教程。本文只希望成为一篇供 WebGL 初学者使用的纲要。

WebGL 很酷,有以下 demos 为证:

 

Canvas

纯熟 Canvas 的同学都晓得,Canvas 绘图先要获取绘图上下文:

JavaScript

var context = canvas.getContext(‘2d’);

1
var context = canvas.getContext(‘2d’);

context上调用种种函数绘制图形,比如:

JavaScript

// 绘制左上角为(0,0),右下角为(50, 50)的矩形 context.fillRect(0, 0, 50,
50);

1
2
// 绘制左上角为(0,0),右下角为(50, 50)的矩形
context.fillRect(0, 0, 50, 50);

WebGL 同样需求获得绘图上下文:

JavaScript

var gl = canvas.getContext(‘webgl’); // 或 experimental-webgl

1
var gl = canvas.getContext(‘webgl’); // 或 experimental-webgl

只是接下去,假诺想画一个矩形的话,就没这么简单了。实际上,Canvas
是浏览器封装好的贰个制图环境,在其实举行绘图操作时,浏览器依然须要调用
OpenGL API。而 WebGL API 差不多正是 OpenGL API 未经封装,直接套了一层壳。

Canvas 的愈多知识,能够参见:

  • JS
    权威指南的
    21.4 节或 JS
    高级程序设计中的
    15 章
  • W3CSchool
  • 阮一峰的 Canvas
    教程

Canvas

纯熟 Canvas 的同班都知道,Canvas 绘图先要获取绘图上下文:

var context = canvas.getContext('2d');

context上调用各个函数绘制图形,比如:

// 绘制左上角为(0,0),右下角为(50, 50)的矩形
context.fillRect(0, 0, 50, 50);

WebGL 同样要求获得绘图上下文:

var gl = canvas.getContext('webgl'); // 或 experimental-webgl

唯独接下去,借使想画二个矩形的话,就没那样简单了。实际上,Canvas
是浏览器封装好的2个绘制环境,在实际开始展览绘图操作时,浏览器依旧必要调用
OpenGL API。而 WebGL API 大约就是 OpenGL API 未经封装,直接套了一层壳。

Canvas 的更加多学问,能够参照:

  • JS
    权威指南的
    21.4 节或 JS
    高级程序设计中的
    15 章
  • W3CSchool
  • 阮一峰的 Canvas
    教程

招来奥兹国

二、正文

矩阵变换

三维模型,从文件中读出来,到绘制在 Canvas 中,经历了频仍坐标变换。

借使有3个最简单易行的模子:三角形,多少个终端分别为(-1,-1,0),(1,-1,0),(0,1,0)。那五个数据是从文件中读出来的,是三角形最开头的坐标(局地坐标)。如下图所示,右手坐标系。

图片 2

模型平时不会放在场景的原点,假诺三角形的原点位于(0,0,-1)处,没有转动或缩放,八个极端分别为(-1,-1,-1),(1,-1,-1),(0,1,-1),即世界坐标。

图片 3

绘图三维场景必须钦定二个观察者,如果观看者位于(0,0,1)处而且看向三角形,那么四个极端相对于观望者的坐标为(-1,-1,-2),(1,-1,-2),(0,1,-2),即视图坐标。

图片 4

观看者的肉眼是2个点(那是看破投影的前提),水平视角和垂直视角都以90度,视野范围(目力所及)为[0,2]在Z轴上,观望者可以看到的区域是2个四棱台体。

图片 5

将四棱台体映射为专业立方(CCV,中央为原点,边长为2,边与坐标轴平行)。顶点在
CCV 中的坐标,离它最终在 Canvas 中的坐标已经很接近了,如若把 CCV
的前表面看成 Canvas,那么最后三角形就画在图中米黄三角形的任务。

图片 6

上述变换是用矩阵来实行的。

一对坐标 –(模型变换)-> 世界坐标 –(视图变换)-> 视图坐标
–(投影变换)–> CCV 坐标。

以(0,1,0)为例,它的齐次向量为(0,0,1,1),上述变换的代表经过能够是:

图片 7

下边八个矩阵依次是看破投影矩阵,视图矩阵,模型矩阵。八个矩阵的值分别取决于:阅览者的看法和视野距离,阅览者在世界中的状态(地点和大势),模型在世界中的状态(地方和样子)。总结的结果是(0,1,1,2),化成齐次坐标是(0,0.5,0.5,1),正是以此点在CCV中的坐标,那么(0,0.5)正是在Canvas中的坐标(认为
Canvas 中央为原点,长宽都为2)。

下边出现的(0,0,1,1)是(0,0,1)的齐次向量。齐次向量(x,y,z,w)能够表示三维向量(x,y,z)出席矩阵运算,通俗地说,w
分量为 1 时表示地点,w 分量为 0 时表示位移。

WebGL 没有提供任何有关上述变换的建制,开发者须求亲自总计顶点的 CCV
坐标。

有关坐标变换的越来越多内容,能够参考:

  • 处理器图形学中的5-7章
  • 更换矩阵@维基百科
  • 透视投影详解

相比复杂的是模型变换中的绕任意轴旋转(日常用四元数生成矩阵)和投影变换(上边的例证都没收涉及到)。

有关绕任意轴旋转和四元数,能够参考:

  • 四元数@维基百科
  • 三个老外对四元数公式的求证

至于齐次向量的更加多内容,能够参考。

  • 微型总括机图形学的5.2节
  • 齐次坐标@维基百科

矩阵变换

三维模型,从文件中读出来,到绘制在 Canvas 中,经历了数次坐标变换。

借使有三个最简便的模子:三角形,八个极端分别为(-1,-1,0),(1,-1,0),(0,1,0)。那多少个数据是从文件中读出来的,是三角形最开首的坐标(局地坐标)。如下图所示,右手坐标系。

图片 8

模型经常不会放在场景的原点,固然三角形的原点位于(0,0,-1)处,没有转动或缩放,四个顶峰分别为(-1,-1,-1),(1,-1,-1),(0,1,-1),即世界坐标。

图片 9

制图三维场景必须钦赐3个观看者,假使观望者位于(0,0,1)处而且看向三角形,那么七个极点相对于阅览者的坐标为(-1,-1,-2),(1,-1,-2),(0,1,-2),即视图坐标。

图片 10

观看者的眸子是三个点(那是看破投影的前提),水平视角和垂直视角都以90度,视野范围(目力所及)为[0,2]在Z轴上,观望者能够看出的区域是1个四棱台体。

图片 11

将四棱台体映射为标准立方(CCV,中央为原点,边长为2,边与坐标轴平行)。顶点在
CCV 中的坐标,离它说到底在 Canvas 中的坐标已经很相近了,如若把 CCV
的前表面看成 Canvas,那么最终三角形就画在图中淡红三角形的岗位。

图片 12

上述变换是用矩阵来拓展的。

一对坐标 –(模型变换)-> 世界坐标 –(视图变换)-> 视图坐标
–(投影变换)–> CCV 坐标。

以(0,1,0)为例,它的齐次向量为(0,0,1,1),上述变换的代表经过能够是:

图片 13

上面七个矩阵依次是看破投影矩阵,视图矩阵,模型矩阵。多个矩阵的值分别取决于:观望者的观点和视野距离,观看者在世界中的状态(地点和取向),模型在世界中的状态(位置和自由化)。总结的结果是(0,1,1,2),化成齐次坐标是(0,0.5,0.5,1),便是其一点在CCV中的坐标,那么(0,0.5)正是在Canvas中的坐标(认为
Canvas 中央为原点,长度宽度都为2)。

上边出现的(0,0,1,1)是(0,0,1)的齐次向量。齐次向量(x,y,z,w)能够代表三维向量(x,y,z)出席矩阵运算,通俗地说,w
分量为 1 时表示地点,w 分量为 0 时表示位移。

WebGL 没有提供别的关于上述变换的体制,开发者要求亲自总计顶点的 CCV
坐标。

至于坐标变换的愈多内容,能够参见:

  • 微机图形学中的5-7章
  • 转移矩阵@维基百科
  • 透视投影详解

相比较复杂的是模型变换中的绕任意轴旋转(常常用四元数生成矩阵)和投影变换(上边的事例都没收涉及到)。

至于绕任意轴旋转和四元数,能够参见:

  • 四元数@维基百科
  • 一个老外对四元数公式的表明

关于齐次向量的越多内容,能够参照。

  • 总计机图形学的5.2节
  • 齐次坐标@维基百科

跑车游戏

    
 **
Example1: 复合变换
**

着色器和光栅化

在 WebGL
中,开发者是经过着色器来完毕上述变换的。着色器是运维在显卡中的程序,以
GLSL 语言编写,开发者须求将着色器的源码以字符串的款型传给 WebGL
上下文的连锁函数。

着色器有三种,顶点着色器和片元(像素)着色器,它们成对出现。顶点着色器职务是接到顶点的有的坐标,输出
CCV 坐标。CCV
坐标经过光栅化,转化为逐像素的数目,传给片元着色器。片元着色器的天职是规定每种片元的水彩。

终极着色器接收的是 attribute 变量,是逐顶点的数量。顶点着色器输出
varying 变量,也是逐顶点的。逐顶点的 varying
变量数据经过光栅化,成为逐片元的 varying
变量数据,输入片元着色器,片元着色器输出的结果就会显得在 Canvas 上。

图片 14

着色器功效很多,上述只是基本效率。超过4/8炫酷的效能都是借助着色器的。假设您对着色器完全没有概念,能够试着明亮下一节
hello world 程序中的着色器再回忆一下本节。

至于越多着色器的知识,可以参见:

  • GLSL@维基百科
  • WebGL@MSDN

着色器和光栅化

在 WebGL
中,开发者是透过着色器来实现上述变换的。着色器是运作在显卡中的程序,以
GLSL 语言编写,开发者供给将着色器的源码以字符串的样式传给 WebGL
上下文的相干函数。

着色器有二种,顶点着色器和片元(像素)着色器,它们成对出现。顶点着色器职责是收纳顶点的一些坐标,输出
CCV 坐标。CCV
坐标经过光栅化,转化为逐像素的数码,传给片元着色器。片元着色器的任务是显明种种片元的颜料。

终点着色器接收的是 attribute 变量,是逐顶点的数码。顶点着色器输出
varying 变量,也是逐顶点的。逐顶点的 varying
变量数据通过光栅化,成为逐片元的 varying
变量数据,输入片元着色器,片元着色器输出的结果就会显得在 Canvas 上。

图片 15

着色器功用很多,上述只是基本效能。大多数炫酷的法力都以凭借着色器的。即使您对着色器完全没有定义,能够试着明亮下一节
hello world 程序中的着色器再回首一下本节。

关于越多着色器的知识,能够参见:

  • GLSL@维基百科
  • WebGL@MSDN

泛舟的男孩(Goo
EngineDemo)

      
在书中,作者为大家封装了一套用于转移的矩阵对象:Matrix4对象。它含有以下二种方法:

程序

这一节解释绘制上述场景(三角形)的 WebGL
程序。点其一链接,查看源代码,试图领悟一下。那段代码出自WebGL
Programming
Guide,我作了有的改动以适应本文内容。假设一切平常,你见到的应该是底下那样:

图片 16

释疑几点(若是以前不领悟 WebGL ,多半会对下面包车型客车代码猜疑,无碍):

  1. 字符串 VSHADER_SOURCE 和 FSHADER_SOUTiggoCE
    是极端着色器和片元着色器的源码。可以将着色器领悟为有稳定输入和出口格式的次序。开发者必要事先编写好着色器,再依照一定格式着色器发送绘图命令。
  2. Part2 将着色器源码编写翻译为 program
    对象:先分别编译顶点着色器和片元着色器,然后连接两者。要是编写翻译源码错误,不会报
    JS 错误,但足以因而其他API(如gl.getShaderInfo等)获取编写翻译状态消息(成功与否,如果出错的错误消息)。
JavaScript

// 顶点着色器 var vshader = gl.createShader(gl.VERTEX\_SHADER);
gl.shaderSource(vshader, VSHADER\_SOURCE);
gl.compileShader(vshader); // 同样新建 fshader var program =
gl.createProgram(); gl.attachShader(program, vshader);
gl.attachShader(program, fshader); gl.linkProgram(program);

<table>
<colgroup>
<col style="width: 50%" />
<col style="width: 50%" />
</colgroup>
<tbody>
<tr class="odd">
<td><div class="crayon-nums-content" style="font-size: 13px !important; line-height: 15px !important;">
<div class="crayon-num" data-line="crayon-5b8f14b3a671c960813930-1">
1
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f14b3a671c960813930-2">
2
</div>
<div class="crayon-num" data-line="crayon-5b8f14b3a671c960813930-3">
3
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f14b3a671c960813930-4">
4
</div>
<div class="crayon-num" data-line="crayon-5b8f14b3a671c960813930-5">
5
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f14b3a671c960813930-6">
6
</div>
<div class="crayon-num" data-line="crayon-5b8f14b3a671c960813930-7">
7
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f14b3a671c960813930-8">
8
</div>
<div class="crayon-num" data-line="crayon-5b8f14b3a671c960813930-9">
9
</div>
</div></td>
<td><div class="crayon-pre" style="font-size: 13px !important; line-height: 15px !important; -moz-tab-size:4; -o-tab-size:4; -webkit-tab-size:4; tab-size:4;">
<div id="crayon-5b8f14b3a671c960813930-1" class="crayon-line">
// 顶点着色器
</div>
<div id="crayon-5b8f14b3a671c960813930-2" class="crayon-line crayon-striped-line">
var vshader = gl.createShader(gl.VERTEX_SHADER);
</div>
<div id="crayon-5b8f14b3a671c960813930-3" class="crayon-line">
gl.shaderSource(vshader, VSHADER_SOURCE);
</div>
<div id="crayon-5b8f14b3a671c960813930-4" class="crayon-line crayon-striped-line">
gl.compileShader(vshader);
</div>
<div id="crayon-5b8f14b3a671c960813930-5" class="crayon-line">
// 同样新建 fshader
</div>
<div id="crayon-5b8f14b3a671c960813930-6" class="crayon-line crayon-striped-line">
var program = gl.createProgram();
</div>
<div id="crayon-5b8f14b3a671c960813930-7" class="crayon-line">
gl.attachShader(program, vshader);
</div>
<div id="crayon-5b8f14b3a671c960813930-8" class="crayon-line crayon-striped-line">
gl.attachShader(program, fshader);
</div>
<div id="crayon-5b8f14b3a671c960813930-9" class="crayon-line">
gl.linkProgram(program);
</div>
</div></td>
</tr>
</tbody>
</table>
  1. program
    对象须求指定使用它,才足以向着色器传数据并绘制。复杂的主次日常有多个program 对 象,(绘制每一帧时)通过切换 program
    对象绘制场景中的不相同作用。
JavaScript

gl.useProgram(program);

<table>
<colgroup>
<col style="width: 50%" />
<col style="width: 50%" />
</colgroup>
<tbody>
<tr class="odd">
<td><div class="crayon-nums-content" style="font-size: 13px !important; line-height: 15px !important;">
<div class="crayon-num" data-line="crayon-5b8f14b3a6720232020477-1">
1
</div>
</div></td>
<td><div class="crayon-pre" style="font-size: 13px !important; line-height: 15px !important; -moz-tab-size:4; -o-tab-size:4; -webkit-tab-size:4; tab-size:4;">
<div id="crayon-5b8f14b3a6720232020477-1" class="crayon-line">
gl.useProgram(program);
</div>
</div></td>
</tr>
</tbody>
</table>
  1. Part3 向正在选取的着色器传入数据,包涵逐顶点的 attribute
    变量和全局的 uniform 变量。向着色器传入数据必须运用
    ArrayBuffer,而不是例行的 JS 数组。
JavaScript

var varray = new Float32Array(\[-1, -1, 0, 1, -1, 0, 0, 1, 0\])

<table>
<colgroup>
<col style="width: 50%" />
<col style="width: 50%" />
</colgroup>
<tbody>
<tr class="odd">
<td><div class="crayon-nums-content" style="font-size: 13px !important; line-height: 15px !important;">
<div class="crayon-num" data-line="crayon-5b8f14b3a6723482450329-1">
1
</div>
</div></td>
<td><div class="crayon-pre" style="font-size: 13px !important; line-height: 15px !important; -moz-tab-size:4; -o-tab-size:4; -webkit-tab-size:4; tab-size:4;">
<div id="crayon-5b8f14b3a6723482450329-1" class="crayon-line">
var varray = new Float32Array([-1, -1, 0, 1, -1, 0, 0, 1, 0])
</div>
</div></td>
</tr>
</tbody>
</table>
  1. WebGL API 对 ArrayBuffer
    的操作(填充缓冲区,传入着色器,绘制等)都以通过 gl.A奥迪Q7RAY_BUFFE宝马X3举办的。在 WebGL 系统中又很多近乎的情形。
JavaScript

// 只有将 vbuffer 绑定到 gl.ARRAY\_BUFFER,才可以填充数据
gl.bindBuffer(gl.ARRAY\_BUFFER, vbuffer); // 这里的意思是,向“绑定到
gl.ARRAY\_BUFFER”的缓冲区中填充数据 gl.bufferData(gl.ARRAY\_BUFFER,
varray, gl.STATIC\_DRAW); // 获取 a\_Position
变量在着色器程序中的位置,参考顶点着色器源码 var aloc =
gl.getAttribLocation(program, 'a\_Position'); // 将 gl.ARRAY\_BUFFER
中的数据传入 aloc 表示的变量,即 a\_Position
gl.vertexAttribPointer(aloc, 3, gl.FLOAT, false, 0, 0);
gl.enableVertexAttribArray(aloc);

<table>
<colgroup>
<col style="width: 50%" />
<col style="width: 50%" />
</colgroup>
<tbody>
<tr class="odd">
<td><div class="crayon-nums-content" style="font-size: 13px !important; line-height: 15px !important;">
<div class="crayon-num" data-line="crayon-5b8f14b3a6727492492738-1">
1
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f14b3a6727492492738-2">
2
</div>
<div class="crayon-num" data-line="crayon-5b8f14b3a6727492492738-3">
3
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f14b3a6727492492738-4">
4
</div>
<div class="crayon-num" data-line="crayon-5b8f14b3a6727492492738-5">
5
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f14b3a6727492492738-6">
6
</div>
<div class="crayon-num" data-line="crayon-5b8f14b3a6727492492738-7">
7
</div>
<div class="crayon-num crayon-striped-num" data-line="crayon-5b8f14b3a6727492492738-8">
8
</div>
<div class="crayon-num" data-line="crayon-5b8f14b3a6727492492738-9">
9
</div>
</div></td>
<td><div class="crayon-pre" style="font-size: 13px !important; line-height: 15px !important; -moz-tab-size:4; -o-tab-size:4; -webkit-tab-size:4; tab-size:4;">
<div id="crayon-5b8f14b3a6727492492738-1" class="crayon-line">
// 只有将 vbuffer 绑定到 gl.ARRAY_BUFFER,才可以填充数据
</div>
<div id="crayon-5b8f14b3a6727492492738-2" class="crayon-line crayon-striped-line">
gl.bindBuffer(gl.ARRAY_BUFFER, vbuffer);
</div>
<div id="crayon-5b8f14b3a6727492492738-3" class="crayon-line">
// 这里的意思是,向“绑定到 gl.ARRAY_BUFFER”的缓冲区中填充数据
</div>
<div id="crayon-5b8f14b3a6727492492738-4" class="crayon-line crayon-striped-line">
gl.bufferData(gl.ARRAY_BUFFER, varray, gl.STATIC_DRAW);
</div>
<div id="crayon-5b8f14b3a6727492492738-5" class="crayon-line">
// 获取 a_Position 变量在着色器程序中的位置,参考顶点着色器源码
</div>
<div id="crayon-5b8f14b3a6727492492738-6" class="crayon-line crayon-striped-line">
var aloc = gl.getAttribLocation(program, 'a_Position');
</div>
<div id="crayon-5b8f14b3a6727492492738-7" class="crayon-line">
// 将 gl.ARRAY_BUFFER 中的数据传入 aloc 表示的变量,即 a_Position
</div>
<div id="crayon-5b8f14b3a6727492492738-8" class="crayon-line crayon-striped-line">
gl.vertexAttribPointer(aloc, 3, gl.FLOAT, false, 0, 0);
</div>
<div id="crayon-5b8f14b3a6727492492738-9" class="crayon-line">
gl.enableVertexAttribArray(aloc);
</div>
</div></td>
</tr>
</tbody>
</table>
  1. 向着色器传入矩阵时,是按列存款和储蓄的。能够相比一下 mmatrix
    和矩阵变换一节中的模型矩阵(第 3 个)。
  2. 终点着色器总计出的 gl_Position 正是 CCV
    中的坐标,比如最上边的终点(紫罗兰色)的 gl_Position
    化成齐次坐标就是(0,0.5,0.5,1)。
  3. 向终点着色器传入的只是七个顶峰的水彩值,而三角形表面包车型大巴颜料渐变是由那多少个颜色值内插出的。光栅化不仅会对
    gl_Position 举行,还会对 varying 变量插值。
  4. gl.drawArrays()方法使得缓冲区举办绘图,gl.T凯雷德IANGLES
    钦命绘制三角形,也得以变更参数绘制点、折线等等。

有关 ArrayBuffer 的详细新闻,能够参照:

  • ArrayBuffer@MDN
  • 阮一峰的 ArrayBuffer
    介绍
  • 张鑫旭的 ArrayBuffer
    介绍

关于 gl.TQashqaiIANGLES
等其余绘制形式,能够参照上面那张图或那篇博文。

图片 17

程序

这一节解释绘制上述现象(三角形)的 WebGL
程序。点这些链接,查看源代码,试图精晓一下。这段代码出自WebGL
Programming
Guide,小编作了有的改动以适应本文内容。固然一切寻常,你看来的相应是底下那样:

图片 18

释疑几点(假如此前不打听 WebGL ,多半会对下面包车型客车代码嫌疑,无碍):

  1. 字符串 VSHADER_SOURCE 和 FSHADER_SOU大切诺基CE
    是极端着色器和片元着色器的源码。可以将着色器明白为有稳定输入和出口格式的次序。开发者供给事先编写好着色器,再根据一定格式着色器发送绘图命令。

  2. Part2 将着色器源码编写翻译为 program
    对象:先分别编写翻译顶点着色器和片元着色器,然后连接两者。假使编写翻译源码错误,不会报
    JS 错误,但足以经过其它API(如gl.getShaderInfo等)获取编写翻译状态新闻(成功与否,倘诺出错的错误消息)。

    // 顶点着色器
    var vshader = gl.createShader(gl.VERTEX_SHADER);
    gl.shaderSource(vshader, VSHADER_SOURCE);
    gl.compileShader(vshader);
    // 同样新建 fshader
    var program = gl.createProgram();
    gl.attachShader(program, vshader);
    gl.attachShader(program, fshader);
    gl.linkProgram(program);
    
  3. program
    对象急需钦赐使用它,才方可向着色器传数据并绘制。复杂的先后平常有几个program 对 象,(绘制每一帧时)通过切换 program
    对象绘制场景中的差别效率。

    gl.useProgram(program);
    
  4. Part3 向正在利用的着色器传入数据,包蕴逐顶点的 attribute
    变量和大局的 uniform 变量。向着色器传入数据必须采纳ArrayBuffer,而不是正规的 JS 数组。

    var varray = new Float32Array([-1, -1, 0, 1, -1, 0, 0, 1, 0])
    
  5. WebGL API 对 ArrayBuffer
    的操作(填充缓冲区,传入着色器,绘制等)都以通过 gl.ARubiconRAY_BUFFE哈弗实行的。在 WebGL 系统中又很多看似的情形。

    // 只有将 vbuffer 绑定到 gl.ARRAY_BUFFER,才可以填充数据
    gl.bindBuffer(gl.ARRAY_BUFFER, vbuffer);
    // 这里的意思是,向“绑定到 gl.ARRAY_BUFFER”的缓冲区中填充数据
    gl.bufferData(gl.ARRAY_BUFFER, varray, gl.STATIC_DRAW);
    // 获取 a_Position 变量在着色器程序中的位置,参考顶点着色器源码
    var aloc = gl.getAttribLocation(program, 'a_Position');
    // 将 gl.ARRAY_BUFFER 中的数据传入 aloc 表示的变量,即 a_Position
    gl.vertexAttribPointer(aloc, 3, gl.FLOAT, false, 0, 0);
    gl.enableVertexAttribArray(aloc);
    
  6. 向着色器传入矩阵时,是按列存储的。能够相比较一下 mmatrix
    和矩阵变换一节中的模型矩阵(第 3 个)。

  7. 终极着色器总结出的 gl_Position 正是 CCV
    中的坐标,比如最上边的终端(杏黄)的 gl_Position
    化成齐次坐标正是(0,0.5,0.5,1)。

  8. 向终极着色器传入的只是八个顶峰的颜色值,而三角形表面包车型客车颜色渐变是由那八个颜色值内插出的。光栅化不仅会对
    gl_Position 举行,还会对 varying 变量插值。

  9. gl.drawArrays()方法使得缓冲区实行绘图,gl.TRubiconIANGLES
    钦点绘制三角形,也足以改变参数绘制点、折线等等。

至于 ArrayBuffer 的详细新闻,能够参见:

  • ArrayBuffer@MDN
  • 阮一峰的 ArrayBuffer
    介绍
  • 张鑫旭的 ArrayBuffer
    介绍

至于 gl.T帕杰罗IANGLES
等此外绘制格局,能够参考上边那张图或那篇博文。

图片 19

正文的对象

  1. Matrix4.setIdentity():
    将Matrix4实例化为单位矩阵
  2. Matrix4.setTranslate(x,y,z):
    将Matrix4实例设置为平移变换矩阵,在x轴平移距离为x,在y轴平移距离为y,在z轴平移距离为z;

  3. Matrix4.setScale(x,y,z):
    将Matrix4实例设置为缩放变换矩阵,缩放因子分别为x,y,z;

  4. Matrix4.setRotate(angle,x,y,z):
    将Matrix4实例设置为旋转变换矩阵,角度为angle,旋转轴为(x,y,z);
  5. Matrix4.translate(x,y,z):
    将Matrix4实例本身乘以贰个平移变换矩阵;
  6. Matrix4.rototate(angle,x,y,z):
    将Matrix4实例本人乘以2个旋转变换矩阵;
  7. Matrix4.scale(x,y,z): 将Matrix4实例本人乘以三个缩放变换矩阵;
  8. Matrix4.set(m): 将Matrix4设置为m;
  9. Matrix4.elements:
    类型化数组包蕴了Matrix4实例的矩阵成分;

    var modelMatrix = new Matrix4();
    modelMatrix.setRotate(ANGLE,0,0,1);
    modelMatrix.translate(Tx,0,0);

    … …

    gl.uniformMatrix4fv(u_ModelMatrix,false,modelMatrix.elements);

深度检查和测试

当五个外表重叠时,前边的模子会遮掩前面包车型地铁模子。比如其一例子,绘制了多个交叉的三角(
varray 和 carray 的尺寸变为 18,gl.drawArrays 最终三个参数变为
6)。为了不难,那些例子去掉了矩阵变换进程,直接向着色器传入 CCV 坐标。

图片 20

图片 21

顶点着色器给出了 6 个极端的 gl_Position ,经过光栅化,片元着色器得到了
2X 个片元(要是 X 为各种三角形的像素个数),每一个片元都离散的 x,y
坐标值,还有 z 值。x,y 坐标便是三角形在 Canvas
上的坐标,但固然有多个颇具相同 x,y 坐标的片元同时出现,那么 WebGL
就会取 z 坐标值较小的万分片元。

在深度检查和测试在此之前,必须在绘制前拉开七个常量。不然,WebGL 就会遵守在 varray
中定义的逐条绘制了,前面包车型大巴会覆盖后边的。

JavaScript

gl.enable(gl.DEPTH_TEST);

1
gl.enable(gl.DEPTH_TEST);

实质上,WebGL 的逻辑是如此的:依次拍卖片元,要是渲染缓冲区(那里正是Canvas
了)的尤其与如今片元对应的像素还没有绘制时,就把片元的颜料画到渲染缓冲区对应像素里,同时把片元的
z
值缓存在另1个深度缓冲区的均等地点;假诺当前缓冲区的附和像素已经绘制过了,就去查看深度缓冲区中对应地方的
z 值,假设当前片元 z 值小,就重绘,不然就放弃当前片元。

WebGL 的那套逻辑,对明白蒙版(前面会说到)有一些赞助。

纵深检测

当四个外表重叠时,前边的模子会遮掩前面的模型。比如其一事例,绘制了多少个交叉的三角(
varray 和 carray 的长短变为 18,gl.drawArrays 最后三个参数变为
6)。为了容易,那几个例子去掉了矩阵变换进度,直接向着色器传入 CCV 坐标。

图片 22

图片 23

终点着色器给出了 6 个终端的 gl_Position ,经过光栅化,片元着色器获得了
2X 个片元(假诺 X 为种种三角形的像素个数),各样片元都离散的 x,y
坐标值,还有 z 值。x,y 坐标就是三角形在 Canvas
上的坐标,但一旦有八个拥有同等 x,y 坐标的片元同时出现,那么 WebGL
就会取 z 坐标值较小的不行片元。

在深度检查和测试在此之前,必须在绘制前拉开一个常量。不然,WebGL 就会安份守己在 varray
中定义的相继绘制了,后边的会覆盖前边的。

gl.enable(gl.DEPTH_TEST);

实在,WebGL 的逻辑是那般的:依次拍卖片元,假诺渲染缓冲区(那里就是Canvas
了)的可怜与眼下片元对应的像素还并未绘制时,就把片元的水彩画到渲染缓冲区对应像素里,同时把片元的
z
值缓存在另贰个纵深缓冲区的一样地方;假如当前缓冲区的对应像素已经绘制过了,就去查看深度缓冲区中对应地点的
z 值,若是当前片元 z 值小,就重绘,不然就甩掉当前片元。

WebGL 的那套逻辑,对理解蒙版(后边会说到)有一部分救助。

本文的意料读者是:不熟悉图形学,熟稔前端,希望了然或系统学习 WebGL
的同学。

 

顶点索引

gl.drawArrays()是比照顶点的次第绘制的,而
gl.drawElements()能够令着色器以一个索引数组为顺序绘制顶点。比如那几个事例。

图片 24

此地画了几个三角,但只用了 4个顶峰,有2个终端被多个三角共用。那时急需树立索引数组,数组的各种成分表示顶点的索引值。将数组填充至gl.ELEMENT_ARRAY,然后调用
gl.drawElements()。

JavaScript

var iarray = new Uint8Array([0,1,2,2,3,4]); var ibuffer =
gl.createBuffer(gl.ARRAY_BUFFER, ibuffer);
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibuffer);
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, iarray, gl.STATIC_DRAW);

1
2
3
4
var iarray = new Uint8Array([0,1,2,2,3,4]);
var ibuffer = gl.createBuffer(gl.ARRAY_BUFFER, ibuffer);
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibuffer);
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, iarray, gl.STATIC_DRAW);

顶点索引

gl.drawArrays()是遵照顶点的次第绘制的,而
gl.drawElements()能够令着色器以3个索引数组为顺序绘制顶点。比如那几个事例。

图片 25

此间画了多少个三角,但只用了 多个顶峰,有3个巅峰被三个三角形共用。那时急需树立索引数组,数组的各类成分表示顶点的索引值。将数组填充至gl.ELEMENT_ARRAY,然后调用
gl.drawElements()。

var iarray = new Uint8Array([0,1,2,2,3,4]);
var ibuffer = gl.createBuffer(gl.ARRAY_BUFFER, ibuffer);
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibuffer);
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, iarray, gl.STATIC_DRAW);

正文不是 WebGL 的概述性小说,也不是完全详细的 WebGL
教程。本文只盼望变成一篇供 WebGL 初学者使用的总纲。

         Example2:
动画

纹理

attribute
变量不仅能够传递顶点的坐标,还是能传递其余任何逐顶点的数目。比如
HelloTriangle 程序把单个顶点的颜料传入了 a_Color,片元着色器收到
v_Color 后直接赋给 gl_FragmentColor,就决定了颜色。

attribute
变量还足以辅助绘制纹理。绘制纹理的基本原理是,为各种终端钦定2个纹理坐标(在(0,0)与(1,1,)的四方形中),然后传入纹理对象。片元着色器得到的是对应片元的内插后的纹路坐标,就使用这些纹理坐标去纹理对象上取颜色,再画到片元上。内插后的纹路坐标很也许不凑巧对应纹理上的某部像素,而是在多少个像素之间(因为一般的图片纹理也是离散),那时只怕会因而周围多少个像素的加权平均算出该像素的值(具体有若干种差异措施,能够参照)。

比如这么些事例。

图片 26

纹理对象和缓冲区指标很接近:使用 gl 的 API 函数创造,要求绑定至常量
gl.ATiggoRAY_BUFFER 和 gl.TEXTURE_2D
,都由此常量对象向里面填入图像和数目。不相同的是,纹理对象在绑定时还须求激活3个纹理单元(此处的gl.TEXTURE0),而
WebGL 系统支持的纹路单元个数是很简单的(一般为 8 个)。

JavaScript

var texture = gl.createTexture();
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 1);
gl.activeTexture(gl.TEXTURE0); gl.bindTexture(gl.TEXTURE_2D, texture);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, gl.RGB, gl.UNSIGNED_BYTE,
textureImage); var sloc = gl.getUniformLocation(program, ‘u_Sampler’);
gl.uniform1i(sloc, 0);

1
2
3
4
5
6
7
8
var texture = gl.createTexture();
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 1);
gl.activeTexture(gl.TEXTURE0);
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, gl.RGB, gl.UNSIGNED_BYTE, textureImage);
var sloc = gl.getUniformLocation(program, ‘u_Sampler’);
gl.uniform1i(sloc, 0);

片元着色器内证明了 sampler2D 类型的 uniform
变量,通过texture2D函数取样。

JavaScript

precision mediump float; uniform sampler2D u_Sampler; varying vec2
v_TexCoord; void main() { gl_FragColor = texture2D(u_Sampler,
v_TexCoord); };

1
2
3
4
5
6
precision mediump float;
uniform sampler2D u_Sampler;
varying vec2 v_TexCoord;
void main() {
  gl_FragColor = texture2D(u_Sampler, v_TexCoord);
};

纹理

attribute
变量不仅能够传递顶点的坐标,还足以传递其余任何逐顶点的数码。比如
HelloTriangle 程序把单个顶点的水彩传入了 a_Color,片元着色器收到
v_Color 后直接赋给 gl_FragmentColor,就决定了颜色。

attribute
变量还足以扶持绘制纹理。绘制纹理的基本原理是,为每一个终端钦点一个纹理坐标(在(0,0)与(1,1,)的圆柱形中),然后传入纹理对象。片元着色器获得的是对应片元的内插后的纹路坐标,就利用这些纹理坐标去纹理对象上取颜色,再画到片元上。内插后的纹路坐标很只怕不凑巧对应纹理上的某部像素,而是在几个像素之间(因为普通的图形纹理也是离散),那时恐怕会经过周围多少个像素的加权平均算出该像素的值(具体有好二种差异方法,能够参见)。

比如以此事例。

图片 27

纹理对象和缓冲区目的很相近:使用 gl 的 API 函数创立,要求绑定至常量
gl.APRADORAY_BUFFER 和 gl.TEXTURE_2D
,都经过常量对象向里面填入图像和数目。区别的是,纹理对象在绑定时还供给激活多少个纹理单元(此处的gl.TEXTURE0),而
WebGL 系统协理的纹路单元个数是很单薄的(一般为 8 个)。

var texture = gl.createTexture();
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 1);
gl.activeTexture(gl.TEXTURE0);
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, gl.RGB, gl.UNSIGNED_BYTE, textureImage);
var sloc = gl.getUniformLocation(program, 'u_Sampler');
gl.uniform1i(sloc, 0);

片元着色器内注脚了 sampler2D 类型的 uniform
变量,通过texture2D函数取样。

precision mediump float;
uniform sampler2D u_Sampler;
varying vec2 v_TexCoord;
void main() {
  gl_FragColor = texture2D(u_Sampler, v_TexCoord);
};

Canvas

 requestAnimationFrame(func):
请求浏览器在未来某时刻回调函数func以形成重绘。大家应该在回调函数最后再次发起该请求。

错落与蒙版

透明效果是用混合机制成功的。混合机制与深度检查和测试类似,也时有产生在准备向有个别已填写的像素填充颜色时。深度检查和测试通过比较z值来明确像素的水彩,而掺杂机制会将三种颜色混合。比如这一个例子。

图片 28

错落的一一是服从绘制的种种举办的,固然绘制的逐条有生成,混合的结果经常也不相同。若是模型既有非透明表面又有晶莹剔透表面,绘制透明表面时打开蒙版,其目标是锁定深度缓冲区,因为半晶莹剔透物体前边的实体照旧得以见见的,假若不那样做,半透明物体前边的实体将会被深度检查和测试机制排除。

翻开混合的代码如下。gl.blendFunc格局钦命了交集的主意,那里的情致是,使用源(待混合)颜色的
α 值乘以源颜色,加上 1-[源颜色的 α]乘以目的颜色。

JavaScript

gl.enable(gl.BLEND); gl.blendFunc(gl.SRC_ALPHA,
gl.ONE_MINUS_SRC_ALPHA);

1
2
gl.enable(gl.BLEND);
gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);

所谓 α 值,便是颜色的第 4 个轻重。

JavaScript

var carray = new Float32Array([ 1,0,0,0.7,1,0,0,0.7,1,0,0,0.7,
0,0,1,0.4,0,0,1,0.4,0,0,1,0.4 ]);

1
2
3
4
var carray = new Float32Array([
  1,0,0,0.7,1,0,0,0.7,1,0,0,0.7,
  0,0,1,0.4,0,0,1,0.4,0,0,1,0.4
  ]);

掺杂与蒙版

晶莹剔透效果是用混合机制实现的。混合机制与深度检测类似,也发生在打算向某些已填写的像素填充颜色时。深度检查和测试通过比较z值来明确像素的颜料,而掺杂机制会将两种颜色混合。比如以此事例。

图片 29

掺杂的相继是奉公守法绘制的相继举行的,假若绘制的逐一有变化,混合的结果平时也不如。要是模型既有非透明表面又有透明表面,绘制透明表面时打开蒙版,其指标是锁定深度缓冲区,因为半透明物体前边的物体如故得以看出的,假设不这么做,半晶莹剔透物体前面包车型大巴物体将会被深度检查和测试机制排除。

打开混合的代码如下。gl.blendFunc方法内定了混合的不二法门,那里的情趣是,使用源(待混合)颜色的
α 值乘以源颜色,加上 1-[源颜色的 α]乘以指标颜色。

gl.enable(gl.BLEND);
gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);

所谓 α 值,就是颜色的第 4 个轻重。

var carray = new Float32Array([
  1,0,0,0.7,1,0,0,0.7,1,0,0,0.7,
  0,0,1,0.4,0,0,1,0.4,0,0,1,0.4
  ]);

熟练 Canvas 的同校都明白,Canvas 绘图先要获取绘图上下文:

var tick = function() {
    currentAngle = animate(currentAngle);  // Update the rotation angle
    draw(gl, n, currentAngle, modelMatrix, u_ModelMatrix);   // Draw the triangle
    requestAnimationFrame(tick, canvas); // Request that the browser calls tick
};
tick();

浏览器的WebGL系统

WebGL 系统依次组成都部队分在既定规则下相互协作。稍作梳理如下。

图片 30

那张图相比轻易,箭头上的文字表示
API,箭头方向大概表现了多少的流动方向,不必深究。

浏览器的WebGL系统

WebGL 系统依次组成部分在既定规则下互相合营。稍作梳理如下。

图片 31

那张图相比较自由,箭头上的文字表示
API,箭头方向大致表现了多少的流动方向,不必深究。

var context = canvas.getContext(‘2d’);

 

光照

WebGL 没有为光照提供其余内置的不二法门,须要开发者在着色器中贯彻光照算法。

只不过有颜色的,模型也是有颜色的。在光照下,最后物体展现的颜料是两者一起作用的结果。

贯彻光照的艺术是:将光照的多寡(点光源的地点,平行光的方向,以及光的颜色和强度)作为
uniform 变量传入着色器中,将物体表面各种顶点处的法线作为 attribute
变量传入着色器,服从光照规则,修订最后片元展现的颜色。

光照又分为逐顶点的和逐片元的,两者的分别是,将法线光线交角因素位居顶点着色器初中结业生升学考试虑还是放在片元着色器初级中学毕业生升学考试虑。逐片元光照更是呼之欲出,三个可是的事例是:

图片 32

此时,点光源在离开3个表面较近处,表面中心 A
处较亮,四周较暗。可是在逐顶点光照下,表面包车型大巴颜色(的震慑因子)是由顶点内插出来的,所以表面大旨也会相比较暗。而逐片元光照直接利用片元的任务和法线总括与点光源的交角,由此表面宗旨会比较亮。

光照

WebGL 没有为光照提供其余内置的点子,须要开发者在着色器中完毕光照算法。

只不过有颜色的,模型也是有颜色的。在光照下,最终物体显示的水彩是相互一起效能的结果。

达成光照的办法是:将光照的数目(点光源的职务,平行光的可行性,以及光的颜料和强度)作为
uniform 变量传入着色器中,将物体表面各个顶点处的法线作为 attribute
变量传入着色器,遵从光照规则,修订最终片元展现的颜料。

光照又分为逐顶点的和逐片元的,两者的区分是,将法线光线交角因素位居顶点着色器中考虑依旧放在片元着色器中考虑。逐片元光照更是绘影绘声,3个无限的例证是:

图片 33

那儿,点光源在距离1个外部较近处,表面主题 A
处较亮,四周较暗。可是在逐顶点光照下,表面包车型大巴颜料(的熏陶因子)是由顶点内插出来的,所以表面中心也会相比较暗。而逐片元光照间接选用片元的地点和法线计算与点光源的交角,由此表面宗旨会比较亮。

在context上调用各个函数绘制图形,比如:

由于浏览器执行Tick()的时间是不可控的,我们要求让三角匀速的旋转,那么就需求控制时间:

复杂模型

复杂模型大概有囊括子模型,子模型只怕与父模型有相对运动。比如开着雨刮器的汽车,雨刮器的世界坐标是受父模型小车,和小编的图景共同决定的。若要总括雨刮器某顶点的职位,需求用雨刮器相对小车的模子矩阵乘北汽车的模型矩阵,再乘以顶点的一对坐标。

复杂模型大概有广大表面,或许每一个表面使用的着色器就分歧。常常将模型拆解为组,使用同一着色器的外部为一组,先绘制同一组中的内容,然后切换着色器。每一次切换着色器都要双重将缓冲区中的数据分配给着色器中相应变量。

复杂模型

复杂模型大概有囊括子模型,子模型或者与父模型有相对运动。比如开着雨刮器的小车,雨刮器的世界坐标是受父模型小车,和自身的情景共同决定的。若要总结雨刮器某顶点的职责,必要用雨刮器相对汽车的模子矩阵乘北汽车的模型矩阵,再乘以顶点的片段坐标。

复杂模型只怕有成都百货上千外表,或然每一个表面使用的着色器就分化。日常将模型拆解为组,使用相同着色器的表面为一组,先绘制同一组中的内容,然后切换着色器。每一次切换着色器都要重复将缓冲区中的数据分配给着色器中相应变量。

// 绘制左上角为(0,0),右下角为(50, 50)的矩形

var g_last = Date.now();
function animate(angle) {
  // Calculate the elapsed time
  var now = Date.now();
  var elapsed = now - g_last;
  g_last = now;
  // Update the current rotation angle (adjusted by the elapsed time)
  var newAngle = angle + ANGLE_STEP * (elapsed / 1000.0);
  return newAngle %= 360;
}

动画

动画片的法则正是快速地擦除和重绘。常用的不二法门是老牌的
requestAnimationFrame
。不熟练的同窗,可以参见正美的介绍。

动画

卡通的法则正是高速地擦除和重绘。常用的法门是鼎鼎大名的
requestAnimationFrame
。不熟悉的同窗,能够参见正美的介绍。

context.fillRect(0, 0, 50, 50);

 

WebGL库

此时此刻最盛行的 WebGL 库是
ThreeJS,很有力,官网,代码。

WebGL库

眼下最盛行的 WebGL 库是
ThreeJS,很强劲,官网,代码。

WebGL 同样要求获得绘图上下文:

三、结尾

调节工具

正如早熟的 WebGL 调节和测试工具是WebGL
Inspector。

调节工具

相比早熟的 WebGL 调试工具是WebGL
Inspector。

var gl = canvas.getContext(‘webgl’); // 或 experimental-webgl

     下礼拜日继续立异第陆章。

互连网能源和本本

英文的有关 WebGL 的财富有广大,包涵:

  • learning webgl
  • WebGL@MDN
  • WebGL Cheat
    Sheet

国内最早的 WebGL 教程是由郝稼力翻译的,放在 hiwebgl 上,近期 hiwebgl
已经倒闭,但教程还能在这里找到。郝稼力近期营业着Lao3D。

国内已经出版的 WebGL 书籍有:

  • WebGL入门指南:其实是一本讲
    ThreeJS 的书
  • WebGL高级编制程序:还不易的一本
  • WebGL编制程序指南:格外可信赖的应有尽有教程

最后再混合一点私货吧。读书时期自身曾花了小7个月时光翻译了一本WebGL的书,也正是地方的第叁本。那本书真的格外可相信,网上各个课程里很多没说驾驭的东西,那本书说得很精晓,而且还提供了一份很完整的API文档。翻译这本书的经过也使作者收益匪浅。假设有同学愿意系统学一下
WebGL
的,提出价收购买一本(文青建议买英文版)。

1 赞 2 收藏 1
评论

图片 34

互联网财富和图书

英文的关于 WebGL 的财富有无数,包涵:

  • learning webgl
  • WebGL@MDN
  • WebGL Cheat
    Sheet

境内最早的 WebGL 教程是由郝稼力翻译的,放在 hiwebgl 上,近来 hiwebgl
已经关闭,但教程还足以在这里找到。郝稼力近期营业着Lao3D。

国内已经出版的 WebGL 书籍有:

  • WebGL入门指南:其实是一本讲
    ThreeJS 的书
  • WebGL高级编制程序:还不易的一本
  • WebGL编程指南:格外可信的通盘教程

可是接下去,借使想画二个矩形的话,就没这么不难了。实际上,Canvas
是浏览器封装好的1个绘制环境,在事实上海展览中心开绘图操作时,浏览器依旧必要调用
OpenGL API。而 WebGL API 大概正是 OpenGL API 未经封装,直接套了一层壳。

Canvas 的越多学问,可以参考:

JS
权威指南的
21.4 节或JS
高级程序设计中的
15 章

W3CSchool

阮一峰的 Canvas
教程

矩阵变换

三维模型,从文件中读出来,到绘制在 Canvas 中,经历了累累坐标变换。

比方有1个最简单易行的模子:三角形,八个顶峰分别为(-1,-1,0),(1,-1,0),(0,1,0)。那多少个数据是从文件中读出来的,是三角形最开头的坐标(局地坐标)。如下图所示,右手坐标系。

图片 35

模型经常不会放在场景的原点,若是三角形的原点位于(0,0,-1)处,没有转动或缩放,八个极端分别为(-1,-1,-1),(1,-1,-1),(0,1,-1),即世界坐标。

图片 36

制图三维场景必须钦命3个阅览者,就算旁观者位于(0,0,1)处而且看向三角形,那么多个极端相对于旁观者的坐标为(-1,-1,-2),(1,-1,-2),(0,1,-2),即视图坐标。

图片 37

观看者的眸子是3个点(那是看破投影的前提),水平视角和垂直视角都以90度,视野范围(目力所及)为[0,2]在Z轴上,观察者可以看出的区域是二个四棱台体。

图片 38

将四棱台体映射为行业内部立方(CCV,中央为原点,边长为2,边与坐标轴平行)。顶点在
CCV 中的坐标,离它说到底在 Canvas 中的坐标已经很类似了,假如把 CCV
的前表面看成 Canvas,那么最终三角形就画在图中黑色三角形的岗位。

图片 39

上述变换是用矩阵来展开的。

有个别坐标 –(模型变换)-> 世界坐标 –(视图变换)-> 视图坐标
–(投影变换)–> CCV 坐标。

以(0,1,0)为例,它的齐次向量为(0,0,1,1),上述变换的象征经过能够是:

图片 40

地点多个矩阵依次是看破投影矩阵,视图矩阵,模型矩阵。八个矩阵的值分别取决于:观看者的见识和视野距离,观望者在世界中的状态(地点和动向),模型在世界中的状态(地点和方向)。计算的结果是(0,1,1,2),化成齐次坐标是(0,0.5,0.5,1),正是以此点在CCV中的坐标,那么(0,0.5)就是在Canvas中的坐标(认为
Canvas 中央为原点,长度宽度都为2)。

地点出现的(0,0,1,1)是(0,0,1)的齐次向量。齐次向量(x,y,z,w)能够表示三维向量(x,y,z)参预矩阵运算,通俗地说,w
分量为 1 时表示地点,w 分量为 0 时表示位移。

WebGL 没有提供任何有关上述变换的体制,开发者供给亲自计算顶点的 CCV
坐标。

有关坐标变换的越多内容,能够参考:

电脑图形学中的5-7章

转移矩阵@维基百科

透视投影详解

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图