Forked from:: keim_at_Si's Real Time Ray Tracing

Real Time Ray Tracing (forked and optimized)

Forked and optimized. Pay tribute to the original author of the code!

Changes:
* draw() - no more setPixel, it now uses setVector
* draw() -tow ln parts rewritten
* sphere() - exchanged trig functions to inlined approximate polynomials

Result:
Original peaks at ~60
This peaks at ~70
(when target fps = 120)

antalg

forked:2
favorite:16
lines:220
license : MIT License
modified : 2012-06-17 07:08:34

Embed: Tweet

// forked from keim_at_Si's Real Time Ray Tracing
package {
    import flash.events.*;
    import flash.display.*;
    import flash.utils.getTimer;
    import net.hires.debug.Stats;
    
    [SWF(frameRate='60')]
    public class main extends Sprite {
        function main() {
            addEventListener(Event.ADDED_TO_STAGE, _onAddedToStage);
        }
        
        private function _onAddedToStage(e:Event) : void {
            removeEventListener(Event.ADDED_TO_STAGE, _onAddedToStage);
            var bitmap:Bitmap = new Bitmap(screen = new BitmapData(size, size, false, 0));
            if (size<232) bitmap.scaleX = bitmap.scaleY = 2;
            bitmap.x = bitmap.y = 232 - size * bitmap.scaleX * 0.5;
            addChild(bitmap);
            addChild(new Stats());
            setup();
            addEventListener(Event.ENTER_FRAME, _onEnterFrame);
            
            startTime = getTimer();
        }
        
        // Added
        private var startTime:Number;        
        //
        
        private function _onEnterFrame(e:Event) : void {
            mx = (mouseX - 232.5) * 0.00390625;
            my = (232.5 - mouseY) * 0.00390625;
            
            // Changed
            time = (getTimer() - startTime) * 0.001;
            //
            
            draw();
        }
    }
}

// parameters, you can modify them.
var size:int = 192;
var ambient:Number = 0.1;
var diffusion:Number = 0.7;
var specular:Number = 0.6;
var power:Number = 12;

import flash.display.*;
import flash.geom.*

class Material {
    public var lmap:Vector.<uint> = new Vector.<uint>(512, true);
    function Material(col:uint, amb:Number, dif:Number) {
        var i:int, a:Number, r:int=col>>16, g:int=(col>>8)&255, b:int=col&255;
        for (i=0; i<512; i++) {
            a = ((i<256) ? amb : ((((i-256) * (dif - amb)) * 0.00390625) + amb)) * 2;
            if (a<1) {
                lmap[i] = ((r*a)<<16)|((g*a)<<8)|((b*a)<<0);
            } else {
                lmap[i] = ((255-(255-r)*(2-a))<<16)|((255-(255-g)*(2-a))<<8)|(((255-(255-b)*(2-a)))<<0);
            }
        }
    }
}

var t:Boolean = true;

class Sphere {
    public var x:Number, y:Number, z:Number, r2:Number, mat:Material;
    public var cx:Number, cy:Number, cz:Number, cr:Number, omg:Number, pha:Number;
    function Sphere(cx:Number, cy:Number, cz:Number, cr:Number, omg:Number, pha:Number, r:Number, mat:Material) {
        this.cx = cx;
        this.cy = cy;
        this.cz = cz;
        this.cr = cr;
        this.omg = omg;
        this.pha = pha;
        this.r2 = r * r;
        this.mat = mat;
    }
    
    public function update() : void {
        var v:Number = time * omg + pha;
        
        while(v > Math.PI) {
            v -= 2*Math.PI;
        }
        
        if(v>0) z = v*(B + C*v)*cr + cz;
        else    z = v*(B - C*v)*cr + cz;
        
        y = cy;
        
        v += HALFPI;
        if(v>Math.PI) v -= TWOPI;
        if(v>0) x = v*(B + C*v)*cr + cx;
        else    x = v*(B - C*v)*cr + cx;
        
    }
    
    private const B:Number = 4.0/Math.PI;
    private const C:Number = -4.0/(Math.PI*Math.PI);
    private const TWOPI:Number = 2*Math.PI;
    private const HALFPI:Number = .5*Math.PI;
}

var focusZ:Number = size;
var floorY:Number = 100;
var screen:BitmapData;
var initialDir:Vector.<Number> = new Vector.<Number>(size*size*3, true);
var spheres:Vector.<Sphere> = new Vector.<Sphere>();
var ldir:Vector3D = new Vector3D();
var light:Vector3D = new Vector3D(100,100,100);
var smap:Vector.<uint> = new Vector.<uint>(512, true);
var fcol:Vector.<uint> = new Vector.<uint>(1024, true);
var refs:Vector.<uint> = Vector.<uint>([0, 1, 2, 3, 3]);
var reff:Vector.<uint> = Vector.<uint>([0xffffff, 0x7f7f7f, 0x3f3f3f, 0x1f1f1f, 0x1f1f1f]);
var time:Number, mx:Number, my:Number, camX:Number, camY:Number, camZ:Number, tcamX:Number, tcamY:Number, tcamZ:Number;

// Added
var pixels:Vector.<uint> = new Vector.<uint>(192*192, true);
//

if (hit) {
                    ox += dx * tmin;
                    oy += dy * tmin;
                    oz += dz * tmin;
                    nx = ox - hit.x;
                    ny = oy - hit.y;
                    nz = oz - hit.z;
                    n = 1/Math.sqrt(nx*nx + ny*ny + nz*nz);
                    nx *= n;
                    ny *= n;
                    nz *= n;
                    n = -(nx*dx + ny*dy + nz*dz) * 2;
                    dx += nx * n;
                    dy += ny * n;
                    dz += nz * n;
                    // Changed
                    ln = (ldir.x * nx + ldir.y * ny + ldir.z * nz + 1) * 256;
                    //
                    a = hit.mat.lmap[ln];
                    a >>= refs[l];
                    a &= reff[l];
                    pixel += a;
                } else {
                    if (dy < 0) {
                        // Changed
                        ln = (ldir.x * dx + ldir.y * dy + ldir.z * dz + 1) * 256;
                        //      
                        a = smap[ln];
                        ln = l - 1;
                        a >>= refs[ln];
                        a &= reff[ln];
                        pixel += a;
                        break;
                    } else {
                        tmin = (floorY-oy)/dy;
                        ox += dx * tmin;
                        oy += dy * tmin;
                        oz += dz * tmin;
                        dy = -dy;
                        ln = (dy*256) + (((((ox+oz)>>7)+((ox-oz)>>7))&1)<<9) + 256;
                        a = fcol[ln];
                        a >>= refs[l];
                        a &= reff[l];
                        pixel += a;
                    }
                }
            }
            
            // Changed
            pixels[rowStart + i] = pixel;
            //
        }
    }
    
    // Added
    screen.setVector(screen.rect, pixels);
    screen.unlock();
    //
}

Code Fullscreen

Preview Fullscreen