Fire JS Bin - Floating-Cubes

// design.js

function get_triangle_normal(point1, point2, point3) {

var result = new Array(3);
  var vettore1 = new Array(3);
  var vettore2 = new Array(3);

vettore1[0] = point2[0] - point1[0];
  vettore1[1] = point2[1] - point1[1];
  vettore1[2] = point2[2] - point1[2];

vettore2[0] = point3[0] - point1[0];
  vettore2[1] = point3[1] - point1[1];
  vettore2[2] = point3[2] - point1[2];

result[0] = vettore1[1] * vettore2[2] - vettore1[2] * vettore2[1];
  result[1] = -(vettore1[0] * vettore2[2] - vettore1[2] * vettore2[0]);
  result[2] = vettore1[0] * vettore2[1] - vettore1[1] * vettore2[0];

return result;
}

function get_triangle(point1, point2, point3) {
  var result = new Array(2, 3);

result[0][1] = point1;
  result[0][2] = point2;
  result[0][3] = point3;
  result[1] = get_triangle_normal(point1, point2, point3);

return result;
}

function get_quadrilateral_normal(point1, point2, point3, point4) {
  var result = new Array(2, 3);

result[0] = get_triangle_normal(point1, point2, point4);
  result[1] = get_triangle_normal(point2, point3, point4);

return result;
}

function get_quadrilateral(point1, point2, point3, point4) {
  var result = new Array(2, 2, 3, 3);

result[0][0][0] = point1;
  result[0][0][1] = point2;
  result[0][0][2] = point3;

result[0][1][0] = point2;
  result[0][1][1] = point3;
  result[0][1][2] = point4;

result[1] = get_quadrilater_normal(point1, point2, point3, point4);

}

function cube(dimensione, fillcolor, linecolor) {
  var punto0 = [-0.5 * dimensione, -0.5 * dimensione, 0.5 * dimensione];
  var punto1 = [0.5 * dimensione, -0.5 * dimensione, 0.5 * dimensione];
  var punto2 = [0.5 * dimensione, 0.5 * dimensione, 0.5 * dimensione];
  var punto3 = [-0.5 * dimensione, 0.5 * dimensione, 0.5 * dimensione];
  var punto4 = [-0.5 * dimensione, -0.5 * dimensione, -0.5 * dimensione];
  var punto5 = [0.5 * dimensione, -0.5 * dimensione, -0.5 * dimensione];
  var punto6 = [0.5 * dimensione, 0.5 * dimensione, -0.5 * dimensione];
  var punto7 = [-0.5 * dimensione, 0.5 * dimensione, -0.5 * dimensione];

this.points = [punto0, punto1, punto2, punto3, punto4, punto5, punto6, punto7];
  this.faces = [
    [0, 1, 2, 3],
    [1, 5, 6, 2],
    [5, 4, 7, 6],
    [4, 0, 3, 7],
    [3, 2, 6, 7],
    [0, 4, 5, 1]
  ];
  this.normals = [
    [0, 0, 1],
    [1, 0, 0],
    [0, 0, -1],
    [-1, 0, 0],
    [0, 1, 0],
    [0, -1, 0]
  ];
  this.center = [0, 0, 0];
  this.points_number = 8;
  this.faces_number = 6;
  this.vertex_number = 4;
  this.axis_x = [1, 0, 0];
  this.axis_y = [0, 1, 0];
  this.axis_z = [0, 0, 1];
  this.fillcolor = fillcolor;
  this.linecolor = linecolor;
}

