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"> Y=</label> <label id="valy">0</label> + <label id="z"> 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