diff --git a/02/index.html b/02/index.html
new file mode 100644
index 00000000..21351db9
--- /dev/null
+++ b/02/index.html
@@ -0,0 +1,119 @@
+<html>
+  <head>
+    <meta content="text/html;charset=utf-8" http-equiv="Content-Type">
+    <meta content="utf-8" http-equiv="encoding">
+    <title>CS460 Assignment 2</title>
+    <style>
+      body {
+        background-color: black;
+        color: white; /* font color */
+        font-family: sans-serif;
+        margin: 0;
+        padding: 0;
+        height: 100%;
+        overflow: hidden !important;
+      }
+
+      #logo {
+        position: absolute;
+        right: 10px;
+        top: 10px;
+      }
+    </style>
+    
+    <script type="text/javascript" src="http://get.goXTK.com/xtk_edge.js"></script>
+
+    <script type="text/javascript">
+
+    window.onload = function() {
+
+      // this gets called when the site is ready
+
+      // create a new scene and renderer
+      r = new X.renderer3D();
+      r.init();
+
+      // create a cube and add it!
+      var c = {};
+
+      for (var x = 0; x < 7; x++) {
+          c[x] = new X.cube();
+          c[x].center = [x*25, 0, 0]
+          r.add(c[x])
+      }
+      for (var x = 0; x < 7; x++) {
+          c[x] = new X.cube();
+          c[x].center = [x*25, 25, 0]
+          r.add(c[x])
+      }
+      for (var x = 0; x < 7; x++) {
+          c[x] = new X.cube();
+          c[x].center = [x*25, 50, 0]
+          if (x > 0 && x < 3) {
+            c[x].color = [0,1,0];
+          }
+          if (x > 3 && x < 6) {
+            c[x].color = [0,1,0];
+          }
+          r.add(c[x])
+      }
+      for (var x = 0; x < 7; x++) {
+          c[x] = new X.cube();
+          c[x].center = [x*25, 75, 0]
+          c[x].color = [1,1,1];
+          r.add(c[x]);
+      }
+      
+      
+      for (var x = 5; x < 7; x++) {
+          c[x] = new X.cube();
+          c[x].center = [x*25, 100, 0]
+          r.add(c[x]);
+      }
+      for (var x = 0; x < 2; x++) {
+          c[x] = new X.cube();
+          c[x].center = [x*25, 100, 0]
+          r.add(c[x]);
+      }
+      for (var x = 1; x < 3; x++) {
+          c[x] = new X.cube();
+          c[x].center = [x*25, -25, 0]
+          r.add(c[x]);
+      }
+      for (var x = 4; x < 6; x++) {
+          c[x] = new X.cube();
+          c[x].center = [x*25, -25, 0]
+          r.add(c[x]);
+      }
+      c = new X.cube();
+      c.center = [75, -25, 0];
+      c.color = [1,0,0];
+      r.add(c);
+      for (var x = 2; x < 5; x++) {
+          c[x] = new X.cube();
+          c[x].center = [x*25, -50, 0]
+          r.add(c[x]);
+      }
+      c = new X.cube();
+      c.center = [150, 125, 0];
+      r.add(c);
+      c = new X.cube();
+      c.center = [0, 125, 0]; 
+      r.add(c);
+      c = new X.cube();
+      c.center = 
+      // set camera further away!
+      r.camera.position = [0, 0, 1000];
+
+      // render everything!
+      r.render();
+
+    };
+
+    </script>
+  </head>
+  <body>
+    <h1>CS460 Assignment 2</h1>
+    <div id="logo"><img style="height:60px" src="gfx/cs460.png"></div>
+  </body>
+</html>
\ No newline at end of file
diff --git a/03/CS460_Assignment_03__Copy_ (1).pdf b/03/CS460_Assignment_03__Copy_ (1).pdf
new file mode 100644
index 00000000..3145741e
Binary files /dev/null and b/03/CS460_Assignment_03__Copy_ (1).pdf differ
diff --git a/03/index.html b/03/index.html
new file mode 100644
index 00000000..67f6295a
--- /dev/null
+++ b/03/index.html
@@ -0,0 +1,169 @@
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <style>
+      html, body { 
+        background-color:#000;
+        margin: 0;
+        padding: 0;
+        height: 100%;
+        overflow: hidden !important;  
+      }
+    </style>
+    <script src="https://threejs.org/build/three.min.js" type="text/javascript"></script>
+    <script src="https://threejs.org/examples/js/controls/TrackballControls.js" type="text/javascript"></script>
+    <script>
+      window.onload = function() {
+
+        scene = new THREE.Scene();
+
+        fov = 75;
+        ratio = window.innerWidth / window.innerHeight;
+        zNear = 1;
+        zFar = 10000;
+        // console.log(ratio);
+        camera = new THREE.PerspectiveCamera(fov, ratio, zNear, zFar);
+        camera.position.set( 0, 0, 100);
+
+        renderer = new THREE.WebGLRenderer();
+        renderer.setSize( window.innerWidth, window.innerHeight );
+        document.body.appendChild( renderer.domElement );
+        
+        ambientLight = new THREE.AmbientLight();
+        scene.add( ambientLight );
+
+        light = new THREE.DirectionalLight( 0xffffff, 5.0 );
+        light.position.set( 10, 100, 10 );
+        scene.add( light );
+
+
+        // now we add the cube
+        // geometry = new THREE.BoxBufferGeometry( 20, 20, 20);
+        // material = new THREE.MeshStandardMaterial({ color: 0xffffff });
+        // cube = new THREE.Mesh( geometry, material);
+        // scene.add(cube);
+
+
+        //
+        // The invisible plane
+        //
+        geometry = new THREE.PlaneBufferGeometry( 10000, 10000 );
+        material = new THREE.MeshBasicMaterial( {
+          visible: false
+        });
+
+        invisible_plane = new THREE.Mesh( geometry, material );
+
+        scene.add( invisible_plane );
+        //
+        //
+        //
+
+
+
+        controls = new THREE.TrackballControls( camera );
+
+        animate();
+
+
+        //
+        // ACTION!
+        //
+
+        renderer.domElement.onclick = function(e) {
+
+          if (!e.shiftKey) {
+            e.preventDefault();
+            return false;
+          }
+
+          console.log('yes! you clicked!');
+
+          pixel_coords = new THREE.Vector2( e.clientX, e.clientY );
+
+          console.log('Pixel coordinates', pixel_coords);
+
+          vp_coords = new THREE.Vector2( ( pixel_coords.x / window.innerWidth ) * 2 - 1,
+                                        -( pixel_coords.y / window.innerHeight ) * 2 + 1);
+
+          console.log('Viewport coordinates', vp_coords);
+
+          vp_coords_near = new THREE.Vector3( vp_coords.x, vp_coords.y, 0);
+
+          raycaster = new THREE.Raycaster();
+          raycaster.setFromCamera(vp_coords_near, camera);
+          intersects = raycaster.intersectObject(invisible_plane);
+
+          console.log('Ray to Invisible Plane', intersects[0].point);
+
+          var x = (Math.floor(Math.random() * 5));
+              
+              if (x = 0) {
+                var geometry = new THREE.BoxBufferGeometry( 1, 1, 1 );
+                var colorstr = '#'+Math.floor(Math.random()*16777215).toString(16);                
+                var material = new THREE.MeshBasicMaterial( {color: colorstr});
+                var cube = new THREE.Mesh( geometry, material );
+                cube.center = [e.clientX, e.clientY, 0];
+                scene.add( cube );
+            }
+            if (x = 1) { 
+                var geometry = new THREE.TorusKnotGeometry( 10, 3, 100, 16 );              
+                var colorstr = '#'+Math.floor(Math.random()*16777215).toString(16);                
+                var material = new THREE.MeshBasicMaterial( {color: colorstr});
+                var torusKnot = new THREE.Mesh( geometry, material);
+                torusKnot.center = [e.clientX, e.clientY, 0];
+                scene.add( torusKnot );
+                 }
+            if (x = 2) {
+              var geometry = new THREE.SphereBufferGeometry( 5, 32, 32 );
+              var colorstr = '#'+Math.floor(Math.random()*16777215).toString(16);                
+                var material = new THREE.MeshBasicMaterial( {color: colorstr});
+              var sphere = new THREE.Mesh( geometry, material );
+              sphere.center = [e.clientX, e.clientY, 0];
+              scene.add( sphere );
+            }
+            if (x = 3) {
+              var geometry = new THREE.OctahedronBufferGeometry(1, 0);
+              var colorstr = '#'+Math.floor(Math.random()*16777215).toString(16);                
+                var material = new THREE.MeshBasicMaterial( {color: colorstr});
+              var octo = new THREE.Mesh(geometry, material );
+              octo.center = [e.clientX, e.clientY, 0];
+              scene.add(octo);
+            }
+            if (x = 4) {
+              var geometry = new THREE.ConeBufferGeometry( 5, 20, 32 );
+              var colorstr = '#'+Math.floor(Math.random()*16777215).toString(16);                
+                var material = new THREE.MeshBasicMaterial( {color: colorstr});
+              var cone = new THREE.Mesh( geometry, material );
+              cone.center = [e.clientX, e.clientY, 0];
+              scene.add( cone );
+            }
+            if (x = 5) {
+              var geometry = new THREE.RingBufferGeometry( 1, 5, 32 );
+              var colorstr = '#'+Math.floor(Math.random()*16777215).toString(16);                
+                var material = new THREE.MeshBasicMaterial( {color: colorstr});             
+              var mesh = new THREE.Mesh( geometry, material );
+              mesh.center = [e.clientX, e.clientY, 0];
+              scene.add( mesh );
+              }
+         
+        }
+
+        
+
+
+      };
+
+      function animate() {
+
+        requestAnimationFrame( animate );
+
+        controls.update();
+        renderer.render( scene, camera );
+
+      };
+
+    </script>
+  </head>
+  <body></body>
+</html>
\ No newline at end of file
diff --git a/04/CS460_Assignment_04__Copy_ (1).pdf b/04/CS460_Assignment_04__Copy_ (1).pdf
new file mode 100644
index 00000000..f7d7cf75
Binary files /dev/null and b/04/CS460_Assignment_04__Copy_ (1).pdf differ
diff --git a/04/index.html b/04/index.html
new file mode 100644
index 00000000..9a8d3714
--- /dev/null
+++ b/04/index.html
@@ -0,0 +1,442 @@
+<html>
+  <head>
+    <meta content="text/html;charset=utf-8" http-equiv="Content-Type">
+    <meta content="utf-8" http-equiv="encoding">
+    <title>Vanilla WebGL!</title>
+    <style>
+      html, body { 
+        background-color:#000;
+        margin: 0;
+        padding: 0;
+        height: 100%;
+        overflow: hidden !important;  
+        background-image: url(https://cs460.org/gfx/bg.gif);
+        background-repeat: no-repeat;
+        background-size: 100% 100%;
+      }
+
+      #c {
+        width: 100%;
+        height: 100%;
+      }
+
+      #scoreboard {
+        position: absolute;
+        top: 10px;
+        right: 10px;
+      };
+    </style>
+  </head>
+  <script type="text/javascript" src="https://cs460.org/js/glmatrix.js"></script>
+  
+  <script id="vertexshader" type="glsl">
+    attribute vec3 a_position;
+
+    uniform vec3 u_offset;
+
+    void main(void) {
+
+      vec3 final_position = a_position;
+      final_position.x += u_offset.x;
+      final_position.y += u_offset.y;
+      final_position.z += u_offset.z;
+    
+      gl_Position = vec4( final_position, 1.);
+      gl_PointSize = 30.0;
+    
+    }
+  </script>
+  
+  <script id="fragmentshader" type="glsl">
+    precision mediump float;
+
+    uniform vec4 u_color;
+
+    void main(void) {
+
+      gl_FragColor = u_color;
+
+    }
+  </script>
+  
+  <script>
+
+    var c, gl;
+    var v_shader, f_shader, shaderprogram;
+    var vertices, indices, v_buffer, i_buffer;
+
+    var step_x = 0.0;
+    var step_y = 0.0;
+    var obstacle_factor = 3; // Hint for the bonus!
+    var direction_y = 0;
+    var direction_x = 0;
+
+
+    window.onload = function() {
+
+      //************************************************************//
+      //
+      // INITIALIZE WEBGL
+      //
+      c = document.getElementById( 'c' ); // setup canvas
+      c.width = window.innerWidth;
+      c.height = window.innerHeight;
+
+      gl = c.getContext( 'webgl' ); // setup GL context
+      gl.viewport(0, 0, c.width, c.height );
+
+
+      //************************************************************//
+      //
+      // SHADERS
+      //
+      v_shader = gl.createShader( gl.VERTEX_SHADER );
+      f_shader = gl.createShader( gl.FRAGMENT_SHADER );
+      
+      // compile vertex shader
+      gl.shaderSource( v_shader, document.getElementById( 'vertexshader' ).innerText );
+      gl.compileShader( v_shader );
+
+      if (!gl.getShaderParameter( v_shader, gl.COMPILE_STATUS)) {
+        console.log(gl.getShaderInfoLog( v_shader ));
+      }
+
+      // compile fragment shader
+      gl.shaderSource( f_shader, document.getElementById( 'fragmentshader' ).innerText );
+      gl.compileShader( f_shader );
+
+      if (!gl.getShaderParameter( f_shader, gl.COMPILE_STATUS)) {
+        console.log(gl.getShaderInfoLog( f_shader ));
+      }
+
+      // attach and link the shaders
+      shaderprogram = gl.createProgram();
+      gl.attachShader( shaderprogram, v_shader );
+      gl.attachShader( shaderprogram, f_shader );
+
+      gl.linkProgram( shaderprogram );
+
+      gl.useProgram( shaderprogram );
+
+
+      // create multiple objects
+      objects = [];
+      objects.push( createAirplane());
+      objects.push( createObstacle());
+      objects.push( createObstacle());
+      objects.push( createObstacle());
+      objects.push( createObstacle());
+      objects.push( createObstacle());
+      objects.push( createObstacle());
+      objects.push( createObstacle());
+      objects.push( createObstacle());
+      objects.push( createObstacle());
+
+      animate();
+
+    };
+
+
+
+    function createAirplane() {
+
+      //
+      // Part 1 Starts
+      //
+      
+      var vertices = new Float32Array([-0.065, -0.05, 0, //v1
+                                        0, 0, 0, //v2
+                                        -0.065, 0.05, 0, //v3
+                                        -0.04, 0.025, 0, //v4
+                                        0, 0, 0, //v5
+                                        -0, 0.025, 0, //v6
+                                        0, 0, 0, //v7
+                                        0.025, 0, 0, //v8
+                                        0, 0.025, 0
+                                        ]);
+     
+      
+
+      var v_buffer = gl.createBuffer(); // create
+      gl.bindBuffer( gl.ARRAY_BUFFER, v_buffer ); // bind
+      gl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW ); // put data in
+      gl.bindBuffer( gl.ARRAY_BUFFER, null ); // unbind
+
+
+
+      //
+      // Part 1 Ends
+      //
+
+      var offset = [0.,0.,0.];
+      var color = [0.,0.,0.,1.];
+
+      //
+      // Bonus Part 3!
+      //
+      return ['airplane', v_buffer, vertices, offset, color, gl.TRIANGLES];
+
+    }
+
+
+
+    function createObstacle() {
+
+      var vertices = new Float32Array( [ 0, 0, 0 ]);
+
+      var v_buffer = gl.createBuffer(); // create
+      gl.bindBuffer( gl.ARRAY_BUFFER, v_buffer ); // bind
+      gl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW ); // put data in
+      gl.bindBuffer( gl.ARRAY_BUFFER, null ); // unbind
+
+      //
+      // Part 2 Starts
+      //
+      
+      var min = -1;
+      var max = 1;
+
+      x = Math.random() * (+max - +min) + +min;   
+      y = Math.random() * (+max - +min) + +min;
+      var offset = [x, y, 0.]; 
+
+
+      //
+      // Part 2 Ends
+      //
+
+      var color = [Math.random(),Math.random(),Math.random(),1.];
+
+      return ['obstacle', v_buffer, vertices, offset, color, gl.POINTS];
+
+    }
+
+
+
+    //
+    // Part 3 Starts (no coding required, just explanations in PDF)
+    //
+    function calculateBoundingBox(vertices, offset) {
+
+      var minx = 1000;
+      var maxx = -1000;
+      var miny = 1000;
+      var maxy = -1000;
+      var minz = 1000;
+      var maxz = -1000;
+
+      for (var v=0; v<vertices.length; v+=3) {
+
+        var currentx = vertices[v] + offset[0];
+        var currenty = vertices[v+1] + offset[1];
+        var currentz = vertices[v+2] + offset[2];
+
+        minx = Math.min( minx, currentx );
+        miny = Math.min( miny, currenty );
+        minz = Math.min( minz, currentz );
+
+        maxx = Math.max( maxx, currentx );
+        maxy = Math.max( maxy, currenty );
+        maxz = Math.max( maxz, currentz );
+
+      }
+
+      return [minx, maxx, miny, maxy, minz, maxz];
+
+    }
+
+    function detectCollision(bbox, point) {
+
+      var collision = false;
+
+      if (point[0] >= bbox[0] && point[0] <= bbox[1]) {
+        if (point[1] >= bbox[2] && point[1] <= bbox[3]) {
+          if (point[2] >= bbox[4] && point[2] <= bbox[5]) {
+
+            collision = true;
+
+          }
+        }
+      }
+
+      return collision;
+
+    }
+    //
+    // Part 3 Ends
+    //
+
+
+
+    //
+    // Part 4 Starts
+    //
+    window.onkeyup = function(e) {
+
+      if ( e.keyCode == 38 ) {
+        direction_y = 1;
+        step_y += .005;
+
+
+      } else if (e.keyCode == 40 ) {
+        // player pressed down
+        step_y -= .005;
+        direction_y = 1;
+
+
+      } else if (e.keyCode == 37 ) {
+        step_x -= .005;
+        direction_x = 1;
+
+
+      } else if (e.keyCode == 39 ) {
+        step_x += .005; 
+        direction_x = 1; 
+
+
+      }
+
+    };
+    //
+    // Part 4 Ends
+    //
+
+
+
+
+    var framecounter = 0;
+
+    function animate() {
+
+      framecounter += 1;
+      var travel_rate = 0; 
+
+      if (framecounter > 150) {
+
+        // roughly every five seconds with 30 FPS
+
+        // update score
+        document.getElementById('scoreboard').innerHTML = parseInt(document.getElementById('scoreboard').innerHTML) + 100;
+         
+        
+
+
+        framecounter = 0;
+
+      }
+
+      gl.clearColor( 0., 0., 0., 0.)
+      gl.clear( gl.COLOR_BUFFER_BIT );
+
+
+
+      for( var o = 0; o < objects.length; o++ ) {
+
+        var current_objecttype = objects[o][0];
+        var current_v_buffer = objects[o][1];
+        var current_vertices = objects[o][2];
+        var current_offset = objects[o][3];
+        var current_color = objects[o][4];
+        var current_drawtype = objects[o][5];
+
+        var current_v_count = current_vertices.length;
+        
+        if (current_objecttype == 'airplane') {
+
+          // update offsets
+          if ( current_offset[0] <= -1. ) {
+            // bumped into left end of screen
+            direction_x = 1;
+          } else if ( current_offset[0] >= 1. ) {
+            // bumped into right end of screen
+            direction_x = -1;
+          }
+          current_offset[0] += direction_x*step_x;
+
+          if ( current_offset[1] <= -1. ) {
+            // bumped into left end of screen
+            direction_y = 1;
+          } else if ( current_offset[1] >= 1. ) {
+            // bumped into right end of screen
+            direction_y = -1;
+          }
+          current_offset[1] += direction_y*step_y;
+
+
+          // get the bounding box of this airplane
+          var bbox_plane = calculateBoundingBox( current_vertices, current_offset);
+
+
+        } else if (current_objecttype == 'obstacle') {
+
+          
+          var current_offset = objects[o][3]; 
+          travel_rate = .005
+          current_offset[0] -= travel_rate; 
+          if (current_offset[0] < -1) { 
+              current_offset[0] = 1; 
+          }
+          
+          
+
+          // collision detection using the bounding box of this airplane
+          if (detectCollision(bbox_plane, current_offset)) {
+
+            document.getElementById('scoreboard').innerHTML += ' AND...GAME OVER!'
+
+            return;
+
+          }
+
+
+        }
+
+
+        //************************************************************//
+        //
+        // CONNECT SHADER WITH GEOMETRY
+        //
+        
+        gl.bindBuffer( gl.ARRAY_BUFFER, current_v_buffer );
+
+       
+
+        // find the attribute in the shader source
+        var a_position = gl.getAttribLocation( shaderprogram, 'a_position' );
+
+        gl.vertexAttribPointer( a_position, 3, gl.FLOAT, false, 0, 0 );
+
+        gl.enableVertexAttribArray ( a_position );
+
+        // find the uniform in the shader source
+        var u_offset = gl.getUniformLocation( shaderprogram, 'u_offset' );
+
+        gl.uniform3fv( u_offset, current_offset)
+
+        var u_color = gl.getUniformLocation( shaderprogram, 'u_color' );
+        
+        gl.uniform4fv( u_color, new Float32Array(current_color) );
+
+        //************************************************************//
+        //
+        // DRAW!
+        //
+
+        //
+        // Bonus Part 3!
+        //
+        gl.drawArrays( current_drawtype, 0, current_v_count/3, 0 );
+
+        }
+
+
+      requestAnimationFrame(animate);
+
+      };
+
+  </script>
+  <body>
+    <canvas id="c"></canvas>
+    <div id="scoreboard">0</div>
+  </body>
+</html>
diff --git a/05/CS460_Assignment_05__Copy_.pdf b/05/CS460_Assignment_05__Copy_.pdf
new file mode 100644
index 00000000..419ea3a0
Binary files /dev/null and b/05/CS460_Assignment_05__Copy_.pdf differ
diff --git a/05/Robot.js b/05/Robot.js
new file mode 100644
index 00000000..9bd71717
--- /dev/null
+++ b/05/Robot.js
@@ -0,0 +1,97 @@
+Robot = function(x,y,z) {
+	this.head = new THREE.Bone();
+	this.head.position.set(x,y,z);
+
+
+	this.neck = new THREE.Bone();
+	this.neck.position.y = -10;
+
+	this.head.add(this.neck);
+
+	this.torso = new THREE.Bone();
+	this.torse.position.y = -30;
+
+	this.neck.add(this.torso);
+
+	this.left_upper_arm = new THREE.Bone();
+	this.left_upper_arm.position.x = 10; 
+	this.left_upper_arm.position.y = -5; 
+
+	this.neck.add(this.left_upper_arm);
+
+	this.left_lower_arm = new THREE.Bone();
+	this.left_lower_arm.position = 10;
+	this.left_lower_arm.position = -15;
+
+	this.left_upper_arm.add(this.left_lower_arm);
+
+	this.left_hand = new THREE.Bone();
+	this.left_hand.position.x = 5;
+
+	this.left_lower_arm.add(this.left_hand);
+
+	this.right_upper_arm = new THREE.Bone();			
+	this.right_upper_arm.position.x = -10;
+	this.right_upper_arm.position.y = -5;
+
+	this.neck.add(this.left_upper_arm);
+
+	this.right_lower_arm = new THREE.Bone();
+	this.right_lower_arm.position.x = -10;
+	this.right_lower_arm.position.y = -15;
+	
+	this.right_upper_arm.add(this.right_lower_arm);
+
+	this.right_hand = new THREE.Bone();
+	this.right_hand.position.x = -5;
+
+	this.left_upper_leg = new THREE.Bone();
+	this.left_upper_leg.position.x = 10;
+	this.left_upper_leg.position.y = -10;
+
+	this.torso.add(this.left_upper_leg);
+
+	this.left_lower_leg = new THREE.Bone();
+	this.left_lower_leg.position.x = 10;
+	this.left_lower_leg.position.y = -10;
+
+	this.left_upper_leg.add(this.left_lower_leg);
+
+	this.right_upper_leg = new THREE.Bone();
+	this.right_upper_leg.position.x = -10
+	this.right_upper_leg.position.y = -10
+
+	this.torso.add(this.right_upper_leg);
+
+	this.right_lower_leg = new THREE.Bone();
+	this.right_lower_position.x = -10;
+	this.right_lower_position.y = -10; 
+
+	this.right_upper_leg.add(this.right_lower_leg);
+
+
+	this.movement = null; 
+
+}
+
+
+Robot.prototype.show = function(scene) {
+	var rGroup = new THREE.Group();
+	rGroup.add(this.head);
+
+	scene.add(rGroup);
+
+	helper = new THREE.SkeletonHelper( rGroup);
+	helper.material.linewidth = 3;
+
+	scene.add(rGroup);
+	scene.add(helper);
+
+
+}
+
+Robot.prototype.raiseLeftArm = function() {
+
+	this.movement = "raise left arm"
+
+}
\ No newline at end of file
diff --git a/06/Robot.js b/06/Robot.js
new file mode 100644
index 00000000..f9c1b346
--- /dev/null
+++ b/06/Robot.js
@@ -0,0 +1,139 @@
+Robot = function(x,y,z) {
+	this.head = new THREE.Bone();
+	this.head.position.set(x,y,z);
+
+
+	this.neck = new THREE.Bone();
+	this.neck.position.y = -10;
+
+	this.head.add(this.neck);
+
+	this.torso = new THREE.Bone();
+	this.torso.position.y = -30;
+
+	this.neck.add(this.torso);
+
+	this.left_upper_arm = new THREE.Bone();
+	this.left_upper_arm.position.x = 10; 
+	this.left_upper_arm.position.y = -5; 
+
+	this.neck.add(this.left_upper_arm);
+
+	this.left_lower_arm = new THREE.Bone();
+	this.left_lower_arm.position.x = 10;
+	this.left_lower_arm.position.y = -15;
+
+	this.left_upper_arm.add(this.left_lower_arm);
+
+	this.left_hand = new THREE.Bone();
+	this.left_hand.position.x = 5;
+
+	this.left_lower_arm.add(this.left_hand);
+
+	this.right_upper_arm = new THREE.Bone();			
+	this.right_upper_arm.position.x = -10;
+	this.right_upper_arm.position.y = -5;
+
+	this.neck.add(this.right_upper_arm);
+
+	this.right_lower_arm = new THREE.Bone();
+	this.right_lower_arm.position.x = -10;
+	this.right_lower_arm.position.y = -15;
+	
+	this.right_upper_arm.add(this.right_lower_arm);
+
+	this.right_hand = new THREE.Bone();
+	this.right_hand.position.x = -5;
+
+	this.right_lower_arm.add(this.right_hand);
+
+	this.left_upper_leg = new THREE.Bone();
+	this.left_upper_leg.position.x = 10;
+	this.left_upper_leg.position.y = -10;
+
+	this.torso.add(this.left_upper_leg);
+
+	this.left_lower_leg = new THREE.Bone();
+	this.left_lower_leg.position.x = 10;
+	this.left_lower_leg.position.y = -10;
+
+	this.left_upper_leg.add(this.left_lower_leg);
+
+	this.right_upper_leg = new THREE.Bone();
+	this.right_upper_leg.position.x = -10;
+	this.right_upper_leg.position.y = -10;
+
+	this.torso.add(this.right_upper_leg);
+
+	this.right_lower_leg = new THREE.Bone();
+	this.right_lower_leg.position.x = -10;
+	this.right_lower_leg.position.y = -10; 
+
+	this.right_upper_leg.add(this.right_lower_leg);
+
+
+	this.movement = null; 
+
+}
+
+
+Robot.prototype.show = function(scene) {
+	var rGroup = new THREE.Group();
+	rGroup.add(this.head);
+
+	scene.add(rGroup);
+
+	helper = new THREE.SkeletonHelper( rGroup);
+	helper.material.linewidth = 3;
+
+	scene.add(rGroup);
+	scene.add(helper);
+
+
+}
+
+Robot.prototype.raiseLeftArm = function() {
+
+	this.movement = 'raise left arm';
+
+}
+
+Robot.prototype.lower_left_arm = function() {
+	this.movement = 'lower left arm'
+}
+
+Robot.prototype.kick = function() {
+	this.movement = 'kick'; 
+}
+
+Robot.prototype.onAnimate = function() {
+	if (this.movement ==  'raise left arm') {
+		var T = -Math.PI;
+		this.left_upper_arm.quaternion.slerp(new THREE.Quaternion(Math.sin(T/2), 
+			0, 0, Math.cos(T/2)), 0.1);
+	}
+	else if (this.movement == 'lower left arm') {
+		this.left_upper_arm.quaternion.slerp(new THREE.Quaternion(0,0,0,1), 0.1); 
+	} 
+	else if (this.movement == 'kick') {
+		if (this.right_upper_leg.quaternion.w < 0.72) {
+
+		this.movement = 'kick done';
+
+		}
+		else {
+			var T = -Math.PI/2; 
+			this.right_upper_leg.quaternion.slerp( new THREE.Quaternion 
+				(Math.sin (T/2 ), 
+				0, 
+				0, 
+				Math.cos(T/2)), 0.1);
+		}
+
+		
+	} else if (this.movement == 'kick done') {
+
+	this.right_upper_leg.quaternion.slerp( new THREE.Quaternion(0, 0, 0, 1), 0.1);
+	}
+
+}
\ No newline at end of file
diff --git a/06/index.html b/06/index.html
index 81c698a3..268c657f 100644
--- a/06/index.html
+++ b/06/index.html
@@ -18,7 +18,12 @@
     <script src="https://threejs.org/build/three.min.js" type="text/javascript"></script>
     <script src="https://threejs.org/examples/js/controls/TrackballControls.js" type="text/javascript"></script>
     <script src="https://threejs.org/examples/js/effects/AnaglyphEffect.js" type="text/javascript"></script>
