<!DOCTYPE html>

<!--

A 3D LIBRARY BY ARROWHEAD CO.

So yes I might be jentgent or xacer... who knows

All the code is owned and created by me (whoever I am)

and is freely available on github. Use the links below

to acces the scripts any time.

Subscribe!

https://www.khanacademy.org/computer-programming/subscribe-to-arrowhead-co/6260274198511616

More stuff!

https://www.khanacademy.org/profile/modavid/projects

-->

<html>

<head>

<title>Open Source Engine3D_v1.0 - Arrowhead Co.</title>

<style>

* {

box-sizing : border-box;

margin : 0;

padding : 0;

overflow : hidden;

}

#fps {

position : fixed;

top : 0;

left : 0;

height : 50px;

padding-top : 10px;

padding-left : 20px;

color : white;

font-size : 25px;

font-family : Russo One;

}

canvas {

top : 0px;

position : fixed;

}

#under {

top : 100px;

position : fixed;

font-size : 50px;

}

</style>

</head>

<div id = "under">Please refresh the window</div>

Please reload the page!

</canvas>

<script>/**

Arrowhead Co. - Object3D.js

>>> A constructor for solids.

>>> Similar to primitives.js for Engine3D.

>>> Used for EngineMECH.

**/

/*GLOBALS*/

var Object3D = {};

/*METHODS*/

Object3D.Cuboid = function(x, y, z,

xl, yl, zl, col,

ax, ay, az,

id, method, mode){

mode = mode === undefined ? true : mode;

col = col ||

[255,

255,

255,

255],

xl /= 2;

yl /= 2;

zl /= 2;

ax = ax || 0;

ay = ay || 0;

az = az || 0;

let rotation = new Vector(ax, ay, az);

Engine3D.create(

new Primitive(

new Vector(x - xl, y - yl, z - zl),

new Vector(x - xl, y + yl, z - zl),

new Vector(x + xl, y + yl, z - zl),

new Vector(x + xl, y - yl, z - zl)

),

new Primitive(

new Vector(x + xl, y - yl, z - zl),

new Vector(x + xl, y + yl, z - zl),

new Vector(x + xl, y + yl, z + zl),

new Vector(x + xl, y - yl, z + zl)

),

new Primitive(

new Vector(x + xl, y - yl, z + zl),

new Vector(x + xl, y + yl, z + zl),

new Vector(x - xl, y + yl, z + zl),

new Vector(x - xl, y - yl, z + zl)

),

new Primitive(

new Vector(x - xl, y - yl, z + zl),

new Vector(x - xl, y + yl, z + zl),

new Vector(x - xl, y + yl, z - zl),

new Vector(x - xl, y - yl, z - zl)

),

new Primitive(

new Vector(x - xl, y + yl, z - zl),

new Vector(x - xl, y + yl, z + zl),

new Vector(x + xl, y + yl, z + zl),

new Vector(x + xl, y + yl, z - zl)

),

new Primitive(

new Vector(x + xl, y - yl, z + zl),

new Vector(x - xl, y - yl, z + zl),

new Vector(x - xl, y - yl, z - zl),

new Vector(x + xl, y - yl, z - zl),

),

new Vector(x, y, z),

col,

rotation,

mode

);

xl *= 2;

yl *= 2;

zl *= 2;

EngineMECH.create(

x, y, z,

xl, yl, zl,

id, method,

);

};

Object3D.Cube = function(x, y, z, s, col,

ax, ay, az,

id, method, mode){

Object3D.Cuboid(x, y, z,

s, s, s, col,

ax, ay, az,

id, method, mode);

};/**

Arrowhead Co. EngineMECH.js

>>> Handles collisions.

>>> Performs the mechanical part of the game.

>>> Has a library of utility functions.

**/

/*GLOBALS*/

var BUFFER = 0.01;

var EngineMECH = {

objects : [],

};

/*METHODS*/

EngineMECH.revert = function(){

this.objects = [];

};

EngineMECH.create = function(x, y, z, xl, yl, zl, id, method){

this.objects.push({

x : x, y : y, z : z,

w : xl, h : yl, l : zl,

id : id,

method : method,

});

};

EngineMECH.collisionAdjust = function(object, adjustable, jump){

let canJump = false;

if(

adjustable.x < object.x + object.w / 2 + adjustable.w / 2 - BUFFER &&

adjustable.x > object.x - object.w / 2 - adjustable.w / 2 + BUFFER &&

adjustable.y < object.y + object.h / 2 + adjustable.h / 2 - BUFFER &&

adjustable.y > object.y - object.h / 2 - adjustable.h / 2 + BUFFER &&

adjustable.z < object.z + object.l / 2 + adjustable.l / 2 - BUFFER &&

adjustable.z > object.z - object.l / 2 - adjustable.l / 2 + BUFFER){

if(adjustable.x < object.x + object.w / 2 + adjustable.w / 2 - BUFFER &&

adjustable.prev.x >= object.x + object.w / 2 + adjustable.w / 2 - BUFFER){

adjustable.x = object.x + object.w / 2 + adjustable.w / 2 - BUFFER;

} else

if(adjustable.x > object.x - object.w / 2 - adjustable.w / 2 + BUFFER &&

adjustable.prev.x <= object.x - object.w / 2 - adjustable.w / 2 + BUFFER){

adjustable.x = object.x - object.w / 2 - adjustable.w / 2 + BUFFER;

} else

if(adjustable.z < object.z + object.l / 2 + adjustable.l / 2 - BUFFER &&

adjustable.prev.z >= object.z + object.l / 2 + adjustable.l / 2 - BUFFER){

adjustable.z = object.z + object.l / 2 + adjustable.l / 2 - BUFFER;

} else

if(adjustable.z > object.z - object.l / 2 - adjustable.l / 2 + BUFFER &&

adjustable.prev.z <= object.z - object.l / 2 - adjustable.l / 2 + BUFFER){

adjustable.z = object.z - object.l / 2 - adjustable.l / 2 + BUFFER;

} else

if(adjustable.y < object.y + object.h / 2 + adjustable.h / 2 - BUFFER &&

adjustable.prev.y >= object.y + object.h / 2 + adjustable.h / 2 - BUFFER){

adjustable.y = object.y + object.h / 2 + adjustable.h / 2 - BUFFER;

} else

if(adjustable.y > object.y - object.h / 2 - adjustable.h / 2 + BUFFER &&

adjustable.prev.y <= object.y - object.h / 2 - adjustable.h / 2 + BUFFER){

adjustable.y = object.y - object.h / 2 - adjustable.h / 2 + BUFFER;

canJump = true;

}

if(jump){

return {

collide : true,

canJump : canJump,

};

} else {

return true;

}

}

if(jump){

return {

collide : false,

canJump : canJump,

};

} else {

return false;

}

};

