diff --git a/lab4/lib/cuon-matrix.js b/lab4/lib/cuon-matrix.js
new file mode 100755
index 0000000000000000000000000000000000000000..c1187280d6a920c8d798dd50c0060bb26c442338
--- /dev/null
+++ b/lab4/lib/cuon-matrix.js
@@ -0,0 +1,742 @@
+// cuon-matrix.js (c) 2012 kanda and matsuda
+/**
+ * This is a class treating 4x4 matrix.
+ * This class contains the function that is equivalent to OpenGL matrix stack.
+ * The matrix after conversion is calculated by multiplying a conversion matrix from the right.
+ * The matrix is replaced by the calculated result.
+ */
+
+/**
+ * Constructor of Matrix4
+ * If opt_src is specified, new matrix is initialized by opt_src.
+ * Otherwise, new matrix is initialized by identity matrix.
+ * @param opt_src source matrix(option)
+ */
+var Matrix4 = function(opt_src) {
+ var i, s, d;
+ if (opt_src && typeof opt_src === 'object' && opt_src.hasOwnProperty('elements')) {
+ s = opt_src.elements;
+ d = new Float32Array(16);
+ for (i = 0; i < 16; ++i) {
+ d[i] = s[i];
+ }
+ this.elements = d;
+ } else {
+ this.elements = new Float32Array([1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]);
+ }
+ };
+
+ /**
+ * Set the identity matrix.
+ * @return this
+ */
+ Matrix4.prototype.setIdentity = function() {
+ var e = this.elements;
+ e[0] = 1; e[4] = 0; e[8] = 0; e[12] = 0;
+ e[1] = 0; e[5] = 1; e[9] = 0; e[13] = 0;
+ e[2] = 0; e[6] = 0; e[10] = 1; e[14] = 0;
+ e[3] = 0; e[7] = 0; e[11] = 0; e[15] = 1;
+ return this;
+ };
+
+ /**
+ * Copy matrix.
+ * @param src source matrix
+ * @return this
+ */
+ Matrix4.prototype.set = function(src) {
+ var i, s, d;
+
+ s = src.elements;
+ d = this.elements;
+
+ if (s === d) {
+ return;
+ }
+
+ for (i = 0; i < 16; ++i) {
+ d[i] = s[i];
+ }
+
+ return this;
+ };
+
+ /**
+ * Multiply the matrix from the right.
+ * @param other The multiply matrix
+ * @return this
+ */
+ Matrix4.prototype.concat = function(other) {
+ var i, e, a, b, ai0, ai1, ai2, ai3;
+
+ // Calculate e = a * b
+ e = this.elements;
+ a = this.elements;
+ b = other.elements;
+
+ // If e equals b, copy b to temporary matrix.
+ if (e === b) {
+ b = new Float32Array(16);
+ for (i = 0; i < 16; ++i) {
+ b[i] = e[i];
+ }
+ }
+
+ for (i = 0; i < 4; i++) {
+ ai0=a[i]; ai1=a[i+4]; ai2=a[i+8]; ai3=a[i+12];
+ e[i] = ai0 * b[0] + ai1 * b[1] + ai2 * b[2] + ai3 * b[3];
+ e[i+4] = ai0 * b[4] + ai1 * b[5] + ai2 * b[6] + ai3 * b[7];
+ e[i+8] = ai0 * b[8] + ai1 * b[9] + ai2 * b[10] + ai3 * b[11];
+ e[i+12] = ai0 * b[12] + ai1 * b[13] + ai2 * b[14] + ai3 * b[15];
+ }
+
+ return this;
+ };
+ Matrix4.prototype.multiply = Matrix4.prototype.concat;
+
+ /**
+ * Multiply the three-dimensional vector.
+ * @param pos The multiply vector
+ * @return The result of multiplication(Float32Array)
+ */
+ Matrix4.prototype.multiplyVector3 = function(pos) {
+ var e = this.elements;
+ var p = pos.elements;
+ var v = new Vector3();
+ var result = v.elements;
+
+ result[0] = p[0] * e[0] + p[1] * e[4] + p[2] * e[ 8] + e[12];
+ result[1] = p[0] * e[1] + p[1] * e[5] + p[2] * e[ 9] + e[13];
+ result[2] = p[0] * e[2] + p[1] * e[6] + p[2] * e[10] + e[14];
+
+ return v;
+ };
+
+ /**
+ * Multiply the four-dimensional vector.
+ * @param pos The multiply vector
+ * @return The result of multiplication(Float32Array)
+ */
+ Matrix4.prototype.multiplyVector4 = function(pos) {
+ var e = this.elements;
+ var p = pos.elements;
+ var v = new Vector4();
+ var result = v.elements;
+
+ result[0] = p[0] * e[0] + p[1] * e[4] + p[2] * e[ 8] + p[3] * e[12];
+ result[1] = p[0] * e[1] + p[1] * e[5] + p[2] * e[ 9] + p[3] * e[13];
+ result[2] = p[0] * e[2] + p[1] * e[6] + p[2] * e[10] + p[3] * e[14];
+ result[3] = p[0] * e[3] + p[1] * e[7] + p[2] * e[11] + p[3] * e[15];
+
+ return v;
+ };
+
+ /**
+ * Transpose the matrix.
+ * @return this
+ */
+ Matrix4.prototype.transpose = function() {
+ var e, t;
+
+ e = this.elements;
+
+ t = e[ 1]; e[ 1] = e[ 4]; e[ 4] = t;
+ t = e[ 2]; e[ 2] = e[ 8]; e[ 8] = t;
+ t = e[ 3]; e[ 3] = e[12]; e[12] = t;
+ t = e[ 6]; e[ 6] = e[ 9]; e[ 9] = t;
+ t = e[ 7]; e[ 7] = e[13]; e[13] = t;
+ t = e[11]; e[11] = e[14]; e[14] = t;
+
+ return this;
+ };
+
+ /**
+ * Calculate the inverse matrix of specified matrix, and set to this.
+ * @param other The source matrix
+ * @return this
+ */
+ Matrix4.prototype.setInverseOf = function(other) {
+ var i, s, d, inv, det;
+
+ s = other.elements;
+ d = this.elements;
+ inv = new Float32Array(16);
+
+ inv[0] = s[5]*s[10]*s[15] - s[5] *s[11]*s[14] - s[9] *s[6]*s[15]
+ + s[9]*s[7] *s[14] + s[13]*s[6] *s[11] - s[13]*s[7]*s[10];
+ inv[4] = - s[4]*s[10]*s[15] + s[4] *s[11]*s[14] + s[8] *s[6]*s[15]
+ - s[8]*s[7] *s[14] - s[12]*s[6] *s[11] + s[12]*s[7]*s[10];
+ inv[8] = s[4]*s[9] *s[15] - s[4] *s[11]*s[13] - s[8] *s[5]*s[15]
+ + s[8]*s[7] *s[13] + s[12]*s[5] *s[11] - s[12]*s[7]*s[9];
+ inv[12] = - s[4]*s[9] *s[14] + s[4] *s[10]*s[13] + s[8] *s[5]*s[14]
+ - s[8]*s[6] *s[13] - s[12]*s[5] *s[10] + s[12]*s[6]*s[9];
+
+ inv[1] = - s[1]*s[10]*s[15] + s[1] *s[11]*s[14] + s[9] *s[2]*s[15]
+ - s[9]*s[3] *s[14] - s[13]*s[2] *s[11] + s[13]*s[3]*s[10];
+ inv[5] = s[0]*s[10]*s[15] - s[0] *s[11]*s[14] - s[8] *s[2]*s[15]
+ + s[8]*s[3] *s[14] + s[12]*s[2] *s[11] - s[12]*s[3]*s[10];
+ inv[9] = - s[0]*s[9] *s[15] + s[0] *s[11]*s[13] + s[8] *s[1]*s[15]
+ - s[8]*s[3] *s[13] - s[12]*s[1] *s[11] + s[12]*s[3]*s[9];
+ inv[13] = s[0]*s[9] *s[14] - s[0] *s[10]*s[13] - s[8] *s[1]*s[14]
+ + s[8]*s[2] *s[13] + s[12]*s[1] *s[10] - s[12]*s[2]*s[9];
+
+ inv[2] = s[1]*s[6]*s[15] - s[1] *s[7]*s[14] - s[5] *s[2]*s[15]
+ + s[5]*s[3]*s[14] + s[13]*s[2]*s[7] - s[13]*s[3]*s[6];
+ inv[6] = - s[0]*s[6]*s[15] + s[0] *s[7]*s[14] + s[4] *s[2]*s[15]
+ - s[4]*s[3]*s[14] - s[12]*s[2]*s[7] + s[12]*s[3]*s[6];
+ inv[10] = s[0]*s[5]*s[15] - s[0] *s[7]*s[13] - s[4] *s[1]*s[15]
+ + s[4]*s[3]*s[13] + s[12]*s[1]*s[7] - s[12]*s[3]*s[5];
+ inv[14] = - s[0]*s[5]*s[14] + s[0] *s[6]*s[13] + s[4] *s[1]*s[14]
+ - s[4]*s[2]*s[13] - s[12]*s[1]*s[6] + s[12]*s[2]*s[5];
+
+ inv[3] = - s[1]*s[6]*s[11] + s[1]*s[7]*s[10] + s[5]*s[2]*s[11]
+ - s[5]*s[3]*s[10] - s[9]*s[2]*s[7] + s[9]*s[3]*s[6];
+ inv[7] = s[0]*s[6]*s[11] - s[0]*s[7]*s[10] - s[4]*s[2]*s[11]
+ + s[4]*s[3]*s[10] + s[8]*s[2]*s[7] - s[8]*s[3]*s[6];
+ inv[11] = - s[0]*s[5]*s[11] + s[0]*s[7]*s[9] + s[4]*s[1]*s[11]
+ - s[4]*s[3]*s[9] - s[8]*s[1]*s[7] + s[8]*s[3]*s[5];
+ inv[15] = s[0]*s[5]*s[10] - s[0]*s[6]*s[9] - s[4]*s[1]*s[10]
+ + s[4]*s[2]*s[9] + s[8]*s[1]*s[6] - s[8]*s[2]*s[5];
+
+ det = s[0]*inv[0] + s[1]*inv[4] + s[2]*inv[8] + s[3]*inv[12];
+ if (det === 0) {
+ return this;
+ }
+
+ det = 1 / det;
+ for (i = 0; i < 16; i++) {
+ d[i] = inv[i] * det;
+ }
+
+ return this;
+ };
+
+ /**
+ * Calculate the inverse matrix of this, and set to this.
+ * @return this
+ */
+ Matrix4.prototype.invert = function() {
+ return this.setInverseOf(this);
+ };
+
+ /**
+ * Set the orthographic projection matrix.
+ * @param left The coordinate of the left of clipping plane.
+ * @param right The coordinate of the right of clipping plane.
+ * @param bottom The coordinate of the bottom of clipping plane.
+ * @param top The coordinate of the top top clipping plane.
+ * @param near The distances to the nearer depth clipping plane. This value is minus if the plane is to be behind the viewer.
+ * @param far The distances to the farther depth clipping plane. This value is minus if the plane is to be behind the viewer.
+ * @return this
+ */
+ Matrix4.prototype.setOrtho = function(left, right, bottom, top, near, far) {
+ var e, rw, rh, rd;
+
+ if (left === right || bottom === top || near === far) {
+ throw 'null frustum';
+ }
+
+ rw = 1 / (right - left);
+ rh = 1 / (top - bottom);
+ rd = 1 / (far - near);
+
+ e = this.elements;
+
+ e[0] = 2 * rw;
+ e[1] = 0;
+ e[2] = 0;
+ e[3] = 0;
+
+ e[4] = 0;
+ e[5] = 2 * rh;
+ e[6] = 0;
+ e[7] = 0;
+
+ e[8] = 0;
+ e[9] = 0;
+ e[10] = -2 * rd;
+ e[11] = 0;
+
+ e[12] = -(right + left) * rw;
+ e[13] = -(top + bottom) * rh;
+ e[14] = -(far + near) * rd;
+ e[15] = 1;
+
+ return this;
+ };
+
+ /**
+ * Multiply the orthographic projection matrix from the right.
+ * @param left The coordinate of the left of clipping plane.
+ * @param right The coordinate of the right of clipping plane.
+ * @param bottom The coordinate of the bottom of clipping plane.
+ * @param top The coordinate of the top top clipping plane.
+ * @param near The distances to the nearer depth clipping plane. This value is minus if the plane is to be behind the viewer.
+ * @param far The distances to the farther depth clipping plane. This value is minus if the plane is to be behind the viewer.
+ * @return this
+ */
+ Matrix4.prototype.ortho = function(left, right, bottom, top, near, far) {
+ return this.concat(new Matrix4().setOrtho(left, right, bottom, top, near, far));
+ };
+
+ /**
+ * Set the perspective projection matrix.
+ * @param left The coordinate of the left of clipping plane.
+ * @param right The coordinate of the right of clipping plane.
+ * @param bottom The coordinate of the bottom of clipping plane.
+ * @param top The coordinate of the top top clipping plane.
+ * @param near The distances to the nearer depth clipping plane. This value must be plus value.
+ * @param far The distances to the farther depth clipping plane. This value must be plus value.
+ * @return this
+ */
+ Matrix4.prototype.setFrustum = function(left, right, bottom, top, near, far) {
+ var e, rw, rh, rd;
+
+ if (left === right || top === bottom || near === far) {
+ throw 'null frustum';
+ }
+ if (near <= 0) {
+ throw 'near <= 0';
+ }
+ if (far <= 0) {
+ throw 'far <= 0';
+ }
+
+ rw = 1 / (right - left);
+ rh = 1 / (top - bottom);
+ rd = 1 / (far - near);
+
+ e = this.elements;
+
+ e[ 0] = 2 * near * rw;
+ e[ 1] = 0;
+ e[ 2] = 0;
+ e[ 3] = 0;
+
+ e[ 4] = 0;
+ e[ 5] = 2 * near * rh;
+ e[ 6] = 0;
+ e[ 7] = 0;
+
+ e[ 8] = (right + left) * rw;
+ e[ 9] = (top + bottom) * rh;
+ e[10] = -(far + near) * rd;
+ e[11] = -1;
+
+ e[12] = 0;
+ e[13] = 0;
+ e[14] = -2 * near * far * rd;
+ e[15] = 0;
+
+ return this;
+ };
+
+ /**
+ * Multiply the perspective projection matrix from the right.
+ * @param left The coordinate of the left of clipping plane.
+ * @param right The coordinate of the right of clipping plane.
+ * @param bottom The coordinate of the bottom of clipping plane.
+ * @param top The coordinate of the top top clipping plane.
+ * @param near The distances to the nearer depth clipping plane. This value must be plus value.
+ * @param far The distances to the farther depth clipping plane. This value must be plus value.
+ * @return this
+ */
+ Matrix4.prototype.frustum = function(left, right, bottom, top, near, far) {
+ return this.concat(new Matrix4().setFrustum(left, right, bottom, top, near, far));
+ };
+
+ /**
+ * Set the perspective projection matrix by fovy and aspect.
+ * @param fovy The angle between the upper and lower sides of the frustum.
+ * @param aspect The aspect ratio of the frustum. (width/height)
+ * @param near The distances to the nearer depth clipping plane. This value must be plus value.
+ * @param far The distances to the farther depth clipping plane. This value must be plus value.
+ * @return this
+ */
+ Matrix4.prototype.setPerspective = function(fovy, aspect, near, far) {
+ var e, rd, s, ct;
+
+ if (near === far || aspect === 0) {
+ throw 'null frustum';
+ }
+ if (near <= 0) {
+ throw 'near <= 0';
+ }
+ if (far <= 0) {
+ throw 'far <= 0';
+ }
+
+ fovy = Math.PI * fovy / 180 / 2;
+ s = Math.sin(fovy);
+ if (s === 0) {
+ throw 'null frustum';
+ }
+
+ rd = 1 / (far - near);
+ ct = Math.cos(fovy) / s;
+
+ e = this.elements;
+
+ e[0] = ct / aspect;
+ e[1] = 0;
+ e[2] = 0;
+ e[3] = 0;
+
+ e[4] = 0;
+ e[5] = ct;
+ e[6] = 0;
+ e[7] = 0;
+
+ e[8] = 0;
+ e[9] = 0;
+ e[10] = -(far + near) * rd;
+ e[11] = -1;
+
+ e[12] = 0;
+ e[13] = 0;
+ e[14] = -2 * near * far * rd;
+ e[15] = 0;
+
+ return this;
+ };
+
+ /**
+ * Multiply the perspective projection matrix from the right.
+ * @param fovy The angle between the upper and lower sides of the frustum.
+ * @param aspect The aspect ratio of the frustum. (width/height)
+ * @param near The distances to the nearer depth clipping plane. This value must be plus value.
+ * @param far The distances to the farther depth clipping plane. This value must be plus value.
+ * @return this
+ */
+ Matrix4.prototype.perspective = function(fovy, aspect, near, far) {
+ return this.concat(new Matrix4().setPerspective(fovy, aspect, near, far));
+ };
+
+ /**
+ * Set the matrix for scaling.
+ * @param x The scale factor along the X axis
+ * @param y The scale factor along the Y axis
+ * @param z The scale factor along the Z axis
+ * @return this
+ */
+ Matrix4.prototype.setScale = function(x, y, z) {
+ var e = this.elements;
+ e[0] = x; e[4] = 0; e[8] = 0; e[12] = 0;
+ e[1] = 0; e[5] = y; e[9] = 0; e[13] = 0;
+ e[2] = 0; e[6] = 0; e[10] = z; e[14] = 0;
+ e[3] = 0; e[7] = 0; e[11] = 0; e[15] = 1;
+ return this;
+ };
+
+ /**
+ * Multiply the matrix for scaling from the right.
+ * @param x The scale factor along the X axis
+ * @param y The scale factor along the Y axis
+ * @param z The scale factor along the Z axis
+ * @return this
+ */
+ Matrix4.prototype.scale = function(x, y, z) {
+ var e = this.elements;
+ e[0] *= x; e[4] *= y; e[8] *= z;
+ e[1] *= x; e[5] *= y; e[9] *= z;
+ e[2] *= x; e[6] *= y; e[10] *= z;
+ e[3] *= x; e[7] *= y; e[11] *= z;
+ return this;
+ };
+
+ /**
+ * Set the matrix for translation.
+ * @param x The X value of a translation.
+ * @param y The Y value of a translation.
+ * @param z The Z value of a translation.
+ * @return this
+ */
+ Matrix4.prototype.setTranslate = function(x, y, z) {
+ var e = this.elements;
+ e[0] = 1; e[4] = 0; e[8] = 0; e[12] = x;
+ e[1] = 0; e[5] = 1; e[9] = 0; e[13] = y;
+ e[2] = 0; e[6] = 0; e[10] = 1; e[14] = z;
+ e[3] = 0; e[7] = 0; e[11] = 0; e[15] = 1;
+ return this;
+ };
+
+ /**
+ * Multiply the matrix for translation from the right.
+ * @param x The X value of a translation.
+ * @param y The Y value of a translation.
+ * @param z The Z value of a translation.
+ * @return this
+ */
+ Matrix4.prototype.translate = function(x, y, z) {
+ var e = this.elements;
+ e[12] += e[0] * x + e[4] * y + e[8] * z;
+ e[13] += e[1] * x + e[5] * y + e[9] * z;
+ e[14] += e[2] * x + e[6] * y + e[10] * z;
+ e[15] += e[3] * x + e[7] * y + e[11] * z;
+ return this;
+ };
+
+ /**
+ * Set the matrix for rotation.
+ * The vector of rotation axis may not be normalized.
+ * @param angle The angle of rotation (degrees)
+ * @param x The X coordinate of vector of rotation axis.
+ * @param y The Y coordinate of vector of rotation axis.
+ * @param z The Z coordinate of vector of rotation axis.
+ * @return this
+ */
+ Matrix4.prototype.setRotate = function(angle, x, y, z) {
+ var e, s, c, len, rlen, nc, xy, yz, zx, xs, ys, zs;
+
+ angle = Math.PI * angle / 180;
+ e = this.elements;
+
+ s = Math.sin(angle);
+ c = Math.cos(angle);
+
+ if (0 !== x && 0 === y && 0 === z) {
+ // Rotation around X axis
+ if (x < 0) {
+ s = -s;
+ }
+ e[0] = 1; e[4] = 0; e[ 8] = 0; e[12] = 0;
+ e[1] = 0; e[5] = c; e[ 9] =-s; e[13] = 0;
+ e[2] = 0; e[6] = s; e[10] = c; e[14] = 0;
+ e[3] = 0; e[7] = 0; e[11] = 0; e[15] = 1;
+ } else if (0 === x && 0 !== y && 0 === z) {
+ // Rotation around Y axis
+ if (y < 0) {
+ s = -s;
+ }
+ e[0] = c; e[4] = 0; e[ 8] = s; e[12] = 0;
+ e[1] = 0; e[5] = 1; e[ 9] = 0; e[13] = 0;
+ e[2] =-s; e[6] = 0; e[10] = c; e[14] = 0;
+ e[3] = 0; e[7] = 0; e[11] = 0; e[15] = 1;
+ } else if (0 === x && 0 === y && 0 !== z) {
+ // Rotation around Z axis
+ if (z < 0) {
+ s = -s;
+ }
+ e[0] = c; e[4] =-s; e[ 8] = 0; e[12] = 0;
+ e[1] = s; e[5] = c; e[ 9] = 0; e[13] = 0;
+ e[2] = 0; e[6] = 0; e[10] = 1; e[14] = 0;
+ e[3] = 0; e[7] = 0; e[11] = 0; e[15] = 1;
+ } else {
+ // Rotation around another axis
+ len = Math.sqrt(x*x + y*y + z*z);
+ if (len !== 1) {
+ rlen = 1 / len;
+ x *= rlen;
+ y *= rlen;
+ z *= rlen;
+ }
+ nc = 1 - c;
+ xy = x * y;
+ yz = y * z;
+ zx = z * x;
+ xs = x * s;
+ ys = y * s;
+ zs = z * s;
+
+ e[ 0] = x*x*nc + c;
+ e[ 1] = xy *nc + zs;
+ e[ 2] = zx *nc - ys;
+ e[ 3] = 0;
+
+ e[ 4] = xy *nc - zs;
+ e[ 5] = y*y*nc + c;
+ e[ 6] = yz *nc + xs;
+ e[ 7] = 0;
+
+ e[ 8] = zx *nc + ys;
+ e[ 9] = yz *nc - xs;
+ e[10] = z*z*nc + c;
+ e[11] = 0;
+
+ e[12] = 0;
+ e[13] = 0;
+ e[14] = 0;
+ e[15] = 1;
+ }
+
+ return this;
+ };
+
+ /**
+ * Multiply the matrix for rotation from the right.
+ * The vector of rotation axis may not be normalized.
+ * @param angle The angle of rotation (degrees)
+ * @param x The X coordinate of vector of rotation axis.
+ * @param y The Y coordinate of vector of rotation axis.
+ * @param z The Z coordinate of vector of rotation axis.
+ * @return this
+ */
+ Matrix4.prototype.rotate = function(angle, x, y, z) {
+ return this.concat(new Matrix4().setRotate(angle, x, y, z));
+ };
+
+ /**
+ * Set the viewing matrix.
+ * @param eyeX, eyeY, eyeZ The position of the eye point.
+ * @param centerX, centerY, centerZ The position of the reference point.
+ * @param upX, upY, upZ The direction of the up vector.
+ * @return this
+ */
+ Matrix4.prototype.setLookAt = function(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ) {
+ var e, fx, fy, fz, rlf, sx, sy, sz, rls, ux, uy, uz;
+
+ fx = centerX - eyeX;
+ fy = centerY - eyeY;
+ fz = centerZ - eyeZ;
+
+ // Normalize f.
+ rlf = 1 / Math.sqrt(fx*fx + fy*fy + fz*fz);
+ fx *= rlf;
+ fy *= rlf;
+ fz *= rlf;
+
+ // Calculate cross product of f and up.
+ sx = fy * upZ - fz * upY;
+ sy = fz * upX - fx * upZ;
+ sz = fx * upY - fy * upX;
+
+ // Normalize s.
+ rls = 1 / Math.sqrt(sx*sx + sy*sy + sz*sz);
+ sx *= rls;
+ sy *= rls;
+ sz *= rls;
+
+ // Calculate cross product of s and f.
+ ux = sy * fz - sz * fy;
+ uy = sz * fx - sx * fz;
+ uz = sx * fy - sy * fx;
+
+ // Set to this.
+ e = this.elements;
+ e[0] = sx;
+ e[1] = ux;
+ e[2] = -fx;
+ e[3] = 0;
+
+ e[4] = sy;
+ e[5] = uy;
+ e[6] = -fy;
+ e[7] = 0;
+
+ e[8] = sz;
+ e[9] = uz;
+ e[10] = -fz;
+ e[11] = 0;
+
+ e[12] = 0;
+ e[13] = 0;
+ e[14] = 0;
+ e[15] = 1;
+
+ // Translate.
+ return this.translate(-eyeX, -eyeY, -eyeZ);
+ };
+
+ /**
+ * Multiply the viewing matrix from the right.
+ * @param eyeX, eyeY, eyeZ The position of the eye point.
+ * @param centerX, centerY, centerZ The position of the reference point.
+ * @param upX, upY, upZ The direction of the up vector.
+ * @return this
+ */
+ Matrix4.prototype.lookAt = function(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ) {
+ return this.concat(new Matrix4().setLookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ));
+ };
+
+ /**
+ * Multiply the matrix for project vertex to plane from the right.
+ * @param plane The array[A, B, C, D] of the equation of plane "Ax + By + Cz + D = 0".
+ * @param light The array which stored coordinates of the light. if light[3]=0, treated as parallel light.
+ * @return this
+ */
+ Matrix4.prototype.dropShadow = function(plane, light) {
+ var mat = new Matrix4();
+ var e = mat.elements;
+
+ var dot = plane[0] * light[0] + plane[1] * light[1] + plane[2] * light[2] + plane[3] * light[3];
+
+ e[ 0] = dot - light[0] * plane[0];
+ e[ 1] = - light[1] * plane[0];
+ e[ 2] = - light[2] * plane[0];
+ e[ 3] = - light[3] * plane[0];
+
+ e[ 4] = - light[0] * plane[1];
+ e[ 5] = dot - light[1] * plane[1];
+ e[ 6] = - light[2] * plane[1];
+ e[ 7] = - light[3] * plane[1];
+
+ e[ 8] = - light[0] * plane[2];
+ e[ 9] = - light[1] * plane[2];
+ e[10] = dot - light[2] * plane[2];
+ e[11] = - light[3] * plane[2];
+
+ e[12] = - light[0] * plane[3];
+ e[13] = - light[1] * plane[3];
+ e[14] = - light[2] * plane[3];
+ e[15] = dot - light[3] * plane[3];
+
+ return this.concat(mat);
+ }
+
+ /**
+ * Multiply the matrix for project vertex to plane from the right.(Projected by parallel light.)
+ * @param normX, normY, normZ The normal vector of the plane.(Not necessary to be normalized.)
+ * @param planeX, planeY, planeZ The coordinate of arbitrary points on a plane.
+ * @param lightX, lightY, lightZ The vector of the direction of light.(Not necessary to be normalized.)
+ * @return this
+ */
+ Matrix4.prototype.dropShadowDirectionally = function(normX, normY, normZ, planeX, planeY, planeZ, lightX, lightY, lightZ) {
+ var a = planeX * normX + planeY * normY + planeZ * normZ;
+ return this.dropShadow([normX, normY, normZ, -a], [lightX, lightY, lightZ, 0]);
+ };
+
+ /**
+ * Constructor of Vector3
+ * If opt_src is specified, new vector is initialized by opt_src.
+ * @param opt_src source vector(option)
+ */
+ var Vector3 = function(opt_src) {
+ var v = new Float32Array(3);
+ if (opt_src && typeof opt_src === 'object') {
+ v[0] = opt_src[0]; v[1] = opt_src[1]; v[2] = opt_src[2];
+ }
+ this.elements = v;
+ }
+
+ /**
+ * Normalize.
+ * @return this
+ */
+ Vector3.prototype.normalize = function() {
+ var v = this.elements;
+ var c = v[0], d = v[1], e = v[2], g = Math.sqrt(c*c+d*d+e*e);
+ if(g){
+ if(g == 1)
+ return this;
+ } else {
+ v[0] = 0; v[1] = 0; v[2] = 0;
+ return this;
+ }
+ g = 1/g;
+ v[0] = c*g; v[1] = d*g; v[2] = e*g;
+ return this;
+ };
+
+ /**
+ * Constructor of Vector4
+ * If opt_src is specified, new vector is initialized by opt_src.
+ * @param opt_src source vector(option)
+ */
+ var Vector4 = function(opt_src) {
+ var v = new Float32Array(4);
+ if (opt_src && typeof opt_src === 'object') {
+ v[0] = opt_src[0]; v[1] = opt_src[1]; v[2] = opt_src[2]; v[3] = opt_src[3];
+ }
+ this.elements = v;
+ }
+
\ No newline at end of file
diff --git a/lab4/src/lab4.html b/lab4/src/lab4.html
index 2bb37bcbd21a70f6bb9acddb83953d93aa5bf516..6a66f46796597805188cccbb35424dd4f914254e 100644
--- a/lab4/src/lab4.html
+++ b/lab4/src/lab4.html
@@ -5,9 +5,23 @@
<title>Lab 4</title>
</head>
<body onload="main()">
-<canvas width="400" height="600" id="my-canvas">
+<canvas width="800" height="600" id="my-canvas">
Please use a browser that supports "canvas"
</canvas>
+<p id="activatedLight">Activated light: Point light</p>
+<div>
+ <p id="pointLightPosition">Point light position:</p>
+ <p id="pointLightX">x: 0</p>
+ <p id="pointLightY">y: 2</p>
+ <p id="pointLightZ">z: 0</p>
+</div>
+<div>
+ <p id="directionalLightDirection">Directional light direction:</p>
+ <p id="directionalLightX">x: 0</p>
+ <p id="directionalLightY">y: 2</p>
+ <p id="directionalLightZ">z: 0</p>
+</div>
+<script src="../lib/cuon-matrix.js"></script>
<script src="../lib/webgl-utils.js"></script>
<script src="../lib/webgl-debug.js"></script>
<script src="../lib/cuon-utils.js"></script>
diff --git a/lab4/src/lab4.js b/lab4/src/lab4.js
index 105a227db9e7e4d4abde40b5002e7c75eb860fb4..d691a2026b92cdd3ed5739008825be32bb194a2c 100644
--- a/lab4/src/lab4.js
+++ b/lab4/src/lab4.js
@@ -1,18 +1,883 @@
+// Source shaders shadows: http://rodger.global-linguist.com/webgl/ch10/Shadow_highp.html
+// Vertex shader program for generating a shadow map
+var SHADOW_VSHADER_SOURCE =
+ 'attribute vec4 a_Position;\n' +
+ 'uniform mat4 u_MvpMatrix;\n' +
+ 'void main() {\n' +
+ ' gl_Position = u_MvpMatrix * a_Position;\n' +
+ '}\n';
+
+// Fragment shader program for generating a shadow map
+var SHADOW_FSHADER_SOURCE =
+ '#ifdef GL_ES\n' +
+ 'precision mediump float;\n' +
+ '#endif\n' +
+ 'void main() {\n' +
+ ' const vec4 bitShift = vec4(1.0, 256.0, 256.0 * 256.0, 256.0 * 256.0 * 256.0);\n' +
+ ' const vec4 bitMask = vec4(1.0/256.0, 1.0/256.0, 1.0/256.0, 0.0);\n' +
+ ' vec4 rgbaDepth = fract(gl_FragCoord.z * bitShift);\n' + // Calculate the value stored into each byte
+ ' rgbaDepth -= rgbaDepth.gbaa * bitMask;\n' + // Cut off the value which do not fit in 8 bits
+ ' gl_FragColor = rgbaDepth;\n' +
+ '}\n';
+
// Vertex shader program
-const VSHADER_SOURCE =
- '\n' +
- // TODO: Implement your vertex shader code here
- '\n';
+var VSHADER_SOURCE =
+ 'attribute vec4 a_Position;\n' +
+ 'attribute vec4 a_Color;\n' +
+ 'attribute vec3 a_Normal;\n' + // Normal
+
+ 'uniform mat4 u_MvpMatrix;\n' +
+ 'uniform bool u_Clicked;\n' + //CLICK
+ 'uniform mat4 u_ModelMatrix;\n' + //Point
+ 'uniform mat4 u_ModelMatrixInverseTransposee;\n' + //Directional + Point
+ 'uniform vec3 u_PositionLight;\n' + //Point
+
+ 'varying vec4 v_Color;\n' +
+ 'varying vec3 v_Normal;\n' +
+ 'varying vec3 v_ModelToLightDirection;\n' + //Point
+
+ //SHADOWS
+ 'uniform mat4 u_MvpMatrixFromLight;\n' +
+ 'varying vec4 v_PositionFromLight;\n' +
+
+ 'void main() {\n' +
+ ' gl_Position = u_MvpMatrix * a_Position ;\n' +
+ //CLICK
+ ' if (u_Clicked) {\n' +
+ ' v_Color = vec4(1.0, 0.0, 0.0, 1.0);\n' + // Set the varying color value with the attribute color value
+ ' } else {\n' +
+ ' v_Color = a_Color;\n' +
+ ' }' +
+ ' v_Normal = mat3(u_ModelMatrixInverseTransposee) * a_Normal;\n' + //Réorientation des normales selon la position du modèle (Directional et Point)
+
+ ' vec3 actualModelPosition = (u_ModelMatrix * a_Position).xyz;\n' + //Point
+ ' v_ModelToLightDirection = u_PositionLight - actualModelPosition;\n' + //Point
+
+ //SHADOWS
+ ' v_PositionFromLight = u_MvpMatrixFromLight * a_Position;\n' +
+ '}\n';
// Fragment shader program
const FSHADER_SOURCE =
- '\n' +
- // TODO: Implement your fragment shader code here
- '\n';
+ 'precision mediump float;\n' + // This determines how much precision the GPU uses when calculating floats
+
+ 'varying vec4 v_Color;\n' + // Varying variable color to get the vertex color from
+ 'varying vec3 v_Normal;\n' + //Directional et Point
+ 'varying vec3 v_ModelToLightDirection;\n' + //Point
+
+ 'uniform vec3 u_Ambiant;\n' +
+ 'uniform vec3 u_LightDirection;\n' + //Directional
+ 'uniform vec3 u_LightColor_Directional;\n' +
+ 'uniform vec3 u_LightColor_Point;\n' +
+
+ //SHADOWS
+ 'uniform sampler2D u_ShadowMap;\n' +
+ 'varying vec4 v_PositionFromLight;\n' +
+
+ // Recalculate the z value from the rgba
+ 'float unpackDepth(const in vec4 rgbaDepth) {\n' +
+ ' const vec4 bitShift = vec4(1.0, 1.0/256.0, 1.0/(256.0*256.0), 1.0/(256.0*256.0*256.0));\n' +
+ ' float depth = dot(rgbaDepth, bitShift);\n' + // Use dot() since the calculations is same
+ ' return depth;\n' +
+ '}\n' +
+
+ 'void main() {\n' +
+ //SHADOWS
+ ' vec3 shadowCoord = (v_PositionFromLight.xyz/v_PositionFromLight.w)/2.0 + 0.5;\n' +
+ ' vec4 rgbaDepth = texture2D(u_ShadowMap, shadowCoord.xy);\n' +
+ ' float depth = unpackDepth(rgbaDepth);\n' + // Recalculate the z value from the rgba
+ ' float visibility = (shadowCoord.z > depth + 0.0005) ? 0.7 : 1.0;\n' +
+
+ ' vec3 normal = normalize(v_Normal.xyz);\n' + //Directional et Point
+ ' vec3 ambiant = v_Color.rgb * u_Ambiant;\n' + //Directional et Point
+
+ ' float lightDirectional = max(dot(normal, u_LightDirection), 0.0);\n' + //Directional
+ ' float lightPoint = max(dot(normal, normalize(v_ModelToLightDirection)), 0.0);\n' + //Point
+
+ ' gl_FragColor = vec4((u_LightColor_Point * v_Color.rgb * lightPoint * visibility) + (u_LightColor_Directional * v_Color.rgb * lightDirectional * visibility) + ambiant, v_Color.a);\n' + // Set the fragment color with the vertex shader
+ '}\n';
+
+ //Array utilisés pour modifier la position ou la direction des lumières avec les touches du clavier.
+ var directionalLightDirection = [0.00001, 2.0, 0.00001];
+ var pointLightPosition = [0.00001, 2.0, 0.00001];
+ var lightDirection;
+ pointLight = true;
+
+ var clickAndRotate = false;
+ var clickAndRotateValue = 0;
+
+ var viewProjMatrixFromLight = new Matrix4(); // Prepare a view projection matrix for generating a shadow map
+ var viewProjMatrix = new Matrix4();
+
+ var mvpMatrixFromLight_sablier_top = new Matrix4();
+ var mvpMatrixFromLight_sablier_bottom = new Matrix4();
+ var mvpMatrixFromLight_plain = new Matrix4();
+ var mvpMatrix = new Matrix4(); // Model view projection matrix
+
+ var modelMatrix = new Matrix4();
+ var modelMatrixInverseTransposee = new Matrix4();
+
+ var mouseMovement = [0.0, 0.0];
+
+ var OFFSCREEN_WIDTH = 2048, OFFSCREEN_HEIGHT = 2048;
function main() {
// Retrieve <canvas> element
const canvas = document.getElementById('my-canvas');
- // TODO: Complete with your code here
+ // Get the rendering context for WebGL
+ const gl = getWebGLContext(canvas);
+ if (!gl) {
+ console.log('Failed to get the rendering context for WebGL');
+ return;
+ }
+
+ // Initialize shaders for generating a shadow map
+ var shadowProgram = createProgram(gl, SHADOW_VSHADER_SOURCE, SHADOW_FSHADER_SOURCE);
+ shadowProgram.a_Position = gl.getAttribLocation(shadowProgram, 'a_Position');
+ shadowProgram.u_MvpMatrix = gl.getUniformLocation(shadowProgram, 'u_MvpMatrix');
+ if (shadowProgram.a_Position < 0 || !shadowProgram.u_MvpMatrix) {
+ console.log('Failed to get the storage location of attribute or uniform variable from shadowProgram');
+ return;
+ }
+
+ // Initialize shaders for regular drawing
+ var normalProgram = createProgram(gl, VSHADER_SOURCE, FSHADER_SOURCE);
+ normalProgram.a_Position = gl.getAttribLocation(normalProgram, 'a_Position');
+ normalProgram.a_Color = gl.getAttribLocation(normalProgram, 'a_Color');
+ normalProgram.a_Normal = gl.getAttribLocation(normalProgram, 'a_Normal');
+ normalProgram.u_MvpMatrix = gl.getUniformLocation(normalProgram, 'u_MvpMatrix');
+ normalProgram.u_Clicked = gl.getUniformLocation(normalProgram, 'u_Clicked');
+ normalProgram.u_ModelMatrix = gl.getUniformLocation(normalProgram, 'u_ModelMatrix');
+ normalProgram.u_ModelMatrixInverseTransposee = gl.getUniformLocation(normalProgram, 'u_ModelMatrixInverseTransposee');
+ normalProgram.u_PositionLight = gl.getUniformLocation(normalProgram, 'u_PositionLight');
+ normalProgram.u_MvpMatrixFromLight = gl.getUniformLocation(normalProgram, 'u_MvpMatrixFromLight');
+ normalProgram.u_Ambiant = gl.getUniformLocation(normalProgram, 'u_Ambiant');
+ normalProgram.u_LightDirection = gl.getUniformLocation(normalProgram, 'u_LightDirection');
+ normalProgram.u_LightColor_Directional = gl.getUniformLocation(normalProgram, 'u_LightColor_Directional');
+ normalProgram.u_LightColor_Point = gl.getUniformLocation(normalProgram, 'u_LightColor_Point');
+ normalProgram.u_ShadowMap = gl.getUniformLocation(normalProgram, 'u_ShadowMap');
+ if (normalProgram.a_Position < 0 || normalProgram.a_Color < 0 || normalProgram.a_Normal < 0 || !normalProgram.u_MvpMatrix || !normalProgram.u_Clicked ||
+ !normalProgram.u_ModelMatrix || !normalProgram.u_ModelMatrixInverseTransposee || !normalProgram.u_PositionLight || !normalProgram.u_MvpMatrixFromLight ||
+ !normalProgram.u_Ambiant || !normalProgram.u_LightDirection || !normalProgram.u_LightColor_Directional || !normalProgram.u_LightColor_Point || !normalProgram.u_ShadowMap) {
+ console.log('Failed to get the storage location of attribute or uniform variable from normalProgram');
+ return;
+ }
+
+ var sablierObject = initVertexBuffersForSablier(gl);
+ var plainObject = initVertexBuffersForPlain(gl);
+ if (!sablierObject || !plainObject) {
+ console.log('Failed to set the vertex information');
+ return;
+ }
+
+ // Initialize framebuffer object (FBO)
+ var fbo = initFramebufferObject(gl);
+ if (!fbo) {
+ console.log('Failed to initialize frame buffer object');
+ return;
+ }
+ gl.activeTexture(gl.TEXTURE0); // Set a texture object to the texture unit. Active l'unité de texture 0
+ gl.bindTexture(gl.TEXTURE_2D, fbo.texture);
+
+ // Specify the color for clearing <canvas>
+ gl.clearColor(0, 0, 0, 1);
+
+ //OpenGL performs a depth test and if this test passes,
+ //the fragment is rendered and the depth buffer is updated with the new depth value. If the depth test fails, the fragment is discarded.
+ gl.enable(gl.DEPTH_TEST);
+
+ gl.useProgram(normalProgram);
+
+ //Directional
+ gl.uniform3f(normalProgram.u_LightColor_Directional, 0.0, 0.0, 0.0);
+ lightDirection = new Vector3(directionalLightDirection);
+ gl.uniform3fv(normalProgram.u_LightDirection, lightDirection.normalize().elements);
+
+ //Positional
+ gl.uniform3f(normalProgram.u_LightColor_Point, 1.0, 1.0, 1.0);
+ gl.uniform3fv(normalProgram.u_PositionLight, pointLightPosition);
+
+ gl.uniform3f(normalProgram.u_Ambiant, 0.2, 0.2, 0.2);
+
+ gl.uniform1i(normalProgram.u_Clicked, 0); // Pass false to u_Clicked
+
+ viewProjMatrixFromLight.setPerspective(100.0, OFFSCREEN_WIDTH/OFFSCREEN_HEIGHT, 0.1, 100.0);
+ viewProjMatrixFromLight.lookAt(pointLightPosition[0], pointLightPosition[1], pointLightPosition[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
+
+ // Calculate the view projection matrix
+ viewProjMatrix.setPerspective(30.0, canvas.width / canvas.height, 1.0, 100.0); //Profondeur
+ viewProjMatrix.lookAt(3.0, 3.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); //Position, Point de vision, Direction
+
+ initEventHandlers(document, canvas, gl, fbo, shadowProgram, normalProgram, plainObject, sablierObject, viewProjMatrix, viewProjMatrixFromLight);
+
+ var render = function() {
+ drawScene(canvas, gl, fbo, shadowProgram, normalProgram, plainObject, sablierObject, viewProjMatrix, viewProjMatrixFromLight);
+ //Appel de la fonction render à chaque image
+ requestAnimationFrame(render);
+ };
+ render();
+}
+
+function drawScene(canvas, gl, fbo, shadowProgram, normalProgram, plainObject, sablierObject, viewProjMatrix, viewProjMatrixFromLight) {
+ viewProjMatrixFromLight.setPerspective(100.0, OFFSCREEN_WIDTH/OFFSCREEN_HEIGHT, 0.1, 100.0);
+ if (pointLight) {
+ viewProjMatrixFromLight.lookAt(pointLightPosition[0], pointLightPosition[1], pointLightPosition[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
+ }
+ else {
+ viewProjMatrixFromLight.lookAt(directionalLightDirection[0], directionalLightDirection[1], directionalLightDirection[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
+ }
+
+ gl.bindFramebuffer(gl.FRAMEBUFFER, fbo); // Change the drawing destination to FBO
+ gl.viewport(0, 0, OFFSCREEN_HEIGHT, OFFSCREEN_HEIGHT); // Modif du viewport pour être à la taille du FBO
+ gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); // Clear FBO
+
+ gl.useProgram(shadowProgram); // Set shaders for generating a shadow map
+
+ drawPyramid(gl, shadowProgram, viewProjMatrixFromLight, sablierObject, false);
+ mvpMatrixFromLight_sablier_bottom.set(mvpMatrix);
+
+ drawPyramid(gl, shadowProgram, viewProjMatrixFromLight, sablierObject, true);
+ mvpMatrixFromLight_sablier_top.set(mvpMatrix);
+
+ drawPlain(gl, shadowProgram, viewProjMatrixFromLight, plainObject);
+ mvpMatrixFromLight_plain.set(mvpMatrix);
+
+ gl.bindFramebuffer(gl.FRAMEBUFFER, null); // Change the drawing destination to color buffer
+ gl.viewport(0, 0, canvas.width, canvas.height);
+ gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); // Clear color and depth buffer
+
+ gl.useProgram(normalProgram); // Set the shader for regular drawing
+ gl.uniform1i(normalProgram.u_ShadowMap, 0); // Pass 0 because gl.TEXTURE0 is enabled
+
+ gl.uniformMatrix4fv(normalProgram.u_MvpMatrixFromLight, false, mvpMatrixFromLight_sablier_bottom.elements);
+ drawPyramid(gl, normalProgram, viewProjMatrix, sablierObject, false);
+
+ gl.uniformMatrix4fv(normalProgram.u_MvpMatrixFromLight, false, mvpMatrixFromLight_sablier_top.elements);
+ drawPyramid(gl, normalProgram, viewProjMatrix, sablierObject, true);
+
+ gl.uniformMatrix4fv(normalProgram.u_MvpMatrixFromLight, false, mvpMatrixFromLight_plain.elements);
+ drawPlain(gl, normalProgram, viewProjMatrix, plainObject);
+}
+
+function drawPyramid(gl, program, viewProjMatrix, o, drawTop) {
+ //Update model movement with mouse
+ modelMatrix.setRotate(mouseMovement[0], 1.0, 0.0, 0.0);
+ modelMatrix.rotate(mouseMovement[1], 0.0, 1.0, 0.0);
+
+ if (drawTop) {
+ modelMatrix.rotate(180, 1.0, 0.0, 0.0);
+
+ if (clickAndRotateValue % 180 == 0) {
+ clickAndRotate = false;
+ }
+ }
+ else {
+ if (clickAndRotate) {
+ clickAndRotateValue += 1
+ }
+ }
+
+ modelMatrix.rotate(clickAndRotateValue, 1.0, 0.0, 0.0);
+
+ draw(gl, program, viewProjMatrix, o)
+}
+
+function drawPlain(gl, program, viewProjMatrix, o) {
+ //Update model movement with mouse
+ modelMatrix.setRotate(mouseMovement[0], 1.0, 0.0, 0.0);
+ modelMatrix.rotate(mouseMovement[1], 0.0, 1.0, 0.0);
+
+ draw(gl, program, viewProjMatrix, o)
+}
+
+function draw(gl, program, viewProjMatrix, o) {
+ initAttributeVariable(gl, program.a_Position, o.vertices);
+ if (program.a_Color != undefined && program.a_Normal != undefined) {
+ initAttributeVariable(gl, program.a_Color, o.colors);
+ initAttributeVariable(gl, program.a_Normal, o.normals);
+ }
+ gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, o.indices);
+
+ if (program.u_PositionLight != undefined && program.u_LightDirection != undefined) {
+ //Point light position
+ gl.uniform3fv(program.u_PositionLight, pointLightPosition);
+ //Directional light direction
+ lightDirection = new Vector3(directionalLightDirection);
+ gl.uniform3fv(program.u_LightDirection, lightDirection.normalize().elements);
+ }
+
+ mvpMatrix.set(viewProjMatrix).multiply(modelMatrix);
+ gl.uniformMatrix4fv(program.u_MvpMatrix, false, mvpMatrix.elements);
+ if (program.u_ModelMatrix != undefined && program.u_ModelMatrixInverseTransposee != undefined) {
+ gl.uniformMatrix4fv(program.u_ModelMatrix, false, modelMatrix.elements);
+
+ modelMatrixInverseTransposee.setInverseOf(modelMatrix).transpose()
+ gl.uniformMatrix4fv(program.u_ModelMatrixInverseTransposee, false, modelMatrixInverseTransposee.elements);
+ }
+
+ gl.drawElements(gl.TRIANGLES, o.nIndices, gl.UNSIGNED_BYTE, 0);
+}
+
+function initAttributeVariable(gl, attribute, buffer) {
+ gl.bindBuffer(gl.ARRAY_BUFFER, buffer)
+ gl.vertexAttribPointer(attribute, buffer.num, buffer.type, false, 0, 0);
+ gl.enableVertexAttribArray(attribute);
+}
+
+function subtractArrays(array1, array2) {
+ result = []
+ for (let i = 0; i < array1.length; i++){
+ result.push(array1[i] - array2[i]);
+ }
+ return result;
+}
+
+function calcNormal(vertices, normals, indices) {
+ for (let i = 0; i < indices.length; i += 3) {
+ let A = [vertices[indices[i] * 3], vertices[indices[i] * 3 + 1], vertices[indices[i] * 3 + 2]];
+ let B = [vertices[indices[i + 1] * 3], vertices[indices[i + 1] * 3 + 1], vertices[indices[i + 1] * 3 + 2]];
+ let C = [vertices[indices[i + 2] * 3], vertices[indices[i + 2] * 3 + 1], vertices[indices[i + 2] * 3 + 2]];
+
+ let U = subtractArrays(B, A);
+ let V = subtractArrays(C, A);
+
+ for (let j = 0; j < 3; j++) {
+ normals[indices[i + j] * 3] = (U[1] * V[2] - U[2] * V[1]);
+ normals[indices[i + j] * 3 + 1] = (U[2] * V[0] - U[0] * V[2]);
+ normals[indices[i + j] * 3 + 2] = (U[0] * V[1] - U[1] * V[0]);
+ }
+ }
+}
+
+function initVertexBuffersForPlain(gl) {
+ // This is the model
+ let vertices = new Float32Array([
+ //Plain
+ -2.0, -0.9, -2.0,
+ -2.0, -0.9, 2.0,
+ 2.0, -0.9, -2.0,
+ 2.0, -0.9, 2.0
+ ]);
+
+ let colors = new Float32Array([
+ //Plain
+ 1.0, 1.0, 1.0,
+ 1.0, 1.0, 1.0,
+ 1.0, 1.0, 1.0,
+ 1.0, 1.0, 1.0
+ ]);
+
+ let normals = new Float32Array([
+ //Plain
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0
+ ]);
+
+ let indices = new Uint8Array([
+ 0, 1, 2, //Plain
+ 1, 3, 2
+ ]);
+
+ calcNormal(vertices, normals, indices);
+
+ var o = new Object();
+
+ o.vertices = initArrayBuffer(gl, vertices, 3, gl.FLOAT);
+ o.colors = initArrayBuffer(gl, colors, 3, gl.FLOAT);
+ o.normals = initArrayBuffer(gl, normals, 3, gl.FLOAT);
+ o.indices = initElementArrayBuffer(gl, indices, 3, gl.FLOAT);
+ if (!o.vertices || !o.colors || !o.normals || !o.indices) {
+ console.log("Failed to create object");
+ return -1;
+ }
+
+ o.nIndices = indices.length;
+
+ // Unbind the buffer object
+ gl.bindBuffer(gl.ARRAY_BUFFER, null);
+ gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+
+ return o;
+}
+
+let colors_blue = new Float32Array([
+ //Grande base
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+
+ //Petite base
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+
+ //Face arrière
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+
+ //Face gauche
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+
+ //Face droite
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+
+ //Face avant
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+ 0.0, 0.0, 1.0,
+]);
+
+let colors_green = new Float32Array([
+ //Grande base
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+
+ //Petite base
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+
+ //Face arrière
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+
+ //Face gauche
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+
+ //Face droite
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+
+ //Face avant
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 1.0, 0.0,
+]);
+
+function initVertexBuffersForSablier(gl) {
+ // This is the model
+ let vertices = new Float32Array([
+ //Grande base
+ -0.4, -0.8, -0.4,
+ -0.4, -0.8, 0.4,
+ 0.4, -0.8, -0.4,
+ 0.4, -0.8, 0.4,
+
+ //Petite base
+ -0.2, 0.0, -0.2,
+ -0.2, 0.0, 0.2,
+ 0.2, 0.0, -0.2,
+ 0.2, 0.0, 0.2,
+
+ //Face arrière
+ -0.4, -0.8, 0.4,
+ -0.2, 0.0, 0.2,
+ 0.0, -0.8, 0.4,
+ 0.2, 0.0, 0.2,
+ 0.4, -0.8, 0.4,
+
+ //Face gauche
+ -0.4, -0.8, 0.4,
+ -0.2, 0.0, 0.2,
+ -0.4, -0.8, 0.0,
+ -0.2, 0.0, -0.2,
+ -0.4, -0.8, -0.4,
+
+ //Face droite
+ 0.4, -0.8, -0.4,
+ 0.2, 0.0, -0.2,
+ 0.4, -0.8, 0.0,
+ 0.2, 0.0, 0.2,
+ 0.4, -0.8, 0.4,
+
+ //Face avant
+ -0.4, -0.8, -0.4,
+ -0.2, 0.0, -0.2,
+ 0.0, -0.8, -0.4,
+ 0.2, 0.0, -0.2,
+ 0.4, -0.8, -0.4
+ ]);
+
+ let normals = new Float32Array([
+ //Grande base
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+
+ //Petite base
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+
+ //Face arrière
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+
+ //Face gauche
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+
+ //Face droite
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+
+ //Face avant
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0
+ ]);
+
+ let indices = new Uint8Array([
+ 0, 2, 1, //Grande base
+ 2, 3, 1,
+
+ 4, 5, 6, //Petite base
+ 5, 7, 6,
+
+ 8, 10, 9, //Face arrière
+ 10, 11, 9,
+ 10, 12, 11,
+
+ 13, 14, 15, //Face gauche
+ 14, 16, 15,
+ 16, 17, 15,
+
+ 18, 19, 20, //Face droite
+ 19, 21, 20,
+ 21, 22, 20,
+
+ 23, 24, 25, //Face avant
+ 24, 26, 25,
+ 26, 27, 25
+ ]);
+
+ calcNormal(vertices, normals, indices);
+
+ var o = new Object();
+
+ o.vertices = initArrayBuffer(gl, vertices, 3, gl.FLOAT);
+ o.colors = initArrayBuffer(gl, colors_green, 3, gl.FLOAT);
+ o.normals = initArrayBuffer(gl, normals, 3, gl.FLOAT);
+ o.indices = initElementArrayBuffer(gl, indices, 3, gl.FLOAT);
+ if (!o.vertices || !o.colors || !o.normals || !o.indices) {
+ console.log("Failed to create object");
+ return -1;
+ }
+
+ o.nIndices = indices.length;
+
+ // Unbind the buffer object
+ gl.bindBuffer(gl.ARRAY_BUFFER, null);
+ gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+
+ return o;
+}
+
+function initArrayBuffer(gl, data, num, type) {
+ // Create a buffer object
+ var buffer = gl.createBuffer();
+ if (!buffer) {
+ console.log('Failed to create the buffer object');
+ return null;
+ }
+ // Write date into the buffer object
+ gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+ gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
+
+ // Store the necessary information to assign the object to the attribute variable later
+ buffer.num = num;
+ buffer.type = type;
+
+ return buffer;
+}
+
+function initElementArrayBuffer(gl, data, type) {
+ // Create a buffer object
+ var buffer = gl.createBuffer();
+ if (!buffer) {
+ console.log('Failed to create the buffer object');
+ return null;
+ }
+ // Write date into the buffer object
+ gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer);
+ gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW);
+
+ buffer.type = type;
+
+ return buffer;
+}
+
+function initEventHandlers(document, canvas, gl, fbo, shadowProgram, normalProgram, plainObject, sablierObject, viewProjMatrix, viewProjMatrixFromLight) {
+ var dragging = false;
+ var lastX = -1, lastY = -1;
+ color = true //Green color
+
+ // Init buffers
+ colorBlueBuffer = initArrayBuffer(gl, colors_blue, 3, gl.FLOAT);
+ colorGreenBuffer = initArrayBuffer(gl, colors_green, 3, gl.FLOAT);
+ if (!colorBlueBuffer || !colorGreenBuffer) {
+ console.log("Failed to create object");
+ return -1;
+ }
+
+ //Mouse down
+ canvas.onmousedown = function(ev) {
+ dragging = true;
+
+ var x = ev.clientX, y = ev.clientY;
+ var rect = ev.target.getBoundingClientRect();
+ var x_in_canvas = x - rect.left, y_in_canvas = rect.bottom - y;
+ var picked = check(gl, canvas, fbo, shadowProgram, normalProgram, plainObject, sablierObject, x_in_canvas, y_in_canvas, viewProjMatrix, viewProjMatrixFromLight);
+
+ if (picked) {
+ if (color) {
+ color = false;
+ sablierObject.colors = colorBlueBuffer;
+ } else {
+ color = true;
+ sablierObject.colors = colorGreenBuffer;
+ }
+
+ clickAndRotate = true; //Lance la rotation du sablier
+ }
+ };
+
+ //Mouse up
+ canvas.onmouseup = function(ev) {
+ dragging = false;
+ };
+
+ //Mouse mouve
+ canvas.onmousemove = function(ev) {
+ var x = ev.clientX, y = ev.clientY;
+ if (dragging) {
+ //Speed factor
+ var speedFactor = 0.2;
+ var dx = speedFactor * (x - lastX);
+ var dy = speedFactor * (y - lastY);
+
+ //Update angle
+ mouseMovement[1] = mouseMovement[1] + dx;
+ mouseMovement[0] = mouseMovement[0] + dy;
+ }
+ lastX = x, lastY = y;
+ };
+
+ document.onkeydown = function(ev) {
+ if (ev.keyCode == 76) { // L Key (Light mode)
+ if (pointLight) {
+ gl.uniform3f(normalProgram.u_LightColor_Point, 0.0, 0.0, 0.0);
+ gl.uniform3f(normalProgram.u_LightColor_Directional, 1.0, 1.0, 1.0);
+ pointLight = false;
+ }
+ else {
+ gl.uniform3f(normalProgram.u_LightColor_Point, 1.0, 1.0, 1.0);
+ gl.uniform3f(normalProgram.u_LightColor_Directional, 0.0, 0.0, 0.0);
+ pointLight = true;
+ }
+ }
+
+ //Direction (Directional) & Position (Point)
+ else if (ev.keyCode == 81) { //Q key
+ if (pointLight) {
+ pointLightPosition[0] += 0.1;
+ }
+ else {
+ directionalLightDirection[0] += 0.1;
+ }
+ }
+ else if (ev.keyCode == 65) { //A key
+ if (pointLight) {
+ pointLightPosition[0] -= 0.12;
+ }
+ else {
+ directionalLightDirection[0] -= 0.1;
+ }
+ }
+ else if (ev.keyCode == 87) { //W key
+ if (pointLight) {
+ pointLightPosition[1] += 0.12;
+ }
+ else {
+ directionalLightDirection[1] += 0.1;
+ }
+ }
+ else if (ev.keyCode == 83) { //S key
+ if (pointLight) {
+ pointLightPosition[1] -= 0.12;
+ }
+ else {
+ directionalLightDirection[1] -= 0.1;
+ }
+ }
+ else if (ev.keyCode == 69) { //E key
+ if (pointLight) {
+ pointLightPosition[2] -= 0.12;
+ }
+ else {
+ directionalLightDirection[2] -= 0.1;
+ }
+ }
+ else if (ev.keyCode == 68) { //D key
+ if (pointLight) {
+ pointLightPosition[2] += 0.12;
+ }
+ else {
+ directionalLightDirection[2] += 0.1;
+ }
+ }
+
+ updateHtmlLightText(pointLightPosition, directionalLightDirection, pointLight);
+ };
+}
+
+function updateHtmlLightText(pointLightPosition, directionalLightDirection, pointLight) {
+ if (pointLight) {
+ document.getElementById("activatedLight").innerHTML = "Activated light: Point light";
+ }
+ else {
+ document.getElementById("activatedLight").innerHTML = "Activated light: Directional light";
+ }
+
+ document.getElementById("pointLightX").innerHTML = "x: " + Math.round(pointLightPosition[0] * 10) / 10;
+ document.getElementById("pointLightY").innerHTML = "y: " + Math.round(pointLightPosition[1] * 10) / 10;
+ document.getElementById("pointLightZ").innerHTML = "z: " + Math.round(pointLightPosition[2] * 10) / 10;
+
+ document.getElementById("directionalLightX").innerHTML = "x: " + Math.round(directionalLightDirection[0] * 10) / 10;
+ document.getElementById("directionalLightY").innerHTML = "y: " + Math.round(directionalLightDirection[1] * 10) / 10;
+ document.getElementById("directionalLightZ").innerHTML = "z: " + Math.round(directionalLightDirection[2] * 10) / 10;
+}
+
+//Source: http://rodger.global-linguist.com/webgl/ch10/PickObject.html
+function check(gl, canvas, fbo, shadowProgram, normalProgram, plainObject, sablierObject, x, y, viewProjMatrix, viewProjMatrixFromLight) {
+ var picked = false;
+
+ gl.uniform1i(normalProgram.u_Clicked, 1); // u_Clicked à 1 pour dessiner le sablier en rouge
+ gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+ drawPyramid(gl, normalProgram, viewProjMatrix, sablierObject, false);
+ drawPyramid(gl, normalProgram, viewProjMatrix, sablierObject, true);
+
+ // Read pixel at the clicked position
+ var pixels = new Uint8Array(4);
+ gl.readPixels(x, y, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+
+ if (pixels[0] > 0) { //Si l'endroit où l'utilisateur a cliqué est rouge alors picked = true
+ picked = true;
+ }
+
+ gl.uniform1i(normalProgram.u_Clicked, 0); // u_Clicked à 0 pour redessiner dans la couleur par défaut
+
+ drawScene(canvas, gl, fbo, shadowProgram, normalProgram, plainObject, sablierObject, viewProjMatrix, viewProjMatrixFromLight); //Redessiner toute la scène
+
+ return picked;
+}
+
+//Source http://rodger.global-linguist.com/webgl/ch10/Shadow_highp.html
+function initFramebufferObject(gl) {
+ var framebuffer, texture, depthBuffer;
+
+ // Define the error handling function
+ var error = function() {
+ if (framebuffer) gl.deleteFramebuffer(framebuffer);
+ if (texture) gl.deleteTexture(texture);
+ if (depthBuffer) gl.deleteRenderbuffer(depthBuffer);
+ return null;
+ }
+
+ // Create a framebuffer object (FBO)
+ framebuffer = gl.createFramebuffer();
+ if (!framebuffer) {
+ console.log('Failed to create frame buffer object');
+ return error();
+ }
+
+ // Create a texture object and set its size and parameters
+ texture = gl.createTexture(); // Create a texture object
+ if (!texture) {
+ console.log('Failed to create texture object');
+ return error();
+ }
+ gl.bindTexture(gl.TEXTURE_2D, texture);
+ //Paramètres texImage2D (Texture bidimensionnelle, niveau de détail de l'image de base, composantes de couleur dans la texture, largeur de la texture, hauteur de la texture
+ //largeur de la bordure, format des données de texel - pareil que le format interne, types des données de texel. 8 bits par canal pour gl.RGBA, object source de pixels de la texture)
+ gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, OFFSCREEN_WIDTH, OFFSCREEN_HEIGHT, 0, gl.RGBA, gl.UNSIGNED_BYTE, null); //Spécifie l'image 2D de la texture.
+ gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); //Permet de paramétrer la texture (Filtre de réduction de texture)
+ gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); //Permet de paramétrer la texture (Filtre de grossissement de la texture)
+
+ // Create a renderbuffer object and Set its size and parameters
+ depthBuffer = gl.createRenderbuffer(); // Create a renderbuffer object
+ if (!depthBuffer) {
+ console.log('Failed to create renderbuffer object');
+ return error();
+ }
+ gl.bindRenderbuffer(gl.RENDERBUFFER, depthBuffer);
+ //Paramètres (target renderbuffer object, internal format of renderbuffer - 16 depth bits, width of renderbuffer, height of renderbuffer)
+ gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, OFFSCREEN_WIDTH, OFFSCREEN_HEIGHT);
+
+ // Attach the texture and the renderbuffer object to the FBO
+ gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+ gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); //Attache la texture au framebuffer au point COLOR_ATTACHMENT0 = color buffer, texture bidimensionnelle, texture object
+ gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, depthBuffer); //Attache le renderbuffer au framebuffer au point DEPTH_ATTACHMENT = Depth buffer
+
+ // Check if FBO is configured correctly
+ var e = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
+ if (gl.FRAMEBUFFER_COMPLETE !== e) {
+ console.log('Frame buffer object is incomplete: ' + e.toString());
+ return error();
+ }
+
+ framebuffer.texture = texture; // keep the required object
+
+ // Unbind the buffer object
+ gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+ gl.bindTexture(gl.TEXTURE_2D, null);
+ gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+
+ return framebuffer;
}
\ No newline at end of file