+<<<<<<< HEAD
+    <script src="robot.js"></script>
+    <script src="https://threejs.org/examples/js/libs/dat.gui.min.js" type="text/javascript"></script>
+=======
 
+>>>>>>> 6a6b96e4d883f0379d7ee30b4db15eeb459da0ab
     <script>
 
       var scene, camera, renderer, ambientLight, light, controls;
@@ -58,8 +63,31 @@
         floor.rotateX(-30);
         scene.add( floor );
 
+<<<<<<< HEAD
+        //controls = new THREE.TrackballControls( camera );
+        var r = new Robot(0, 0, 0);
+        r.show(scene);
+        
+        var controller = {
+          anaglyph: false
+
+        }
+        var gui = new dat.GUI();
+        var rendering = gui.addFolder("Rendering"); 
+        rendering.add( controller, 'anaglyph');
+        rendering.open();
+        var moving = gui.addFolder( "Movement" );
+        moving.add( r.head.position, "x", -1000,1000); 
+        moving.add( r.head.position, "y", -1000,1000);
+        moving.add( r.head.position, "z", -1000,1000);
+ 
+        moving.open();
+
+        controls = new THREE.TrackballControls(camera, renderer.domElement); 
+=======
         controls = new THREE.TrackballControls( camera );
 
+>>>>>>> 6a6b96e4d883f0379d7ee30b4db15eeb459da0ab
         animate();
 
 
