diff --git a/lab4/.DS_Store b/lab4/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..b74c8fbc6d7df9d6f576446aa21920d491590d10
Binary files /dev/null and b/lab4/.DS_Store differ
diff --git a/lab4/lib/cuon-matrix.js b/lab4/lib/cuon-matrix.js
new file mode 100644
index 0000000000000000000000000000000000000000..26585b7cb8ecf46e240822455d5afb60caf2f778
--- /dev/null
+++ b/lab4/lib/cuon-matrix.js
@@ -0,0 +1,741 @@
+// 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;
+}
diff --git a/lab4/src/.DS_Store b/lab4/src/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6
Binary files /dev/null and b/lab4/src/.DS_Store differ
diff --git a/lab4/src/lab4.html b/lab4/src/lab4.html
index 2bb37bcbd21a70f6bb9acddb83953d93aa5bf516..4f4185d71660418182eac05a0a1875edc5be07fb 100644
--- a/lab4/src/lab4.html
+++ b/lab4/src/lab4.html
@@ -2,15 +2,28 @@
 <html lang="en">
 <head>
   <meta charset="UTF-8">
-  <title>Lab 4</title>
+  <title>Simple model</title>
 </head>
 <body onload="main()">
+
+
+  <input type="checkbox" id="camx" name="camx" onclick="getCamera();"value="camx" />Rotate X  
+  <input type="checkbox" id="camy" name="camy" 
+    value="camy" onclick="getCamera();" /> Rotate Y     
+  <input type="checkbox" id="camz" name="camz" 
+    value="camz" /> Rotate Z<br onclick="getCamera();" />
+    <label id="x">X=</label >  <label id="valx">0</label>
+    <label id="y">&nbsp;Y=</label>  <label id="valy">0</label>
+    <label id="z">&nbsp; Z=</label>  <label id="valz">0</label> <br>
 <canvas width="400" height="600" id="my-canvas">
-  Please use a browser that supports "canvas"
+  Please use a browser that supports "canvas" \n
 </canvas>
+ 
+
 <script src="../lib/webgl-utils.js"></script>
 <script src="../lib/webgl-debug.js"></script>
 <script src="../lib/cuon-utils.js"></script>
+<script src="../lib/cuon-matrix.js"></script>
 <script src="lab4.js"></script>
 </body>
 </html>
\ No newline at end of file
diff --git a/lab4/src/lab4.js b/lab4/src/lab4.js
index 105a227db9e7e4d4abde40b5002e7c75eb860fb4..74e137ab82f05134b245d9a575c9b01876b75ca2 100644
--- a/lab4/src/lab4.js
+++ b/lab4/src/lab4.js
@@ -1,18 +1,523 @@
-// Vertex shader program
-const VSHADER_SOURCE =
-  '\n' +
-  // TODO: Implement your vertex shader code here
-  '\n';
-
-// Fragment shader program
-const FSHADER_SOURCE =
-  '\n' +
-  // TODO: Implement your fragment shader code here
-  '\n';
+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';
+var SHADOW_FSHADER_SOURCE =
+  '#ifdef GL_ES\n' +
+  'precision mediump float;\n' +
+  '#endif\n' +
+  'void main() {\n' +
+  '  gl_FragColor = vec4(gl_FragCoord.z, 0.0, 0.0, 0.0);\n' +
+  '}\n';
+var VSHADER_SOURCE =
+  'attribute vec4 a_Position;\n' +
+  'attribute vec4 a_Color;\n' +
+  'uniform mat4 u_MvpMatrix;\n' +
+  'uniform mat4 u_MvpMatrixFromLight;\n' +
+  'varying vec4 v_PositionFromLight;\n' +
+  'varying vec4 v_Color;\n' +
+  'uniform bool u_Clicked;\n' +
+  'attribute vec4 a_Normal;\n' +
+  'varying vec3 v_normal;\n' +
+  'uniform mat4 u_NormalMatrix;\n' +
+  'varying vec4 v_VertexPosition;\n' +
+  'uniform mat4 u_ModelMatrix;\n' +
+  'void main() {\n' +
+  '  gl_Position = u_MvpMatrix * a_Position;\n' +
+  '  v_normal = normalize(vec3(u_NormalMatrix * a_Normal));\n' +
+  '  v_VertexPosition = u_ModelMatrix * a_Position;\n' +
+  '  v_PositionFromLight = u_MvpMatrixFromLight * a_Position;\n' +
+  '  if (u_Clicked) {\n' + //  Draw in red if mouse is pressed
+  '    v_Color = vec4(1.0, 0.0, 0.0, 1.0);\n' +
+  '  } else {\n' +
+  '    v_Color = a_Color;\n' +
+  '  }\n' +
+  '}\n';
+var FSHADER_SOURCE =
+  '#ifdef GL_ES\n' +
+  'precision mediump float;\n' +
+  '#endif\n' +
+  'uniform sampler2D u_ShadowMap;\n' +
+  'varying vec4 v_PositionFromLight;\n' +
+  'varying vec4 v_Color;\n' +
+  'varying vec3 v_normal;\n' +
+  'varying vec4 v_VertexPosition;\n' +
+  'uniform vec3 u_LightPosition;\n' +
+  'uniform vec3 u_LightColor;\n' +
+  'uniform bool u_Clicked;\n' +
+  'void main() {\n' +
 