function get_letter(letter, dimensione, fillcolor, linecolor) {
  var risultato = new Array();

if (letter == "C") {
    for (var i = 0; i < 13; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }
    translate_solid([0, 0, -dimensione], risultato[1]);
    translate_solid([0, 0, -2 * dimensione], risultato[2]);
    translate_solid([0, 0, -3 * dimensione], risultato[3]);
    translate_solid([0, 0, -4 * dimensione], risultato[4]);
    translate_solid([0, 0, -5 * dimensione], risultato[5]);
    translate_solid([0, 0, -6 * dimensione], risultato[6]);
    translate_solid([dimensione, 0, -6 * dimensione], risultato[7]);
    translate_solid([2 * dimensione, 0, -6 * dimensione], risultato[8]);
    translate_solid([3 * dimensione, 0, -6 * dimensione], risultato[9]);
    translate_solid([dimensione, 0, 0], risultato[10]);
    translate_solid([2 * dimensione, 0, 0], risultato[11]);
    translate_solid([3 * dimensione, 0, 0], risultato[12]);

}

if (letter == "O") {
    for (var i = 0; i < 19; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }

translate_solid([0, 0, -dimensione], risultato[1]);
    translate_solid([0, 0, -2 * dimensione], risultato[2]);
    translate_solid([0, 0, -3 * dimensione], risultato[3]);
    translate_solid([0, 0, -4 * dimensione], risultato[4]);
    translate_solid([0, 0, -5 * dimensione], risultato[5]);
    translate_solid([0, 0, -6 * dimensione], risultato[6]);

translate_solid([dimensione, 0, -6 * dimensione], risultato[7]);
    translate_solid([2 * dimensione, 0, -6 * dimensione], risultato[8]);
    translate_solid([3 * dimensione, 0, -6 * dimensione], risultato[9]);
    translate_solid([dimensione, 0, 0], risultato[10]);
    translate_solid([2 * dimensione, 0, 0], risultato[11]);
    translate_solid([3 * dimensione, 0, 0], risultato[12]);

translate_solid([3 * dimensione, 0, -dimensione], risultato[13]);
    translate_solid([3 * dimensione, 0, -2 * dimensione], risultato[14]);
    translate_solid([3 * dimensione, 0, -3 * dimensione], risultato[15]);
    translate_solid([3 * dimensione, 0, -4 * dimensione], risultato[16]);
    translate_solid([3 * dimensione, 0, -5 * dimensione], risultato[17]);
    translate_solid([3 * dimensione, 0, -6 * dimensione], risultato[18]);
  }

if (letter == "R") {
    for (var i = 0; i < 16; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }

translate_solid([0, 0, -dimensione], risultato[1]);
    translate_solid([0, 0, -2 * dimensione], risultato[2]);
    translate_solid([0, 0, -3 * dimensione], risultato[3]);
    translate_solid([0, 0, -4 * dimensione], risultato[4]);
    translate_solid([0, 0, -5 * dimensione], risultato[5]);
    translate_solid([0, 0, -6 * dimensione], risultato[6]);
    translate_solid([dimensione, 0, -6 * dimensione], risultato[7]);
    translate_solid([2 * dimensione, 0, -6 * dimensione], risultato[8]);

translate_solid([3 * dimensione, 0, -5 * dimensione], risultato[9]);
    translate_solid([3 * dimensione, 0, -4 * dimensione], risultato[10]);

translate_solid([dimensione, 0, -3 * dimensione], risultato[11]);
    translate_solid([2 * dimensione, 0, -3 * dimensione], risultato[12]);

translate_solid([3 * dimensione, 0, -2 * dimensione], risultato[13]);
    translate_solid([3 * dimensione, 0, -dimensione], risultato[14]);
    translate_solid([3 * dimensione, 0, 0], risultato[15]);
  }

if (letter == "M") {
    for (var i = 0; i < 17; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }

translate_solid([0, 0, -dimensione], risultato[1]);
    translate_solid([0, 0, -2 * dimensione], risultato[2]);
    translate_solid([0, 0, -3 * dimensione], risultato[3]);
    translate_solid([0, 0, -4 * dimensione], risultato[4]);
    translate_solid([0, 0, -5 * dimensione], risultato[5]);
    translate_solid([0, 0, -6 * dimensione], risultato[6]);

translate_solid([dimensione, 0, -5 * dimensione], risultato[7]);
    translate_solid([2 * dimensione, 0, -4 * dimensione], risultato[8]);

translate_solid([3 * dimensione, 0, -5 * dimensione], risultato[9]);
    translate_solid([4 * dimensione, 0, -6 * dimensione], risultato[10]);

translate_solid([4 * dimensione, 0, -5 * dimensione], risultato[11]);
    translate_solid([4 * dimensione, 0, -4 * dimensione], risultato[12]);
    translate_solid([4 * dimensione, 0, -3 * dimensione], risultato[13]);
    translate_solid([4 * dimensione, 0, -2 * dimensione], risultato[14]);
    translate_solid([4 * dimensione, 0, -dimensione], risultato[15]);
    translate_solid([4 * dimensione, 0, 0], risultato[16]);
  }

if (letter == "H") {
    for (var i = 0; i < 17; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }

translate_solid([0, 0, -dimensione], risultato[1]);
    translate_solid([0, 0, -2 * dimensione], risultato[2]);
    translate_solid([0, 0, -3 * dimensione], risultato[3]);
    translate_solid([0, 0, -4 * dimensione], risultato[4]);
    translate_solid([0, 0, -5 * dimensione], risultato[5]);
    translate_solid([0, 0, -6 * dimensione], risultato[6]);

translate_solid([dimensione, 0, -3 * dimensione], risultato[7]);
    translate_solid([2 * dimensione, 0, -3 * dimensione], risultato[8]);

translate_solid([3 * dimensione, 0, -3 * dimensione], risultato[9]);
    translate_solid([4 * dimensione, 0, -6 * dimensione], risultato[10]);

translate_solid([4 * dimensione, 0, -5 * dimensione], risultato[11]);
    translate_solid([4 * dimensione, 0, -4 * dimensione], risultato[12]);
    translate_solid([4 * dimensione, 0, -3 * dimensione], risultato[13]);
    translate_solid([4 * dimensione, 0, -2 * dimensione], risultato[14]);
    translate_solid([4 * dimensione, 0, -dimensione], risultato[15]);
    translate_solid([4 * dimensione, 0, 0], risultato[16]);
  }

if (letter == "E") {
    for (var i = 0; i < 16; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }

translate_solid([0, 0, -dimensione], risultato[1]);
    translate_solid([0, 0, -2 * dimensione], risultato[2]);
    translate_solid([0, 0, -3 * dimensione], risultato[3]);
    translate_solid([0, 0, -4 * dimensione], risultato[4]);
    translate_solid([0, 0, -5 * dimensione], risultato[5]);
    translate_solid([0, 0, -6 * dimensione], risultato[6]);

translate_solid([dimensione, 0, -6 * dimensione], risultato[7]);
    translate_solid([2 * dimensione, 0, -6 * dimensione], risultato[8]);
    translate_solid([3 * dimensione, 0, -6 * dimensione], risultato[9]);

translate_solid([dimensione, 0, -3 * dimensione], risultato[10]);
    translate_solid([2 * dimensione, 0, -3 * dimensione], risultato[11]);
    translate_solid([3 * dimensione, 0, -3 * dimensione], risultato[12]);

translate_solid([dimensione, 0, 0], risultato[13]);
    translate_solid([2 * dimensione, 0, 0], risultato[14]);
    translate_solid([3 * dimensione, 0, 0], risultato[15]);
  }

if (letter == "F") {  
    for (var i = 0; i < 13; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }

translate_solid([0, 0, -dimensione], risultato[1]);
    translate_solid([0, 0, -2 * dimensione], risultato[2]);
    translate_solid([0, 0, -3 * dimensione], risultato[3]);
    translate_solid([0, 0, -4 * dimensione], risultato[4]);
    translate_solid([0, 0, -5 * dimensione], risultato[5]);
    translate_solid([0, 0, -6 * dimensione], risultato[6]);

translate_solid([dimensione, 0, -6 * dimensione], risultato[7]);
    translate_solid([2 * dimensione, 0, -6 * dimensione], risultato[8]);
    translate_solid([3 * dimensione, 0, -6 * dimensione], risultato[9]);

translate_solid([dimensione, 0, -3 * dimensione], risultato[10]);
    translate_solid([2 * dimensione, 0, -3 * dimensione], risultato[11]);
    translate_solid([3 * dimensione, 0, -3 * dimensione], risultato[12]);

}
  
  if (letter == "X") {
    for (var i = 0; i < 13; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }

translate_solid([0, 0, -dimensione], risultato[1]);
    translate_solid([dimensione, 0, -2 * dimensione], risultato[2]);
    translate_solid([2 * dimensione, 0, -3 * dimensione], risultato[3]);
    translate_solid([dimensione, 0, -4 * dimensione], risultato[4]);
    translate_solid([0, 0, -5 * dimensione], risultato[5]);
    translate_solid([0, 0, -6 * dimensione], risultato[6]);

translate_solid([4 * dimensione, 0, -6 * dimensione], risultato[7]);
    translate_solid([4 * dimensione, 0, -5 * dimensione], risultato[8]);
    translate_solid([3 * dimensione, 0, -4 * dimensione], risultato[9]);
    translate_solid([3 * dimensione, 0, -2 * dimensione], risultato[10]);
    translate_solid([4 * dimensione, 0, -dimensione], risultato[11]);
    translate_solid([4 * dimensione, 0, 0], risultato[12]);

}

if (letter == "P") {
    for (var i = 0; i < 15; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }

translate_solid([0, 0, -dimensione], risultato[1]);
    translate_solid([0, 0, -2 * dimensione], risultato[2]);
    translate_solid([0, 0, -3 * dimensione], risultato[3]);
    translate_solid([0, 0, -4 * dimensione], risultato[4]);
    translate_solid([0, 0, -5 * dimensione], risultato[5]);
    translate_solid([0, 0, -6 * dimensione], risultato[6]);

translate_solid([dimensione, 0, -6 * dimensione], risultato[7]);
    translate_solid([2 * dimensione, 0, -6 * dimensione], risultato[8]);
    translate_solid([3 * dimensione, 0, -6 * dimensione], risultato[9]);

translate_solid([3 * dimensione, 0, -5 * dimensione], risultato[10]);
    translate_solid([3 * dimensione, 0, -4 * dimensione], risultato[11]);
    translate_solid([3 * dimensione, 0, -3 * dimensione], risultato[12]);

translate_solid([2 * dimensione, 0, -3 * dimensione], risultato[13]);
    translate_solid([dimensione, 0, -3 * dimensione], risultato[14]);

}

if (letter == "I") {
    for (var i = 0; i < 7; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }

translate_solid([0, 0, -dimensione], risultato[1]);
    translate_solid([0, 0, -2 * dimensione], risultato[2]);
    translate_solid([0, 0, -3 * dimensione], risultato[3]);
    translate_solid([0, 0, -4 * dimensione], risultato[4]);
    translate_solid([0, 0, -5 * dimensione], risultato[5]);
    translate_solid([0, 0, -6 * dimensione], risultato[6]);
  }

if (letter == "J") {
    for (var i = 0; i < 12; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }

translate_solid([0, 0, -1 * dimensione], risultato[1]);
    
    translate_solid([dimensione, 0, 0], risultato[2]);
    translate_solid([2 * dimensione, 0, 0], risultato[3]);
    translate_solid([3 * dimensione, 0, 0], risultato[4]);

translate_solid([3 * dimensione, 0, -dimensione], risultato[5]);
    translate_solid([3 * dimensione, 0, -2 * dimensione], risultato[6]);
    translate_solid([3 * dimensione, 0, -3 * dimensione], risultato[7]);
    translate_solid([3 * dimensione, 0, -4 * dimensione], risultato[8]);
    translate_solid([3 * dimensione, 0, -5 * dimensione], risultato[9]);
    translate_solid([3 * dimensione, 0, -6 * dimensione], risultato[10]);
    translate_solid([3 * dimensione, 0, -6 * dimensione], risultato[11]);
  }
  
  if (letter == "N") {
    for (var i = 0; i < 17; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }

translate_solid([0, 0, -dimensione], risultato[1]);
    translate_solid([0, 0, -2 * dimensione], risultato[2]);
    translate_solid([0, 0, -3 * dimensione], risultato[3]);
    translate_solid([0, 0, -4 * dimensione], risultato[4]);
    translate_solid([0, 0, -5 * dimensione], risultato[5]);
    translate_solid([0, 0, -6 * dimensione], risultato[6]);

translate_solid([dimensione, 0, -5 * dimensione], risultato[7]);
    translate_solid([2 * dimensione, 0, -4 * dimensione], risultato[8]);

translate_solid([3 * dimensione, 0, -3 * dimensione], risultato[9]);
    translate_solid([4 * dimensione, 0, -6 * dimensione], risultato[10]);

translate_solid([4 * dimensione, 0, -5 * dimensione], risultato[11]);
    translate_solid([4 * dimensione, 0, -4 * dimensione], risultato[12]);
    translate_solid([4 * dimensione, 0, -3 * dimensione], risultato[13]);
    translate_solid([4 * dimensione, 0, -2 * dimensione], risultato[14]);
    translate_solid([4 * dimensione, 0, -dimensione], risultato[15]);
    translate_solid([4 * dimensione, 0, 0], risultato[16]);
  }

if (letter == "T") {
    for (var i = 0; i < 11; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }

translate_solid([2 * dimensione, 0, 0], risultato[0]);
    translate_solid([2 * dimensione, 0, -dimensione], risultato[1]);
    translate_solid([2 * dimensione, 0, -2 * dimensione], risultato[2]);
    translate_solid([2 * dimensione, 0, -3 * dimensione], risultato[3]);
    translate_solid([2 * dimensione, 0, -4 * dimensione], risultato[4]);
    translate_solid([2 * dimensione, 0, -5 * dimensione], risultato[5]);
    translate_solid([2 * dimensione, 0, -6 * dimensione], risultato[6]);
    translate_solid([0, 0, -6 * dimensione], risultato[7]);
    translate_solid([dimensione, 0, -6 * dimensione], risultato[8]);
    translate_solid([3 * dimensione, 0, -6 * dimensione], risultato[9]);
    translate_solid([4 * dimensione, 0, -6 * dimensione], risultato[10]);
  }

if (letter == "U") {
    for (var i = 0; i < 17; i++) {
      risultato[i] = new cube(dimensione, fillcolor, linecolor);
    }

translate_solid([0, 0, -dimensione], risultato[1]);
    translate_solid([0, 0, -2 * dimensione], risultato[2]);
    translate_solid([0, 0, -3 * dimensione], risultato[3]);
    translate_solid([0, 0, -4 * dimensione], risultato[4]);
    translate_solid([0, 0, -5 * dimensione], risultato[5]);
    translate_solid([0, 0, -6 * dimensione], risultato[6]);

translate_solid([dimensione, 0, 0], risultato[7]);
    translate_solid([2 * dimensione, 0, 0], risultato[8]);
    translate_solid([3 * dimensione, 0, 0], risultato[9]);

translate_solid([3 * dimensione, 0, -dimensione], risultato[10]);
    translate_solid([3 * dimensione, 0, -2 * dimensione], risultato[11]);
    translate_solid([3 * dimensione, 0, -3 * dimensione], risultato[12]);
    translate_solid([3 * dimensione, 0, -4 * dimensione], risultato[13]);
    translate_solid([3 * dimensione, 0, -5 * dimensione], risultato[14]);
    translate_solid([3 * dimensione, 0, -6 * dimensione], risultato[15]);
    translate_solid([3 * dimensione, 0, -6 * dimensione], risultato[16]);
  }
  
  
  return risultato;

}

