Category Archives: 3D

Vectorpark Style Hemisphere

By Zevan | June 10, 2009

Actionscript:

const TWO_PI:Number = Math.PI * 2;
const PI_HALF_PI:Number = Math.PI + Math.PI / 2;
x = stage.stageWidth / 2;
y = stage.stageHeight / 2;
 
var runHemisphere:Function = makeHemisphere(0,0, 100,0xFF0000, 0xFFCC00);
var dx:Number = 0;
var dy:Number = 0;
 
addEventListener(Event.ENTER_FRAME, onLoop);
function onLoop(evt:Event):void {
    dx += (mouseX / 50 - dx) / 4;
    dy += (mouseY - dy) / 4;
    runHemisphere(dx, dy);
}
function makeHemisphere(x:Number, y:Number, size:Number, colA:uint, colB:uint):Function{
    var s:Sprite = Sprite(addChild(new Sprite()));
    s.x = x;
    s.y = y;
    var bg:Sprite = Sprite(s.addChild(new Sprite()));
    
    with (bg.graphics) clear(), beginFill(colA), halfCircle(bg.graphics, 0,0 , size);
    var scol:uint = colB;
    var slice:Sprite = Sprite(s.addChild(new Sprite()));
    return function(theta:Number, rot:Number){
         theta %= TWO_PI;
        if (theta <0){
            theta = TWO_PI - -theta;
        }
        var scale:Number = Math.cos(theta);
        if (theta> 1.57){
            scol = colA;
        } else {
            scol = colB;
        }
        if (theta> Math.PI){
            bg.rotation = 180;
        }else{
            bg.rotation = 0;
        }
        if (theta> PI_HALF_PI){
            scol = colB;
        }
        with(slice.graphics) clear(), beginFill(scol), scaleYcircle(slice.graphics,size, scale);
        s.rotation = rot;
    }
}
// original circle function by senocular (www.senocular.com) from here http://www.actionscript.org/forums/showthread.php3?s=&threadid=30328
function halfCircle(g:Graphics, x:Number,y:Number,r:Number):void {
    var c1:Number = r * (Math.SQRT2 - 1);
    var c2:Number = r * Math.SQRT2 / 2;
    var xr:Number = x + r, yr:Number = y + r;
    var x_r:Number = x - r, yc1:Number = y + c1;
    var yc2:Number = y + c2, xc1:Number = x + c1, xc2:Number = x + c2;
    var x_c1:Number = x - c1;
    g.moveTo(xr, y);
    g.curveTo(xr, yc1, xc2, yc2);
    g.curveTo(xc1, yr, x, yr);
    g.curveTo(x - c1,yr, x - c2, yc2);
    g.curveTo(x_r, yc1, x_r, y);
}
// circle that can be scaled on the y axis
function scaleYcircle(g:Graphics, r:Number, s:Number = 1):void {
    var c1:Number = r * (Math.SQRT2 - 1);
    var c2:Number = r * Math.SQRT2 / 2;
    var rs:Number = r * s, c1s:Number = c1 * s, c2s:Number = c2 * s;
    var x_r:Number =  -r, y_r:Number = -rs, x_c2:Number =  -c2;
    var y_c2:Number =  -c2s, x_c1:Number =  -c1, y_c1:Number =  -c1s
    g.moveTo(r, 0), g.curveTo(r, c1s, c2, c2s);
    g.curveTo(c1, rs, 0, rs), g.curveTo(x_c1,rs, x_c2, c2s);
    g.curveTo(x_r, c1s, x_r, 0), g.curveTo(x_r,y_c1,x_c2,y_c2);
    g.curveTo(x_c1,y_r,0,y_r), g.curveTo(c1,y_r,c2,y_c2);
    g.curveTo(r,y_c1,r,0);
}

The above snippet draws a 3D hemisphere using a technique I first saw at vectorpark.com. Vectorpark.com has been around for years and it's an amazing site... if you've never seen it before I highly recommend spending some time there...

When I decided to post the half-circle snippet yesterday... I knew I would be writing this today. It's one of those things I've always thought about doing, but never gotten around to. I show vectorpark.com to my animation class (almost no coding in that class) and we emulate some of the 3D techniques for simple primitives with pure timeline animation. The above is the first time I've tried to emulate one of these techniques with code.