EngineMECH.cuboidCollision = function(cuboid, point){

if(

point.x < cuboid.x + cuboid.w && cuboid.x < point.x &&

point.y < cuboid.y + cuboid.h && cuboid.y < point.y &&

point.z < cuboid.z + cuboid.l && cuboid.z < point.z){

return true;

}

return false;

};

EngineMECH.sphereCollision = function(sphere, point){

if(

(point.x - sphere.x) * (point.x - sphere.x) +

(point.y - sphere.y) * (point.y - sphere.y) +

(point.z - sphere.z) * (point.z - sphere.z) <

sphere.r * sphere.r){

return true;

}

return false;

};

EngineMECH.cuboidVcuboid = function(cuboid1, cuboid2){

if(

(cuboid1.x < cuboid2.x + cuboid2.w || cuboid2.x < cuboid1.x + cuboid1.w) &&

(cuboid1.y < cuboid2.y + cuboid2.h || cuboid2.y < cuboid1.y + cuboid1.h) &&

(cuboid1.z < cuboid2.z + cuboid2.l || cuboid2.z < cuboid1.z + cuboid1.l)){

return {

collide : true,

canJump : false,

};

}

return false;

};

EngineMECH.sphereVsphere = function(sphere1, sphere2){

if(

(sphere1.x - sphere2.x) * (sphere1.x - sphere2.x) +

(sphere1.y - sphere2.y) * (sphere1.y - sphere2.y) +

(sphere1.z - sphere2.z) * (sphere1.z - sphere2.z) <

(sphere1.r + sphere2.r) * (sphere1.r * sphere2.r)){

return true;

}

return false;

};

EngineMECH.none = function(){

return false;

};

EngineMECH.run = function(reference){

let collide = false,

canJump = false,

current = "";

for(let i = 0; i < this.objects.length; i++){

let info = this[

this.objects[i].method](

this.objects[i], reference, true);

current += this.objects[i].id;

if(info){

if(info.collide){

collide = true;

if(info.canJump){

canJump = true;

}

}

}

}

if(canJump){

reference.canJump = true;

}

if(collide){

reference.collide = true;

} else {

reference.collide = false;

}

if(collide){

return current;

} else {

return false;

}

};/**

Arrowhead Co. - Engine3D-primitive.js

>>> A library of the triangle primitive.

>>> Uses vector.js and matrix.js.

>>> Can be used by mesh.js.

**/

/*CONTRUCTOR*/

function Primitive(){

this.vectors = arguments;

this.id = "prim";

return this;

};/**

Arrowhead Co. - Engine3D-matrix.js

>>> A custom library for matrices and matrix utility functions.

>>> Contains a constructor for 4x4 matrices.

>>> Works with vector.js.

**/

/*CONSTRUCTOR*/

//4x4 Matrix Constructor

function Matrix(

x0, x1, x2, x3,

y0, y1, y2, y3,

z0, z1, z2, z3,

w0, w1, w2, w3){

this.x = [x0, x1, x2, x3];

this.y = [y0, y1, y2, y3];

this.z = [z0, z1, z2, z3];

this.w = [w0, w1, w2, w3];

this.id = "mat";

return this;

};

/*PROTOTYPE METHODS*/

//Matrix x Matrix

Matrix.prototype.xMatrix = function(matrix){

let self = new Matrix(

this.x[0], this.x[1], this.x[2], this.x[3],

this.y[0], this.y[1], this.y[2], this.y[3],

this.z[0], this.z[1], this.z[2], this.z[3],

this.w[0], this.w[1], this.w[2], this.w[3]);

for(let i = 0; i < 4; i++){

this.x[i] =

self.x[0] * matrix.x[i] +

self.x[1] * matrix.y[i] +

self.x[2] * matrix.z[i] +

self.x[3] * matrix.w[i];

this.y[i] =

self.y[0] * matrix.x[i] +

self.y[1] * matrix.y[i] +

self.y[2] * matrix.z[i] +

self.y[3] * matrix.w[i];

this.z[i] =

self.z[0] * matrix.x[i] +

self.z[1] * matrix.y[i] +

self.z[2] * matrix.z[i] +

self.z[3] * matrix.w[i];

this.w[i] =

self.w[0] * matrix.x[i] +

self.w[1] * matrix.y[i] +

self.w[2] * matrix.z[i] +

self.w[3] * matrix.w[i];

}

return this;

};

/*METHODS*/

//Matrix x Matrix

Matrix.xMatrix = function(matrix1, matrix2){

let prod = new Matrix(

0, 0, 0, 0,

0, 0, 0, 0,

0, 0, 0, 0,

0, 0, 0, 0);

for(let i = 0; i < 4; i++){

prod.x[i] =

matrix1.x[0] * matrix2.x[i] +

matrix1.x[1] * matrix2.y[i] +

matrix1.x[2] * matrix2.z[i] +

matrix1.x[3] * matrix2.w[i];

prod.y[i] =

matrix1.y[0] * matrix2.x[i] +

matrix1.y[1] * matrix2.y[i] +

matrix1.y[2] * matrix2.z[i] +

matrix1.y[3] * matrix2.w[i];

prod.z[i] =

matrix1.z[0] * matrix2.x[i] +

matrix1.z[1] * matrix2.y[i] +

matrix1.z[2] * matrix2.z[i] +

matrix1.z[3] * matrix2.w[i];

prod.w[i] =

matrix1.w[0] * matrix2.x[i] +

matrix1.w[1] * matrix2.y[i] +

matrix1.w[2] * matrix2.z[i] +

matrix1.w[3] * matrix2.w[i];

}

return prod;

};

/*INSTANCES*/

//Pre-defined matrices

Matrix.identity = function(){

let identity = new Matrix(

1, 0, 0, 0,

0, 1, 0, 0,

0, 0, 1, 0,

0, 0, 0, 1

);

return identity;

};

//Projection matrix

Matrix.projection = function(ratio, fov, zMin, zMax){

let projection = new Matrix(

ratio / Math.tan(fov / 2), 0, 0, 0,

0, 1 / Math.tan(fov / 2), 0, 0,

0, 0, zMax / (zMax - zMin), 1,

0, 0, -zMin * zMax / (zMax - zMin), 0);

return projection;

};

//Rotation Matrices

Matrix.xRotation = function(angle){

let rotation = new Matrix(

1, 0, 0, 0,

0, Math.cos(angle), Math.sin(angle), 0,

0, -Math.sin(angle), Math.cos(angle), 0,

0, 0, 0, 1);

return rotation;

};