// transform.js

function rotate_x(center, sin_cos_angle, point) {
  var diff1 = point[1] - center[1];
  var diff2 = center[2] - point[2];

point[1] = center[1] + diff1 * sin_cos_angle[1] + diff2 * sin_cos_angle[0];
  point[2] = center[2] - diff2 * sin_cos_angle[1] + diff1 * sin_cos_angle[0];
}

function rotate_x_normal(sin_cos_angle, point) {
  var temp = point[1];

point[1] = temp * sin_cos_angle[1] - point[2] * sin_cos_angle[0];
  point[2] = point[2] * sin_cos_angle[1] + temp * sin_cos_angle[0];
}

function rotate_y(center, sin_cos_angle, point) {
  var diff1 = point[0] - center[0];
  var diff2 = point[2] - center[2];

point[0] = center[0] + diff1 * sin_cos_angle[1] + diff2 * sin_cos_angle[0];
  point[2] = center[2] + diff2 * sin_cos_angle[1] - diff1 * sin_cos_angle[0];
}

function rotate_y_normal(sin_cos_angle, point) {
  var temp = point[0];

point[0] = temp * sin_cos_angle[1] + point[2] * sin_cos_angle[0];
  point[2] = point[2] * sin_cos_angle[1] - temp * sin_cos_angle[0];
}

