diff --git a/lab4/src/lab4.html b/lab4/src/lab4.html
index 025912edd89308c152c714ec7e4bf410a8b1737e..5c5c281d32a6333401736553bf0e683bd2da830c 100644
--- a/lab4/src/lab4.html
+++ b/lab4/src/lab4.html
@@ -1,4 +1,54 @@
+<!-- Created by Cedric Dos Reis 07-11-2019 -->
<!DOCTYPE html>
-<html>
+<html lang="en">
+<head>
+ <meta charset="UTF-8">
+ <title>Lab 4</title>
+ <style type="text/css">
+ .keys {
+ border-spacing: 0;
+ border-collapse: collapse;
+ }
+ .keys tr td, .keys tr th {
+ border: solid black 1px;
+ padding: 2px 20px;
+ }
+ div {
+ margin: 10px;
+ }
+
+ </style>
+</head>
+<body onload="main()">
+<div id="main">
+ <canvas height="500" width="500" id="my_Canvas">
+ Please use a browser that supports "canvas"
+ </canvas>
+ <button value="Refresh Page" onClick="window.location.reload();">Reset</button>
+ <p>Move camera with drag & drop on left click.</p>
+ <p>Select object with right click.</p>
+ <p>Move light with arrows (up, down, left, right)</p>
-</html>
+ <p>Cedric Dos Reis</p>
+
+
+</div>
+
+
+
+<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="models/V.js"></script>
+<script src="models/N.js"></script>
+<script src="models/K.js"></script>
+<script src="models/Plane.js"></script>
+<script src="WebglInstance.js"></script>
+<!--
+ lab4_fromShadow_notworking.js
+ labo.js
+-->
+<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 ac563915ce1bd919bb27a7d35c107070caf0c146..87321c9a4b65a20f000804535a8135dab68af7aa 100644
--- a/lab4/src/lab4.js
+++ b/lab4/src/lab4.js
@@ -1,9 +1,555 @@
-// TODO: Shaders definition
+// Shadow.js (c) 2012 matsuda and tanaka
+// 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' +
+ ' gl_FragColor = vec4(gl_FragCoord.z, 0.0, 0.0, 0.0);\n' + // Write the z-value in R
+ '}\n';
+
+// Vertex shader program for regular drawing
+var VSHADER_SOURCE =
+ 'attribute vec4 a_Position;\n' +
+ 'attribute vec4 a_Color;\n' +
+ 'attribute vec4 a_Normal;\n' + // new
+ 'uniform mat4 u_MvpMatrix;\n' +
+ 'uniform mat4 u_mMatrix;\n' +
+ 'uniform bool u_Clicked;\n' +
+ 'uniform float u_Id;\n' +
+ //'uniform mat4 u_vpMatrix;\n' +
+ 'uniform mat4 u_NormalMatrix;\n' + // Transformation matrix of the normal
+ 'uniform vec3 u_DiffuseLight;\n' + // diffuse Light color
+ 'uniform vec3 u_LightPosition;\n' + // Position of the light source (in the world coordinate system)
+ 'uniform vec3 u_AmbientLight;\n' + // Ambient light color
+ 'uniform mat4 u_MvpMatrixFromLight;\n' +
+ 'varying vec4 v_PositionFromLight;\n' +
+ 'varying vec4 v_Color;\n' +
+ 'void main() {\n' +
+ //' gl_Position = u_vpMatrix * u_mMatrix * a_Position;\n' +
+ ' gl_Position = u_MvpMatrix * a_Position;\n' +
+ ' if(!u_Clicked){\n' +
+ ' v_PositionFromLight = u_MvpMatrixFromLight * a_Position;\n' +
+ // Recalculate the normal based on the model matrix and make its length 1.
+ ' vec3 normal = normalize(vec3(u_NormalMatrix * a_Normal));\n' +
+ // Calculate world coordinate of vertex
+ ' vec4 vertexPosition = u_mMatrix * a_Position;\n' +
+ // Calculate the light direction and make it 1.0 in length
+ ' vec3 lightDirection = normalize(u_LightPosition - vec3(vertexPosition));\n' +
+ // The dot product of the light direction and the normal
+ ' float nDotL = max(dot(lightDirection, normal), 0.0);\n' +
+ // Calculate the color due to diffuse reflection
+ ' vec3 diffuse = u_DiffuseLight * a_Color.rgb * nDotL;\n' +
+ // Calculate the color due to ambient reflection
+ ' vec3 ambient = u_AmbientLight * a_Color.rgb;\n' +
+ // Add the surface colors due to diffuse reflection and ambient reflection
+ ' v_Color = vec4(diffuse + ambient, a_Color.a);\n' +
+ ' }else{\n ' +
+ ' v_Color = vec4(u_Id, u_Id, u_Id, u_Id);\n' +
+ ' }\n'+
+ '}\n';
+
+// Fragment shader program for regular drawing
+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' +
+ 'void main() {\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.005) ? 0.7 : 1.0;\n' +
+ ' gl_FragColor = vec4(v_Color.rgb * visibility, v_Color.a);\n' +
+ '}\n';
+
+var OFFSCREEN_WIDTH = 2048, OFFSCREEN_HEIGHT = 2048;
+var LIGHT_X = 0, LIGHT_Y = 7, LIGHT_Z = 2; // Position of the light source
+
+let modelsList = [];
+var canvas = document.getElementById('my_Canvas');
+
+var shadowProgram, normalProgram;
-/**
- * This is the main entry point of your JavaScript program
- * called in the "onload" event of the body tag in HTML
- */
function main() {
- // TODO: put your implementation here
+
+ // Get the rendering context for WebGL
+ var 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.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_Clicked = gl.getUniformLocation(normalProgram, 'u_Clicked');
+ normalProgram.u_Id = gl.getUniformLocation(normalProgram, 'u_Id');
+ normalProgram.u_MvpMatrix = gl.getUniformLocation(normalProgram, 'u_MvpMatrix');
+ //normalProgram.u_vpMatrix = gl.getUniformLocation(normalProgram, 'u_vpMatrix');
+ normalProgram.u_mMatrix = gl.getUniformLocation(normalProgram, 'u_mMatrix');
+ normalProgram.u_NormalMatrix = gl.getUniformLocation(normalProgram, 'u_NormalMatrix');
+ normalProgram.u_DiffuseLight = gl.getUniformLocation(normalProgram, 'u_DiffuseLight');
+ normalProgram.u_AmbientLight = gl.getUniformLocation(normalProgram, 'u_AmbientLight');
+ normalProgram.u_LightPosition = gl.getUniformLocation(normalProgram, 'u_LightPosition');
+ normalProgram.u_MvpMatrixFromLight = gl.getUniformLocation(normalProgram, 'u_MvpMatrixFromLight');
+ normalProgram.u_ShadowMap = gl.getUniformLocation(normalProgram, 'u_ShadowMap');
+ if (normalProgram.a_Position < 0 || normalProgram.a_Color < 0 || normalProgram.a_Normal < 0 ||
+ !normalProgram.u_Clicked || !normalProgram.u_Id || !normalProgram.u_MvpMatrix ||
+ /*!normalProgram.u_vpMatrix ||*/ !normalProgram.u_mMatrix || !normalProgram.u_NormalMatrix || !normalProgram.u_DiffuseLight ||
+ !normalProgram.u_AmbientLight || !normalProgram.u_LightPosition || !normalProgram.u_MvpMatrixFromLight || !normalProgram.u_ShadowMap) {
+ console.log('Failed to get the storage location of attribute or uniform variable from normalProgram');
+ return;
+ }
+
+ /**
+ * INIT objects
+ */
+ var letterK = initVertexBuffers(gl, new K());
+ var letterV = initVertexBuffers(gl, new V());
+ var letterN = initVertexBuffers(gl, new N());
+ var plane = initVertexBuffers(gl, new Plane());
+ if (!letterK || !letterV || !letterN || !plane) {
+ console.log('Failed to set the vertex information');
+ return;
+ }
+
+ // Model: defining the transform matrix for each object
+ let transformModel = new Matrix4()
+ .scale(1.0, 1.0, 1.0)
+ .translate(0, 0, 0);
+
+ let normalMatrix = new Matrix4()
+ .setInverseOf(transformModel)
+ .transpose();
+
+ // letter K and plane
+ modelsList.push({id:0.1, objectArray: letterK,
+ modelMatrix: transformModel,
+ normalMatrix: normalMatrix,
+ mvpMatrixFromLight: new Matrix4(),
+ animates: false
+ });
+ modelsList.push({id:0.2, objectArray: plane,
+ modelMatrix: transformModel,
+ normalMatrix: normalMatrix,
+ mvpMatrixFromLight: new Matrix4(),
+ animates: false
+ });
+
+ // Model: defining the transform matrix
+ transformModel = new Matrix4()
+ .scale(.5, .5, .5)
+ .translate(7, -.5, 0)
+ .rotate(-45, 0, 1, 0);
+
+ normalMatrix = new Matrix4()
+ .setInverseOf(transformModel)
+ .transpose();
+
+ // letter N
+ modelsList.push({id:0.3, objectArray: letterN,
+ modelMatrix: transformModel,
+ normalMatrix: normalMatrix,
+ mvpMatrixFromLight: new Matrix4(),
+ animates: false
+ });
+
+ // Model: defining the transform matrix
+ transformModel = new Matrix4()
+ .translate(-2, -.25, -3)
+ .rotate(90, 1, 0, 0);
+
+ normalMatrix = new Matrix4()
+ .setInverseOf(transformModel)
+ .transpose();
+ // letter V
+ modelsList.push({id:0.4,objectArray: letterV, modelMatrix: transformModel, normalMatrix: normalMatrix, mvpMatrixFromLight: new Matrix4()}); // lettre 3
+
+ // 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
+ gl.bindTexture(gl.TEXTURE_2D, fbo.texture);
+
+ // Set the clear color and enable the depth test
+ gl.clearColor(0, 0, 0, 1);
+ gl.enable(gl.DEPTH_TEST);
+
+ gl.useProgram(normalProgram);
+ gl.uniform3fv(normalProgram.u_DiffuseLight, new Vector3([1.0, 1.0, 1.0]).elements);
+ gl.uniform3fv(normalProgram.u_LightPosition, currentLightPosition.elements);
+ gl.uniform3fv(normalProgram.u_AmbientLight, new Vector3([0.5, 0.5, 0.5]).elements);
+
+ var currentAngle = 0.0; // Current rotation angle (degrees)
+
+ var tick = function() {
+ // light position
+ var vpMatrixFromLight = new Matrix4(); // Prepare a view projection matrix for generating a shadow map
+ vpMatrixFromLight.setPerspective(70.0, OFFSCREEN_WIDTH/OFFSCREEN_HEIGHT, 1.0, 100.0);
+ vpMatrixFromLight.lookAt(currentLightPosition.elements[0], currentLightPosition.elements[1], currentLightPosition.elements[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
+ // camera position
+ var viewProjMatrix = new Matrix4(); // Prepare a view projection matrix for regular drawing
+ viewProjMatrix.setPerspective(...DEFAULT_PROJECTION);
+ viewProjMatrix.lookAt(...currentLookAt);
+ currentAngle = animate(currentAngle);
+ /**
+ * DRAW SHADOWs
+ */
+ 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
+
+
+ modelsList.forEach((model) => {
+ var mvpMatrix = new Matrix4();
+ mvpMatrix.set(vpMatrixFromLight);
+ mvpMatrix.multiply(model.modelMatrix);
+ if(model.animates === true){
+ drawAnimated(gl, shadowProgram, model.objectArray, mvpMatrix, currentAngle);
+ }else{
+ draw(gl, shadowProgram, model.objectArray, mvpMatrix);
+ }
+ model.mvpMatrixFromLight.set(vpMatrixFromLight);
+ });
+
+ /**
+ * DRAW normaly..
+ */
+ 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);
+ gl.uniform3fv(normalProgram.u_LightPosition, currentLightPosition.elements);
+ modelsList.forEach((model) => {
+ // calculate model view matrix
+ var mvpMatrix = new Matrix4();
+ mvpMatrix.set(viewProjMatrix);
+ mvpMatrix.multiply(model.modelMatrix);
+
+ gl.uniformMatrix4fv(normalProgram.u_MvpMatrixFromLight, false, model.mvpMatrixFromLight.elements);// A model view projection matrix from light source
+ gl.uniformMatrix4fv(normalMatrix.u_mMatrix, false, model.modelMatrix.elements);
+ gl.uniformMatrix4fv(normalProgram.u_NormalMatrix, false, model.normalMatrix.elements);
+ if(model.animates === true){
+ drawAnimated(gl, normalProgram, model.objectArray, mvpMatrix, currentAngle);
+ }else{
+ draw(gl, normalProgram, model.objectArray, mvpMatrix);
+ }
+
+
+ });
+
+ window.requestAnimationFrame(tick, canvas);
+ };
+ tick();
+
+
+ // enable camera mouvement & check for clicked object
+ canvas.addEventListener("mousedown", function(e){
+ if (e.button === 0) { // left button
+ mouseClicked = true;
+ prevPosition.x = e.clientX;
+ prevPosition.y = e.clientY;
+
+ }else if(e.button === 2){ // right button
+ // check forobject clicked
+ var x = e.clientX, y = e.clientY;
+ var rect = e.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;
+ check(gl, x_in_canvas, y_in_canvas, normalProgram.u_Clicked);
+ }
+ }
+
+ });
+}
+
+function normalizeRGB(value){
+ normalized = value / 255;
+ return normalized.toFixed(1);
+}
+
+function draw(gl, program, o, viewProjMatrix) {
+ initAttributeVariable(gl, program.a_Position, o.vertexBuffer);
+ if (program.a_Color != undefined) // If a_Color is defined to attribute
+ initAttributeVariable(gl, program.a_Color, o.colorBuffer);
+
+ gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, o.indexBuffer);
+
+ gl.uniformMatrix4fv(program.u_MvpMatrix, false, viewProjMatrix.elements);
+
+ gl.drawElements(gl.TRIANGLES, o.numIndices, gl.UNSIGNED_BYTE, 0);
+}
+
+function drawAnimated(gl, program, o, viewProjMatrix, angle) {
+
+ var vpMatrix = new Matrix4();
+ vpMatrix.set(viewProjMatrix);
+ vpMatrix.rotate(angle, 0, 1,0);
+
+ draw(gl, program, o, vpMatrix);
+}
+
+// Assign the buffer objects and enable the assignment
+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 initVertexBuffers(gl, model) {
+ var o = new Object(); // Utilize Object object to return multiple buffer objects together
+
+ // Write vertex information to buffer object
+ o.vertexBuffer = initArrayBufferForLaterUse(gl, model.vertices, 3, gl.FLOAT);
+ o.colorBuffer = initArrayBufferForLaterUse(gl, model.colors, 3, gl.FLOAT);
+ o.normalBuffer = initArrayBufferForLaterUse(gl, model.normals, 3, gl.FLOAT);
+ o.indexBuffer = initElementArrayBufferForLaterUse(gl, model.indices, gl.UNSIGNED_BYTE);
+ if (!o.vertexBuffer || !o.colorBuffer || !o.normalBuffer || !o.indexBuffer) return null;
+
+ o.numIndices = model.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 check(gl,x, y, u_Clicked) {
+ gl.useProgram(normalProgram);
+ var viewProjMatrix = new Matrix4() // Prepare a view projection matrix for regular drawing
+ .setPerspective(...DEFAULT_PROJECTION)
+ .lookAt(...currentLookAt);
+ gl.uniform1i(u_Clicked, 1); // Pass true to u_Clicked
+
+ modelsList.forEach((model) => {
+ var mvpMatrix = new Matrix4();
+ mvpMatrix.set(viewProjMatrix);
+ mvpMatrix.multiply(model.modelMatrix);
+ // send id to use as color
+ gl.uniform1f(normalProgram.u_Id, model.id); // pass the id to the object
+ draw(gl, normalProgram, model.objectArray, mvpMatrix);
+ // Read pixel at the clicked position
+ });
+
+ gl.uniform1i(u_Clicked, 0);// Pass false to u_Clicked
+ var pixels = new Uint8Array(4); // Array for storing the pixel value
+ gl.readPixels(x, y, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixels); // read pixel value at clicked position
+
+ if (pixels[0] == pixels[1] && pixels[0] == pixels[2] && pixels[0] == pixels[3]){ // varify that values are equals
+ var id = normalizeRGB(pixels[0]);
+ //enable object animation
+ modelsList.forEach((model) => {
+ if(id == model.id){
+ model.animates = true;
+ }
+ });
+ }
+}
+
+var ANGLE_STEP = 40; // The increments of rotation angle (degrees)
+
+var last = Date.now(); // Last time that this function was called
+function animate(angle) {
+ var now = Date.now(); // Calculate the elapsed time
+ var elapsed = now - last;
+ last = now;
+ // Update the current rotation angle (adjusted by the elapsed time)
+ var newAngle = angle + (ANGLE_STEP * elapsed) / 1000.0;
+ return newAngle % 360;
+}
+
+
+
+//******************************
+// Defining scene cameras
+//******************************
+const CAMERAS = [
+ {
+ // [eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ]
+ lookAt: [-4, 0, 2, 0, 0, 0, 0, 1, 0]
+ },
+ {
+ lookAt: [1, 4, 7, 0, 0, 0, 0, 1, 0]
+ }
+];
+const DEFAULT_PROJECTION = [100, 1, 1, 100];
+let currentCameraNum = 1;
+let currentLookAt = [...CAMERAS[currentCameraNum].lookAt];
+const CAMERA_SPEED = 0.2;
+
+let currentLightPosition = new Vector3([0,7,2]);
+const LIGHT_SPEED = 0.2;
+
+const KEYS = {
+ ArrowLeft: { direction: -1, pos: 0 },
+ ArrowRight: { direction: 1, pos: 0 },
+ ArrowUp: { direction: 1, pos: 1 },
+ ArrowDown: { direction: -1, pos: 1 },
+ KeyI: { direction: -1, pos: 2 },
+ KeyK: { direction: 1, pos: 2 },
+ KeyA: { direction: -1, pos: 3 },
+ KeyD: { direction: 1, pos: 3 },
+ KeyR: { direction: 1, pos: 4 },
+ KeyF: { direction: -1, pos: 4 },
+ KeyW: { direction: 1, pos: 5 },
+ KeyS: { direction: -1, pos: 5 },
+};
+
+window.addEventListener("keydown", function (event) {
+
+
+ if (!KEYS[event.code] || currentCameraNum === 0) return;
+ let { direction, pos } = KEYS[event.code];
+ //currentLookAt[pos] += CAMERA_SPEED * direction;
+ //change light position
+ currentLightPosition.elements[pos] += LIGHT_SPEED * direction;
+});
+
+let mouseClicked = false;
+let prevPosition = {x : 0, y : 0};
+
+canvas.addEventListener("mousemove", function(e){
+ //camera movement
+ if (mouseClicked){
+ let diff = {
+ x : prevPosition.x - e.clientX,
+ y : prevPosition.y - e.clientY
+ }
+ currentLookAt[0] += CAMERA_SPEED * diff.x;
+ currentLookAt[2] -= CAMERA_SPEED * diff.y;
+ prevPosition.x = e.clientX;
+ prevPosition.y = e.clientY;
+ }
+});
+
+//disable camera movement
+canvas.addEventListener("mouseup", function(e){
+ if (e.button === 0) { //left button
+ mouseClicked = false;
+ }
+});
diff --git a/lab4/src/lib/cuon-matrix.js b/lab4/src/lib/cuon-matrix.js
new file mode 100644
index 0000000000000000000000000000000000000000..b67a5dd1b998eba54f585cf3849b8c17052d2a35
--- /dev/null
+++ b/lab4/src/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/lib/cuon-utils.js b/lab4/src/lib/cuon-utils.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc08b2ef1ee96304e68dafa7caed57f7e80894bb
--- /dev/null
+++ b/lab4/src/lib/cuon-utils.js
@@ -0,0 +1,113 @@
+// cuon-utils.js (c) 2012 kanda and matsuda
+/**
+ * Create a program object and make current
+ * @param gl GL context
+ * @param vshader a vertex shader program (string)
+ * @param fshader a fragment shader program (string)
+ * @return true, if the program object was created and successfully made current
+ */
+function initShaders(gl, vshader, fshader) {
+ var program = createProgram(gl, vshader, fshader);
+ if (!program) {
+ console.log('Failed to create program');
+ return false;
+ }
+
+ gl.useProgram(program);
+ gl.program = program;
+
+ return true;
+}
+
+/**
+ * Create the linked program object
+ * @param gl GL context
+ * @param vshader a vertex shader program (string)
+ * @param fshader a fragment shader program (string)
+ * @return created program object, or null if the creation has failed
+ */
+function createProgram(gl, vshader, fshader) {
+ // Create shader object
+ var vertexShader = loadShader(gl, gl.VERTEX_SHADER, vshader);
+ var fragmentShader = loadShader(gl, gl.FRAGMENT_SHADER, fshader);
+ if (!vertexShader || !fragmentShader) {
+ return null;
+ }
+
+ // Create a program object
+ var program = gl.createProgram();
+ if (!program) {
+ return null;
+ }
+
+ // Attach the shader objects
+ gl.attachShader(program, vertexShader);
+ gl.attachShader(program, fragmentShader);
+
+ // Link the program object
+ gl.linkProgram(program);
+
+ // Check the result of linking
+ var linked = gl.getProgramParameter(program, gl.LINK_STATUS);
+ if (!linked) {
+ var error = gl.getProgramInfoLog(program);
+ console.log('Failed to link program: ' + error);
+ gl.deleteProgram(program);
+ gl.deleteShader(fragmentShader);
+ gl.deleteShader(vertexShader);
+ return null;
+ }
+ return program;
+}
+
+/**
+ * Create a shader object
+ * @param gl GL context
+ * @param type the type of the shader object to be created
+ * @param source shader program (string)
+ * @return created shader object, or null if the creation has failed.
+ */
+function loadShader(gl, type, source) {
+ // Create shader object
+ var shader = gl.createShader(type);
+ if (shader == null) {
+ console.log('unable to create shader');
+ return null;
+ }
+
+ // Set the shader program
+ gl.shaderSource(shader, source);
+
+ // Compile the shader
+ gl.compileShader(shader);
+
+ // Check the result of compilation
+ var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
+ if (!compiled) {
+ var error = gl.getShaderInfoLog(shader);
+ console.log('Failed to compile shader: ' + error);
+ gl.deleteShader(shader);
+ return null;
+ }
+
+ return shader;
+}
+
+/**
+ * Initialize and get the rendering for WebglInstance
+ * @param canvas <cavnas> element
+ * @param opt_debug flag to initialize the context for debugging
+ * @return the rendering context for WebglInstance
+ */
+function getWebGLContext(canvas, opt_debug) {
+ // Get the rendering context for WebglInstance
+ var gl = WebGLUtils.setupWebGL(canvas);
+ if (!gl) return null;
+
+ // if opt_debug is explicitly false, create the context for debugging
+ if (arguments.length < 2 || opt_debug) {
+ gl = WebGLDebugUtils.makeDebugContext(gl);
+ }
+
+ return gl;
+}
diff --git a/lab4/src/lib/webgl-debug.js b/lab4/src/lib/webgl-debug.js
new file mode 100644
index 0000000000000000000000000000000000000000..685868dc61347ea10c0376520f1e20ed57a765c7
--- /dev/null
+++ b/lab4/src/lib/webgl-debug.js
@@ -0,0 +1,677 @@
+//Copyright (c) 2009 The Chromium Authors. All rights reserved.
+//Use of this source code is governed by a BSD-style license that can be
+//found in the LICENSE file.
+
+// Various functions for helping debug WebglInstance apps.
+
+WebGLDebugUtils = function() {
+
+/**
+ * Wrapped logging function.
+ * @param {string} msg Message to log.
+ */
+var log = function(msg) {
+ if (window.console && window.console.log) {
+ window.console.log(msg);
+ }
+};
+
+/**
+ * Which arguements are enums.
+ * @type {!Object.<number, string>}
+ */
+var glValidEnumContexts = {
+
+ // Generic setters and getters
+
+ 'enable': { 0:true },
+ 'disable': { 0:true },
+ 'getParameter': { 0:true },
+
+ // Rendering
+
+ 'drawArrays': { 0:true },
+ 'drawElements': { 0:true, 2:true },
+
+ // Shaders
+
+ 'createShader': { 0:true },
+ 'getShaderParameter': { 1:true },
+ 'getProgramParameter': { 1:true },
+
+ // Vertex attributes
+
+ 'getVertexAttrib': { 1:true },
+ 'vertexAttribPointer': { 2:true },
+
+ // Textures
+
+ 'bindTexture': { 0:true },
+ 'activeTexture': { 0:true },
+ 'getTexParameter': { 0:true, 1:true },
+ 'texParameterf': { 0:true, 1:true },
+ 'texParameteri': { 0:true, 1:true, 2:true },
+ 'texImage2D': { 0:true, 2:true, 6:true, 7:true },
+ 'texSubImage2D': { 0:true, 6:true, 7:true },
+ 'copyTexImage2D': { 0:true, 2:true },
+ 'copyTexSubImage2D': { 0:true },
+ 'generateMipmap': { 0:true },
+
+ // Buffer objects
+
+ 'bindBuffer': { 0:true },
+ 'bufferData': { 0:true, 2:true },
+ 'bufferSubData': { 0:true },
+ 'getBufferParameter': { 0:true, 1:true },
+
+ // Renderbuffers and framebuffers
+
+ 'pixelStorei': { 0:true, 1:true },
+ 'readPixels': { 4:true, 5:true },
+ 'bindRenderbuffer': { 0:true },
+ 'bindFramebuffer': { 0:true },
+ 'checkFramebufferStatus': { 0:true },
+ 'framebufferRenderbuffer': { 0:true, 1:true, 2:true },
+ 'framebufferTexture2D': { 0:true, 1:true, 2:true },
+ 'getFramebufferAttachmentParameter': { 0:true, 1:true, 2:true },
+ 'getRenderbufferParameter': { 0:true, 1:true },
+ 'renderbufferStorage': { 0:true, 1:true },
+
+ // Frame buffer operations (clear, blend, depth test, stencil)
+
+ 'clear': { 0:true },
+ 'depthFunc': { 0:true },
+ 'blendFunc': { 0:true, 1:true },
+ 'blendFuncSeparate': { 0:true, 1:true, 2:true, 3:true },
+ 'blendEquation': { 0:true },
+ 'blendEquationSeparate': { 0:true, 1:true },
+ 'stencilFunc': { 0:true },
+ 'stencilFuncSeparate': { 0:true, 1:true },
+ 'stencilMaskSeparate': { 0:true },
+ 'stencilOp': { 0:true, 1:true, 2:true },
+ 'stencilOpSeparate': { 0:true, 1:true, 2:true, 3:true },
+
+ // Culling
+
+ 'cullFace': { 0:true },
+ 'frontFace': { 0:true },
+};
+
+/**
+ * Map of numbers to names.
+ * @type {Object}
+ */
+var glEnums = null;
+
+/**
+ * Initializes this module. Safe to call more than once.
+ * @param {!WebGLRenderingContext} ctx A WebglInstance context. If
+ * you have more than one context it doesn't matter which one
+ * you pass in, it is only used to pull out constants.
+ */
+function init(ctx) {
+ if (glEnums == null) {
+ glEnums = { };
+ for (var propertyName in ctx) {
+ if (typeof ctx[propertyName] == 'number') {
+ glEnums[ctx[propertyName]] = propertyName;
+ }
+ }
+ }
+}
+
+/**
+ * Checks the utils have been initialized.
+ */
+function checkInit() {
+ if (glEnums == null) {
+ throw 'WebGLDebugUtils.init(ctx) not called';
+ }
+}
+
+/**
+ * Returns true or false if value matches any WebglInstance enum
+ * @param {*} value Value to check if it might be an enum.
+ * @return {boolean} True if value matches one of the WebglInstance defined enums
+ */
+function mightBeEnum(value) {
+ checkInit();
+ return (glEnums[value] !== undefined);
+}
+
+/**
+ * Gets an string version of an WebglInstance enum.
+ *
+ * Example:
+ * var str = WebGLDebugUtil.glEnumToString(ctx.getError());
+ *
+ * @param {number} value Value to return an enum for
+ * @return {string} The string version of the enum.
+ */
+function glEnumToString(value) {
+ checkInit();
+ var name = glEnums[value];
+ return (name !== undefined) ? name :
+ ("*UNKNOWN WebglInstance ENUM (0x" + value.toString(16) + ")");
+}
+
+/**
+ * Returns the string version of a WebglInstance argument.
+ * Attempts to convert enum arguments to strings.
+ * @param {string} functionName the name of the WebglInstance function.
+ * @param {number} argumentIndx the index of the argument.
+ * @param {*} value The value of the argument.
+ * @return {string} The value as a string.
+ */
+function glFunctionArgToString(functionName, argumentIndex, value) {
+ var funcInfo = glValidEnumContexts[functionName];
+ if (funcInfo !== undefined) {
+ if (funcInfo[argumentIndex]) {
+ return glEnumToString(value);
+ }
+ }
+ return value.toString();
+}
+
+/**
+ * Given a WebglInstance context returns a wrapped context that calls
+ * gl.getError after every command and calls a function if the
+ * result is not gl.NO_ERROR.
+ *
+ * @param {!WebGLRenderingContext} ctx The webgl context to
+ * wrap.
+ * @param {!function(err, funcName, args): void} opt_onErrorFunc
+ * The function to call when gl.getError returns an
+ * error. If not specified the default function calls
+ * console.log with a message.
+ */
+function makeDebugContext(ctx, opt_onErrorFunc) {
+ init(ctx);
+ opt_onErrorFunc = opt_onErrorFunc || function(err, functionName, args) {
+ // apparently we can't do args.join(",");
+ var argStr = "";
+ for (var ii = 0; ii < args.length; ++ii) {
+ argStr += ((ii == 0) ? '' : ', ') +
+ glFunctionArgToString(functionName, ii, args[ii]);
+ }
+ log("WebglInstance error "+ glEnumToString(err) + " in "+ functionName +
+ "(" + argStr + ")");
+ };
+
+ // Holds booleans for each GL error so after we get the error ourselves
+ // we can still return it to the client app.
+ var glErrorShadow = { };
+
+ // Makes a function that calls a WebglInstance function and then calls getError.
+ function makeErrorWrapper(ctx, functionName) {
+ return function() {
+ var result = ctx[functionName].apply(ctx, arguments);
+ var err = ctx.getError();
+ if (err != 0) {
+ glErrorShadow[err] = true;
+ opt_onErrorFunc(err, functionName, arguments);
+ }
+ return result;
+ };
+ }
+
+ // Make a an object that has a copy of every property of the WebglInstance context
+ // but wraps all functions.
+ var wrapper = {};
+ for (var propertyName in ctx) {
+ if (typeof ctx[propertyName] == 'function') {
+ wrapper[propertyName] = makeErrorWrapper(ctx, propertyName);
+ } else {
+ wrapper[propertyName] = ctx[propertyName];
+ }
+ }
+
+ // Override the getError function with one that returns our saved results.
+ wrapper.getError = function() {
+ for (var err in glErrorShadow) {
+ if (glErrorShadow[err]) {
+ glErrorShadow[err] = false;
+ return err;
+ }
+ }
+ return ctx.NO_ERROR;
+ };
+
+ return wrapper;
+}
+
+function resetToInitialState(ctx) {
+ var numAttribs = ctx.getParameter(ctx.MAX_VERTEX_ATTRIBS);
+ var tmp = ctx.createBuffer();
+ ctx.bindBuffer(ctx.ARRAY_BUFFER, tmp);
+ for (var ii = 0; ii < numAttribs; ++ii) {
+ ctx.disableVertexAttribArray(ii);
+ ctx.vertexAttribPointer(ii, 4, ctx.FLOAT, false, 0, 0);
+ ctx.vertexAttrib1f(ii, 0);
+ }
+ ctx.deleteBuffer(tmp);
+
+ var numTextureUnits = ctx.getParameter(ctx.MAX_TEXTURE_IMAGE_UNITS);
+ for (var ii = 0; ii < numTextureUnits; ++ii) {
+ ctx.activeTexture(ctx.TEXTURE0 + ii);
+ ctx.bindTexture(ctx.TEXTURE_CUBE_MAP, null);
+ ctx.bindTexture(ctx.TEXTURE_2D, null);
+ }
+
+ ctx.activeTexture(ctx.TEXTURE0);
+ ctx.useProgram(null);
+ ctx.bindBuffer(ctx.ARRAY_BUFFER, null);
+ ctx.bindBuffer(ctx.ELEMENT_ARRAY_BUFFER, null);
+ ctx.bindFramebuffer(ctx.FRAMEBUFFER, null);
+ ctx.bindRenderbuffer(ctx.RENDERBUFFER, null);
+ ctx.disable(ctx.BLEND);
+ ctx.disable(ctx.CULL_FACE);
+ ctx.disable(ctx.DEPTH_TEST);
+ ctx.disable(ctx.DITHER);
+ ctx.disable(ctx.SCISSOR_TEST);
+ ctx.blendColor(0, 0, 0, 0);
+ ctx.blendEquation(ctx.FUNC_ADD);
+ ctx.blendFunc(ctx.ONE, ctx.ZERO);
+ ctx.clearColor(0, 0, 0, 0);
+ ctx.clearDepth(1);
+ ctx.clearStencil(-1);
+ ctx.colorMask(true, true, true, true);
+ ctx.cullFace(ctx.BACK);
+ ctx.depthFunc(ctx.LESS);
+ ctx.depthMask(true);
+ ctx.depthRange(0, 1);
+ ctx.frontFace(ctx.CCW);
+ ctx.hint(ctx.GENERATE_MIPMAP_HINT, ctx.DONT_CARE);
+ ctx.lineWidth(1);
+ ctx.pixelStorei(ctx.PACK_ALIGNMENT, 4);
+ ctx.pixelStorei(ctx.UNPACK_ALIGNMENT, 4);
+ ctx.pixelStorei(ctx.UNPACK_FLIP_Y_WEBGL, false);
+ ctx.pixelStorei(ctx.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+ // TODO: Delete this IF.
+ if (ctx.UNPACK_COLORSPACE_CONVERSION_WEBGL) {
+ ctx.pixelStorei(ctx.UNPACK_COLORSPACE_CONVERSION_WEBGL, ctx.BROWSER_DEFAULT_WEBGL);
+ }
+ ctx.polygonOffset(0, 0);
+ ctx.sampleCoverage(1, false);
+ ctx.scissor(0, 0, ctx.canvas.width, ctx.canvas.height);
+ ctx.stencilFunc(ctx.ALWAYS, 0, 0xFFFFFFFF);
+ ctx.stencilMask(0xFFFFFFFF);
+ ctx.stencilOp(ctx.KEEP, ctx.KEEP, ctx.KEEP);
+ ctx.viewport(0, 0, ctx.canvas.clientWidth, ctx.canvas.clientHeight);
+ ctx.clear(ctx.COLOR_BUFFER_BIT | ctx.DEPTH_BUFFER_BIT | ctx.STENCIL_BUFFER_BIT);
+
+ // TODO: This should NOT be needed but Firefox fails with 'hint'
+ while(ctx.getError());
+}
+
+function makeLostContextSimulatingContext(ctx) {
+ var wrapper_ = {};
+ var contextId_ = 1;
+ var contextLost_ = false;
+ var resourceId_ = 0;
+ var resourceDb_ = [];
+ var onLost_ = undefined;
+ var onRestored_ = undefined;
+ var nextOnRestored_ = undefined;
+
+ // Holds booleans for each GL error so can simulate errors.
+ var glErrorShadow_ = { };
+
+ function isWebGLObject(obj) {
+ //return false;
+ return (obj instanceof WebGLBuffer ||
+ obj instanceof WebGLFramebuffer ||
+ obj instanceof WebGLProgram ||
+ obj instanceof WebGLRenderbuffer ||
+ obj instanceof WebGLShader ||
+ obj instanceof WebGLTexture);
+ }
+
+ function checkResources(args) {
+ for (var ii = 0; ii < args.length; ++ii) {
+ var arg = args[ii];
+ if (isWebGLObject(arg)) {
+ return arg.__webglDebugContextLostId__ == contextId_;
+ }
+ }
+ return true;
+ }
+
+ function clearErrors() {
+ var k = Object.keys(glErrorShadow_);
+ for (var ii = 0; ii < k.length; ++ii) {
+ delete glErrorShdow_[k];
+ }
+ }
+
+ // Makes a function that simulates WebglInstance when out of context.
+ function makeLostContextWrapper(ctx, functionName) {
+ var f = ctx[functionName];
+ return function() {
+ // Only call the functions if the context is not lost.
+ if (!contextLost_) {
+ if (!checkResources(arguments)) {
+ glErrorShadow_[ctx.INVALID_OPERATION] = true;
+ return;
+ }
+ var result = f.apply(ctx, arguments);
+ return result;
+ }
+ };
+ }
+
+ for (var propertyName in ctx) {
+ if (typeof ctx[propertyName] == 'function') {
+ wrapper_[propertyName] = makeLostContextWrapper(ctx, propertyName);
+ } else {
+ wrapper_[propertyName] = ctx[propertyName];
+ }
+ }
+
+ function makeWebGLContextEvent(statusMessage) {
+ return {statusMessage: statusMessage};
+ }
+
+ function freeResources() {
+ for (var ii = 0; ii < resourceDb_.length; ++ii) {
+ var resource = resourceDb_[ii];
+ if (resource instanceof WebGLBuffer) {
+ ctx.deleteBuffer(resource);
+ } else if (resource instanceof WebctxFramebuffer) {
+ ctx.deleteFramebuffer(resource);
+ } else if (resource instanceof WebctxProgram) {
+ ctx.deleteProgram(resource);
+ } else if (resource instanceof WebctxRenderbuffer) {
+ ctx.deleteRenderbuffer(resource);
+ } else if (resource instanceof WebctxShader) {
+ ctx.deleteShader(resource);
+ } else if (resource instanceof WebctxTexture) {
+ ctx.deleteTexture(resource);
+ }
+ }
+ }
+
+ wrapper_.loseContext = function() {
+ if (!contextLost_) {
+ contextLost_ = true;
+ ++contextId_;
+ while (ctx.getError());
+ clearErrors();
+ glErrorShadow_[ctx.CONTEXT_LOST_WEBGL] = true;
+ setTimeout(function() {
+ if (onLost_) {
+ onLost_(makeWebGLContextEvent("context lost"));
+ }
+ }, 0);
+ }
+ };
+
+ wrapper_.restoreContext = function() {
+ if (contextLost_) {
+ if (onRestored_) {
+ setTimeout(function() {
+ freeResources();
+ resetToInitialState(ctx);
+ contextLost_ = false;
+ if (onRestored_) {
+ var callback = onRestored_;
+ onRestored_ = nextOnRestored_;
+ nextOnRestored_ = undefined;
+ callback(makeWebGLContextEvent("context restored"));
+ }
+ }, 0);
+ } else {
+ throw "You can not restore the context without a listener"
+ }
+ }
+ };
+
+ // Wrap a few functions specially.
+ wrapper_.getError = function() {
+ if (!contextLost_) {
+ var err;
+ while (err = ctx.getError()) {
+ glErrorShadow_[err] = true;
+ }
+ }
+ for (var err in glErrorShadow_) {
+ if (glErrorShadow_[err]) {
+ delete glErrorShadow_[err];
+ return err;
+ }
+ }
+ return ctx.NO_ERROR;
+ };
+
+ var creationFunctions = [
+ "createBuffer",
+ "createFramebuffer",
+ "createProgram",
+ "createRenderbuffer",
+ "createShader",
+ "createTexture"
+ ];
+ for (var ii = 0; ii < creationFunctions.length; ++ii) {
+ var functionName = creationFunctions[ii];
+ wrapper_[functionName] = function(f) {
+ return function() {
+ if (contextLost_) {
+ return null;
+ }
+ var obj = f.apply(ctx, arguments);
+ obj.__webglDebugContextLostId__ = contextId_;
+ resourceDb_.push(obj);
+ return obj;
+ };
+ }(ctx[functionName]);
+ }
+
+ var functionsThatShouldReturnNull = [
+ "getActiveAttrib",
+ "getActiveUniform",
+ "getBufferParameter",
+ "getContextAttributes",
+ "getAttachedShaders",
+ "getFramebufferAttachmentParameter",
+ "getParameter",
+ "getProgramParameter",
+ "getProgramInfoLog",
+ "getRenderbufferParameter",
+ "getShaderParameter",
+ "getShaderInfoLog",
+ "getShaderSource",
+ "getTexParameter",
+ "getUniform",
+ "getUniformLocation",
+ "getVertexAttrib"
+ ];
+ for (var ii = 0; ii < functionsThatShouldReturnNull.length; ++ii) {
+ var functionName = functionsThatShouldReturnNull[ii];
+ wrapper_[functionName] = function(f) {
+ return function() {
+ if (contextLost_) {
+ return null;
+ }
+ return f.apply(ctx, arguments);
+ }
+ }(wrapper_[functionName]);
+ }
+
+ var isFunctions = [
+ "isBuffer",
+ "isEnabled",
+ "isFramebuffer",
+ "isProgram",
+ "isRenderbuffer",
+ "isShader",
+ "isTexture"
+ ];
+ for (var ii = 0; ii < isFunctions.length; ++ii) {
+ var functionName = isFunctions[ii];
+ wrapper_[functionName] = function(f) {
+ return function() {
+ if (contextLost_) {
+ return false;
+ }
+ return f.apply(ctx, arguments);
+ }
+ }(wrapper_[functionName]);
+ }
+
+ wrapper_.checkFramebufferStatus = function(f) {
+ return function() {
+ if (contextLost_) {
+ return ctx.FRAMEBUFFER_UNSUPPORTED;
+ }
+ return f.apply(ctx, arguments);
+ };
+ }(wrapper_.checkFramebufferStatus);
+
+ wrapper_.getAttribLocation = function(f) {
+ return function() {
+ if (contextLost_) {
+ return -1;
+ }
+ return f.apply(ctx, arguments);
+ };
+ }(wrapper_.getAttribLocation);
+
+ wrapper_.getVertexAttribOffset = function(f) {
+ return function() {
+ if (contextLost_) {
+ return 0;
+ }
+ return f.apply(ctx, arguments);
+ };
+ }(wrapper_.getVertexAttribOffset);
+
+ wrapper_.isContextLost = function() {
+ return contextLost_;
+ };
+
+ function wrapEvent(listener) {
+ if (typeof(listener) == "function") {
+ return listener;
+ } else {
+ return function(info) {
+ listener.handleEvent(info);
+ }
+ }
+ }
+
+ wrapper_.registerOnContextLostListener = function(listener) {
+ onLost_ = wrapEvent(listener);
+ };
+
+ wrapper_.registerOnContextRestoredListener = function(listener) {
+ if (contextLost_) {
+ nextOnRestored_ = wrapEvent(listener);
+ } else {
+ onRestored_ = wrapEvent(listener);
+ }
+ }
+
+ return wrapper_;
+}
+
+return {
+ /**
+ * Initializes this module. Safe to call more than once.
+ * @param {!WebGLRenderingContext} ctx A WebglInstance context. If
+ * you have more than one context it doesn't matter which one
+ * you pass in, it is only used to pull out constants.
+ */
+ 'init': init,
+
+ /**
+ * Returns true or false if value matches any WebglInstance enum
+ * @param {*} value Value to check if it might be an enum.
+ * @return {boolean} True if value matches one of the WebglInstance defined enums
+ */
+ 'mightBeEnum': mightBeEnum,
+
+ /**
+ * Gets an string version of an WebglInstance enum.
+ *
+ * Example:
+ * WebGLDebugUtil.init(ctx);
+ * var str = WebGLDebugUtil.glEnumToString(ctx.getError());
+ *
+ * @param {number} value Value to return an enum for
+ * @return {string} The string version of the enum.
+ */
+ 'glEnumToString': glEnumToString,
+
+ /**
+ * Converts the argument of a WebglInstance function to a string.
+ * Attempts to convert enum arguments to strings.
+ *
+ * Example:
+ * WebGLDebugUtil.init(ctx);
+ * var str = WebGLDebugUtil.glFunctionArgToString('bindTexture', 0, gl.TEXTURE_2D);
+ *
+ * would return 'TEXTURE_2D'
+ *
+ * @param {string} functionName the name of the WebglInstance function.
+ * @param {number} argumentIndx the index of the argument.
+ * @param {*} value The value of the argument.
+ * @return {string} The value as a string.
+ */
+ 'glFunctionArgToString': glFunctionArgToString,
+
+ /**
+ * Given a WebglInstance context returns a wrapped context that calls
+ * gl.getError after every command and calls a function if the
+ * result is not NO_ERROR.
+ *
+ * You can supply your own function if you want. For example, if you'd like
+ * an exception thrown on any GL error you could do this
+ *
+ * function throwOnGLError(err, funcName, args) {
+ * throw WebGLDebugUtils.glEnumToString(err) + " was caused by call to" +
+ * funcName;
+ * };
+ *
+ * ctx = WebGLDebugUtils.makeDebugContext(
+ * canvas.getContext("webgl"), throwOnGLError);
+ *
+ * @param {!WebGLRenderingContext} ctx The webgl context to wrap.
+ * @param {!function(err, funcName, args): void} opt_onErrorFunc The function
+ * to call when gl.getError returns an error. If not specified the default
+ * function calls console.log with a message.
+ */
+ 'makeDebugContext': makeDebugContext,
+
+ /**
+ * Given a WebglInstance context returns a wrapped context that adds 4
+ * functions.
+ *
+ * ctx.loseContext:
+ * simulates a lost context event.
+ *
+ * ctx.restoreContext:
+ * simulates the context being restored.
+ *
+ * ctx.registerOnContextLostListener(listener):
+ * lets you register a listener for context lost. Use instead
+ * of addEventListener('webglcontextlostevent', listener);
+ *
+ * ctx.registerOnContextRestoredListener(listener):
+ * lets you register a listener for context restored. Use
+ * instead of addEventListener('webglcontextrestored',
+ * listener);
+ *
+ * @param {!WebGLRenderingContext} ctx The webgl context to wrap.
+ */
+ 'makeLostContextSimulatingContext': makeLostContextSimulatingContext,
+
+ /**
+ * Resets a context to the initial state.
+ * @param {!WebGLRenderingContext} ctx The webgl context to
+ * reset.
+ */
+ 'resetToInitialState': resetToInitialState
+};
+
+}();
+
diff --git a/lab4/src/lib/webgl-utils.js b/lab4/src/lib/webgl-utils.js
new file mode 100644
index 0000000000000000000000000000000000000000..26ed37e0d6adf469edabfa17b0c9e3d00199e744
--- /dev/null
+++ b/lab4/src/lib/webgl-utils.js
@@ -0,0 +1,197 @@
+/*
+ * Copyright 2010, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+/**
+ * @fileoverview This file contains functions every webgl program will need
+ * a version of one way or another.
+ *
+ * Instead of setting up a context manually it is recommended to
+ * use. This will check for success or failure. On failure it
+ * will attempt to present an approriate message to the user.
+ *
+ * gl = WebGLUtils.setupWebGL(canvas);
+ *
+ * For animated WebglInstance apps use of setTimeout or setInterval are
+ * discouraged. It is recommended you structure your rendering
+ * loop like this.
+ *
+ * function render() {
+ * window.requestAnimationFrame(render, canvas);
+ *
+ * // do rendering
+ * ...
+ * }
+ * render();
+ *
+ * This will call your rendering function up to the refresh rate
+ * of your display but will stop rendering if your app is not
+ * visible.
+ */
+
+WebGLUtils = function() {
+
+/**
+ * Creates the HTLM for a failure message
+ * @param {string} canvasContainerId id of container of th
+ * canvas.
+ * @return {string} The html.
+ */
+var makeFailHTML = function(msg) {
+ return '' +
+ '<div style="margin: auto; width:500px;z-index:10000;margin-top:20em;text-align:center;">' + msg + '</div>';
+ return '' +
+ '<table style="background-color: #8CE; width: 100%; height: 100%;"><tr>' +
+ '<td align="center">' +
+ '<div style="display: table-cell; vertical-align: middle;">' +
+ '<div style="">' + msg + '</div>' +
+ '</div>' +
+ '</td></tr></table>';
+};
+
+/**
+ * Mesasge for getting a webgl browser
+ * @type {string}
+ */
+var GET_A_WEBGL_BROWSER = '' +
+ 'This page requires a browser that supports WebglInstance.<br/>' +
+ '<a href="http://get.webgl.org">Click here to upgrade your browser.</a>';
+
+/**
+ * Mesasge for need better hardware
+ * @type {string}
+ */
+var OTHER_PROBLEM = '' +
+ "It doesn't appear your computer can support WebglInstance.<br/>" +
+ '<a href="http://get.webgl.org">Click here for more information.</a>';
+
+/**
+ * Creates a webgl context. If creation fails it will
+ * change the contents of the container of the <canvas>
+ * tag to an error message with the correct links for WebglInstance.
+ * @param {Element} canvas. The canvas element to create a
+ * context from.
+ * @param {WebGLContextCreationAttirbutes} opt_attribs Any
+ * creation attributes you want to pass in.
+ * @param {function:(msg)} opt_onError An function to call
+ * if there is an error during creation.
+ * @return {WebGLRenderingContext} The created context.
+ */
+var setupWebGL = function(canvas, opt_attribs, opt_onError) {
+ function handleCreationError(msg) {
+ var container = document.getElementsByTagName("body")[0];
+ //var container = canvas.parentNode;
+ if (container) {
+ var str = window.WebGLRenderingContext ?
+ OTHER_PROBLEM :
+ GET_A_WEBGL_BROWSER;
+ if (msg) {
+ str += "<br/><br/>Status: " + msg;
+ }
+ container.innerHTML = makeFailHTML(str);
+ }
+ };
+
+ opt_onError = opt_onError || handleCreationError;
+
+ if (canvas.addEventListener) {
+ canvas.addEventListener("webglcontextcreationerror", function(event) {
+ opt_onError(event.statusMessage);
+ }, false);
+ }
+ var context = create3DContext(canvas, opt_attribs);
+ if (!context) {
+ if (!window.WebGLRenderingContext) {
+ opt_onError("");
+ } else {
+ opt_onError("");
+ }
+ }
+
+ return context;
+};
+
+/**
+ * Creates a webgl context.
+ * @param {!Canvas} canvas The canvas tag to get context
+ * from. If one is not passed in one will be created.
+ * @return {!WebGLContext} The created context.
+ */
+var create3DContext = function(canvas, opt_attribs) {
+ var names = ["webgl", "experimental-webgl", "webkit-3d", "moz-webgl"];
+ var context = null;
+ for (var ii = 0; ii < names.length; ++ii) {
+ try {
+ context = canvas.getContext(names[ii], opt_attribs);
+ } catch(e) {}
+ if (context) {
+ break;
+ }
+ }
+ return context;
+}
+
+return {
+ create3DContext: create3DContext,
+ setupWebGL: setupWebGL
+};
+}();
+
+/**
+ * Provides requestAnimationFrame in a cross browser
+ * way.
+ */
+if (!window.requestAnimationFrame) {
+ window.requestAnimationFrame = (function() {
+ return window.requestAnimationFrame ||
+ window.webkitRequestAnimationFrame ||
+ window.mozRequestAnimationFrame ||
+ window.oRequestAnimationFrame ||
+ window.msRequestAnimationFrame ||
+ function(/* function FrameRequestCallback */ callback, /* DOMElement Element */ element) {
+ window.setTimeout(callback, 1000/60);
+ };
+ })();
+}
+
+/** * ERRATA: 'cancelRequestAnimationFrame' renamed to 'cancelAnimationFrame' to reflect an update to the W3C Animation-Timing Spec.
+ *
+ * Cancels an animation frame request.
+ * Checks for cross-browser support, falls back to clearTimeout.
+ * @param {number} Animation frame request. */
+if (!window.cancelAnimationFrame) {
+ window.cancelAnimationFrame = (window.cancelRequestAnimationFrame ||
+ window.webkitCancelAnimationFrame || window.webkitCancelRequestAnimationFrame ||
+ window.mozCancelAnimationFrame || window.mozCancelRequestAnimationFrame ||
+ window.msCancelAnimationFrame || window.msCancelRequestAnimationFrame ||
+ window.oCancelAnimationFrame || window.oCancelRequestAnimationFrame ||
+ window.clearTimeout);
+}
\ No newline at end of file
diff --git a/lab4/src/models/K.js b/lab4/src/models/K.js
index 0b830af4eed61cd462feb72f2dde20386b9cd8f2..eaba34ab6667558b729f86d9a78de0c9f07c0dea 100644
--- a/lab4/src/models/K.js
+++ b/lab4/src/models/K.js
@@ -4,6 +4,7 @@
* - Define vertices
* - Define indices
* - Define colors
+ * - Define normals
*/
function K() {
// Define vertices
diff --git a/lab4/src/models/N.js b/lab4/src/models/N.js
index 22260b71e266b3aec5a475c85604d47026325b6d..b2c77c4c35ad07c8529e6f926a5911a4a4aa5b3b 100644
--- a/lab4/src/models/N.js
+++ b/lab4/src/models/N.js
@@ -4,6 +4,7 @@
* - Define vertices
* - Define indices
* - Define colors
+ * - Define normals
*/
function N() {
// Define vertices
diff --git a/lab4/src/models/Plane.js b/lab4/src/models/Plane.js
new file mode 100644
index 0000000000000000000000000000000000000000..82582d7b06e43f1a8699c7a7cc37661be2ecb871
--- /dev/null
+++ b/lab4/src/models/Plane.js
@@ -0,0 +1,31 @@
+/**
+ * Created Cedric Dos Reis 03-11-2019
+ */
+
+/**
+ * Model 3D
+ * @constructor
+ * - Define vertices
+ * - Define indices
+ * - Define colors
+ * - Define normals
+ */
+function Plane() {
+ // Define vertices
+ const
+ //plane
+ v0 = [10.0, -1.0, -10.0],
+ v1 = [-10.0,-1.0,-10.0],
+ v2 = [-10.0,-1.0, 10.0],
+ v3 = [10.0,-1.0, 10.0] ; // PLANE
+
+ this.vertices = new Float32Array([ v0, v1, v2, v3, ].flat(2));
+
+ this.normals = new Float32Array([0,1,0, 0,1,0, 0,1,0, 0,1,0]);
+
+ // Define vertices indices
+ this.indices = new Uint8Array([ 0,1,2 ,0,2,3 ]);
+
+ // Define colors
+ this.colors = new Float32Array([0.5,0.5,0.5, 0.5,0.5,0.5, 0.5,0.5,0.5,]);
+}
\ No newline at end of file
diff --git a/lab4/src/models/V.js b/lab4/src/models/V.js
index 56e158357d25905336eb9c7b77b5981fbb818945..7c42bb083b9ecc4986d4428aec02b0e3d7a91ed7 100644
--- a/lab4/src/models/V.js
+++ b/lab4/src/models/V.js
@@ -4,6 +4,7 @@
* - Define vertices
* - Define indices
* - Define colors
+ * - Define normals
*/
function V() {