Matrix.yRotation = function(angle){

let rotation = new Matrix(

Math.cos(angle), 0, Math.sin(angle), 0,

0, 1, 0, 0,

-Math.sin(angle), 0, Math.cos(angle), 0,

0, 0, 0, 1

);

return rotation;

};

Matrix.zRotation = function(angle){

let rotation = new Matrix(

Math.cos(angle), Math.sin(angle), 0, 0,

-Math.sin(angle), Math.cos(angle), 0, 0,

0, 0, 1, 0,

0, 0, 0, 1);

return rotation;

};

//Translation matrix

Matrix.translate = function(tx, ty, tz){

let translation = new Matrix(

1, 0, 0, 0,

0, 1, 0, 0,

0, 0, 1, 0,

tx, ty, tz, 1);

return translation;

};

//View matrix

Matrix.view = function(camera, direction, north){

let newF = Vector.norm(direction),

newU = Vector.sub(north,

Vector.mul(newF,

Vector.dot(north, newF))).norm(),

newR = Vector.cross(newU, newF);

let view = new Matrix(

newR.x, newU.x, newF.x, 0,

newR.y, newU.y, newF.y, 0,

newR.z, newU.z, newF.z, 0,

-Vector.dot(camera, newR),

-Vector.dot(camera, newU),

-Vector.dot(camera, newF), 1);

return view;

};

/*GLOBALS*/

var IDENTITY = Matrix.identity();/**

Arrowhead Co. - Engine3D.js

>>> Runs the 3D engine.

>>> Performs graphics stuff.

**/

/*GLOBALS*/

var Engine3D = {

primitives : [],

};

/*METHODS*/

//Engine

Engine3D.revert = function(){

//Resets scene

this.primitives = [];

}

Engine3D.create = function(){

let Color = color(255),

darkMode = true,

Basis = new Vector(0, 0, 0),

Rot = new Vector(0, 0, 0),

Center = new Vector(0, 0, 0),

prims = arguments.length;

darkMode = arguments[--prims];

Rot = arguments[--prims];

Color = arguments[--prims];

Center = arguments[--prims];

if(!darkMode){

console.log(darkMode);

}

//Adds object to primitives array

for(let i = 0; i < prims; i++){

arguments[i].color = Color;

arguments[i].center = Center;

arguments[i].rotation = Rot;

arguments[i].darkMode = darkMode;

this.primitives.push(arguments[i]);

}

return this;

};

Engine3D.update = function(){

for(let i = 0; i < this.primitives.length; i++){

for(let j = 0; j <

this.primitives[i].vectors.length; j++){

this.primitives[i].vectors[j].

xMatrix(

Matrix.translate(

-this.primitives[i].center.x,

-this.primitives[i].center.y,

-this.primitives[i].center.z)).

xMatrix(

Matrix.zRotation(

this.primitives[i].rotation.z)).

xMatrix(

Matrix.yRotation(

this.primitives[i].rotation.y)).

xMatrix(

Matrix.xRotation(

this.primitives[i].rotation.x)).

xMatrix(

Matrix.translate(

this.primitives[i].center.x,

this.primitives[i].center.y,

this.primitives[i].center.z));

}

}

};

Engine3D.view = function(){

this.visiblePrimitives = [];

//Transformations based on camera

for(let i = 0; i <

this.primitives.length; i++){

//Normal used for shading

this.primitives[i].normal =

Vector.cross(

Vector.sub(this.primitives[i].vectors[1],

this.primitives[i].vectors[0]),

Vector.sub(this.primitives[i].vectors[2],

this.primitives[i].vectors[0])).norm();

//If primitive can be seen

if(Vector.dot(

Vector.sub(

Vector.copy(

this.primitives[i].vectors[0]),

Camera.pos),

this.primitives[i].normal) < 0 ||

alpha(

this.primitives[i].color) < 255){

this.primitives[i].projectedVectors = [];

//Ensures original vector info are not lost

for(let j = 0; j <

this.primitives[i].vectors.length; j++){

this.primitives[i].projectedVectors[j] =

Vector.xMatrix(

Vector.copy(this.primitives[i].vectors[j]),

Matrix.view(Camera.pos,

Camera.dir,

Camera.nor)

);

}

this.visiblePrimitives.push(this.primitives[i]);

}

}

return this;

};