@@ -69,7 +97,10 @@
 
         requestAnimationFrame( animate );
 
+<<<<<<< HEAD
+=======
         controls.update();
+>>>>>>> 6a6b96e4d883f0379d7ee30b4db15eeb459da0ab
         renderer.render( scene, camera );
 
       };
diff --git a/09/CS460_Assignment_09__Copy_.pdf b/09/CS460_Assignment_09__Copy_.pdf
new file mode 100644
index 00000000..b886bef3
Binary files /dev/null and b/09/CS460_Assignment_09__Copy_.pdf differ
diff --git a/09/index.html b/09/index.html
index b36f1a10..36b36787 100644
--- a/09/index.html
+++ b/09/index.html
@@ -22,6 +22,7 @@
 
       var scene, camera, renderer, effect, ambientLight, light, controls;
       var floor;
+      var mesh; 
 
       window.onload = function() {
 
@@ -44,6 +45,22 @@
 
 
         // TODO Part 3 (add 2 pointlights)
+        
+
+
+        
+        var pointLight = new THREE.PointLight( 0xffffff, 1);
+        pointLight.position.set(0, 10, 0);
+        scene.add(pointLight);  
+
+        var pointLight_2 = new THREE.PointLight(0xffffff, 1);
+        pointLight_2.position.set(100, 10, 0); 
+        scene.add(pointLight_2);
+
+
+        
+
+
 
 
 
@@ -62,7 +79,20 @@
 
         } );
 