function rotate_z(center, sin_cos_angle, point) {
  var diff1 = point[0] - center[0];
  var diff2 = point[1] - center[1];

point[0] = center[0] + diff1 * sin_cos_angle[1] - diff2 * sin_cos_angle[0];
  point[1] = center[1] + diff2 * sin_cos_angle[1] + diff1 * sin_cos_angle[0];
}

function rotate_z_normal(sin_cos_angle, point) {
  var temp = point[0];

point[0] = temp * sin_cos_angle[1] - point[1] * sin_cos_angle[0];
  point[1] = point[1] * sin_cos_angle[1] + temp * sin_cos_angle[0];
}

function get_rotation_parameter(center, vector, teta) {
  var result = new Array();

var u_u = vector[0] * vector[0];
  var v_v = vector[1] * vector[1];
  var w_w = vector[2] * vector[2];

var v_v_p_w_w = (v_v + w_w);
  var u_u_p_w_w = (u_u + w_w);
  var u_u_p_v_v = (u_u + v_v);

var b_v_p_c_w = center[1] * vector[1] + center[2] * vector[2];
  var a_u_p_c_w = center[0] * vector[0] + center[2] * vector[2];
  var a_u_p_b_v = center[0] * vector[0] + center[1] * vector[1];

var b_w_m_c_v = center[1] * vector[2] - center[2] * vector[1];
  var c_u_m_a_w = center[2] * vector[0] - center[0] * vector[2];
  var a_v_m_b_u = center[0] * vector[1] - center[1] * vector[0];

var den = v_v + u_u + w_w;

result[0] = den;

result[1] = v_v_p_w_w;
  result[2] = u_u_p_w_w;
  result[3] = u_u_p_v_v;

result[4] = center[0] * v_v_p_w_w;
  result[5] = center[1] * u_u_p_w_w;
  result[6] = center[2] * u_u_p_v_v;

result[7] = b_v_p_c_w;
  result[8] = a_u_p_c_w;
  result[9] = a_u_p_b_v;

result[10] = Math.cos(teta);

result[11] = Math.sin(teta) * Math.sqrt(den);

result[12] = b_w_m_c_v;
  result[13] = c_u_m_a_w;
  result[14] = a_v_m_b_u;

result[15] = center[0];
  result[16] = center[1];
  result[17] = center[2];
  result[18] = vector[0];
  result[19] = vector[1];
  result[20] = vector[2];

return result;
}

