// The ray tracer code in this file is written by Adam Burmister. It

// is available in its original form from:

//

//   http://labs.flog.nz.co/raytracer/

//

// It has been modified slightly by Google to work as a standalone

// benchmark, but the all the computational code remains

// untouched. This file also contains a copy of parts of the Prototype

// JavaScript framework which is used by the ray tracer.

// Variable used to hold a number that can be used to verify that

// the scene was ray traced correctly.

var checkNumber;

// ------------------------------------------------------------------------

// ------------------------------------------------------------------------

// The following is a copy of parts of the Prototype JavaScript library:

// Prototype JavaScript framework, version 1.5.0

// (c) 2005-2007 Sam Stephenson

//

// Prototype is freely distributable under the terms of an MIT-style license.

// For details, see the Prototype web site: http://prototype.conio.net/

var Class = {

  create: function() {

    return function() {

      this.initialize.apply(this, arguments);

    }

  }

};

Object.extend = function(destination, source) {

  for (var property in source) {

    destination[property] = source[property];

  }

  return destination;

};

// ------------------------------------------------------------------------

// ------------------------------------------------------------------------

// The rest of this file is the actual ray tracer written by Adam

// Burmister. It's a concatenation of the following files:

//

//   flog/color.js

//   flog/light.js

//   flog/vector.js

//   flog/ray.js

//   flog/scene.js

//   flog/material/basematerial.js

//   flog/material/solid.js

//   flog/material/chessboard.js

//   flog/shape/baseshape.js

//   flog/shape/sphere.js

//   flog/shape/plane.js

//   flog/intersectioninfo.js

//   flog/camera.js

//   flog/background.js

//   flog/engine.js

/* Fake a Flog.* namespace */

if(typeof(Flog) == 'undefined') var Flog = {};

if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Color = Class.create();

Flog.RayTracer.Color.prototype = {

    red : 0.0,

    green : 0.0,

    blue : 0.0,

    initialize : function(r, g, b) {

        if(!r) r = 0.0;

        if(!g) g = 0.0;

        if(!b) b = 0.0;

        this.red = r;

        this.green = g;

        this.blue = b;

    },

    add : function(c1, c2){

        var result = new Flog.RayTracer.Color(0,0,0);

        result.red = c1.red + c2.red;

        result.green = c1.green + c2.green;

        result.blue = c1.blue + c2.blue;

        return result;

    },

    addScalar: function(c1, s){

        var result = new Flog.RayTracer.Color(0,0,0);

        result.red = c1.red + s;

        result.green = c1.green + s;

        result.blue = c1.blue + s;

        result.limit();

        return result;

    },

    subtract: function(c1, c2){

        var result = new Flog.RayTracer.Color(0,0,0);

        result.red = c1.red - c2.red;

        result.green = c1.green - c2.green;

        result.blue = c1.blue - c2.blue;

        return result;

    },

    multiply : function(c1, c2) {

        var result = new Flog.RayTracer.Color(0,0,0);

        result.red = c1.red * c2.red;

        result.green = c1.green * c2.green;

        result.blue = c1.blue * c2.blue;

        return result;

    },

    multiplyScalar : function(c1, f) {

        var result = new Flog.RayTracer.Color(0,0,0);

        result.red = c1.red * f;

        result.green = c1.green * f;

        result.blue = c1.blue * f;

        return result;

    },

    divideFactor : function(c1, f) {

        var result = new Flog.RayTracer.Color(0,0,0);

        result.red = c1.red / f;

        result.green = c1.green / f;

        result.blue = c1.blue / f;

        return result;

    },

    limit: function(){

        this.red = (this.red > 0.0) ? ( (this.red > 1.0) ? 1.0 : this.red ) : 0.0;

        this.green = (this.green > 0.0) ? ( (this.green > 1.0) ? 1.0 : this.green ) : 0.0;

        this.blue = (this.blue > 0.0) ? ( (this.blue > 1.0) ? 1.0 : this.blue ) : 0.0;

    },

    distance : function(color) {

        var d = Math.abs(this.red - color.red) + Math.abs(this.green - color.green) + Math.abs(this.blue - color.blue);

        return d;

    },

    blend: function(c1, c2, w){

        var result = new Flog.RayTracer.Color(0,0,0);

        result = Flog.RayTracer.Color.prototype.add(

                    Flog.RayTracer.Color.prototype.multiplyScalar(c1, 1 - w),

                    Flog.RayTracer.Color.prototype.multiplyScalar(c2, w)

                  );

        return result;

    },

    brightness : function() {

        var r = Math.floor(this.red*255);

        var g = Math.floor(this.green*255);

        var b = Math.floor(this.blue*255);

        return (r * 77 + g * 150 + b * 29) >> 8;

    },

    toString : function () {

        var r = Math.floor(this.red*255);

        var g = Math.floor(this.green*255);

        var b = Math.floor(this.blue*255);

        return "rgb("+ r +","+ g +","+ b +")";

    }

}

