Viewing Program

Program Data

Program thumbnail for "{props.program.title}"

Title	smallpt
ID	938524741
Created	12 years ago, 1352757106701
Updated	12 years ago, 1348088142916
Code	// smallpt ray tracer, translated directly from // http://www.kevinbeason.com/smallpt/ // // Standard three dimensional vector class var Vec = function(x, y, z) { this.x = x; this.y = y; this.z = z; }; Vec.prototype = { // Vector addition plus: function(b) { return new Vec(this.x + b.x, this.y + b.y, this.z + b.z); }, // Vector subraction // equivalently: return this.minus(b.times(-1)); minus: function(b) { return new Vec(this.x - b.x, this.y - b.y, this.z - b.z); }, // Scalar multiplication times: function(b) { return new Vec(this.x * b, this.y * b, this.z * b); }, // Pointwise multiplication - aka Hadamard product mult: function(b) { return new Vec(this.x * b.x, this.y * b.y, this.z * b.z); }, // Normalize the vector - return a vector pointing in the // same direction with length 1 norm: function() { // div = 1 / (length of this vector) var div = 1 / sqrt(this.x * this.x + this.y * this.y + this.z * this.z); return this.times(div); }, // Dot product - describes the angle between two vectors dot: function(b) { return this.x * b.x + this.y * b.y + this.z * b.z; }, // Cross product - given two vectors return a third that // is perpendicular to both cross: function(b) { return new Vec(this.y * b.z - this.z * b.y, this.z * b.x - this.x * b.z, this.x * b.y - this.y * b.x); } }; // Represents a ray of light var Ray = function(origin, direction) { this.origin = origin; this.direction = direction; }; // Reflection types var diff = 0, // diffuse - random scattering spec = 1, // specular - mirror-like reflection refr = 2; // refractive - passing through an optical medium // In this model a sphere has several properties. Any sphere // always has a radius and a position. Due to our rendering // model we also allow a sphere to have emission - light // coming out of it, a color, and one of the three reflection // types we just defined. For example the walls are diffuse, // the shiny ball is specular and the glass ball is refractive. // Spheres are all we need to model the entire scene because // the walls are just spheres that are so large they look flat. var Sphere = function(radius, position, emission, color, reflectionType) { this.radius = radius; this.position = position; this.emission = emission; this.color = color; this.reflectionType = reflectionType; }; Sphere.prototype = { // Ray/sphere intersection - returns the distance to // intersection if there is one or null if not. // A ray / sphere can have 0, 1, or 2 points of // intersection. Kind of like... a quadratic equation. // In fact we can use the quadratic formula to find the // solution. intersect: function(ray) { // op = origin/position = the vector from the ray's // origin to the sphere's position var op = this.position.minus(ray.origin), tmp, eps = 1e-4, // margin of error // b is one of the terms in the discriminant, // b^2 - 4ac b = op.dot(ray.direction), discriminant = bb - op.dot(op) + this.radius this.radius; // Discriminant is negative, the ray missed the // sphere if (discriminant < 0) { return null; } else { discriminant = sqrt(discriminant); } // Try out both solutions to the quadratic formula, // this is the first. tmp = b - discriminant; if (tmp > eps) { return tmp; } // And this is the second. tmp = b + discriminant; if (tmp > eps) { return tmp; } // The sphere is behind the ray return null; } }; // Just for convenience, because we often need this color. var black = function(){ return new Vec(0, 0, 0); }; // This is the scene! Remember the order of parameters goes: // radius, position, emission, color, reflectionType. var spheres = [ // Left new Sphere(1e5, new Vec(1e5+1, 40.8, 81.6), black(), new Vec(0.75, 0.25, 0.25), diff), // Right new Sphere(1e5, new Vec(-1e5+99, 40.8, 81.6), black(), new Vec(0.25, 0.25, 0.75), diff), // Back new Sphere(1e5, new Vec(50, 40.8, 1e5), black(), new Vec(0.75, 0.75, 0.75), diff), // Front new Sphere(1e5, new Vec(50, 40.8, -1e5+170), black(), black(), diff), // Bottom new Sphere(1e5, new Vec(50, 1e5, 81.6), black(), new Vec(0.75, 0.75, 0.75), diff), // Top new Sphere(1e5, new Vec(50, -1e5+81.6, 81.6), black(), new Vec(0.75, 0.75, 0.75), diff), // Mirror new Sphere(16.5, new Vec(27, 16.5, 47), black(), new Vec(0.999, 0.999, 0.999), spec), // Glass new Sphere(16.5, new Vec(73, 16.5, 78), black(), new Vec(0.999, 0.999, 0.999), refr), // Light - This is a large sphere located above the scene // that just peeks down below the top sphere (so it's // almost entirely contained within the large sphere). // It's actually black and diffuse, but you see the // bright emission coming from it. new Sphere(600, new Vec(50, 681.6-0.27, 81.6), new Vec(12, 12, 12), black(), diff) ]; // Constrain a number to within 0 and 1. var clamp = function(x) { return x < 0 ? 0 : x > 1 ? 1 : x; }; // Converts a color intensity in the range [0,1] (what // smallpt works with internally) to [0,255] (how color is // represented in the image). This applies a gamma // correction of 2.2 (pretty standard). var toInt = function(x) { return round(pow(clamp(x), 1 / 2.2) * 255 + 0.49); }; // This simply iterates through each sphere, testing to // see which is the first the ray intersects var intersectSpheres = function(ray){ var least = 1e20, id; for (var i = 0; i < spheres.length; i++) { var d = spheres[i].intersect(ray); if (d && d < least) { least = d; id = i; } } if (least < 1e20) { return { dist: least, id: id }; } }; // This calculates the radiance returned by a ray sent // into the scene. Depth is used to limit recursion // depth (the farther we recurse the more work we do // and the less effect it will have on the final result). var radiance = function(ray, depth){ var isect = intersectSpheres(ray); if (!isect) { return black(); // if miss, return black } var dist = isect.dist, // distance to intersection id = isect.id; // id of intersected object var obj = spheres[id], // the hit object // the hit point hitPoint = ray.origin.plus(ray.direction.times(dist)), // direction of hit point from center of sphere // (sphere normal) sphereNormal = hitPoint.minus(obj.position).norm(), // If the dot product is negative the vectors are // facing opposite directions, which means the ray is // entering the surface. Otherwise the ray is exiting // the surface (only possible for the glass surface). // Notice this is mainly used in the refraction case. normal = sphereNormal.dot(ray.direction) < 0 ? sphereNormal : sphereNormal.times(-1), f = obj.color, // the largest color magnitude p = f.x > f.y && f.x > f.z ? f.x : f.y > f.z ? f.y : f.z; // Randomly stop the rucursion based on how reflective the // surface is (and therefore how much is has to contribute // to the final result if (++depth > 5) { if (random() < p) { f = f.times(1 / p); } else { return obj.emission; } } // Ideal diffuse reflection if (obj.reflectionType === diff) { // These definitions are all about sampling a random // point on the unit hemisphere from the hit point // A random angle in [0, 2 pi] radians var r1 = 2 * 3.141592654 * random(), // a random distance from the center of the unit // hemisphere r2 = random(), r2s = sqrt(r2), // The normal of the sphere at the hit point - // basically the starting point for our random // sample. w = normal, // A perpendicular vector to w. u = ((abs(w.x) > 0.1 ? (new Vec(0, 1, 0)) : (new Vec(1, 0, 0)) ).cross(w)).norm(), // A perpendicular vector to w and u. Now w, u, and // v form an orthonormal coordinate frame. v = w.cross(u), // Our random sample d = (u.times(cos(r1) * r2s) .plus(v.times(sin(r1) * r2s)) .plus(w.times(sqrt(1 - r2))) ).norm(); // Return the light this object is emitting... return obj.emission.plus( // plus the light found by our random sample, // multiplied by the color of this object // (because white light hitting a diffuse red // sphere looks red) f.mult(radiance(new Ray(hitPoint, d), depth))); } else if (obj.reflectionType === spec) { // Specular (mirror-like) reflection is easy - return // the light emitting from this object plus the reflected // light tinted the color of this object return obj.emission.plus( f.mult(radiance(new Ray(hitPoint, ray.direction.minus(sphereNormal.times(2).mult( sphereNormal.dot(ray.direction)), depth))))); } // Final case - Ideal dielectric refraction (glass) var reflRay = new Ray(hitPoint, ray.direction.minus(sphereNormal.times(2).mult(sphereNormal.dot(ray.direction)))), into = sphereNormal.dot(normal) > 0, // Ray from outside going in? nc = 1, nt = 1.5, nnt = into ? nc / nt : nt / nc, ddn = ray.direction.dot(normal), cos2t = 1 - nnt * nnt * (1 - ddn * ddn); if (cos2t < 0) { // Total internal reflection return obj.emission.plus(f.mult(radiance(reflRay, depth))); } var tdir = (ray.direction.times(nnt).minus(sphereNormal.times((into ? 1 : -1)(ddn nnt + sqrt(cos2t))))).norm(), a = nt - nc, b = nt + nc, r0 = a * a / (b * b), c = 1 - (into ? -ddn : tdir.dot(sphereNormal)), re = r0 + (1 - r0)ccccc, tr = 1 - re; p = 0.25 + 0.5 re; var rp = re / p, tp = tr / (1 - p); var tmp = 0; return obj.emission.plus(f.mult(depth > 2 ? (random() < p ? radiance(reflRay, depth).times(rp) : radiance(new Ray(hitPoint, tdir), depth).times(tp)) : radiance(reflRay, depth).times(re) + radiance(new Ray(hitPoint, tdir), depth).times(tr))); }; background(255, 255, 255); var w = 80, h = 80, samps = 4, cam = new Ray(new Vec(50, 52, 295.6), (new Vec(0, -0.042612, -1)).norm()), cx = new Vec(w * 0.5135 / h, 0, 0), cy = cx.cross(cam.direction).norm().times(0.5135), // Monte Carlo methods are algorithms relying on // random sampling, which are very common in rendering. // The main algorithm does some random sampling but // this variable just controls what order the pixels // are rendered in. If monteCarlo is set to true pixels // will be rendered at random, if false they will be // rendered row-by-row. monteCarlo = true, iterX = 0, iterY = 0; var singlePixel = function(x, y) { var c = black(); for (var sy = 0, i = (h-y-1)w+x; sy < 2; sy++) { for (var sx = 0; sx < 2; sx++) { var r = black(); for (var s = 0; s < samps; s++) { var r1 = 2 random(), dx = r1 < 1 ? sqrt(r1) - 1 : 1 - sqrt(2 - r1), r2 = 2 * random(), dy = r2 < 1 ? sqrt(r2) - 1 : 1 - sqrt(2 - r2), d = cx.times(((sx + 0.5 + dx) / 2 + x) / w - 0.5).plus( cy.times(((sy + 0.5 + dy) / 2 + y) / h - 0.5)).plus(cam.direction); r = r.plus(radiance(new Ray(cam.origin.plus(d.times(140)), d.norm()), 0).times(1 / samps)); } c = c.plus(new Vec(clamp(r.x), clamp(r.y), clamp(r.z))).times(0.25); } } return c; }; var draw = function() { var c; if (monteCarlo) { for (var j = 0; j < 10; j++) { var x = floor(random()w), y = floor(random()h); c = singlePixel(x, y); stroke(toInt(c.x), toInt(c.y), toInt(c.z)); point(x, y); } } else { iterX = (iterX + 1) % w; if (iterX === 0) { iterY = (iterY + 1) % h; } c = singlePixel(iterX, iterY); stroke(toInt(c.x), toInt(c.y), toInt(c.z)); point(iterX, iterY); } };
Folds
Fork	false
Key	ag5zfmtoYW4tYWNhZGVteXIUCxIKU2NyYXRjaHBhZBjFgMO_Aww
Votes	2
Spin-Offs	0
Type	PJS
Width	400
Height	400
User Flagged	false
Origin Scratchpad	null
Hidden From Hotlist	false
Restricted Posting	true
By Child	false
Author Nick	Joel Burget
Author Name	joelburget
Author ID	kaid_956098430296535181795345
Author Profile Access	COACH

Archive Data

Added	7 months ago, 1716389995709
Updated	7 months ago, 1716389995709
Source Deleted	unknown