function rotate(p, point) {
  var p_20_p_2 = p[20] * point[2];
  var p_19_p_1 = p[19] * point[1];
  var p_18_p_0 = p[18] * point[0];
  var u_x_p_v_y_p_w_z = p_18_p_0 + p_19_p_1 + p_20_p_2;

var temp0 = point[0];
  var temp1 = point[1];

point[0] = (p[4] + p[18] * (-p[7] + u_x_p_v_y_p_w_z) + ((temp0 - p[15]) * p[1] + p[18] * (p[7] - p_19_p_1 - p_20_p_2)) * p[10] + p[11] * (p[12] - p[20] * temp1 + p[19] * point[2])) / p[0];
  point[1] = (p[5] + p[19] * (-p[8] + u_x_p_v_y_p_w_z) + ((temp1 - p[16]) * p[2] + p[19] * (p[8] - p_18_p_0 - p_20_p_2)) * p[10] + p[11] * (p[13] + p[20] * temp0 - p[18] * point[2])) / p[0];
  point[2] = (p[6] + p[20] * (-p[9] + u_x_p_v_y_p_w_z) + ((point[2] - p[17]) * p[3] + p[20] * (p[9] - p_18_p_0 - p_19_p_1)) * p[10] + p[11] * (p[14] - p[19] * temp0 + p[18] * temp1)) / p[0];
}

function translate(vector, point) {
  point[0] = point[0] + vector[0];
  point[1] = point[1] + vector[1];
  point[2] = point[2] + vector[2];
}

function scale(vector, point) {
  point[0] = point[0] * vector[0];
  point[1] = point[1] * vector[1];
  point[2] = point[2] * vector[2];
}

function translate_solid(vector, solid) {
  translate(vector, solid.center);

for (var i = 0; i < solid.points_number; i++) {
    translate(vector, solid.points[i]);
  }
}

function translate_solid_direction(vector, delta, solid) {
  translate([vector[0] * delta, vector[1] * delta, vector[2] * delta], solid.center);

for (var i = 0; i < solid.points_number; i++) {
    translate([vector[0] * delta, vector[1] * delta, vector[2] * delta], solid.points[i]);
  }
}

function scale_solid(vector, solid) {
  var da = solid.center;
  var a = [-solid.center[0], -solid.center[1], -solid.center[2]];

translate_solid(a, solid);
  for (var i = 0; i < solid.points_number; i++) {
    scale(vector, solid.points[i]);
  }

translate_solid(da, solid);
}

function rotate_solid(point, vector, angle, solid) {
  parametri = get_rotation_parameter(point, vector, angle);
  parametri2 = get_rotation_parameter([0, 0, 0], vector, angle);

rotate(parametri, solid.center);
  rotate(parametri2, solid.axis_x);
  rotate(parametri2, solid.axis_y);
  rotate(parametri2, solid.axis_z);

for (var i = 0; i < solid.faces_number; i++) {
    rotate(parametri2, solid.normals[i]);
  }

for (var j = 0; j < solid.points_number; j++) {
    rotate(parametri, solid.points[j]);
  }
}

