| // 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); | |
| } |