Engine3D.clip3D = function(){

let primitiveCount =

this.visiblePrimitives.length;

this.clipped3DPrimitives = [];

//Clips against zMin plane

for(let i = 0; i < primitiveCount; i++){

let currentPrimitive = this.visiblePrimitives[i],

point = Camera.zMinPlane[0],

normal = Camera.zMinPlane[1],

inside = [],

outside = [];

//Checks whether each vector (point) is inside of plane

for(let j = 0; j < currentPrimitive.projectedVectors.length; j++){

if(Vector.dot(currentPrimitive.projectedVectors[j], normal) -

Vector.dot(point, normal) >= 0){

inside.push({

primitive : currentPrimitive.

projectedVectors[j],

index : j

});

} else {

outside.push({

primitive : currentPrimitive.

projectedVectors[j],

index : j

});

}

}

let clippedPrimitive = new Primitive();

clippedPrimitive.projectedVectors = [];

clippedPrimitive.darkMode = currentPrimitive.darkMode;

clippedPrimitive.normal = currentPrimitive.normal;

clippedPrimitive.center = currentPrimitive.center;

clippedPrimitive.color = currentPrimitive.color;

//Checks the conditions and does something based on them

if(outside.length === 0){

//Entire primitive is inside

this.clipped3DPrimitives.push(currentPrimitive);

continue;

} else if(inside.length === 1){

//Merely a triangle is formed

clippedPrimitive.projectedVectors.push(

Vector.xPlane(point, normal, inside[0].primitive,

currentPrimitive.projectedVectors[(inside[0].index - 1 +

currentPrimitive.projectedVectors.length) %

currentPrimitive.projectedVectors.length]));

clippedPrimitive.projectedVectors.push(inside[0].primitive);

clippedPrimitive.projectedVectors.push(

Vector.xPlane(point, normal, inside[0].primitive,

currentPrimitive.projectedVectors[(inside[0].index + 1) %

currentPrimitive.projectedVectors.length]));

} else if(outside.length === 1){

//Loops through original points; includes those inside and creates two new points

for(let k = 0; k < currentPrimitive.projectedVectors.length; k++){

if(k !== outside[0].index){

clippedPrimitive.projectedVectors.push(

currentPrimitive.projectedVectors[k]);

} else {

//Two new points

clippedPrimitive.projectedVectors.push(

Vector.xPlane(point, normal,

currentPrimitive.projectedVectors[(k - 1 +

currentPrimitive.projectedVectors.length) %

currentPrimitive.projectedVectors.length],

outside[0].primitive));

clippedPrimitive.projectedVectors.push(

Vector.xPlane(point, normal,

currentPrimitive.projectedVectors[(k + 1) %

currentPrimitive.projectedVectors.length],

outside[0].primitive));

}

}

} else if(inside.length === 0){

//Nothing happens because the entire primitive is outside

continue;

} else {

let minIn, minOut,

maxIn, maxOut,

notInside = true;

//The pairs of points whose adjacents are on the other side

for(let k = 0; k < inside.length; k++){

if(inside[k].index === 0){

minOut = outside[0].index;

maxOut = outside[outside.length - 1].index;

minIn = (maxOut + 1) %

currentPrimitive.projectedVectors.length;

maxIn = (minOut - 1 +

currentPrimitive.projectedVectors.length) %

currentPrimitive.projectedVectors.length;

notInside = false;

break;

}

}

if(notInside){

minIn = inside[0].index;

maxIn = inside[inside.length - 1].index;

minOut = (maxIn + 1) %

currentPrimitive.projectedVectors.length;

maxOut = (minIn - 1 +

currentPrimitive.projectedVectors.length) %

currentPrimitive.projectedVectors.length;

}

//Adds inside points, as well as two new ones

for(let k = 0; k < inside.length; k++){

if(inside[k].index === minIn){

//First new point

clippedPrimitive.projectedVectors.push(

Vector.xPlane(point, normal,

currentPrimitive.projectedVectors[minIn],

currentPrimitive.projectedVectors[maxOut]));

//One of the original points

clippedPrimitive.projectedVectors.push(

currentPrimitive.projectedVectors[inside[k].index]);

} else if(inside[k].index === maxIn){

//One of the original points

clippedPrimitive.projectedVectors.push(

currentPrimitive.projectedVectors[inside[k].index]);

//Second new point

clippedPrimitive.projectedVectors.push(

Vector.xPlane(point, normal,

currentPrimitive.projectedVectors[maxIn],

currentPrimitive.projectedVectors[minOut]));

} else {

//Original points

clippedPrimitive.projectedVectors.push(

currentPrimitive.projectedVectors[inside[k].index]);

}

}

}

this.clipped3DPrimitives.push(clippedPrimitive);

}

return this;

};

Engine3D.project = function(){

//Projects each primitive

for(let i = 0; i < this.clipped3DPrimitives.length; i++){

//Projects each vector of each primitive

for(let j = 0; j <

this.clipped3DPrimitives[i].projectedVectors.length; j++){

this.clipped3DPrimitives[i].projectedVectors[j].xMatrix(

Matrix.projection(

Camera.aspectRatio,

Camera.fieldOfView,

Camera.zMin,

Camera.zMax

)

);

//Re-scales beacuse projected version is normalized

this.clipped3DPrimitives[i].projectedVectors[j].x *= width;

this.clipped3DPrimitives[i].projectedVectors[j].x += width / 2;

this.clipped3DPrimitives[i].projectedVectors[j].y *= height;

this.clipped3DPrimitives[i].projectedVectors[j].y += height / 2;

}

//Computes shade based on light direction (if it hasn't)

if(!this.clipped3DPrimitives[i].shade){

if(this.clipped3DPrimitives[i].darkMode){

this.clipped3DPrimitives[i].shade = dim(

this.clipped3DPrimitives[i].color, 1 -

(Vector.dot(

Vector.norm(

Vector.mul(Light.dir, -1)),

this.clipped3DPrimitives[i].normal) + 1) / 2.5);

} else {

this.clipped3DPrimitives[i].shade = lit(

this.clipped3DPrimitives[i].color, 0.4 -

(Vector.dot(

Vector.norm(

Vector.mul(Light.dir, 1)),

this.clipped3DPrimitives[i].normal) + 1) / 2.5);

}

}

}

return this;

};

Engine3D.order = function(){

//Sorts primitives based on z

this.clipped3DPrimitives.sort(function(a, b){

let bDepth = 0,

aDepth = 0,

bCenter = 0,

aCenter = 0;

//Uses their midpoints for reference

for(let i = 0; i < b.vectors.length; i++){

bDepth = Math.max(bDepth,

Vector.sub(b.vectors[i],

Camera.pos).mag());

}

for(let i = 0; i < a.vectors.length; i++){

aDepth = Math.max(aDepth,

Vector.sub(a.vectors[i],

Camera.pos).mag());

}

bCenter = Vector.sub(b.center, Camera.pos).mag();

aCenter = Vector.sub(a.center, Camera.pos).mag();

return (bDepth - aDepth) || (bCenter - aCenter);

});

return this;

};