-        // TODO Part 1, load another mesh
+        var loader = new THREE.PLYLoader();
+        loader.load('armadillo.ply', function (geometry) {
+          geometry.computeVertexNormals(); 
+
+          phongMaterial = new THREE.MeshPhongMaterial( {
+            color: 0xa74f4f
+          } ); 
+
+          mesh2 = new THREE.Mesh( geometry, phongMaterial );
+          mesh2.position.set(180, 0, 0);
+          scene.add(mesh2);
+
+        } ); 
+
         // TODO Part 2, use a different material for this mesh
 
 
@@ -76,6 +106,8 @@
           // TODO Bonus Part 2
         }
 
+        
+        
 
         var gui = new dat.GUI();
         var ambientFolder = gui.addFolder('Ambient Light');
@@ -91,9 +123,27 @@
 
         // TODO Part 4 (control the color and position of point lights)
 
-        // TODO Part 5 (control the color of both materials in the scene)
+        var pointFolder = gui.addFolder('Point Light');
+        pointFolder.addColor(controller, 'color').onChange( function(value) {
+        pointLight.color.setHex(value); });
+        pointFolder.add(pointLight, 'distance', 0, 40 ).onChange( function(value) {pointLight.position.set(value); }); 
+
+        
+        pointFolder.addColor(controller, 'color').onChange( function(value) {
+        pointLight.color.setHex(value); });
+        pointFolder.add(pointLight, 'distance', 0, 40 ).onChange( function(value) {pointLight.position.set(value); }); 
 
