| Index: chrome/test/data/v8_benchmark/raytrace.js
|
| diff --git a/chrome/test/data/v8_benchmark/raytrace.js b/chrome/test/data/v8_benchmark/raytrace.js
|
| deleted file mode 100644
|
| index 971ef7218ee6a4060e11b8def5bbc00f4dc1a087..0000000000000000000000000000000000000000
|
| --- a/chrome/test/data/v8_benchmark/raytrace.js
|
| +++ /dev/null
|
| @@ -1,904 +0,0 @@
|
| -// 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.
|
| -
|
| -var RayTrace = new BenchmarkSuite('RayTrace', 739989, [
|
| - new Benchmark('RayTrace', renderScene)
|
| -]);
|
| -
|
| -
|
| -// 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);
|
| - },
|
| -
|
| - 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.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);
|
| - var v = info.position.dot(vV);
|
| - info.color = this.material.getColor(u,v);
|
| - } else {
|
| - info.color = this.material.getColor(0,0);
|
| - }
|
| -
|
| - return info;
|
| - },
|
| -
|
| - toString : function () {
|
| - return 'Plane [' + this.position + ', d=' + this.d + ']';
|
| - }
|
| -}
|
| -/* Fake a Flog.* namespace */
|
| -if(typeof(Flog) == 'undefined') var Flog = {};
|
| -if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
| -
|
| -Flog.RayTracer.IntersectionInfo = Class.create();
|
| -
|
| -Flog.RayTracer.IntersectionInfo.prototype = {
|
| - isHit: false,
|
| - hitCount: 0,
|
| - shape: null,
|
| - position: null,
|
| - normal: null,
|
| - color: null,
|
| - distance: null,
|
| -
|
| - initialize : function() {
|
| - this.color = new Flog.RayTracer.Color(0,0,0);
|
| - },
|
| -
|
| - toString : function () {
|
| - return 'Intersection [' + this.position + ']';
|
| - }
|
| -}
|
| -/* Fake a Flog.* namespace */
|
| -if(typeof(Flog) == 'undefined') var Flog = {};
|
| -if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
| -
|
| -Flog.RayTracer.Camera = Class.create();
|
| -
|
| -Flog.RayTracer.Camera.prototype = {
|
| - position: null,
|
| - lookAt: null,
|
| - equator: null,
|
| - up: null,
|
| - screen: null,
|
| -
|
| - initialize : function(pos, lookAt, up) {
|
| - this.position = pos;
|
| - this.lookAt = lookAt;
|
| - this.up = up;
|
| - this.equator = lookAt.normalize().cross(this.up);
|
| - this.screen = Flog.RayTracer.Vector.prototype.add(this.position, this.lookAt);
|
| - },
|
| -
|
| - getRay: function(vx, vy){
|
| - var pos = Flog.RayTracer.Vector.prototype.subtract(
|
| - this.screen,
|
| - Flog.RayTracer.Vector.prototype.subtract(
|
| - Flog.RayTracer.Vector.prototype.multiplyScalar(this.equator, vx),
|
| - Flog.RayTracer.Vector.prototype.multiplyScalar(this.up, vy)
|
| - )
|
| - );
|
| - pos.y = pos.y * -1;
|
| - var dir = Flog.RayTracer.Vector.prototype.subtract(
|
| - pos,
|
| - this.position
|
| - );
|
| -
|
| - var ray = new Flog.RayTracer.Ray(pos, dir.normalize());
|
| -
|
| - return ray;
|
| - },
|
| -
|
| - toString : function () {
|
| - return 'Ray []';
|
| - }
|
| -}
|
| -/* Fake a Flog.* namespace */
|
| -if(typeof(Flog) == 'undefined') var Flog = {};
|
| -if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
| -
|
| -Flog.RayTracer.Background = Class.create();
|
| -
|
| -Flog.RayTracer.Background.prototype = {
|
| - color : null,
|
| - ambience : 0.0,
|
| -
|
| - initialize : function(color, ambience) {
|
| - this.color = color;
|
| - this.ambience = ambience;
|
| - }
|
| -}
|
| -/* Fake a Flog.* namespace */
|
| -if(typeof(Flog) == 'undefined') var Flog = {};
|
| -if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
| -
|
| -Flog.RayTracer.Engine = Class.create();
|
| -
|
| -Flog.RayTracer.Engine.prototype = {
|
| - canvas: null, /* 2d context we can render to */
|
| -
|
| - initialize: function(options){
|
| - this.options = Object.extend({
|
| - canvasHeight: 100,
|
| - canvasWidth: 100,
|
| - pixelWidth: 2,
|
| - pixelHeight: 2,
|
| - renderDiffuse: false,
|
| - renderShadows: false,
|
| - renderHighlights: false,
|
| - renderReflections: false,
|
| - rayDepth: 2
|
| - }, options || {});
|
| -
|
| - this.options.canvasHeight /= this.options.pixelHeight;
|
| - this.options.canvasWidth /= this.options.pixelWidth;
|
| -
|
| - /* TODO: dynamically include other scripts */
|
| - },
|
| -
|
| - setPixel: function(x, y, color){
|
| - var pxW, pxH;
|
| - pxW = this.options.pixelWidth;
|
| - pxH = this.options.pixelHeight;
|
| -
|
| - if (this.canvas) {
|
| - this.canvas.fillStyle = color.toString();
|
| - this.canvas.fillRect (x * pxW, y * pxH, pxW, pxH);
|
| - } else {
|
| - if (x === y) {
|
| - checkNumber += color.brightness();
|
| - }
|
| - // print(x * pxW, y * pxH, pxW, pxH);
|
| - }
|
| - },
|
| -
|
| - renderScene: function(scene, canvas){
|
| - checkNumber = 0;
|
| - /* Get canvas */
|
| - if (canvas) {
|
| - this.canvas = canvas.getContext("2d");
|
| - } else {
|
| - this.canvas = null;
|
| - }
|
| -
|
| - var canvasHeight = this.options.canvasHeight;
|
| - var canvasWidth = this.options.canvasWidth;
|
| -
|
| - for(var y=0; y < canvasHeight; y++){
|
| - for(var x=0; x < canvasWidth; x++){
|
| - var yp = y * 1.0 / canvasHeight * 2 - 1;
|
| - var xp = x * 1.0 / canvasWidth * 2 - 1;
|
| -
|
| - var ray = scene.camera.getRay(xp, yp);
|
| -
|
| - var color = this.getPixelColor(ray, scene);
|
| -
|
| - this.setPixel(x, y, color);
|
| - }
|
| - }
|
| - if (checkNumber !== 2321) {
|
| - throw new Error("Scene rendered incorrectly");
|
| - }
|
| - },
|
| -
|
| - getPixelColor: function(ray, scene){
|
| - var info = this.testIntersection(ray, scene, null);
|
| - if(info.isHit){
|
| - var color = this.rayTrace(info, ray, scene, 0);
|
| - return color;
|
| - }
|
| - return scene.background.color;
|
| - },
|
| -
|
| - testIntersection: function(ray, scene, exclude){
|
| - var hits = 0;
|
| - var best = new Flog.RayTracer.IntersectionInfo();
|
| - best.distance = 2000;
|
| -
|
| - for(var i=0; i<scene.shapes.length; i++){
|
| - var shape = scene.shapes[i];
|
| -
|
| - if(shape != exclude){
|
| - var info = shape.intersect(ray);
|
| - if(info.isHit && info.distance >= 0 && info.distance < best.distance){
|
| - best = info;
|
| - hits++;
|
| - }
|
| - }
|
| - }
|
| - best.hitCount = hits;
|
| - return best;
|
| - },
|
| -
|
| - getReflectionRay: function(P,N,V){
|
| - var c1 = -N.dot(V);
|
| - var R1 = Flog.RayTracer.Vector.prototype.add(
|
| - Flog.RayTracer.Vector.prototype.multiplyScalar(N, 2*c1),
|
| - V
|
| - );
|
| - return new Flog.RayTracer.Ray(P, R1);
|
| - },
|
| -
|
| - rayTrace: function(info, ray, scene, depth){
|
| - // Calc ambient
|
| - var color = Flog.RayTracer.Color.prototype.multiplyScalar(info.color, scene.background.ambience);
|
| - var oldColor = color;
|
| - var shininess = Math.pow(10, info.shape.material.gloss + 1);
|
| -
|
| - for(var i=0; i<scene.lights.length; i++){
|
| - var light = scene.lights[i];
|
| -
|
| - // Calc diffuse lighting
|
| - var v = Flog.RayTracer.Vector.prototype.subtract(
|
| - light.position,
|
| - info.position
|
| - ).normalize();
|
| -
|
| - if(this.options.renderDiffuse){
|
| - var L = v.dot(info.normal);
|
| - if(L > 0.0){
|
| - color = Flog.RayTracer.Color.prototype.add(
|
| - color,
|
| - Flog.RayTracer.Color.prototype.multiply(
|
| - info.color,
|
| - Flog.RayTracer.Color.prototype.multiplyScalar(
|
| - light.color,
|
| - L
|
| - )
|
| - )
|
| - );
|
| - }
|
| - }
|
| -
|
| - // The greater the depth the more accurate the colours, but
|
| - // this is exponentially (!) expensive
|
| - if(depth <= this.options.rayDepth){
|
| - // calculate reflection ray
|
| - if(this.options.renderReflections && info.shape.material.reflection > 0)
|
| - {
|
| - var reflectionRay = this.getReflectionRay(info.position, info.normal, ray.direction);
|
| - var refl = this.testIntersection(reflectionRay, scene, info.shape);
|
| -
|
| - if (refl.isHit && refl.distance > 0){
|
| - refl.color = this.rayTrace(refl, reflectionRay, scene, depth + 1);
|
| - } else {
|
| - refl.color = scene.background.color;
|
| - }
|
| -
|
| - color = Flog.RayTracer.Color.prototype.blend(
|
| - color,
|
| - refl.color,
|
| - info.shape.material.reflection
|
| - );
|
| - }
|
| -
|
| - // Refraction
|
| - /* TODO */
|
| - }
|
| -
|
| - /* Render shadows and highlights */
|
| -
|
| - var shadowInfo = new Flog.RayTracer.IntersectionInfo();
|
| -
|
| - if(this.options.renderShadows){
|
| - var shadowRay = new Flog.RayTracer.Ray(info.position, v);
|
| -
|
| - shadowInfo = this.testIntersection(shadowRay, scene, info.shape);
|
| - if(shadowInfo.isHit && shadowInfo.shape != info.shape /*&& shadowInfo.shape.type != 'PLANE'*/){
|
| - var vA = Flog.RayTracer.Color.prototype.multiplyScalar(color, 0.5);
|
| - var dB = (0.5 * Math.pow(shadowInfo.shape.material.transparency, 0.5));
|
| - color = Flog.RayTracer.Color.prototype.addScalar(vA,dB);
|
| - }
|
| - }
|
| -
|
| - // Phong specular highlights
|
| - if(this.options.renderHighlights && !shadowInfo.isHit && info.shape.material.gloss > 0){
|
| - var Lv = Flog.RayTracer.Vector.prototype.subtract(
|
| - info.shape.position,
|
| - light.position
|
| - ).normalize();
|
| -
|
| - var E = Flog.RayTracer.Vector.prototype.subtract(
|
| - scene.camera.position,
|
| - info.shape.position
|
| - ).normalize();
|
| -
|
| - var H = Flog.RayTracer.Vector.prototype.subtract(
|
| - E,
|
| - Lv
|
| - ).normalize();
|
| -
|
| - var glossWeight = Math.pow(Math.max(info.normal.dot(H), 0), shininess);
|
| - color = Flog.RayTracer.Color.prototype.add(
|
| - Flog.RayTracer.Color.prototype.multiplyScalar(light.color, glossWeight),
|
| - color
|
| - );
|
| - }
|
| - }
|
| - color.limit();
|
| - return color;
|
| - }
|
| -};
|
| -
|
| -
|
| -function renderScene(){
|
| - var scene = new Flog.RayTracer.Scene();
|
| -
|
| - scene.camera = new Flog.RayTracer.Camera(
|
| - new Flog.RayTracer.Vector(0, 0, -15),
|
| - new Flog.RayTracer.Vector(-0.2, 0, 5),
|
| - new Flog.RayTracer.Vector(0, 1, 0)
|
| - );
|
| -
|
| - scene.background = new Flog.RayTracer.Background(
|
| - new Flog.RayTracer.Color(0.5, 0.5, 0.5),
|
| - 0.4
|
| - );
|
| -
|
| - var sphere = new Flog.RayTracer.Shape.Sphere(
|
| - new Flog.RayTracer.Vector(-1.5, 1.5, 2),
|
| - 1.5,
|
| - new Flog.RayTracer.Material.Solid(
|
| - new Flog.RayTracer.Color(0,0.5,0.5),
|
| - 0.3,
|
| - 0.0,
|
| - 0.0,
|
| - 2.0
|
| - )
|
| - );
|
| -
|
| - var sphere1 = new Flog.RayTracer.Shape.Sphere(
|
| - new Flog.RayTracer.Vector(1, 0.25, 1),
|
| - 0.5,
|
| - new Flog.RayTracer.Material.Solid(
|
| - new Flog.RayTracer.Color(0.9,0.9,0.9),
|
| - 0.1,
|
| - 0.0,
|
| - 0.0,
|
| - 1.5
|
| - )
|
| - );
|
| -
|
| - var plane = new Flog.RayTracer.Shape.Plane(
|
| - new Flog.RayTracer.Vector(0.1, 0.9, -0.5).normalize(),
|
| - 1.2,
|
| - new Flog.RayTracer.Material.Chessboard(
|
| - new Flog.RayTracer.Color(1,1,1),
|
| - new Flog.RayTracer.Color(0,0,0),
|
| - 0.2,
|
| - 0.0,
|
| - 1.0,
|
| - 0.7
|
| - )
|
| - );
|
| -
|
| - scene.shapes.push(plane);
|
| - scene.shapes.push(sphere);
|
| - scene.shapes.push(sphere1);
|
| -
|
| - var light = new Flog.RayTracer.Light(
|
| - new Flog.RayTracer.Vector(5, 10, -1),
|
| - new Flog.RayTracer.Color(0.8, 0.8, 0.8)
|
| - );
|
| -
|
| - var light1 = new Flog.RayTracer.Light(
|
| - new Flog.RayTracer.Vector(-3, 5, -15),
|
| - new Flog.RayTracer.Color(0.8, 0.8, 0.8),
|
| - 100
|
| - );
|
| -
|
| - scene.lights.push(light);
|
| - scene.lights.push(light1);
|
| -
|
| - var imageWidth = 100; // $F('imageWidth');
|
| - var imageHeight = 100; // $F('imageHeight');
|
| - var pixelSize = "5,5".split(','); // $F('pixelSize').split(',');
|
| - var renderDiffuse = true; // $F('renderDiffuse');
|
| - var renderShadows = true; // $F('renderShadows');
|
| - var renderHighlights = true; // $F('renderHighlights');
|
| - var renderReflections = true; // $F('renderReflections');
|
| - var rayDepth = 2;//$F('rayDepth');
|
| -
|
| - var raytracer = new Flog.RayTracer.Engine(
|
| - {
|
| - canvasWidth: imageWidth,
|
| - canvasHeight: imageHeight,
|
| - pixelWidth: pixelSize[0],
|
| - pixelHeight: pixelSize[1],
|
| - "renderDiffuse": renderDiffuse,
|
| - "renderHighlights": renderHighlights,
|
| - "renderShadows": renderShadows,
|
| - "renderReflections": renderReflections,
|
| - "rayDepth": rayDepth
|
| - }
|
| - );
|
| -
|
| - raytracer.renderScene(scene, null, 0);
|
| -}
|
|
|