Engine3D.clip2D = function(){

let primitiveCount = this.clipped3DPrimitives.length;

this.clipped2DPrimitives = this.clipped3DPrimitives;

//Clips all primitives against each of the side planes

for(let i = 0; i < primitiveCount; i++){

let subsetPrimitives = [this.clipped2DPrimitives[0]],

nextSubset = [],

toClip = 1;

this.clipped2DPrimitives.shift();

//For each plane

for(let j = 0; j < Camera.planes.length; j++){

let point = Camera.planes[j][0],

normal = Camera.planes[j][1];

//If there are primitives to clip

for(let k = 0; k < toClip; k++){

let inside = [],

outside = [];

//For each projected vector of the current primitive, determine if in or out

for(let l = 0; l < subsetPrimitives[k].projectedVectors.length; l++){

if(Vector.dot(subsetPrimitives[k].projectedVectors[l], normal) -

Vector.dot(point, normal) >= 0){

inside.push({

primitive : subsetPrimitives[k].

projectedVectors[l],

index : l

});

} else {

outside.push({

primitive : subsetPrimitives[k].

projectedVectors[l],

index : l

});

}

}

let clippedPrimitive = new Primitive();

clippedPrimitive.projectedVectors = [];

clippedPrimitive.shade = subsetPrimitives[k].shade;

//Based on conditions, it clips the primitive

if(outside.length === 0){

//The entire primitive is within this plane

nextSubset.push(subsetPrimitives[k]);

continue;

} else if(inside.length === 1){

//A new triangle is created from the original primitive

clippedPrimitive.projectedVectors.push(

Vector.xPlane(point, normal, inside[0].primitive,

subsetPrimitives[k].projectedVectors[(inside[0].index - 1 +

subsetPrimitives[k].projectedVectors.length) %

subsetPrimitives[k].projectedVectors.length]));

clippedPrimitive.projectedVectors.push(inside[0].primitive);

clippedPrimitive.projectedVectors.push(

Vector.xPlane(point, normal, inside[0].primitive,

subsetPrimitives[k].projectedVectors[(inside[0].index + 1) %

subsetPrimitives[k].projectedVectors.length]));

} else if(outside.length === 1){

//Adds all inside points and two new ones

for(let l = 0; l < subsetPrimitives[k].projectedVectors.length; l++){

if(l !== outside[0].index){

clippedPrimitive.projectedVectors.push(

subsetPrimitives[k].projectedVectors[l]);

} else {

//Two new points

clippedPrimitive.projectedVectors.push(

Vector.xPlane(point, normal,

subsetPrimitives[k].projectedVectors[(l - 1 +

subsetPrimitives[k].projectedVectors.length) %

subsetPrimitives[k].projectedVectors.length],

outside[0].primitive));

clippedPrimitive.projectedVectors.push(

Vector.xPlane(point, normal,

subsetPrimitives[k].projectedVectors[(l + 1) %

subsetPrimitives[k].projectedVectors.length],

outside[0].primitive));

}

}

} else if(inside.length === 0){

//Nothing happens because it is completely outside this plane

continue;

} else {

let minIn, minOut,

maxIn, maxOut,

notInside = true;

//The pairs of points whose adjacents are on the other side

for(let l = 0; l < inside.length; l++){

if(inside[l].index === 0){

minOut = outside[0].index;

maxOut = outside[outside.length - 1].index;

minIn = (maxOut + 1) %

subsetPrimitives[k].projectedVectors.length;

maxIn = (minOut - 1 +

subsetPrimitives[k].projectedVectors.length) %

subsetPrimitives[k].projectedVectors.length;

notInside = false;

break;

}

}

if(notInside){

minIn = inside[0].index;

maxIn = inside[inside.length - 1].index;

minOut = (maxIn + 1) %

subsetPrimitives[k].projectedVectors.length;

maxOut = (minIn - 1 +

subsetPrimitives[k].projectedVectors.length) %

subsetPrimitives[k].projectedVectors.length;

}

//Add all inside points and two new ones

for(let l = 0; l < inside.length; l++){

if(inside[l].index === minIn){

//First new point

clippedPrimitive.projectedVectors.push(

Vector.xPlane(point, normal,

subsetPrimitives[k].projectedVectors[minIn],

subsetPrimitives[k].projectedVectors[maxOut]));

//One of the old points

clippedPrimitive.projectedVectors.push(

subsetPrimitives[k].projectedVectors[inside[l].index]);

} else if(inside[l].index === maxIn){

//One of the old points

clippedPrimitive.projectedVectors.push(

subsetPrimitives[k].projectedVectors[inside[l].index]);

//Second new point

clippedPrimitive.projectedVectors.push(

Vector.xPlane(point, normal,

subsetPrimitives[k].projectedVectors[maxIn],

subsetPrimitives[k].projectedVectors[minOut]));

} else {

//Original points

clippedPrimitive.projectedVectors.push(

subsetPrimitives[k].projectedVectors[inside[l].index]);

}

}

}

nextSubset.push(clippedPrimitive);

}

subsetPrimitives = [];

toClip = nextSubset.length;

//Adds new primitives for evaluation on next plane

for(let k = 0; k < nextSubset.length; k++){

subsetPrimitives[k] = nextSubset[k];

}

nextSubset = [];

//If that was actually the last plane

if(j === Camera.planes.length - 1){

for(let k = 0; k < subsetPrimitives.length; k++){

this.clipped2DPrimitives.push(

subsetPrimitives[k]);

}

}

}

}

return this;

};

Engine3D.display = function(){

//Display primitives

for(let i = 0; i < this.clipped2DPrimitives.length; i++){

let points = [];

//For each vector

for(let j = 0; j < this.clipped2DPrimitives[i].

projectedVectors.length; j++){

points.push(this.clipped2DPrimitives[i].

projectedVectors[j].x);

points.push(this.clipped2DPrimitives[i].

projectedVectors[j].y);

}

//In case shade is undefined

if(this.clipped2DPrimitives[i].shade){

fill( this.clipped2DPrimitives[i].shade);

if(alpha(this.clipped2DPrimitives[i].shade) < 255){

this.clipped2DPrimitives[i].shade = [

red( this.clipped2DPrimitives[i].shade),

green(this.clipped2DPrimitives[i].shade),

blue( this.clipped2DPrimitives[i].shade),

alpha(this.clipped2DPrimitives[i].shade) / 2,

];

}

stroke(this.clipped2DPrimitives[i].shade);

} else {

noFill();

noStroke();

}

poly(points);

}

return this;

};

Engine3D.render = function(){

//Renders entire scene

this.update();

this.view();

this.clip3D();

this.project();

this.order();

this.clip2D();

this.display();

};/**

Arrowhead Co. - Engine3D-vector.js

>>> A custom library for vectors and vector utility functions.

>>> Supports 3-dimensional vectors.

>>> Works with matrix.js.

**/

/*CONSTRUCTOR*/

function Vector(x, y, z){

this.x = x;

this.y = y;

this.z = z;

this.id = "vec";

return this;

};

/*PROTOTYPE METHODS*/

//Vector Arithmetic

Vector.prototype.add = function(vector){

this.x += vector.x;

this.y += vector.y;

this.z += vector.z;

return this;

};

Vector.prototype.sub = function(vector){

this.x -= vector.x;

this.y -= vector.y;

this.z -= vector.z;

return this;

};

Vector.prototype.mul = function(scalar){

this.x *= scalar;

this.y *= scalar;

this.z *= scalar;

return this;

};

Vector.prototype.div = function(scalar){

this.x /= scalar;

this.y /= scalar;

this.z /= scalar;

return this;

};

//Vector Magnitude

Vector.prototype.mag = function(){

let x = this.x * this.x,

y = this.y * this.y,

z = this.z * this.z;

return Math.pow(x + y + z, 0.5);

};

//Normalizing a Vector

Vector.prototype.norm = function(){

this.div(this.mag());

return this;

};

//With matrix