I was pleasantly surprised when visiting vectorpark.com this morning... Patrick Smith has posted some new work there. Really excellent stuff...

UPDATE:
Katopz converted this to a doc class and put it up on wonderfl...

Also posted in Graphics | Tagged actionscript, as3, flash | 6 Comments

Polygon Triangulation

By Zevan | May 29, 2009

CLICK HERE TO COPY

Actionscript:

var triangulate:Triangulate = new Triangulate();
 
var poly:Array=[];
 
stage.addEventListener(MouseEvent.MOUSE_DOWN, onDown);
function onDown(evt:MouseEvent):void {
    poly.push(new Pnt(mouseX, mouseY));
}
 
addEventListener(Event.ENTER_FRAME, onLoop);
function onLoop(evt:Event):void {
    var i:int;
    graphics.clear();
    var verts:Array=triangulate.process(poly);
 
    if (verts==null) {
        // draw a red polygon if there is some kind of error,
        // or if there are too few points on the poly
        if (poly.length>1) {
            graphics.lineStyle(0,0xFF0000);
            graphics.moveTo(poly[0].x, poly[0].y);
            for (i = 1; i<poly.length; i++) {
                graphics.lineTo(poly[i].x, poly[i].y);
            }
        }
    }else{
        // draw the triangulated polygon
        var tcount:int = verts.length / 3;
        graphics.lineStyle(0,0x000000);
        for (i = 0; i<tcount; i++) {
            var index:int = i * 3;
            var p1:Pnt=verts[index];
            var p2:Pnt=verts[index+1];
            var p3:Pnt=verts[index+2];
            graphics.moveTo(p1.x,p1.y);
            graphics.lineTo(p2.x,p2.y);
            graphics.lineTo(p3.x,p3.y);
            graphics.lineTo(p1.x,p1.y);
        }
    }
}

The above demo's a class that triangulates a polygon given a list of points. To test this snippet you'll need the Pnt and Triangulate Classes, which you can download or copy from below.

Polygon triangulation is useful for lots of things... I first found that I needed it back in my Director days. I wanted to be able to draw a polygon and then extrude it into 3D space - in order to do this I needed to triangulate the polygon that was drawn. Luckily there was an undocumented feature in Lingo that did the triangulation. I'll probably do an extrusion demo soon. I've been looking into this to make the QuickBox2D polygon stuff a little easier.

Take a look at the swf here

Download all source and fla here....

Here is the Triangulate class:

CLICK HERE TO COPY

Actionscript:

/**
This code is a quick port of code written in C++ which was submitted to 
flipcode.com by John W. Ratcliff  // July 22, 2000 
See original code and more information here:
http://www.flipcode.com/archives/Efficient_Polygon_Triangulation.shtml
 
ported to actionscript by Zevan Rosser
www.actionsnippet.com
*/
 