/* Fake a Flog.* namespace */

if(typeof(Flog) == 'undefined') var Flog = {};

if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Light = Class.create();

Flog.RayTracer.Light.prototype = {

    position: null,

    color: null,

    intensity: 10.0,

    initialize : function(pos, color, intensity) {

        this.position = pos;

        this.color = color;

        this.intensity = (intensity ? intensity : 10.0);

    },

    getIntensity: function(distance){

        if(distance >= intensity) return 0;

        return Math.pow((intensity - distance) / strength, 0.2);

    },

    toString : function () {

        return 'Light [' + this.position.x + ',' + this.position.y + ',' + this.position.z + ']';

    }

}

/* Fake a Flog.* namespace */

if(typeof(Flog) == 'undefined') var Flog = {};

if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Vector = Class.create();

Flog.RayTracer.Vector.prototype = {

    x : 0.0,

    y : 0.0,

    z : 0.0,

    initialize : function(x, y, z) {

        this.x = (x ? x : 0);

        this.y = (y ? y : 0);

        this.z = (z ? z : 0);

    },

    copy: function(vector){

        this.x = vector.x;

        this.y = vector.y;

        this.z = vector.z;

    },

    normalize : function() {

        var m = this.magnitude();

        return new Flog.RayTracer.Vector(this.x / m, this.y / m, this.z / m);

    },

    magnitude : function() {

        return Math.sqrt((this.x * this.x) + (this.y * this.y) + (this.z * this.z));

    },

    cross : function(w) {

        return new Flog.RayTracer.Vector(

                                            -this.z * w.y + this.y * w.z,

                                           this.z * w.x - this.x * w.z,

                                          -this.y * w.x + this.x * w.y);

    },

    dot : function(w) {

        return this.x * w.x + this.y * w.y + this.z * w.z;

    },

    add : function(v, w) {

        return new Flog.RayTracer.Vector(w.x + v.x, w.y + v.y, w.z + v.z);

    },

    subtract : function(v, w) {

        if(!w || !v) throw 'Vectors must be defined [' + v + ',' + w + ']';

        return new Flog.RayTracer.Vector(v.x - w.x, v.y - w.y, v.z - w.z);

    },

    multiplyVector : function(v, w) {

        return new Flog.RayTracer.Vector(v.x * w.x, v.y * w.y, v.z * w.z);

    },

    multiplyScalar : function(v, w) {

        return new Flog.RayTracer.Vector(v.x * w, v.y * w, v.z * w);

    },

    toString : function () {

        return 'Vector [' + this.x + ',' + this.y + ',' + this.z + ']';

    }

}

/* Fake a Flog.* namespace */

if(typeof(Flog) == 'undefined') var Flog = {};

if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Ray = Class.create();

Flog.RayTracer.Ray.prototype = {

    position : null,

    direction : null,

    initialize : function(pos, dir) {

        this.position = pos;

        this.direction = dir;

    },

    toString : function () {

        return 'Ray [' + this.position + ',' + this.direction + ']';

    }

}

/* Fake a Flog.* namespace */

if(typeof(Flog) == 'undefined') var Flog = {};

if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Scene = Class.create();

Flog.RayTracer.Scene.prototype = {

    camera : null,

    shapes : [],

    lights : [],

    background : null,

    initialize : function() {

        this.camera = new Flog.RayTracer.Camera(

            new Flog.RayTracer.Vector(0,0,-5),

            new Flog.RayTracer.Vector(0,0,1),

            new Flog.RayTracer.Vector(0,1,0)

        );

        this.shapes = new Array();

        this.lights = new Array();

        this.background = new Flog.RayTracer.Background(new Flog.RayTracer.Color(0,0,0.5), 0.2);

    }

}

/* Fake a Flog.* namespace */

if(typeof(Flog) == 'undefined') var Flog = {};

if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

if(typeof(Flog.RayTracer.Material) == 'undefined') Flog.RayTracer.Material = {};

Flog.RayTracer.Material.BaseMaterial = Class.create();

Flog.RayTracer.Material.BaseMaterial.prototype = {

    gloss: 2.0,             // [0...infinity] 0 = matt

    transparency: 0.0,      // 0=opaque

    reflection: 0.0,        // [0...infinity] 0 = no reflection

    refraction: 0.50,

    hasTexture: false,

    initialize : function() {

    },

    getColor: function(u, v){

    },

    wrapUp: function(t){

        t = t % 2.0;

        if(t < -1) t += 2.0;

        if(t >= 1) t -= 2.0;

        return t;

    },

    toString : function () {

        return 'Material [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture +']';

    }

}

/* Fake a Flog.* namespace */

if(typeof(Flog) == 'undefined') var Flog = {};

if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Material.Solid = Class.create();