Vector.prototype.xMatrix = function(matrix){

let self = new Vector(

this.x,

this.y,

this.z);

let w =

matrix.x[3] * self.x +

matrix.y[3] * self.y +

matrix.z[3] * self.z +

matrix.w[3] * 1;

this.x =

matrix.x[0] * self.x +

matrix.y[0] * self.y +

matrix.z[0] * self.z +

matrix.w[0] * 1;

this.y =

matrix.x[1] * self.x +

matrix.y[1] * self.y +

matrix.z[1] * self.z +

matrix.w[1] * 1;

this.z =

matrix.x[2] * self.x +

matrix.y[2] * self.y +

matrix.z[2] * self.z +

matrix.w[2] * 1;

this.div(w);

return this;

};

/*METHODS*/

//Vector arithmetic

Vector.add = function(vector1, vector2){

let sum = new Vector(0, 0, 0);

sum.x = vector1.x + vector2.x;

sum.y = vector1.y + vector2.y;

sum.z = vector1.z + vector2.z;

return sum;

};

Vector.sub = function(vector1, vector2){

let diff = new Vector(0, 0, 0);

diff.x = vector1.x - vector2.x;

diff.y = vector1.y - vector2.y;

diff.z = vector1.z - vector2.z;

return diff;

};

Vector.mul = function(vector, scalar){

let prod = new Vector(0, 0, 0);

prod.x = vector.x * scalar;

prod.y = vector.y * scalar;

prod.z = vector.z * scalar;

return prod;

};

Vector.div = function(vector, scalar){

let quo = new Vector(0, 0, 0);

quo.x = vector.x / scalar;

quo.y = vector.y / scalar;

quo.z = vector.z / scalar;

return quo;

};

//Normalizing a Vector

Vector.norm = function(vector){

let normal = new Vector(

vector.x,

vector.y,

vector.z);

normal.norm();

return normal;

};

//Dot and Cross Products

Vector.dot = function(vector1, vector2){

let x = vector1.x * vector2.x,

y = vector1.y * vector2.y,

z = vector1.z * vector2.z;

return x + y + z;

};

Vector.cross = function(vector1, vector2){

let prod = new Vector(0, 0, 0);

prod.x =

vector1.y * vector2.z -

vector1.z * vector2.y;

prod.y =

vector1.z * vector2.x -

vector1.x * vector2.z;

prod.z =

vector1.x * vector2.y -

vector1.y * vector2.x;

return prod;

};

//Product with a matrix

Vector.xMatrix = function(vector, matrix){

let prod = new Vector(0, 0, 0);

let w =

matrix.x[3] * vector.x +

matrix.y[3] * vector.y +

matrix.z[3] * vector.z +

matrix.w[3] * 1;

prod.x =

matrix.x[0] * vector.x +

matrix.y[0] * vector.y +

matrix.z[0] * vector.z +

matrix.w[0] * 1;

prod.y =

matrix.x[1] * vector.x +

matrix.y[1] * vector.y +

matrix.z[1] * vector.z +

matrix.w[1] * 1;

prod.z =

matrix.x[2] * vector.x +

matrix.y[2] * vector.y +

matrix.z[2] * vector.z +

matrix.w[2] * 1;

prod.div(w);

return prod;

};

//Plane intersection with vector

Vector.xPlane = function(point, normal, startVector, endVector){

normal = Vector.norm(normal);

let dist = Vector.dot(normal, point),

start = Vector.dot(startVector, normal),

end = Vector.dot(endVector, normal),

vec = Vector.sub(endVector, startVector),

arrow = Vector.mul(vec, (dist - start) / (end - start));

return Vector.add(startVector, arrow);

};

//Copies a vector

Vector.copy = function(vector){

let copy = new Vector(0, 0, 0);

copy.x = vector.x;

copy.y = vector.y;

copy.z = vector.z;

return copy;

};

/**

Arrowhead Co. - time.js

>>> Helps determine the current fps.

>>> Also standardizes time.

>>> Helps simulations / games run in uniform time.

**/

/*GLOBALS*/

var TIME = {

start : (new Date()).getTime(),

current : (new Date()).getTime(),

latent : (new Date()).getTime(),

old : (new Date()).getTime(),

new : (new Date()).getTime(),

dt : 0,

fps : 0,

FPS : 60,

thresh : 1000 / 3,

};

/*METHODS*/

TIME.update = function(){

this.old = this.new;

this.new = (new Date()).getTime();

this.current = this.new;

this.dt = this.new - this.old;

if(this.current -

this.latent > this.thresh){

this.latent = this.current;

this.fps = ~~(1000 / this.dt);

}

this.dt *= this.FPS / 1000;

};

TIME.fpsCounter = function(color, back){

let fpsCounter = document.getElementById("fps");

if(fpsCounter){

fpsCounter.innerHTML = "FPS : " + this.fps;

} else {

fpsCounter = document.createElement("div");

fpsCounter.id = "fps";

fpsCounter.style.color = color;

if(back){

fpsCounter.style.background = back;

}

document.getElementById("body").

appendChild(fpsCounter);

}

};

/**

Arrowhead Co. - graphics.js

>>> Custom shorthand functions.

>>> A graphics library for the 2d rendering context.

**/

/*CONSTRUCTORS*/

var color = function(r, g, b, a){

let info = [];

if(!g && g !== 0){

info = [r, r, r, 255];

} else {

if(!b && b !== 0){

info = [r, r, r, g];

} else {

if(!a && a !== 0){

info = [r, g, b, 255];

} else {

info = [r, g, b, a];

}

}

}

return info;

};

/*COLOR MODIFYING FUNCTIONS*/

function red(Color){

return Color[0];

};

function green(Color){

return Color[1];

};

function blue(Color){

return Color[2];

};

function alpha(Color){

return Color[3];

};

function gray(Color){

let grayVal = 0;

for(let i = 0; i < 3; i++){

grayVal += Color[i];

}

grayVal /= 3;

return color(grayVal, Color[3]);

}

function lerp(color1, color2, amount){

let lerped = [];

lerped[0] = red(color1) * (1 - amount) +

red(color2) * (amount);

lerped[1] = green(color1) * (1 - amount) +

green(color2) * amount;

lerped[2] = blue(color1) * (1 - amount) +

blue(color2) * amount;

lerped[3] = alpha(color1) * (1 - amount) +

alpha(color2) * amount;

return lerped;

};

function dim(Color, amount){

return lerp(Color,

color(0,

alpha(Color)), amount);

};

function lit(Color, amount){

return lerp(Color,

color(255,

alpha(Color)), amount);

};

/*COLOR DRAWING FUNCTIONS*/

//Sets canvas fillStyle