+  'vec3 to_light;\n' +
+  'vec3 vertex_normal;\n' +
+  'vec3 reflection;\n' +
+  'float cos_angle;\n' +
+  'vec3 specular_color;\n' +
+  'vec3 object_color;\n' +
+
+  
+  '  vec3 normalref = normalize(v_normal);\n' +
+
+  'cos_angle=dot(normalref,to_light);\n' +
+  'cos_angle=clamp(cos_angle,0.0,1.0);\n' +
+
+  '  vec3 lightDirection = normalize(u_LightPosition - vec3(v_VertexPosition));\n' +
+  '  float nDotL = max(dot(v_normal, lightDirection), 0.0);\n' +
+  '  vec3 diffuse = u_LightColor * v_Color.rgb * nDotL;\n' +
+
+  'reflection =1.5 * dot(normalref,lightDirection) * normalref - lightDirection;\n' +
+  'reflection=normalize(reflection);\n' +
+  'cos_angle=dot(reflection,lightDirection);\n' +
+  'cos_angle=clamp(cos_angle,0.0,1.0);\n' +
+  'if (cos_angle > 0.0) {\n' +
+  'specular_color=vec3(1.0,1.0,1.0) * cos_angle;\n' +
+  '} else {\n' +
+  'specular_color=vec3(0.0,0.0,0.0); }\n' +
+  '  vec3 shadowCoord = (v_PositionFromLight.xyz/v_PositionFromLight.w)/2.0 + 0.5;\n' +
+  '  vec4 rgbaDepth = texture2D(u_ShadowMap, shadowCoord.xy);\n' +
+  '  float depth = rgbaDepth.r;\n' + // Retrieve the z-value from R
+  '  float visibility = (shadowCoord.z > depth + 0.03) ? 0.7 : 1.0;\n' +
+  
+  
+
+  
+  '  if (u_Clicked) {\n' + //  Draw in red if mouse is pressed
+  '    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n' +
+  '  } else {\n' +
+  '  gl_FragColor = vec4((specular_color + diffuse )* visibility, v_Color.a);\n' +
+  '  }\n' +
+  '}\n';
+
+
+var normalsBas = new Float32Array([    // Normal Bas
+  0.5, 0.2, 0.5, 0, 0.2, 0.5, -0.5, -1.0, 1.0, 1.0, -1.0, 1.0, //font
+  0.5, 0.2, 0.5, 1.0, -1.0, 1.0, 1.0, -1.0, -0.5, 0.5, 0.2, 0,     //right
+  0.5, 0.2, 0.5, 0.5, 0.2, 0, 0, 0.2, 0, 0, 0.2, 0.5,                 //up
+  -0.5, 0.2, 0.5, -1, 0.2, 0, -1, -1.0, -0.5, -0.5, -1.0, 1.0,     //left 
+  -0.5, -1.0, -1, 1.0, -1.0, -0.5, 1.0, -1.0, 1.0, -0.5, -1.0, 1.0,   //down
+  1.0, -1.0, -0.5, -0.5, -0.5, -0.5, 0, 0.1, -1.0, 0.5, 0.2, -1.0     //back
+]);
+
+var normalsHaut = new Float32Array([    // Normal Haut
+  0.5, 0.2, 0.5, 0, 0.2, 0.5, -0.5, -1.0, 1.0, 1.0, -1.0, 1.0, //font
+  0.5, 0.2, 0.5, 1.0, -1.0, 1.0, 1.0, -1.0, -0.5, 0.5, 0.2, 0,     //right
+  -0.5, -1.0, -1, 1.0, -1.0, -0.5, 1.0, -1.0, 1.0, -0.5, -1.0, 1.0,   //down
+  -0.5, 0.2, 0.5, -1, 0.2, 0, -1, -1.0, -0.5, -0.5, -1.0, 1.0,     //left 
+  0.5, 0.2, 0.5, 0.5, 0.2, 0, 0, 0.2, 0, 0, 0.2, 0.5,                 //up
+  1.0, -1.0, -0.5, -0.5, -0.5, -0.5, 0, 0.1, -1.0, 0.5, 0.2, -1.0     //back
+
+]);
+
+var colors1 = new Float32Array([     // Couleurs
+  0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,
+  0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,
+  0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,
+  0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,
+  0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,
+  0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,
+]);
+var colors2 = new Float32Array([     // Couleurs
+  0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0,
+  0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0,
+  0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0,
+  0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0,
+  0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0,
+  0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0,
+]);
+
+var OFFSCREEN_WIDTH = 2048, OFFSCREEN_HEIGHT = 2048;
+var LIGHT_X = 0, LIGHT_Y = 4, LIGHT_Z = 6;
+var viewProjMatrix = new Matrix4();
+var clicked = false;
+var rotation = 0;
+var ANGLE_STEP = 45.0;
+var camX = 1;
+var camY = 0;
+var camZ = 0;
+var lookx = 5;
+var looky = 3;
+var lookz = 12;
+var canvas = document.getElementById('my-canvas');
+var gl;
+var shadowProgram;
+var normalProgram;
+var sab;
+var plane;
+var fbo
+var g_modelMatrix = new Matrix4();
+var g_mvpMatrix = new Matrix4();
+var colors;
 function main() {
-  // Retrieve <canvas> element
-  const canvas = document.getElementById('my-canvas');
+  controler();
+  // Get the rendering context for WebGL
+  gl = getWebGLContext(canvas);
+  if (!gl) {
+    console.log('Failed to get the rendering context for WebGL');
+    return;
+  }
+  // Initialize shaders for generating a shadow map
+  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
+  normalProgram = createProgram(gl, VSHADER_SOURCE, FSHADER_SOURCE);
+  normalProgram.u_MvpMatrix = gl.getUniformLocation(normalProgram, 'u_MvpMatrix');
+  normalProgram.u_MvpMatrixFromLight = gl.getUniformLocation(normalProgram, 'u_MvpMatrixFromLight');
+  normalProgram.u_ShadowMap = gl.getUniformLocation(normalProgram, 'u_ShadowMap');
+  normalProgram.u_Clicked = gl.getUniformLocation(normalProgram, 'u_Clicked');
+  normalProgram.u_NormalMatrix = gl.getUniformLocation(normalProgram, 'u_NormalMatrix');
+  normalProgram.u_ModelMatrix = gl.getUniformLocation(normalProgram, 'u_ModelMatrix');
+  normalProgram.u_LightPosition = gl.getUniformLocation(normalProgram, 'u_LightPosition');
+  normalProgram.u_LightColor = gl.getUniformLocation(normalProgram, 'u_LightColor');
+  normalProgram.a_Position = gl.getAttribLocation(normalProgram, 'a_Position');
+  normalProgram.a_Color = gl.getAttribLocation(normalProgram, 'a_Color');
+  normalProgram.a_Normal = gl.getAttribLocation(normalProgram, 'a_Normal');
+  colors=colors1;
+  sab = initVertexBuffersForSab(gl,normalsBas);
+  plane = initVertexBuffersForPlane(gl);
+  if (!sab || !plane) {
+    console.log('Failed to set the vertex information');
+    return;
+  }
+  gl.useProgram(normalProgram);
+  gl.uniform1i(normalProgram.u_Clicked, 0); // Pass false to u_Clicked
+  // Initialize framebuffer object (FBO)  
+  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
+  gl.bindTexture(gl.TEXTURE_2D, fbo.texture);
+  drawContext(gl, canvas, fbo, normalProgram, shadowProgram, sab, plane, rotation, lookx, looky, lookz);
+  canvas.onmousedown = function (ev) {   // Mouse is pressed
+    var x = ev.clientX, y = ev.clientY;
+    var rect = ev.target.getBoundingClientRect();
+    if (rect.left <= x && x < rect.right && rect.top <= y && y < rect.bottom) {
+      // If pressed position is inside <canvas>, check if it is above object
+      var x_in_canvas = x - rect.left, y_in_canvas = rect.bottom - y;
+      gl.useProgram(normalProgram);
+      gl.uniform1i(normalProgram.u_Clicked, 1);  // Pass true to u_Clicked
+      drawSab(gl, normalProgram, sab, viewProjMatrix, rotation)
+      // Read pixel at the clicked position
+      var pixels = new Uint8Array(4); // Array for storing the pixel value
+      gl.readPixels(x_in_canvas, y_in_canvas, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+      gl.uniform1i(normalProgram.u_Clicked, 0);  // Pass false to u_Clicked(rewrite the cube)
+      drawContext(gl, canvas, fbo, normalProgram, shadowProgram, sab, plane, rotation, lookx, looky, lookz);
+      if (pixels[0] == 255) // The mouse in on cube if R(pixels[0]) is 255
+        clicked = true;
+      if (clicked) {
+        colors=colors2;
+        //sab = initVertexBuffersForSab(gl,normalsBas);
+        var tick = function () {
+          rotation = animate(rotation);
+          if ((rotation %= 180) < 177) {
+            console.log(rotation %= 180);
+            drawContext(gl, canvas, fbo, normalProgram, shadowProgram, sab, plane, rotation, lookx, looky, lookz);
+            requestAnimationFrame(tick, canvas);
+          }
+          else{
+            colors=colors1;
+           
+    drawContext(gl, canvas, fbo, normalProgram, shadowProgram, sab, plane, rotation, lookx, looky, lookz); 
+          }
+        };
+        
+        tick();
+        clicked = false;
+       
+      }
+    
+    }
+   
+  }
+}
+function drawSab(gl, program, sab, viewProjMatrix, rotation) {
+  g_modelMatrix.setRotate(rotation, camX, camY, camZ);
+  sab = initVertexBuffersForSab(gl,normalsHaut);
+  draw(gl, program, sab, viewProjMatrix);
+  translate = new Matrix4();
+  rotate = new Matrix4();
+  rotate.setRotate(180, 1, 0, 0);
+  translate.setTranslate(0, 0.4, 0.5); //(0, 0.4, 0.5);
+  g_modelMatrix.multiply(translate).multiply(rotate);
+  sab = initVertexBuffersForSab(gl,normalsBas);
+  draw(gl, program, sab, viewProjMatrix);
+
+}
+function drawPlane(gl, program, plane, viewProjMatrix) {
+  g_modelMatrix.setRotate(0, 1, 1, 1);
+
+  /*  tran= new Matrix4();
+  tran.setTranslate(0,1.7,0);
+  g_modelMatrix.multiply(tran);
+  */
+  draw(gl, program, plane, viewProjMatrix);
+}
+function draw(gl, program, o, viewProjMatrix) {
+  initAttributeVariable(gl, program.a_Position, o.vertexBuffer);
+  if (program.a_Color != undefined)
+    initAttributeVariable(gl, program.a_Color, o.colorBuffer);
+  if (program.a_Normal != undefined) {
+    initAttributeVariable(gl, program.a_Normal, o.normalsBuffer);
+  }
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, o.indexBuffer);
+  g_mvpMatrix.set(viewProjMatrix);
+  g_mvpMatrix.multiply(g_modelMatrix);
+  gl.uniformMatrix4fv(program.u_MvpMatrix, false, g_mvpMatrix.elements);
+  normalMatrix = new Matrix4();
+  normalMatrix.setInverseOf(g_modelMatrix);
+  normalMatrix.transpose();
+  gl.uniformMatrix4fv(program.u_NormalMatrix, false, normalMatrix.elements);
+  gl.uniformMatrix4fv(program.u_ModelMatrix, false, g_modelMatrix.elements);
+  gl.uniformMatrix4fv(program.u_MvpMatrix, false, g_mvpMatrix.elements);
+  gl.drawElements(gl.TRIANGLES, o.numIndices, gl.UNSIGNED_BYTE, 0);
+}
+function initAttributeVariable(gl, a_attribute, buffer) {
+  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+  gl.vertexAttribPointer(a_attribute, buffer.num, buffer.type, false, 0, 0);
+  gl.enableVertexAttribArray(a_attribute);
+}
+function initVertexBuffersForPlane(gl,colors) {
+  var vertices = new Float32Array([
+    4.0, -3, 2.5,
+    -7.0, -3, 2.5,
+    -7.0, -3, -15,
+    4.0, -3, -15
+  ]);
+  // Colors
+  var colors = new Float32Array([
+    1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
+  ]);
+  var normals = new Float32Array([
+    0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0
+  ]);
+  // Indices of the vertices
+  var indices = new Uint8Array([0, 1, 2, 0, 2, 3]);
+  var o = new Object(); // Utilize Object object to return multiple buffer objects together
+  // Write vertex information to buffer object
+  o.vertexBuffer = initArrayBufferForLaterUse(gl, vertices, 3, gl.FLOAT);
+  o.colorBuffer = initArrayBufferForLaterUse(gl, colors, 3, gl.FLOAT);
+  o.indexBuffer = initElementArrayBufferForLaterUse(gl, indices, gl.UNSIGNED_BYTE);
+  o.normalsBuffer = initArrayBufferForLaterUse(gl, normals, 3, gl.FLOAT);
+  if (!o.vertexBuffer || !o.colorBuffer || !o.indexBuffer || !o.normalsBuffer) return null;
+  o.numIndices = indices.length;
+  // Unbind the buffer object
+  gl.bindBuffer(gl.ARRAY_BUFFER, null);
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+  return o;
+}
+function initVertexBuffersForSab(gl,normals) {
+  var vertices = new Float32Array([   // Vertex 
+    0.5, 0.2, 0.5, 0, 0.2, 0.5, -0.5, -1.0, 1.0, 1, -1.0, 1.0,
+    0.5, 0.2, 0.5, 1.0, -1.0, 1.0, 1.0, -1.0, -0.5, 0.5, 0.2, 0,
+    0.5, 0.2, 0.5, 0.5, 0.2, 0, 0, 0.2, 0, 0, 0.2, 0.5,
+    0.0, 0.2, 0.5, 0.0, 0.2, 0, -0.5, -1.0, -0.5, -0.5, -1.0, 1.0,
+    -0.5, -1.0, -0.5, 1.0, -1.0, -0.5, 1.0, -1.0, 1.0, -0.5, -1.0, 1.0,
+    1.0, -1.0, -0.5, -0.5, -1.0, -0.5, 0, 0.2, 0, 0.5, 0.2, 0
+  ]);
+
+  var indices = new Uint8Array([       // Indices 
+    0, 1, 2, 0, 2, 3,
+    4, 5, 6, 4, 6, 7,
+    8, 9, 10, 8, 10, 11,
+    12, 13, 14, 12, 14, 15,
+    16, 17, 18, 16, 18, 19,
+    20, 21, 22, 20, 22, 23
+  ]);
+
+  var o = new Object();  // Utilize Object object to return multiple buffer objects together
+  // Write vertex information to buffer object
+  o.vertexBuffer = initArrayBufferForLaterUse(gl, vertices, 3, gl.FLOAT);
+  o.normalsBuffer = initArrayBufferForLaterUse(gl, normals, 3, gl.FLOAT);
+  o.colorBuffer = initArrayBufferForLaterUse(gl, colors, 3, gl.FLOAT);
 
-  // TODO: Complete with your code here
+  o.indexBuffer = initElementArrayBufferForLaterUse(gl, indices, gl.UNSIGNED_BYTE);
+  if (!o.vertexBuffer || !o.colorBuffer || !o.indexBuffer) return null;
+  o.numIndices = indices.length;
+  // Unbind the buffer object
+  gl.bindBuffer(gl.ARRAY_BUFFER, null);
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+  return o;
+}
+function initArrayBufferForLaterUse(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 initElementArrayBufferForLaterUse(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 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);
+  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, OFFSCREEN_WIDTH, OFFSCREEN_HEIGHT, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+  // 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);
+  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);
+  gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, depthBuffer);
+  // 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;
+}
+function drawContext(gl, canvas, fbo, normalProgram, shadowProgram, sab, plane, rotation, lookx, looky, lookz) {
+  // Set the clear color and enable the depth test
+  gl.clearColor(0, 0, 0, 1);
+  gl.enable(gl.DEPTH_TEST);
+  var viewProjMatrixFromLight = new Matrix4(); // Prepare a view projection matrix for generating a shadow map
+  viewProjMatrixFromLight.setPerspective(70.0, OFFSCREEN_WIDTH / OFFSCREEN_HEIGHT, 1.0, 100.0);
+  viewProjMatrixFromLight.lookAt(LIGHT_X, LIGHT_Y, LIGHT_Z, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
+  viewProjMatrix.setPerspective(50, canvas.width / canvas.height, 1.0, 100.0);
+  viewProjMatrix.lookAt(lookx, looky, lookz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
+  var mvpMatrixFromLight_t = new Matrix4();
+  var mvpMatrixFromLight_p = new Matrix4(); // A model view projection matrix from light source (for plane)
+  gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);               // Change the drawing destination to FBO
+  gl.viewport(0, 0, OFFSCREEN_HEIGHT, OFFSCREEN_HEIGHT); // Set view port for FBO
+  gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);   // Clear FBO    
+  gl.useProgram(shadowProgram); // Set shaders for generating a shadow map
+  drawSab(gl, shadowProgram, sab, viewProjMatrixFromLight, rotation);
+  mvpMatrixFromLight_t.set(g_mvpMatrix); // Used later
+  drawPlane(gl, shadowProgram, plane, viewProjMatrixFromLight);
+  mvpMatrixFromLight_p.set(g_mvpMatrix); // Used later
+  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);
+  gl.uniform3f(normalProgram.u_LightColor, 1.0, 1.0, 1.0); // The light is white
+  gl.uniform3f(normalProgram.u_LightPosition, LIGHT_X, LIGHT_Y, LIGHT_Z);
+  gl.uniform1i(normalProgram.u_ShadowMap, 0);  // Pass 0 because gl.TEXTURE0 is enabled
+  gl.uniformMatrix4fv(normalProgram.u_MvpMatrixFromLight, false, mvpMatrixFromLight_t.elements);
+  drawSab(gl, normalProgram, sab, viewProjMatrix, rotation);
+  gl.uniformMatrix4fv(normalProgram.u_MvpMatrixFromLight, false, mvpMatrixFromLight_p.elements);
+  drawPlane(gl, normalProgram, plane, viewProjMatrix);
+}
+function getCamera() {
+  if (document.getElementById("camx").checked == 1)
+    camX = 1;
+  else
+    camX = 0;
+  if (document.getElementById("camy").checked == 1)
+    camY = 1;
+  else
+    camY = 0;
+  if (document.getElementById("camz").checked == 1)
+    camZ = 1;
+  else
+    camZ = 0;
+}
+function controler() {
+  window.addEventListener('keydown', function (event) {
+    if (event.defaultPrevented) {
+      return;
+    }
+    switch (event.key) {
+      case 'ArrowDown':
+        LIGHT_Y--;
+        document.getElementById("valy").innerHTML = LIGHT_Y;
+        drawContext(gl, canvas, fbo, normalProgram, shadowProgram, sab, plane, rotation, lookx, looky, lookz);
+        break;
+      case 'ArrowUp':
+        if (LIGHT_Y < 8)
+          LIGHT_Y++;
+        document.getElementById("valy").innerHTML = LIGHT_Y;
+        drawContext(gl, canvas, fbo, normalProgram, shadowProgram, sab, plane, rotation, lookx, looky, lookz);
+        break;
+      case 'ArrowLeft':
+        LIGHT_X--;
+        document.getElementById("valx").innerHTML = LIGHT_X;
+        drawContext(gl, canvas, fbo, normalProgram, shadowProgram, sab, plane, rotation, lookx, looky, lookz);
+        break;
+      case "ArrowRight":
+        LIGHT_X++;
+        document.getElementById("valx").innerHTML = LIGHT_X;
+        drawContext(gl, canvas, fbo, normalProgram, shadowProgram, sab, plane, rotation, lookx, looky, lookz);
+        break;
+      case 'Enter':
+        LIGHT_Z++;
+        document.getElementById("valz").innerHTML = LIGHT_Z;
+        drawContext(gl, canvas, fbo, normalProgram, shadowProgram, sab, plane, rotation, lookx, looky, lookz);
+        break;
+      case "Escape":
+        LIGHT_Z--;
+        document.getElementById("valz").innerHTML = LIGHT_Z;
+        drawContext(gl, canvas, fbo, normalProgram, shadowProgram, sab, plane, rotation, lookx, looky, lookz);
+        break;
+      default:
+        return;
+    }
+    event.preventDefault();
+  }, true);
+}
+function normaliser(val) {
+  return -15 + ((val * 30) / canvas.height);
+}
+var g_last = Date.now();
+function animate(angle) {
+  var now = Date.now();
+  var elapsed = now - g_last;
+  g_last = now;
+  var newAngle = angle + (ANGLE_STEP * elapsed) / 1000.0;
+  return newAngle %= 360;
 }
\ No newline at end of file