Flog.RayTracer.Material.Solid.prototype = Object.extend(

    new Flog.RayTracer.Material.BaseMaterial(), {

        initialize : function(color, reflection, refraction, transparency, gloss) {

            this.color = color;

            this.reflection = reflection;

            this.transparency = transparency;

            this.gloss = gloss;

            this.hasTexture = false;

        },

        getColor: function(u, v){

            return this.color;

        },

        toString : function () {

            return 'SolidMaterial [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture +']';

        }

    }

);

/* Fake a Flog.* namespace */

if(typeof(Flog) == 'undefined') var Flog = {};

if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

Flog.RayTracer.Material.Chessboard = Class.create();

Flog.RayTracer.Material.Chessboard.prototype = Object.extend(

    new Flog.RayTracer.Material.BaseMaterial(), {

        colorEven: null,

        colorOdd: null,

        density: 0.5,

        initialize : function(colorEven, colorOdd, reflection, transparency, gloss, density) {

            this.colorEven = colorEven;

            this.colorOdd = colorOdd;

            this.reflection = reflection;

            this.transparency = transparency;

            this.gloss = gloss;

            this.density = density;

            this.hasTexture = true;

        },

        getColor: function(u, v){

            var t = this.wrapUp(u * this.density) * this.wrapUp(v * this.density);

            if(t < 0.0)

                return this.colorEven;

            else

                return this.colorOdd;

        },

        toString : function () {

            return 'ChessMaterial [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture +']';

        }

    }

);

/* Fake a Flog.* namespace */

if(typeof(Flog) == 'undefined') var Flog = {};

if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

if(typeof(Flog.RayTracer.Shape) == 'undefined') Flog.RayTracer.Shape = {};

Flog.RayTracer.Shape.BaseShape = Class.create();

Flog.RayTracer.Shape.BaseShape.prototype = {

    position: null,

    material: null,

    initialize : function() {

        this.position = new Vector(0,0,0);

        this.material = new Flog.RayTracer.Material.SolidMaterial(

            new Flog.RayTracer.Color(1,0,1),

            0,

            0,

            0

        );

    },

    toString : function () {

        return 'Material [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture +']';

    }

}

/* Fake a Flog.* namespace */

if(typeof(Flog) == 'undefined') var Flog = {};

if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

if(typeof(Flog.RayTracer.Shape) == 'undefined') Flog.RayTracer.Shape = {};

Flog.RayTracer.Shape.Sphere = Class.create();

Flog.RayTracer.Shape.Sphere.prototype = {

    initialize : function(pos, radius, material) {

        this.radius = radius;

        this.position = pos;

        this.material = material;

    },

    intersect: function(ray){

        var info = new Flog.RayTracer.IntersectionInfo();

        info.shape = this;

        var dst = Flog.RayTracer.Vector.prototype.subtract(ray.position, this.position);

        var B = dst.dot(ray.direction);

        var C = dst.dot(dst) - (this.radius * this.radius);

        var D = (B * B) - C;

        if(D > 0){ // intersection!

            info.isHit = true;

            info.distance = (-B) - Math.sqrt(D);

            info.position = Flog.RayTracer.Vector.prototype.add(

                                                ray.position,

                                                Flog.RayTracer.Vector.prototype.multiplyScalar(

                                                    ray.direction,

                                                    info.distance

                                                )

                                            );

            info.normal = Flog.RayTracer.Vector.prototype.subtract(

                                            info.position,

                                            this.position

                                        ).normalize();

            info.color = this.material.getColor(0,0);

        } else {

            info.isHit = false;

        }

        return info;

    },

    toString : function () {

        return 'Sphere [position=' + this.position + ', radius=' + this.radius + ']';

    }

}

/* Fake a Flog.* namespace */

if(typeof(Flog) == 'undefined') var Flog = {};

if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};

if(typeof(Flog.RayTracer.Shape) == 'undefined') Flog.RayTracer.Shape = {};

Flog.RayTracer.Shape.Plane = Class.create();

Flog.RayTracer.Shape.Plane.prototype = {

    d: 0.0,

    initialize : function(pos, d, material) {

        this.position = pos;

        this.d = d;

        this.material = material;

    },

    intersect: function(ray){

        var info = new Flog.RayTracer.IntersectionInfo();

        var Vd = this.position.dot(ray.direction);

        if(Vd == 0) return info; // no intersection

        var t = -(this.position.dot(ray.position) + this.d) / Vd;

        if(t <= 0) return info;

        info.shape = this;

        info.isHit = true;

        info.position = Flog.RayTracer.Vector.prototype.add(

                                            ray.position,

                                            Flog.RayTracer.Vector.prototype.multiplyScalar(

                                                ray.direction,

                                                t

                                            )

                                        );

        info.normal = this.position;

        info.distance = t;

        if(this.material.hasTexture){

            var vU = new Flog.RayTracer.Vector(this.position.y, this.position.z, -this.position.x);

            var vV = vU.cross(this.position);

            var u = info.position.dot(vU);