package {
    
    public class Triangulate {
        
        private const EPSILON:Number = 0.0000000001;
        
        public function Triangulate(){}
        
        public function process(contour:Array):Array{
            var result:Array = [];
            var n:int = contour.length
            if ( n <3 ) return null
            
            var verts:Array = [];
            
              /* we want a counter-clockwise polygon in verts */
            var v:int
            
              if ( 0.0 <area(contour) ){
                for (v=0; v<n; v++) verts[v] = v;
              }else{
                for(v=0; v<n; v++) verts[v] = (n-1)-v;
              }
            
              var nv:int = n;
            
              /*  remove nv-2 vertsertices, creating 1 triangle every time */
              var count:int = 2*nv;   /* error detection */
             var m:int;
              for(m=0, v=nv-1; nv>2; )
              {
                /* if we loop, it is probably a non-simple polygon */
                if (0>= (count--)){
                  //** Triangulate: ERROR - probable bad polygon!
                 // trace("bad poly");
                  return null;
                }
            
                /* three consecutive vertices in current polygon, <u,v,w> */
                var u:int = v; if (nv <= u) u = 0;     /* previous */
                v = u+1; if (nv <= v) v = 0;     /* new v    */
                var w:int = v+1; if (nv <= w) w = 0;     /* next     */
            
                if ( snip(contour,u,v,w,nv,verts)){
                  var a:int,b:int,c:int,s:int,t:int;
            
                  /* true names of the vertices */
                  a = verts[u]; b = verts[v]; c = verts[w];
            
                  /* output Triangle */
                  result.push( contour[a] );
                  result.push( contour[b] );
                  result.push( contour[c] );
            
                  m++;
            
                  /* remove v from remaining polygon */
                  for(s=v,t=v+1;t<nv;s++,t++) verts[s] = verts[t]; nv--;
            
                  /* resest error detection counter */
                  count = 2 * nv;
                }
              }
            
              return result;
        }
        
        // calculate area of the contour polygon
        public function area(contour:Array):Number{
            var n:int = contour.length;
            var a:Number  = 0.0;
            
            for(var p:int=n-1, q:int=0; q<n; p=q++){
                a += contour[p].x * contour[q].y - contour[q].x * contour[p].y;
            }
            return a * 0.5;
        }
        
        // see if p is inside triangle abc
        public function insideTriangle(ax:Number, ay:Number, bx:Number, by:Number, cx:Number, cy:Number,px:Number,py:Number):Boolean{
                                                           
              var aX:Number, aY:Number, bX:Number, bY:Number
              var cX:Number, cY:Number, apx:Number, apy:Number;
              var bpx:Number, bpy:Number, cpx:Number, cpy:Number;
              var cCROSSap:Number, bCROSScp:Number, aCROSSbp:Number;
            
              aX = cx - bx;  aY = cy - by;
              bX = ax - cx;  bY = ay - cy;
              cX = bx - ax;  cY = by - ay;
              apx= px  -ax;  apy= py - ay;
              bpx= px - bx;  bpy= py - by;
              cpx= px - cx;  cpy= py - cy;
            
              aCROSSbp = aX*bpy - aY*bpx;
              cCROSSap = cX*apy - cY*apx;
              bCROSScp = bX*cpy - bY*cpx;
            
              return ((aCROSSbp>= 0.0) && (bCROSScp>= 0.0) && (cCROSSap>= 0.0));
        }
        
        private function snip(contour:Array, u:int, v:int, w:int, n:int, verts:Array):Boolean{
              var p:int;
              var ax:Number, ay:Number, bx:Number, by:Number;
              var cx:Number, cy:Number, px:Number, py:Number;
            
                  ax = contour[verts[u]].x;
                  ay = contour[verts[u]].y;
                
                  bx = contour[verts[v]].x;
                  by = contour[verts[v]].y;
                
                  cx = contour[verts[w]].x;
                  cy = contour[verts[w]].y;
            
          if ( EPSILON> (((bx-ax)*(cy-ay)) - ((by-ay)*(cx-ax))) ) return false;
            
              for (p=0;p<n;p++){
                    if( (p == u) || (p == v) || (p == w) ) continue;
                    px = contour[verts[p]].x
                    py = contour[verts[p]].y
                    if (insideTriangle(ax,ay,bx,by,cx,cy,px,py)) return false;
              }
              return true;
        }
    }
}

... and the Pnt class:

CLICK HERE TO COPY

Actionscript:

// Point class, no reason to use AS3's build in Point
package{
    public class Pnt {
        public var x:Number;
        public var y:Number;
        public function Pnt(x:Number, y:Number){
            this.x = x;
            this.y = y;
        }
    }
}

I also found a nice description of the basic technique being employed here.

UPDATE:
This should be obvious, but I was targeting fp9 with this... thus the use of Array instead of Vector.

Also posted in Math, graphics algorithms, misc | Tagged actionscript, flash | 6 Comments

Parametric UV Surface

By Zevan | May 13, 2009

CLICK HERE TO COPY

Actionscript:

var matrix:Matrix3D = new Matrix3D();
var verts:Vector.<Number> = new Vector.<Number>();
var pVerts:Vector.<Number> = new Vector.<Number>();
var uvts:Vector.<Number> = new Vector.<Number>();
var sqrt2:Number = Math.sqrt(2)
var pi:Number = Math.PI;
var pi23:Number= 2 * Math.PI / 3;
var step:Number= pi / 50;
for (var u:Number = -pi; u<pi; u+=step) {
    for (var v:Number = -pi; v<pi; v+=step) {
        // from here http://local.wasp.uwa.edu.au/~pbourke/geometry/hexatorus/
        var px = Math.sin(u) / Math.abs(sqrt2+ Math.cos(v))
        var py = Math.sin(u+pi23) / Math.abs(sqrt2 +Math.cos(v + pi23))
        var pz = Math.cos(u-pi23) / Math.abs(sqrt2 +Math.cos(v - pi23))
        verts.push(px * 50);
        verts.push(py * 50);
        verts.push(pz * 50);
    }
}
var brush:BitmapData=new BitmapData(3,2,true,0x41FFFFFF);
var canvas:BitmapData=new BitmapData(400,400,false,0x000000);
addChild(new Bitmap(canvas));
var dx:Number=0;
var dy:Number=0;
addEventListener(Event.ENTER_FRAME, onLoop);
function onLoop(evt:Event):void {
    dx += (mouseX - dx)/4;
    dy += (mouseY - dy)/4;
    matrix.identity();
    matrix.appendRotation(dy,Vector3D.X_AXIS);
    matrix.appendRotation(dx,Vector3D.Y_AXIS);
    matrix.appendTranslation(200, 200, 0);
    Utils3D.projectVectors(matrix, verts, pVerts, uvts);
    canvas.lock();
    canvas.fillRect(canvas.rect, 0x000000);
    var p = new Point();
    for (var i:int = 0; i<pVerts.length; i+=2) {
        p.x = pVerts[i];
        p.y = pVerts[i+1];
        canvas.copyPixels(brush, brush.rect, p, null, null, true);
    }
    canvas.unlock();
}

More 3D shapes inspired by (taken from) Paul Bourke's website. I figured I should probably add a parametric 3D surface to this set of posts - so I chose to plot the Triaxial Hexatorus. It's important to note that U and V go from -PI to PI.

I googled Triaxial Hexatorus and stumbled upon a great papervision demo that creates meshes using parametric equations - it also morphs between shapes.

I also noticed that I don't need to populate the uvts or pVerts Vectors with zeros - seems to work fine without doing that.

Also posted in BitmapData, Math, Vector, graphics algorithms, pixel manipulation | Tagged actionscript, flash | Leave a comment

Wormhole

By Zevan | May 12, 2009

CLICK HERE TO COPY

Actionscript:

var matrix:Matrix3D = new Matrix3D();
var verts:Vector.<Number> = new Vector.<Number>();
var pVerts:Vector.<Number> = new Vector.<Number>();
var uvts:Vector.<Number> = new Vector.<Number>();
for (var i:Number = -10; i<10; i+=.04) {
    for (var j:Number = -5; j<8; j+=.04) {
        for (var k:Number = -10; k<10; k+=.04) {
            var s:Number =  i * i * j + j * k * k;
            if (s <10 && s> 9.95) {
                verts.push(i * 20);
                verts.push(j * 20);
                verts.push(k * 20);
                pVerts.push(0),pVerts.push(0);
                uvts.push(0),uvts.push(0),uvts.push(0);
            }
        }
    }
}
var brush:BitmapData=new BitmapData(3,2,true,0x41FFFFFF);
var canvas:BitmapData=new BitmapData(400,400,false,0x000000);
addChild(new Bitmap(canvas));
var dx:Number=0;
var dy:Number=0;
addEventListener(Event.ENTER_FRAME, onLoop);
function onLoop(evt:Event):void {
    dx += (mouseX - dx)/4;
    dy += (mouseY - dy)/4;
    matrix.identity();
    matrix.appendRotation(dy,Vector3D.X_AXIS);
    matrix.appendRotation(dx,Vector3D.Y_AXIS);
    matrix.appendTranslation(200, 200, 0);
    Utils3D.projectVectors(matrix, verts, pVerts, uvts);
    canvas.lock();
    canvas.fillRect(canvas.rect, 0x000000);
    var p = new Point();
    for (var i:int = 0; i<pVerts.length; i+=2) {
        p.x = pVerts[i];
        p.y = pVerts[i+1];
        canvas.copyPixels(brush, brush.rect, p, null, null, true);
    }
    canvas.unlock();
}

Yet another variation on the post from the last two days. This one plots something resembling a wormhole - I was randomly tweaking the equation for a sphere and stumbled upon this...

Also posted in BitmapData, Math, Vector, graphics algorithms, pixel manipulation | Tagged actionscript, flash | Leave a comment

Category Archives: 3D

Vectorpark Style Hemisphere

Polygon Triangulation

Parametric UV Surface

Wormhole

Search

Pages

Recent Posts

Categories

Archives

RSS Feeds