function fill(r, g, b, a){

if(!g && g !== 0){

if(typeof r === "number"){

ctx.fillStyle =

"rgb(" +

r + "," +

r + "," +

r + ")";

} else {

ctx.fillStyle =

"rgba(" +

r[0] + "," +

r[1] + "," +

r[2] + "," +

r[3] / 255 + ")";

}

} else {

if(!b && b !== 0){

g /= 255;

ctx.fillStyle =

"rgba(" +

r + "," +

r + "," +

r + "," +

g + ")";

} else {

if(!a && a !== 0){

ctx.fillStyle =

"rgb(" +

r + "," +

g + "," +

b + ")";

} else {

a /= 255;

ctx.fillStyle =

"rgba(" +

r + "," +

g + "," +

b + "," +

a + ")";

}

}

}

};

function noFill(){

fill(0, 0);

};

function background(r, g, b, a){

if(typeof r === "number"){

fill(r, g, b, a);

} else {

fill(r);

}

ctx.fillRect(-1, -1,

width + 2, height + 2);

}

//Sets canvas strokeStyle

function stroke(r, g, b, a){

if(!g && g !== 0){

if(typeof r === "number"){

ctx.strokeStyle =

"rgb(" +

r + "," +

r + "," +

r + ")";

} else {

ctx.strokeStyle =

"rgba(" +

r[0] + "," +

r[1] + "," +

r[2] + "," +

r[3] / 255 + ")";

}

} else {

if(!b && b !== 0){

g /= 255;

ctx.strokeStyle =

"rgba(" +

r + "," +

r + "," +

r + "," +

g + ")";

} else {

if(!a && a !== 0){

ctx.strokeStyle =

"rgb(" +

r + "," +

g + "," +

b + ")";

} else {

a /= 255;

ctx.strokeStyle =

"rgba(" +

r + "," +

g + "," +

b + "," +

a + ")";

}

}

}

};

function noStroke(){

stroke(0, 0);

};

function weight(n){

ctx.lineWidth = n;

};

/*SHAPE FUNCTIONS*/

//Ellipse

function ellipse(x, y, w, h){

ctx.beginPath();

ctx.ellipse(x, y, w / 2, h / 2,

0, 0, Math.PI * 2);

ctx.fill();

ctx.stroke();

};

//Rectangle

function rect(x, y, w, h){

ctx.beginPath();

ctx.moveTo(x, y);

ctx.lineTo(x + w, y);

ctx.lineTo(x + w, y + h);

ctx.lineTo(x, y + h);

ctx.lineTo(x, y);

ctx.fill();

ctx.stroke();

};

//General polygon function

function poly(){

let points = [];

if(typeof arguments[0] === "number"){

points = arguments;

} else {

points = arguments[0];

}

let pointCount = points.length;

ctx.beginPath();

ctx.moveTo(

points[pointCount - 2],

points[pointCount - 1]);

for(let i = 0; i < pointCount; i += 2){

ctx.lineTo(

points[i],

points[i + 1]);

}

ctx.fill();

ctx.stroke();

};

/*TEXT FUNCTIONS*/

function font(font, size){

if(!size){

size = 20;

}

ctx.font = size + "px " + font;

};

function align(x, y){

switch(x){

case "LEFT":

ctx.textAlign = "start";

break;

case "CENTER":

ctx.textAlign = "center";

break;

case "RIGHT":

ctx.textAlign = "end";

break;

default:

ctx.textAlign = "start";

break;

}

switch(y){

case "TOP":

ctx.textBaseline = "top";

break;

case "CENTER":

ctx.textBaseline = "middle";

break;

case "BOTTOM":

ctx.textBaseline = "bottom";

break;

default:

ctx.textBaseline = "alphabetic";

break;

}

};

function text(text, x, y, borderWeight){

ctx.fillText(text, x, y);

if(borderWeight){

let prevWeight = ctx.lineWidth;

ctx.lineWidth = borderWeight;

ctx.strokeText(text, x, y);

ctx.lineWidth = prevWeight;

}

};

/*GLOBALS*/

var BLACK = color(0),

WHITE = color(255),

RED = color(255, 0, 0),

GREEN = color(0, 255, 0),

BLUE = color(0, 0, 255);/**

Arrowhead Co. - input.js

>>> Implementation of user input.

>>> Mouse and key responses and bindings.

**/

/*GLOBALS*/

var keys = {};

var mouse = {

x : 0,

y : 0,

dx : 0,

dy : 0,

pressed : false,

released : false,

isPressed : false,

reset : function(){

this.dx = 0;

this.dy = 0;

this.pressed = false;

this.released = false;

}

};

var pointerLock =

document.body.requestPointerLock ||

document.body.mozRequestPointerLock;

var exitPointerLock =

document.body.exitPointerLock ||

document.body.mozExitPointerLock;

/*UTILITY FUNCTIONS*/

//For Mouse

function isLocked(){

if(document.pointerLockElement !== null){

document.addEventListener("mousemove", mouseMove);

} else {

document.removeEventListener("mousemove", mouseMove);

}

};

function mouseMove(input){

mouse.dx = input.movementX;

mouse.dy = input.movementY;

};

function mousePress(input){

mouse.pressed = true;

mouse.isPressed = true;

if(input.button == 0){

mouse.button = "left";

} else {

mouse.button = "right";

}

};

function mouseRelease(input){

mouse.released = true;

mouse.isPressed = false;

mouse.button = undefined;

};

//For Keys

function keyPress(input){

let key = input.code;

if(key.includes("Key")){

key = key.slice(3);

}

if(key.includes("Arrow")){

key = key.slice(5);

}

keys[key.toUpperCase()] = true;

};

function keyRelease(input){

let key = input.code;

if(key.includes("Key")){

key = key.slice(3);

}

if(key.includes("Arrow")){

key = key.slice(5);

}

keys[key.toUpperCase()] = false;

};

/*BINDINGS*/

document.addEventListener("mousedown", mousePress);

document.addEventListener("mouseup", mouseRelease);

document.getElementById("canvas").onclick = pointerLock;

document.addEventListener("pointerlockchange", isLocked);

document.addEventListener("mozpointerlockchange", isLocked);

document.addEventListener("keydown", keyPress);

document.addEventListener("keyup", keyRelease);/**

Arrowhead Co. - Camera3D.js

>>> Creates a camera that is used by the 3D Engine.

>>> Also includes light source.

>>> FPS-style camera implementation.

**/

/*GLOBALS*/

/**

Arrowhead Co. - canvas.js

>>> Sets 2d context of canvas.

>>> Resizes it when necessary.

**/

/*GLOBALS*/

//Canvas, context, dimensions

var canvas = document.getElementById("canvas"),

ctx = canvas.getContext("2d"),

width,

height;

/*CANVAS*/

//Resizes canvas when needed

function resize(){

canvas.width = window.innerWidth;

canvas.height = window.innerHeight;

width = canvas.width;

height = canvas.height;

};