function rotate_solid_fast(parametri1, parametri2, solid) {
  rotate(parametri1, solid.center);
  rotate(parametri2, solid.axis_x);
  rotate(parametri2, solid.axis_y);
  rotate(parametri2, solid.axis_z);

for (var i = 0; i < solid.faces_number; i++) {
    rotate(parametri2, solid.normals[i]);
  }

for (var j = 0; j < solid.points_number; j++) {
    rotate(parametri1, solid.points[j]);
  }
}

function rotate_solid_x(center, angle, solid) {

var sin_cosin_teta = [Math.sin(angle), Math.cos(angle)];

rotate_x(center, sin_cosin_teta, solid.center);
  rotate_x_normal(sin_cosin_teta, solid.axis_x);
  rotate_x_normal(sin_cosin_teta, solid.axis_y);
  rotate_x_normal(sin_cosin_teta, solid.axis_z);

for (var i = 0; i < solid.faces_number; i++) {
    rotate_x_normal(sin_cosin_teta, solid.normals[i]);
  }

for (var j = 0; j < solid.points_number; j++) {
    rotate_x(center, sin_cosin_teta, solid.points[j]);
  }
}

function rotate_solid_y(center, angle, solid) {
  var sin_cosin_teta = [Math.sin(angle), Math.cos(angle)];

rotate_y(center, sin_cosin_teta, solid.center);
  rotate_y_normal(sin_cosin_teta, solid.axis_x);
  rotate_y_normal(sin_cosin_teta, solid.axis_y);
  rotate_y_normal(sin_cosin_teta, solid.axis_z);

for (var i = 0; i < solid.faces_number; i++) {
    rotate_y_normal(sin_cosin_teta, solid.normals[i]);
  }

for (var j = 0; j < solid.points_number; j++) {
    rotate_y(center, sin_cosin_teta, solid.points[j]);
  }
}

function rotate_solid_z(center, angle, solid) {
  var sin_cosin_teta = [Math.sin(angle), Math.cos(angle)];

rotate_z(center, sin_cosin_teta, solid.center);
  rotate_z_normal(sin_cosin_teta, solid.axis_x);
  rotate_z_normal(sin_cosin_teta, solid.axis_y);
  rotate_z_normal(sin_cosin_teta, solid.axis_z);

for (var i = 0; i < solid.faces_number; i++) {
    rotate_z_normal(sin_cosin_teta, solid.normals[i]);
  }

for (var j = 0; j < solid.points_number; j++) {
    rotate_z(center, sin_cosin_teta, solid.points[j]);
  }
}

function project(distance, point) {
  var result = new Array();

result[0] = point[0] * distance / point[2] + 500;
  result[1] = 300 - point[1] * distance / point[2];
  result[2] = distance;

return result;
}

// inline
function scene() {
  this.solid_number = 0;
  this.solid = new Array();
  this.observer = [0, 0, 0];
  this.distance = -650;
}

var world = new scene();

var caduta = new Array();
var oscillazione = new Array();
var cadente = 0;
var cadente2 = 0;
var iterazioni = 0;
var alpha = 1;
var teta_x_global = 0;
var teta_y_global = 0;

function init() {
  var lettera_f = get_letter("F", 10, [255, 20, 44], [0, 0, 0]);
  var lettera_i = get_letter("I", 10, [255, 255, 95], [0, 0, 0]);
  var lettera_r = get_letter("R", 10, [64, 175, 74], [0, 0, 0]);
  var lettera_e = get_letter("E", 10, [33, 133, 204], [0, 0, 0]);
  var lettera_j = get_letter("J", 10, [255, 20, 44], [0, 0, 0]);
  var lettera_u = get_letter("U", 10, [255, 255, 95], [0, 0, 0]);
  var lettera_n = get_letter("N", 10, [64, 175, 74], [0, 0, 0]);
  var lettera_e1 = get_letter("E", 10, [33, 133, 204], [0, 0, 0]);

for (var i = 0; i < lettera_f.length; i++) {
    translate_solid([-200, -50, -240], lettera_f[i]);
    world.solid[world.solid_number++] = lettera_f[i];
  }

for (var i = 0; i < lettera_i.length; i++) {
    translate_solid([-150, -50, -240], lettera_i[i]);
    world.solid[world.solid_number++] = lettera_i[i];
  }

for (var i = 0; i < lettera_r.length; i++) {
    translate_solid([-130, -50, -240], lettera_r[i]);
    world.solid[world.solid_number++] = lettera_r[i];
  }

for (var i = 0; i < lettera_e.length; i++) {
    translate_solid([-80, -50, -240], lettera_e[i]);
    world.solid[world.solid_number++] = lettera_e[i];
  }

for (var i = 0; i < lettera_j.length; i++) {
    translate_solid([-30, -50, -240], lettera_j[i]);
    world.solid[world.solid_number++] = lettera_j[i];
  }

for (var i = 0; i < lettera_u.length; i++) {
    translate_solid([20, -50, -240], lettera_u[i]);
    world.solid[world.solid_number++] = lettera_u[i];
  }

for (var i = 0; i < lettera_n.length; i++) {
    translate_solid([70, -50, -240], lettera_n[i]);
    world.solid[world.solid_number++] = lettera_n[i];
  }

for (var i = 0; i < lettera_e1.length; i++) {
    translate_solid([130, -50, -240], lettera_e1[i]);
    world.solid[world.solid_number++] = lettera_e1[i];
  }

parametri = get_rotation_parameter([0, 0, 0], [1, 0, 0], 0.8);

for (var i = 0; i < world.solid_number; i++) {
    rotate_solid_fast(parametri, parametri, world.solid[i]);
  }

for (var i = 0; i < world.solid_number; i++) {
    caduta[i] = 25;
    oscillazione[i] = 0;
  }

document.onkeydown = onKeyDown;
  document.onmousemove = onMouseMove;

setInterval(draw, 5);

}