-        gui.open();
+        pointFolder.open(); 
+
+        // TODO P 5 (control the color of both materials in the scene)
+        var meshColor = gui.addColor(controller, 'color').onChange(function(value) {
+        mesh.material.color.setHex(value); 
+        } ); 
+        gui.open(); 
+        
+        var meshColor = gui.addColor(controller, 'color').onChange(function(value) {
+        mesh2.material.color.setHex(value); 
+        } ); 
 
 
 
diff --git a/Final_Project.pdf b/Final_Project.pdf
new file mode 100644
index 00000000..22b304af
Binary files /dev/null and b/Final_Project.pdf differ
diff --git a/LICENSE b/LICENSE
deleted file mode 100644
index aac3b690..00000000
--- a/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2019 BostonGFX
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/README.md b/README.md
deleted file mode 100644
index 4fc6e05d..00000000
--- a/README.md
+++ /dev/null
@@ -1,2 +0,0 @@
-# cs460student
-The assignments for the CS460 Computer Graphics course at UMass Boston.
diff --git a/converter.py b/converter.py
new file mode 100644
index 00000000..34bc93a8
--- /dev/null
+++ b/converter.py
@@ -0,0 +1,146 @@
+#GLTF file converter
+import numpy as np
+import pymesh
+import base64
+
+print("enter the file name")
+filestring = str(input()) 
+
+mesh = pymesh.load_mesh(filestring); 
+
+vertex_data = mesh.vertices
+face_data = mesh.faces
+
+VERTICES = vertex_data.ravel().astype(np.float32) 
+MAX_X = -np.inf
+MAX_Y = -np.inf
+MAX_Z = -np.inf
+MIN_X =  np.inf
+MIN_Y =  np.inf
+MIN_Z =  np.inf
+
+for v in vertex_data:
+
+    MAX_X = max(MAX_X, v[0])
+    MAX_Y = max(MAX_Y, v[1])
+    MAX_Z = max(MAX_Z, v[2])
+    MIN_X = min(MIN_X, v[0]) 
+    MIN_Y = min(MIN_Y, v[1])
+    MIN_Z = min(MIN_Z, v[2]) 
+
+
+INDICES = face_data.ravel().astype(np.ushort)
+
+MAX = -np.inf
+MIN = np.inf
+
+for i in face_data:
+
+    MAX = max(MAX, i[0])
+    MAX = max(MAX, i[1])
+    MAX = max(MAX, i[2])
+    MIN = min(MIN, i[0])
+    MIN = min(MIN, i[1])
+    MIN = min(MIN, i[2])
+    
+VERTICES = np.array(VERTICES, dtype=np.float32)
+INDICES = np.array(INDICES, dtype = np.ushort)
+
+HOWMANY_V = len(VERTICES) / 3 
+HOWMANY_I = len(INDICES) 
+
+HOWMANYBYTES_V = VERTICES.nbytes
+HOWMANYBYTES_I = INDICES.nbytes
+
+B64_VERTICES = base64.b64encode(VERTICES)
+B64_INDICES = base64.b64encode(INDICES)
+
+gltf = {
+
+    "asset": {
+        "version": "2.0",
+        "generator": "Pymesh gltf converter"
+    },
+
+  "accessors": [
+        {
+            "bufferView": 0,
+            "byteOffset": 0,
+            "componentType": 5126,
+            "count": HOWMANY_V,
+            "type": "VEC3",
+            "max": [MAX_X, MAX_Y, MAX_Z],
+            "min": [MIN_X, MIN_Y, MIN_Z]
+        },
+        {
+            "bufferView": 1,
+            "byteOffset": 0,
+            "componentType": 5123,
+            "count": HOWMANY_I,
+            "type": "SCALAR",
+            "max": [MAX],
+            "min": [MIN]
+        }
+    ], 
+
+    "bufferViews": [
+        {
+            "buffer": 0,
+            "byteOffset": 0,
+            "byteLength": HOWMANYBYTES_V,
+            "target": 34962
+        },
+        {
+            "buffer": 1,
+            "byteOffset": 0,
+            "byteLength": HOWMANYBYTES_I,
+            "target": 34963
+        }
+    ],
+    
+    "buffers": [
+        {
+            "uri": "data:application/octet-stream;base64,"+str(B64_VERTICES, 'utf-8'),
+            "byteLength": HOWMANYBYTES_V
+        },
+        {
+            "uri": "data:application/octet-stream;base64,"+str(B64_INDICES, 'utf-8'),
+            "byteLength": HOWMANYBYTES_I
+        }
+    ],
+  
+    "meshes": [
+        {
+            "primitives": [{
+                 "mode": 4,
+                 "attributes": {
+                     "POSITION": 0
+                 },
+                 "indices": 1
+            }]
+        }
+    ],
+
+    "nodes": [
+        {
+            "mesh": 0
+        }
+    ],
+
+    "scenes": [
+        {
+            "nodes": [
+                0
+            ]
+        }
+    ],
+
+    "scene": 0
+}
+
+print ( str(gltf).replace("'", '"') ) # we need double quotes instead of single quotes
+
+#save file
+
+with open('cube.gltf', 'w') as f:
+    f.write(str(gltf).replace("'", '"'))
diff --git a/cube.gltf b/cube.gltf
new file mode 100644
index 00000000..6449d2aa
--- /dev/null
+++ b/cube.gltf
@@ -0,0 +1 @@
+{"asset": {"version": "2.0", "generator": "Pymesh gltf converter"}, "accessors": [{"bufferView": 0, "byteOffset": 0, "componentType": 5126, "count": 8.0, "type": "VEC3", "max": [0.5, 0.5, 0.5], "min": [-0.5, -0.5, -0.5]}, {"bufferView": 1, "byteOffset": 0, "componentType": 5123, "count": 36, "type": "SCALAR", "max": [7], "min": [0]}], "bufferViews": [{"buffer": 0, "byteOffset": 0, "byteLength": 96, "target": 34962}, {"buffer": 1, "byteOffset": 0, "byteLength": 72, "target": 34963}], "buffers": [{"uri": "data:application/octet-stream;base64,AAAAvwAAAL8AAAA/AAAAPwAAAL8AAAA/AAAAvwAAAD8AAAA/AAAAPwAAAD8AAAA/AAAAvwAAAD8AAAC/AAAAPwAAAD8AAAC/AAAAvwAAAL8AAAC/AAAAPwAAAL8AAAC/", "byteLength": 96}, {"uri": "data:application/octet-stream;base64,AAABAAIAAgABAAMAAgADAAQABAADAAUABAAFAAYABgAFAAcABgAHAAAAAAAHAAEAAQAHAAMAAwAHAAUABgAAAAQABAAAAAIA", "byteLength": 72}], "meshes": [{"primitives": [{"mode": 4, "attributes": {"POSITION": 0}, "indices": 1}]}], "nodes": [{"mesh": 0}], "scenes": [{"nodes": [0]}], "scene": 0}
\ No newline at end of file
diff --git a/cube.obj b/cube.obj
new file mode 100644
index 00000000..2b0ba7c4
--- /dev/null
+++ b/cube.obj
@@ -0,0 +1,21 @@
+# Generated with PyMesh
+v -0.5 -0.5 0.5 
+v 0.5 -0.5 0.5 
+v -0.5 0.5 0.5 
+v 0.5 0.5 0.5 
+v -0.5 0.5 -0.5 
+v 0.5 0.5 -0.5 
+v -0.5 -0.5 -0.5 
+v 0.5 -0.5 -0.5 
+f 1 2 3 
+f 3 2 4 
+f 3 4 5 
+f 5 4 6 
+f 5 6 7 
+f 7 6 8 
+f 7 8 1 
+f 1 8 2 
+f 2 8 4 
+f 4 8 6 
+f 7 1 5 
+f 5 1 3 
diff --git a/cube2.ply b/cube2.ply
new file mode 100644
index 00000000..92d275f0
Binary files /dev/null and b/cube2.ply differ
diff --git a/gltfconverter.py b/gltfconverter.py
new file mode 100644
index 00000000..049d8f3d
--- /dev/null
+++ b/gltfconverter.py
@@ -0,0 +1,45 @@
+# Sam Kellman-Wanzer
+# File converter that takes a gltf file and converts it back to 
+# A graphical file format supported by PyMesh
+
+import pygltflib
+from pygltflib import *
+import base64
+from struct import *
+import pymesh
+import numpy as np
+
+gltf = pygltflib.GLTF2.load_json("cube.gltf")
+
+attributes = gltf.meshes[0].primitives[0].attributes
+
+a_position = gltf.accessors[attributes.POSITION]
+
+a_indices = gltf.accessors[gltf.meshes[0].primitives[0].indices]
+
+bv_position = gltf.bufferViews[a_position.bufferView]
+
+bv_indices = gltf.bufferViews[a_indices.bufferView]
+
+b_position = gltf.buffers[bv_position.buffer]
+
+b_indices = gltf.buffers[bv_indices.buffer]
+
+magic = 'data:application/octet-stream;base64,'
+data_position = base64.b64decode(b_position.uri[len(magic):])
+data_indices = base64.b64decode(b_indices.uri[len(magic):])
+
+c_vertices = unpack('f'*int(len(data_position)/4), data_position)
+
+c_indices = unpack('H'*int(len(data_indices)/2), data_indices)
+
+f_vertices = np.asarray(c_vertices)
+f_faces = np.asarray(c_indices)
+
+mesh = pymesh.form_mesh(f_vertices.reshape(-3,3), f_faces.reshape(-3,3))
+
+
+print("enter the name of the file to save")
+
+filestring = str(input())
+pymesh.save_mesh(filestring, mesh)