resize();

//Fonts

function fontDefine(){

let fontString = "";

for(let i = 0; i < arguments.length; i++){

let font = arguments[i].split(" ");

for(let j = 0; j < font.length; j++){

fontString += font[j];

if(j !== font.length - 1){

fontString += "+";

}

}

if(i !== arguments.length - 1){

fontString += "|";

}

}

let fonts = document.getElementById("fonts");

if(fonts){

fonts.parentNode.removeChild(fonts);

} else {

let link = document.createElement("link");

link.id = "fonts";

link.rel = "stylesheet";

link.type = "text/css";

link.href = "https://fonts.googleapis.com/css?family=" +

fontString;

document.getElementsByTagName("head")[0]

.appendChild(link);

}

}

/*BINDINGS*/

//In case window resizes

window.onresize = resize();

var Camera = {

pos : new Vector(0, 0, 0),

dir : new Vector(0, 0, 1),

nor : new Vector(0, 1, 0),

yaw : 0,

pitch : 0,

zMax : 10000,

zMin : 0.1,

fieldOfView : Math.PI / 2,

aspectRatio : height / width,

zMinPlane : [

new Vector(0, 0, 0.1),

new Vector(0, 0, 1)

],

planes : [

[new Vector(0, 0, 0),

new Vector(0, 1, 0)],

[new Vector(0, height - 1, 0),

new Vector(0, -1, 0)],

[new Vector(0, 0, 0),

new Vector(1, 0, 0)],

[new Vector(width - 1, 0, 0),

new Vector(-1, 0, 0)],

],

};

var Light = {

dir : new Vector(-1, 2, 0),

};

/*METHODS*/

//Light

Light.update = function(){

this.dir.norm();

};

Light.set = function(direction){

this.dir = direction;

};

//Camera

Camera.update = function(){

//In case screen resizes

this.aspectRatio = height / width;

//Resetting

this.dir = new Vector(0, 0, 1);

this.nor = new Vector(0, 1, 0);

this.pitch = Math.min(

Math.max(this.pitch, -Math.PI / 2.1),

Math.PI / 2.1);

//Movements

this.dir.xMatrix(

Matrix.xRotation(this.pitch)

);

this.dir.xMatrix(

Matrix.yRotation(this.yaw)

);

};

Camera.FPSfollow = function(object){

this.pos = new Vector(

object.x,

object.y,

object.z);

this.fieldOfView = object.fov;

this.yaw = object.yaw;

this.pitch = object.pitch;

};

Camera.TPSfollow = function(object){

};

/*PRE-CONS*/

var preset = function(){

noStroke();

noFill();

fontDefine("Russo One", "Londrina Solid");

};

preset();

/*GAME CONSTANTS*/

var

BULLET_SPEED = 10,

GRAVITY = 1 / 300,

PALETTE = [

];

/*PLAYER*/

var player = {

x : 4.0, y : 0.0, z : 4.0,

w : 0.7, h : 2.8, l : 0.7,

prev : {

x : 0, y : 0, z : 0,

},

fov : Math.PI / 2,

yaw : 0, pitch : 0,

speed : 0.05, jump : 0,

canJump : false,

};

player.control = function(){

//Mouse control

this.yaw -= mouse.dx * Math.PI / 1000 * TIME.dt;

this.pitch -= mouse.dy * Math.PI / 1000 * TIME.dt;

this.pitch = Math.min(

Math.max(this.pitch, -Math.PI / 2.35),

Math.PI / 2.35);

this.prev.x = this.x;

this.prev.y = this.y;

this.prev.z = this.z;

//Key control

if(keys.UP || keys.W){

this.z += this.speed * Math.cos(this.yaw) * TIME.dt;

this.x += this.speed * -Math.sin(this.yaw) * TIME.dt;

}

if(keys.DOWN || keys.S){

this.z -= this.speed * Math.cos(this.yaw) * TIME.dt;

this.x -= this.speed * -Math.sin(this.yaw) * TIME.dt;

}

if(keys.RIGHT || keys.D){

this.z += this.speed * Math.sin(this.yaw) * TIME.dt;

this.x += this.speed * Math.cos(this.yaw) * TIME.dt;

}

if(keys.LEFT || keys.A){

this.z -= this.speed * Math.sin(this.yaw) * TIME.dt;

this.x -= this.speed * Math.cos(this.yaw) * TIME.dt;

}

if(keys.SPACE && this.canJump){

this.jump = -0.1;

this.canJump = false;

}

if(keys.SHIFTLEFT ||

keys.SHIFTRIGHT){

this.y += this.speed * TIME.dt;

}

if(!this.canJump || !this.collide){

this.jump += GRAVITY * TIME.dt;

this.y += this.jump * TIME.dt;

this.canJump = false;

} else {

if(this.collide){

this.jump = 0;

}

}

if(this.y > 50){

this.x = 2.5;

this.z = 2.5;

this.y = -10;

}

};

/*GAME ASSETS*/

var Block = function(x, y, z, w, h, l, id, type){

this.x = x;

this.y = y;

this.z = z;

this.w = w;

this.h = h;

this.l = l;

this.id = id;

method = "";

if(type === "none"){

method = "none";

} else if(type === "liquid"){

method = "cuboidVcuboid";

} else {

method = "collisionAdjust";

}

this.method = method;

};

Block.prototype.update = function(){

Object3D.Cuboid(

this.x, this.y, this.z,

this.w, this.h, this.l,

PALETTE[this.id]);

};

//In case of long loops

var resetTimer = function (n) {

var setInf = "KAInfiniteLoopSetTimeout";

if (setInf in this) {

if(typeof this[setInf] === "function"){

this[setInf](n);

}

}

};

/*GAME FUNCTION*/

function game(){

try {

resetTimer(Math.POSITIVE_INFINITY);

requestAnimationFrame(game);

TIME.update();

TIME.fpsCounter("black");

EngineMECH.revert();

Engine3D.revert();

background(215, 151, 66);

for(let i = 0; i < 7; i++){

for(let j = 0; j < 7; j++){

Object3D.Cuboid(

i * 2,

10 - Math.abs(i - 3) - Math.abs(j - 3),

j * 2, 2, 1, 2,

color(255, i * 30, j * 30),

0, 0, 0,

"block",

"collisionAdjust");

}

}

Light.update();

Camera.update();

Camera.FPSfollow(player);

player.control();

EngineMECH.run(player);

Engine3D.render();

} catch(err){

throw "Please reload the page"

}

};

game();

</script>

</body>

</html>

Jacob's Transfer

Super Admins