function onKeyDown(evt) {
  if (evt.keyCode == 49) alpha = 0.1;
  if (evt.keyCode == 50) alpha = 0.2;
  if (evt.keyCode == 51) alpha = 0.3;
  if (evt.keyCode == 52) alpha = 0.4;
  if (evt.keyCode == 53) alpha = 0.5;
  if (evt.keyCode == 54) alpha = 0.6;
  if (evt.keyCode == 55) alpha = 0.7;
  if (evt.keyCode == 56) alpha = 0.8;
  if (evt.keyCode == 57) alpha = 0.9;
  if (evt.keyCode == 48) alpha = 1;
}

function onMouseMove(evt) {
  var x = evt.pageX - document.getElementById("display").offsetLeft;
  var y = evt.pageY - document.getElementById("display").offsetTop;

if ((x > 0) && (x < 1000) && (y > 0) && (y < 600)) {
    teta_y_global = 0.05 * (x - 500) / 500;
    teta_x_global = 0.05 * (y - 300) / 300;
  }

}

function draw() {
  var canvas = document.getElementById("display");

var parametrig1 = get_rotation_parameter([0, -200, -500], [0, 1, 0], teta_y_global);
  var parametrig2 = get_rotation_parameter([0, 0, 0], [0, 1, 0], teta_y_global);
  var parametrig1a = get_rotation_parameter([0, -200, -500], [1, 0, 0], teta_x_global);
  var parametrig2a = get_rotation_parameter([0, 0, 0], [1, 0, 0], teta_x_global);

for (var i = 0; i < world.solid_number; i++) {
    rotate_solid_fast(parametrig1, parametrig2, world.solid[i]);
    rotate_solid_fast(parametrig1a, parametrig2a, world.solid[i]);
  }

if (canvas.getContext) {
    var ctx = canvas.getContext("2d");

if (cadente < world.solid_number) {
      cadente++;
      for (var i = 0; i < cadente; i++) {
        if (caduta[i] > 0) {
          caduta[i]--;
          translate_solid_direction(world.solid[i].axis_y, -10, world.solid[i]);
        }
      }
    }
    else if (cadente2 == 0) {
      for (var i = 0; i < world.solid_number; i++) {
        if (caduta[i] > 0) {
          caduta[i]--;
          translate_solid_direction(world.solid[i].axis_y, -10, world.solid[i]);
        }
      }
    }

if ((caduta[world.solid_number - 1] == 0) && (iterazioni < 100)) {
      iterazioni++;
      var parametri1 = get_rotation_parameter([0, -200, -500], world.solid[0].axis_y, 2 * Math.PI / 50);
      var parametri2 = get_rotation_parameter([0, 0, 0], world.solid[0].axis_y, 2 * Math.PI / 50);
      var parametri1a = get_rotation_parameter([0, -200, -500], world.solid[0].axis_y, -2 * Math.PI / 100);
      var parametri2a = get_rotation_parameter([0, 0, 0], world.solid[0].axis_y, -2 * Math.PI / 100);
      var parametri1b = get_rotation_parameter([0, -200, -500], world.solid[0].axis_y, -2 * Math.PI / 50);
      var parametri2b = get_rotation_parameter([0, 0, 0], world.solid[0].axis_y, -2 * Math.PI / 50);
      var parametri1c = get_rotation_parameter([0, -200, -500], world.solid[0].axis_y, 2 * Math.PI / 25);
      var parametri2c = get_rotation_parameter([0, 0, 0], world.solid[0].axis_y, 2 * Math.PI / 25);
      var parametri1d = get_rotation_parameter([0, -200, -500], world.solid[0].axis_y, -2 * Math.PI / 25);
      var parametri2d = get_rotation_parameter([0, 0, 0], world.solid[0].axis_y, -2 * Math.PI / 25);
      var parametri1e = get_rotation_parameter([0, -200, -500], world.solid[0].axis_y, 2 * Math.PI / 100);
      var parametri2e = get_rotation_parameter([0, 0, 0], world.solid[0].axis_y, 2 * Math.PI / 100);
      var parametri1f = get_rotation_parameter([0, -200, -500], world.solid[0].axis_y, 2 * Math.PI / 20);
      var parametri2f = get_rotation_parameter([0, 0, 0], world.solid[0].axis_y, 2 * Math.PI / 20);
      var parametri1g = get_rotation_parameter([0, -200, -500], world.solid[0].axis_y, 2 * Math.PI / 20);
      var parametri2g = get_rotation_parameter([0, 0, 0], world.solid[0].axis_y, 2 * Math.PI / 20);

for (var i = 0; i < world.solid_number; i++) {
        if (i % 8 == 0) rotate_solid_fast(parametri1, parametri2, world.solid[i]);
        else if (i % 8 == 1) rotate_solid_fast(parametri1a, parametri2a, world.solid[i]);
        else if (i % 8 == 2) rotate_solid_fast(parametri1b, parametri2b, world.solid[i]);
        else if (i % 8 == 3) rotate_solid_fast(parametri1c, parametri2c, world.solid[i]);
        else if (i % 8 == 4) rotate_solid_fast(parametri1d, parametri2d, world.solid[i]);
        else if (i % 8 == 5) rotate_solid_fast(parametri1e, parametri2e, world.solid[i]);
        else if (i % 8 == 6) rotate_solid_fast(parametri1f, parametri2f, world.solid[i]);
        else rotate_solid_fast(parametri1g, parametri2g, world.solid[i]);
      }
    }

for (var i = 0; i < world.solid_number; i++) {
      if (caduta[i] == 0) {
        if (oscillazione[i] < 5) {
          translate_solid_direction(world.solid[i].axis_y, 0.5, world.solid[i]);
        }
        else {
          translate_solid_direction(world.solid[i].axis_y, -0.5, world.solid[i]);
        }
        oscillazione[i]++;
        if (oscillazione[i] == 10) {
          oscillazione[i] = 0;
        }
      }
    }

if (iterazioni == 100) {
      if (cadente2 < world.solid_number) {
        cadente2++;
        for (var i = 0; i < cadente2; i++) {
          if (caduta[i] < 25) {
            caduta[i]++;
            translate_solid_direction(world.solid[i].axis_y, 10, world.solid[i]);
          }
        }
      }
      else {
        for (var i = 0; i < world.solid_number; i++) {
          if (caduta[i] < 25) {
            caduta[i]++;
            translate_solid_direction(world.solid[i].axis_y, 10, world.solid[i]);
          }
        }
      }
    }

if ((iterazioni == 100) && (caduta[world.solid_number - 1] == 25) && (cadente2 == world.solid_number)) {
      iterazioni = 0;
      cadente = 0;
      cadente2 = 0;
    }

var contatore = 0;
    var visible_polygons = new Array();

var delta_x;
    var delta_y;
    var delta_z;

for (var j = 0; j < world.solid_number; j++) {
      for (var i = 0; i < world.solid[j].faces_number; i++) {
        delta_x = (world.solid[j].points[world.solid[j].faces[i][0]][0] + world.solid[j].points[world.solid[j].faces[i][2]][0]) / 2 - world.observer[0];
        delta_y = (world.solid[j].points[world.solid[j].faces[i][0]][1] + world.solid[j].points[world.solid[j].faces[i][2]][1]) / 2 - world.observer[1];
        delta_z = (world.solid[j].points[world.solid[j].faces[i][0]][2] + world.solid[j].points[world.solid[j].faces[i][2]][2]) / 2 - world.observer[2];

visible_polygons[contatore++] = {
          solid: j,
          vertex: world.solid[j].faces[i],
          fillcolor: world.solid[j].fillcolor,
          linecolor: world.solid[j].linecolor,
          distance: delta_x * delta_x + delta_y * delta_y + delta_z * delta_z
        };
      }
    }

visible_polygons.sort(sortfunction);

var projected_points = new Array();

for (var j = 0; j < world.solid_number; j++) {
      projected_points[j] = new Array();

for (var i = 0; i < world.solid[j].points_number; i++) {
        projected_points[j][i] = project(world.distance, world.solid[j].points[i]);
      }
    }

ctx.clearRect(0, 0, 1000, 600);
    for (var i = 0; i < contatore; i++) {
      ctx.fillStyle = 'rgb(' + visible_polygons[i].fillcolor[0] + ',' + visible_polygons[i].fillcolor[1] + ',' + visible_polygons[i].fillcolor[2] + ')';
      ctx.strokeStyle = 'rgb(' + visible_polygons[i].linecolor[0] + ',' + visible_polygons[i].linecolor[1] + ',' + visible_polygons[i].linecolor[2] + ')';
      ctx.globalAlpha = alpha;
      ctx.beginPath();
      ctx.moveTo(projected_points[visible_polygons[i].solid][visible_polygons[i].vertex[0]][0], projected_points[visible_polygons[i].solid][visible_polygons[i].vertex[0]][1]);
      ctx.lineTo(projected_points[visible_polygons[i].solid][visible_polygons[i].vertex[1]][0], projected_points[visible_polygons[i].solid][visible_polygons[i].vertex[1]][1]);
      ctx.lineTo(projected_points[visible_polygons[i].solid][visible_polygons[i].vertex[2]][0], projected_points[visible_polygons[i].solid][visible_polygons[i].vertex[2]][1]);
      ctx.lineTo(projected_points[visible_polygons[i].solid][visible_polygons[i].vertex[3]][0], projected_points[visible_polygons[i].solid][visible_polygons[i].vertex[3]][1]);
      ctx.closePath();
      ctx.fill();
      ctx.stroke();
    }
  }
}

function sortfunction(a, b) {
  return (b.distance - a.distance);
}