※現在、「wonderfl build flash online」求人コンテンツ制作に関してのアンケートを実施中です！みなさまのお力添えを頂いて、続々とアンケート結果が集まっていますが、まだまだ募集しております。ご協力のほど、どうぞよろしくお願いいたします！

wonderfl運営事務局
→アンケートページ（※ログインしてからお答えいただけるようになっています。）

 notice: Flash editor updated! Join the development! Thanks to MiniBuilder


embed

noswf download fullscreen
flash swf thumbnail play
reload download fullscreen

FORKED
>sort

Real time ambient occlusion forked from: Real time ambient occlusion [diff(1)]

  1. // forked from keim_at_Si's Real time ambient occlusion
  2. // gouraud shading based ambient occlusion (PoC)
  3. //   mouse move to move camera, mouse click to stop motion
  4. //   press z key to switch ambient occlusion
  5. //----------------------------------------------------------------------
  6. package {
  7.     import flash.display.*;
  8.     import flash.events.*;
  9.     import flash.geom.*;
  10.     import flash.utils.*;
  12.     [SWF(width='465', height='465', backgroundColor='#000000', frameRate='60')]
  13.     public class main extends Sprite {
  14.         // settings
  15.         private const aoBlendRatio:Number = 0.6; // blending ratio of a.o.
  16.         private const aoRadius:Number = 8;       // pseudo radius for a.o. calculation
  17.         private const divPlane:int = 16;         // partition number of plane
  18.         private const divSphere:int = 24;        // partition number of sphere
  19.         private const hcResolution:int = 3;      // log2 based hemi-cube resolusion 
  20.         
  21.         // 3D renders
  22.         private var _materials:Vector.<Material> = new Vector.<Material>();
  23.         private var _light:Light = new Light(1,1,1);
  24.         private var _meshSphere:Mesh = new Mesh(_materials);
  26.         private var _meshPlane :Mesh = new Mesh(_materials);
  28.         private var _screen:BitmapData = new BitmapData(465, 465, false, 0);
  29.         private var _matscr:Matrix = new Matrix(1, 0, 0, 1, 232.5, 232.5);
  30.         private var gl:Render3D = new Render3D(250);
  31.         // utils
  32.         private var _timer:timer = new timer(10, "Total: ##[ms/frame]", "AO calc: ##[ms/frame]",  "Rendering: ##[ms/frame]");
  33.         
  34.         // objects
  35.         private var camera:Vector3D;
  36.         private var plane:AOPrimitive;
  37.         private var spheres:Vector.<AOPrimitive> = new Vector.<AOPrimitive>(3);
  38.         private var aoShade:Vector.<AOPrimitive> = new Vector.<AOPrimitive>(3);
  39.         private var spheresProjected:Vector.<Point3D> = new Vector.<Point3D>(3);
  40.         private var aoShadeProjected:Vector.<Point3D> = new Vector.<Point3D>(3);
  41.         
  42.         // motions
  43.         private var motionRadius:Vector.<Number> = Vector.<Number>([  10,  -20,   32]);
  44.         private var motionFreq  :Vector.<Number> = Vector.<Number>([0.20, 0.07,-0.12]);
  45.         private var motionFreqY :Vector.<Number> = Vector.<Number>([0.12, 0.25, 0.05]);
  46.         private var vertexCount:int;
  47.         private var frame:int = 0;
  48.         private var frameStep:int = 1;
  49.         private var aoSwitch:Boolean = true;
  50.         
  51.         // entry point
  52.         function main() {
  53.             var sphereVerticesCount:int = ((divSphere>>1)-1)*divSphere+2,
  54.                 planeVerticesCount:int  = (divPlane+1)*(divPlane+1);
  55.             vertexCount = planeVerticesCount + sphereVerticesCount*3;
  56.             _timer.title = "Vertices: " + String(vertexCount) + "\n";
  57.             
  58.             camera = new Vector3D(0, -5, -50);
  59.             plane  = new AOPrimitive(0, 0, 0, 0, planeVerticesCount);
  60.             spheresProjected[0] = spheres[0] = new AOPrimitive(0, 5, 0, aoRadius, sphereVerticesCount);
  61.             spheresProjected[1] = spheres[1] = new AOPrimitive(0, 5, 0, aoRadius, sphereVerticesCount);
  62.             spheresProjected[2] = spheres[2] = new AOPrimitive(0, 5, 0, aoRadius, sphereVerticesCount);
  63.             aoShadeProjected[0] = aoShade[0] = new AOPrimitive(0,-6, 0, aoRadius);
  64.             aoShadeProjected[1] = aoShade[1] = new AOPrimitive(0,-6, 0, aoRadius);
  65.             aoShadeProjected[2] = aoShade[2] = new AOPrimitive(0,-6, 0, aoRadius);
  66.             plane.aoPrimitives.push(spheres[0], spheres[1], spheres[2]);
  67.             spheres[0].aoPrimitives.push(aoShade[0], spheres[1], spheres[2]);
  68.             spheres[1].aoPrimitives.push(spheres[0], aoShade[1], spheres[2]);
  69.             spheres[2].aoPrimitives.push(spheres[0], spheres[1], aoShade[2]);
  71.             _materials.push((new Material()).setColor(0xffffff, 0, 128, 32, 80));
  72.             _createSphere(_meshSphere, 5, divSphere>>1, divSphere);
  73.             _createPlane(_meshPlane, 80, 80, divPlane, divPlane);
  74.             
  75.             addChild(gl).visible = false;
  76.             addChild(new Bitmap(_screen));
  77.             addChild(_timer);
  78.             addEventListener("enterFrame", _onEnterFrame);
  79.             stage.addEventListener("click", _onClick);
  80.             stage.addEventListener("keyUp", _onKeyUp);
  81.         }
  83.         private function _onEnterFrame(e:Event) : void {
  84.             // motion
  85.             for (var i:int=0; i<3; i++) {
  86.                 spheres[i].x = Math.cos(frame*motionFreq[i]) * motionRadius[i];
  87.                 spheres[i].y = Math.sin(frame*motionFreqY[i]) * 5 + 10;
  88.                 spheres[i].z = Math.sin(frame*motionFreq[i]) * motionRadius[i];
  89.                 aoShade[i].x = spheres[i].x;
  90.                 aoShade[i].y = -5;
  91.                 aoShade[i].z = spheres[i].z;
  92.             }
  93.             
  94.             _timer.start(0);
  95.             // clear screen
  96.             _screen.fillRect(_screen.rect, 0);
  97.             // camera
  98.             gl.id().tv(camera).rx((400-mouseY)*0.15).ry((232-mouseX)*0.5);
  99.             _light.transformBy(gl.matrix);
  100.             // project all primitives
  101.             gl.projectPoint3D(spheresProjected);
  102.             gl.projectPoint3D(aoShadeProjected);
  103.             spheresProjected.sort(function(v1:Point3D, v2:Point3D) : Number { return v1.world.z - v2.world.z; });
  104.             // plane
  105.             gl.push().tv(plane).project(_meshPlane);
  106.             calculateVertexNormal(_meshPlane);
  107.             if (frameStep) calculateAmbientOcclusion(_meshPlane, plane.aoPrimitives, plane.ao);
  108.             calculateTexCoordByVertexNormal(_meshPlane, _light, plane.ao);
  109.             _timer.start(2); 
  110.             _screen.draw(gl.renderTexture(_materials[0]), _matscr);
  111.             _timer.pause(2);
  112.             gl.pop();
  113.             // spheres
  114.             for each (var v:Point3D in spheresProjected) {
  115.                 var p:AOPrimitive = AOPrimitive(v);
  116.                 gl.push().tv(p).project(_meshSphere);
  117.                 calculateVertexNormal(_meshSphere);
  118.                 if (frameStep) calculateAmbientOcclusion(_meshSphere, p.aoPrimitives, p.ao);
  119.                 calculateTexCoordByVertexNormal(_meshSphere, _light, p.ao);
  120.                 _timer.start(2);
  121.                 _screen.draw(gl.renderTexture(_materials[0]), _matscr);
  122.                 _timer.pause(2);
  123.                 gl.pop();
  124.             }
  125.             _timer.pause(0);
  126.             
  127.             frame += frameStep;
  128.         }
  129.         
  130.         private function _onClick(e:Event) : void {
  131.             frameStep = 1 - frameStep;
  132.         }
  133.         
  134.         private function _onKeyUp(e:KeyboardEvent) : void {
  135.             var inkey:String = String.fromCharCode(e.keyCode);
  136.             if (inkey == "Z") aoSwitch = !aoSwitch;
  137.         }
  138.         
  139.         private function _createSphere(mesh:Mesh, radius:Number, dlat:int, dlong:int) : Mesh {
  140.             var ilat:int, ilong:int, lat:Number, long:Number, r:Number, vidx:int, 
  141.             slat:Number = 3.141592653589793/dlat, slong:Number  = 6.283185307179586/dlong;
  142.             mesh.vertices.push(0, radius, 0);
  143.             mesh.texCoord.push(0, 0, 0);
  144.             for (ilat=1, lat=slat; ilat<dlat; ilat++, lat+=slat) {
  145.                 r = Math.sin(lat) * radius;
  146.                 for (ilong=0, long=-ilat*slong*0.5; ilong<dlong; ilong++, long+=slong) {
  147.                     mesh.vertices.push(Math.cos(long) * r, Math.cos(lat) * radius, Math.sin(long) * r);
  148.                     mesh.texCoord.push(0, 0, 0);
  149.                 }
  150.             }
  151.             mesh.vertices.push(0, -radius, 0);
  152.             mesh.texCoord.push(0, 0, 0);
  153.             for (ilat=0; ilat<dlat-2; ilat++) {
  154.                 vidx = ilat * dlong + 1;
  155.                 for (ilong=1; ilong<dlong; ilong++, vidx++) {
  156.                     mesh.qface(vidx+1, vidx, vidx+dlong+1, vidx+dlong, 0, true);
  157.                 }
  158.                 mesh.qface(vidx-dlong+1, vidx, vidx+1, vidx+dlong, 0, true);
  159.             }
  160.             vidx = dlong * (dlat-1) + 1;
  161.             for (ilong=0; ilong<dlong-1; ilong++) {
  162.                 mesh.face(0, ilong+1, ilong+2, 0);
  163.                 mesh.face(vidx, vidx-(ilong+1), vidx-(ilong+2), 0);
  164.             }
  165.             mesh.face(0, ilong+1, 1, 0);
  166.             mesh.face(vidx, vidx-(ilong+1), vidx-1, 0);
  167.             mesh.updateFaces();
  168.             
  169.             mesh.vnormals = new Vector.<Vector3D>(mesh.verticesCount, true);
  170.             for (var i:int=0; i<mesh.verticesCount; i++) mesh.vnormals[i] = new Vector3D();
  171.             return mesh;
  172.         }
  173.         
  174.         private function _createPlane(mesh:Mesh, w:Number, h:Number, divx:int, divy:int) : Mesh {
  175.             var x:Number, y:Number, ix:int, iy:int, i:int, j:int, 
  176.                 hw:Number=w*0.5, hh:Number=h*0.5, dx:Number=1/divx, dy:Number=1/divy;
  177.             for (y=0, iy=0; iy<=divy; y+=dy, iy++) {
  178.                 for (x=0, ix=0; ix<=divx; x+=dx, ix++) {
  179.                     mesh.vertices.push(x*w-hw, 0, y*h-hh);
  180.                     mesh.texCoord.push(x, y, 0);
  181.                 }
  182.             }
  183.             for (iy=0; iy<divy; iy++) {
  184.                 for (ix=0; ix<divx; ix++) {
  185.                     i = iy*(divy+1)+ix;
  186.                     j = i + divy+1;
  187.                     mesh.qface(i, i+1, j, j+1, 0, true);
  188.                 }
  189.             }
  190.             mesh.updateFaces();
  191.             
  192.             mesh.vnormals = new Vector.<Vector3D>(mesh.verticesCount, true);
  193.             for (i=0; i<mesh.verticesCount; i++) mesh.vnormals[i] = new Vector3D();
  194.             return mesh;
  195.         }
  196.         
  197.         public function calculateVertexNormal(mesh:Mesh) : void {
  198.             var i:int, v:Vector3D, fn:Vector3D, n:Number, vnormals:Vector.<Vector3D>=mesh.vnormals;
  199.             for each (v in vnormals) {
  200.                 v.x = v.y = v.z = v.w = 0;
  201.             }
  202.             for each (var face:Face in mesh.faces) {
  203.                 fn = face.normal.world;
  204.                 v = vnormals[face.i0]; v.x += fn.x; v.y += fn.y; v.z += fn.z; v.w += 1;
  205.                 v = vnormals[face.i1]; v.x += fn.x; v.y += fn.y; v.z += fn.z; v.w += 1;
  206.                 v = vnormals[face.i2]; v.x += fn.x; v.y += fn.y; v.z += fn.z; v.w += 1;
  207.             }
  208.             for each (v in vnormals) {
  209.                 if (v.w == 0) continue;
  210.                 n = 1/v.w;
  211.                 v.x *= n;
  212.                 v.y *= n;
  213.                 v.z *= n;
  214.             }
  215.             mesh.vnormals = vnormals;
  216.         }
  217.         
  218.         private const bmdw:int = 1<<hcResolution;
  219.         private var v0:Vector3D = new Vector3D(), v1:Vector3D = new Vector3D(), v:Vector3D = new Vector3D();
  220.         private var hc0:BitmapData = new BitmapData(bmdw,bmdw,false);
  221.         private var hcx:Vector.<BitmapData> = Vector.<BitmapData>([
  222.             new BitmapData(bmdw, bmdw>>1, false), 
  223.             new BitmapData(bmdw, bmdw>>1, false)
  224.         ]);
  225.         private var hcy:Vector.<BitmapData> = Vector.<BitmapData>([
  226.             new BitmapData(bmdw, bmdw>>1, false), 
  227.             new BitmapData(bmdw, bmdw>>1, false)
  228.         ]);
  229.         private var rect:Rectangle = new Rectangle();
  230.         public function calculateAmbientOcclusion(mesh:Mesh, prims:Vector.<AOPrimitive>, aoBuffer:Vector.<Number>) : void {
  231.             var x:Number, y:Number, z:Number, w:Number, t:Number, v2:Vector3D, p:AOPrimitive, 
  232.                 i:int=0, j:int=0, k:int, hci:int, ao:int, ix:int, iy:int, 
  233.                 hhc:int = bmdw>>1, hc0s:int = bmdw*bmdw, hcxs:int = hc0s>>1, hcxf:int = bmdw-1, 
  234.                 vnormals:Vector.<Vector3D> = mesh.vnormals, 
  235.                 vertices:Vector.<Number> = mesh.verticesOnWorld;
  236.             _timer.start(1);
  237.             for each (v2 in vnormals) {
  238.                 v1.x = 0.0;
  239.                 v1.y = 0.0;
  240.                 v1.z = 0.0;
  241.                      if ((v2.y < 0.6) && (v2.y > -0.6)) v1.y = -1.0;
  242.                 else if ((v2.z < 0.6) && (v2.z > -0.6)) v1.z = 1.0;
  243.                 else v1.x = 1.0;
  244.                 v0.x = v1.y * v2.z - v1.z * v2.y;
  245.                 v0.y = v1.z * v2.x - v1.x * v2.z;
  246.                 v0.z = v1.x * v2.y - v1.y * v2.x;
  247.                 v0.normalize();
  248.                 v1.x = v2.y * v0.z - v2.z * v0.y;
  249.                 v1.y = v2.z * v0.x - v2.x * v0.z;
  250.                 v1.z = v2.x * v0.y - v2.y * v0.x;
  251.                 v1.normalize();
  252.                 // render on hemi-cubes
  253.                 hc0.fillRect(hc0.rect, 1);
  254.                 hcx[0].fillRect(hcx[0].rect, 1);
  255.                 hcx[1].fillRect(hcx[1].rect, 1);
  256.                 hcy[0].fillRect(hcy[0].rect, 1);
  257.                 hcy[1].fillRect(hcy[1].rect, 1);
  258.                 for each (p in prims) {
  259.                     x = p.world.x - vertices[i];
  260.                     y = p.world.y - vertices[i+1];
  261.                     z = p.world.z - vertices[i+2];
  262.                     v.x = x * v0.x + y * v0.y + z * v0.z;
  263.                     v.y = x * v1.x + y * v1.y + z * v1.z;
  264.                     v.z = x * v2.x + y * v2.y + z * v2.z;
  265.                     // hemi-cube front
  266.                     if (v.z > 0) {
  267.                         t = hhc/v.z;
  268.                         w = p.aoRadius * 0.8 * t;
  269.                         rect.x = v.x * t - w + hhc;
  270.                         rect.y = v.y * t - w + hhc;
  271.                         rect.width = w + w;
  272.                         rect.height = w + w;
  273.                         hc0.fillRect(rect, 0);
  274.                     }
  275.                     // hemi-cube x direction
  276.                     if (v.x != 0) {
  277.                         if (v.x > 0) { hci = 0; t =  hhc/v.x; }
  278.                         else         { hci = 1; t = -hhc/v.x; }
  279.                         w = p.aoRadius * 0.65 * t;
  280.                         rect.x = v.y * t - w + hhc;
  281.                         rect.y = v.z * t - w;
  282.                         rect.width = w + w;
  283.                         rect.height = w + w;
  284.                         hcx[hci].fillRect(rect, 0);
  285.                     }
  286.                     // hemi-cube y direction
  287.                     if (v.y != 0) {
  288.                         if (v.y > 0) { hci = 0; t =  hhc/v.y; }
  289.                         else         { hci = 1; t = -hhc/v.y; }
  290.                         w = p.aoRadius * 0.65 * t;
  291.                         rect.x = v.x * t - w + hhc;
  292.                         rect.y = v.z * t - w;
  293.                         rect.width = w + w;
  294.                         rect.height = w + w;
  295.                         hcy[hci].fillRect(rect, 0);
  296.                     }
  297.                 }
  298.                 ao = 0;
  299.                 for (k=0; k<hc0s; k++) {
  300.                     ao += hc0.getPixel(k&hcxf, k>>hcResolution);
  301.                 }
  302.                 for (k=0; k<hcxs; k++) {
  303.                     ix = k & hcxf;
  304.                     iy = k >> hcResolution;
  305.                     ao += hcx[0].getPixel(ix, iy) + hcx[1].getPixel(ix, iy) +
  306.                           hcy[0].getPixel(ix, iy) + hcy[1].getPixel(ix, iy);
  307.                 }
  308.                 aoBuffer[j] = ao * 0.005208333333333333;
  309.                 i+=3;
  310.                 j++;
  311.             }
  312.             _timer.pause(1);
  313.         }
  314.         
  315.         public function calculateTexCoordByVertexNormal(mesh:Mesh, light:Light, aoBuffer:Vector.<Number>) : void {
  316.             var x:Number, y:Number, v:Vector3D, i:int=0, j:int=0, vnormals:Vector.<Vector3D>=mesh.vnormals,
  317.                 dir:Vector3D=light, hv:Vector3D=light.halfVector, 
  318.                 t:Number = aoBlendRatio, it:Number = 1-aoBlendRatio, offset:Number = 0;
  319.             if (!aoSwitch) {
  320.                 t = 0;
  321.                 offset = aoBlendRatio*0.8;
  322.                 it = 1-offset;
  323.             }
  324.             for each (v in vnormals) {
  325.                 x = dir.x * v.x + dir.y * v.y + dir.z * v.z;
  326.                 y = hv.x  * v.x + hv.y  * v.y + hv.z  * v.z;
  327.                 if (x<0) x = 0;
  328.                 if (y<0) y = 0;
  329.                 mesh.texCoord[i] = x*it + aoBuffer[j]*t + offset; i++; j++;
  330.                 mesh.texCoord[i] = y; i+=2;
  331.             }
  332.         }
  333.     }
  334. }
  336. import flash.display.*;
  337. import flash.text.*;
  338. import flash.geom.*;
  339. import flash.events.*;
  341. import flash.utils.getTimer;
  343. class timer extends TextField {
  344.     public var title:String = "";
  345.     private var _time:Vector.<int>;
  346.     private var _sum :Vector.<int>;
  347.     private var _stat:Vector.<String>;
  348.     private var _cnt :int;
  349.     private var _avc:int;
  350.     function timer(averagingCount:int, ...stat) : void {
  351.         _avc  = averagingCount;
  352.         _stat = Vector.<String>(stat);
  353.         _time = new Vector.<int>(stat.length, true);
  354.         _sum  = new Vector.<int>(stat.length, true);
  355.         _cnt  = new Vector.<int>(stat.length, true);
  356.         background = true;
  357.         backgroundColor = 0x00ff00;
  358.         autoSize = "left";
  359.         multiline = true;
  360.         addEventListener("enterFrame", _onEnterFrame);
  361.     }
  362.     public function start(slot:int=0) : void { _time[slot] = getTimer(); }
  363.     public function pause(slot:int=0) : void { _sum[slot] += getTimer() - _time[slot]; }
  364.     public function _onEnterFrame(e:Event) : void {
  365.         if (++_cnt == _avc) {
  366.             _cnt = 0;
  367.             var str:String = "", line:String;
  368.             for (var slot:int = 0; slot<_sum.length; slot++) {
  369.                 line = _stat[slot].replace("##", String(_sum[slot] / _avc));
  370.                 str += line + "\n";
  371.                 _sum[slot] = 0;
  372.             }
  373.             text = title + str;
  374.         }
  375.     }
  376. }
  379. // 3D Engine
  380. //----------------------------------------------------------------------------------------------------
  381. /** Core */
  382. class Render3D extends Shape {
  383.     /** model view matrix */
  384.     public var matrix:Matrix3D;
  385.     private var _meshProjected:Mesh = null;                              // projecting mesh
  386.     private var _facesProjected:Vector.<Face> = new Vector.<Face>();     // projecting face
  387.     private var _projectionMatrix:Matrix3D;                              // projection matrix
  388.     private var _matrixStac:Vector.<Matrix3D> = new Vector.<Matrix3D>(); // matrix stac
  389.     private var _cmdTriangle:Vector.<int> = Vector.<int>([1,2,2]);       // commands to draw triangle
  390.     private var _cmdQuadrangle:Vector.<int> = Vector.<int>([1,2,2,2]);   // commands to draw quadrangle
  391.     private var _data:Vector.<Number> = new Vector.<Number>(8, true);    // data to draw shape
  392.     private var _clippingZ:Number;                                       // z value of clipping plane
  393.     
  394.     /** constructor */
  395.     function Render3D(focus:Number=300, clippingZ:Number=0) {
  396.         var projector:PerspectiveProjection = new PerspectiveProjection()
  397.         projector.focalLength = focus;
  398.         _projectionMatrix = projector.toMatrix3D();
  399.         _clippingZ = -clippingZ;
  400.         matrix = new Matrix3D();
  401.         _matrixStac.length = 1;
  402.         _matrixStac[0] = matrix;
  403.     }
  405.     // control matrix
  406.     //--------------------------------------------------
  407.     public function clear() : Render3D { matrix = _matrixStac[0]; _matrixStac.length = 1; return this; }
  408.     public function push() : Render3D { _matrixStac.push(matrix.clone()); return this; }
  409.     public function pop() : Render3D { matrix = (_matrixStac.length == 1) ? matrix : _matrixStac.pop(); return this; }
  410.     public function id() : Render3D { matrix.identity(); return this; }
  411.     public function t(x:Number, y:Number, z:Number) : Render3D { matrix.prependTranslation(x, y, z); return this; }
  412.     public function tv(v:Vector3D) : Render3D { matrix.prependTranslation(v.x, v.y, v.z); return this; }
  413.     public function s(x:Number, y:Number, z:Number) : Render3D { matrix.prependScale(x, y, z); return this; }
  414.     public function sv(v:Vector3D) : Render3D { matrix.prependScale(v.x, v.y, v.z); return this; }
  415.     public function r(angle:Number, axis:Vector3D) : Render3D { matrix.prependRotation(angle, axis); return this; }
  416.     public function rv(v:Vector3D) : Render3D { matrix.prependRotation(v.w, v); return this; }
  417.     public function rx(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.X_AXIS); return this; }
  418.     public function ry(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Y_AXIS); return this; }
  419.     public function rz(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Z_AXIS); return this; }
  420.     
  421.     // projections
  422.     //--------------------------------------------------
  423.     /** project */
  424.     public function project(mesh:Mesh) : Render3D {
  425.         matrix.transformVectors(mesh.vertices, mesh.verticesOnWorld);
  426.         var fn:Point3D, vs:Vector.<Number> = mesh.verticesOnWorld;
  427.         var m:Vector.<Number> = matrix.rawData, 
  428.             m00:Number = m[0], m01:Number = m[1], m02:Number = m[2], 
  429.             m10:Number = m[4], m11:Number = m[5], m12:Number = m[6], 
  430.             m20:Number = m[8], m21:Number = m[9], m22:Number = m[10];
  431.         _facesProjected.length = 0;
  432.         for each (var f:Face in mesh.faces) {
  433.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2,
  434.                 x0:Number=vs[i0++], x1:Number=vs[i1++], x2:Number=vs[i2++],
  435.                 y0:Number=vs[i0++], y1:Number=vs[i1++], y2:Number=vs[i2++],
  436.                 z0:Number=vs[i0],   z1:Number=vs[i1],   z2:Number=vs[i2];
  437.             if (z0<_clippingZ && z1<_clippingZ && z2<_clippingZ) {
  438.                 fn = f.normal;
  439.                 fn.world.x = fn.x * m00 + fn.y * m10 + fn.z * m20;
  440.                 fn.world.y = fn.x * m01 + fn.y * m11 + fn.z * m21;
  441.                 fn.world.z = fn.x * m02 + fn.y * m12 + fn.z * m22;
  442.                 if (vs[f.pvi-2]*fn.world.x + vs[f.pvi-1]*fn.world.y + vs[f.pvi]*fn.world.z <= 0) {
  443.                     _facesProjected.push(f);
  444.                 }
  445.             }
  446.         }
  447.         _facesProjected.sort(function(f1:Face, f2:Face):Number{ return vs[f2.pvi] - vs[f1.pvi]; });
  448.         _meshProjected = mesh;
  449.         return this;
  450.     }
  451.     
  452.     /** project slower than transformVectors() but Vector3D.w considerable. */
  453.     public function projectPoint3D(points:Vector.<Point3D>) : Render3D {
  454.         var m:Vector.<Number> = matrix.rawData, p:Point3D, 
  455.             m00:Number = m[0],  m01:Number = m[1],  m02:Number = m[2], 
  456.             m10:Number = m[4],  m11:Number = m[5],  m12:Number = m[6], 
  457.             m20:Number = m[8],  m21:Number = m[9],  m22:Number = m[10], 
  458.             m30:Number = m[12], m31:Number = m[13], m32:Number = m[14];
  459.         for each (p in points) {
  460.             p.world.x = p.x * m00 + p.y * m10 + p.z * m20 + p.w * m30;
  461.             p.world.y = p.x * m01 + p.y * m11 + p.z * m21 + p.w * m31;
  462.             p.world.z = p.x * m02 + p.y * m12 + p.z * m22 + p.w * m32;
  463.         }
  464.         return this;
  465.     }
  467.     // rendering
  468.     //--------------------------------------------------
  469.     /** render solid */
  470.     public function renderSolid(light:Light) : Render3D {
  471.         var idx:int, mat:Material, materials:Vector.<Material> = _meshProjected.materials,
  472.             vout:Vector.<Number> = _meshProjected.verticesOnScreen;
  473.         Utils3D.projectVectors(_projectionMatrix, _meshProjected.verticesOnWorld, vout, _meshProjected.texCoord);
  474.         graphics.clear();
  475.         for each (var face:Face in _facesProjected) {
  476.             mat = materials[face.mat];
  477.             graphics.beginFill(mat.getColor(light, face.normal.world), mat.alpha);
  478.             idx = face.i0<<1;
  479.             _data[0] = vout[idx]; idx++;
  480.             _data[1] = vout[idx];
  481.             idx = face.i1<<1;
  482.             _data[2] = vout[idx]; idx++;
  483.             _data[3] = vout[idx];
  484.             idx = face.i2<<1;
  485.             _data[4] = vout[idx]; idx++;
  486.             _data[5] = vout[idx];
  487.             if (face.i3 == -1) {
  488.                 graphics.drawPath(_cmdTriangle, _data);
  489.             } else {
  490.                 idx = face.i3<<1;
  491.                 _data[6] = vout[idx]; idx++;
  492.                 _data[7] = vout[idx];
  493.                 graphics.drawPath(_cmdQuadrangle, _data);
  494.             }
  495.             graphics.endFill();
  496.         }
  497.         return this;
  498.     }
  499.     
  500.     /** render with texture */
  501.     private var _indices:Vector.<int> = new Vector.<int>(); // temporary index list
  502.     public function renderTexture(texture:BitmapData) : Render3D {
  503.         var idx:int, mat:Material, indices:Vector.<int> = _indices;
  504.         indices.length = 0;
  505.         for each (var face:Face in _facesProjected) { indices.push(face.i0, face.i1, face.i2); }
  506.         Utils3D.projectVectors(_projectionMatrix, 
  507.                                _meshProjected.verticesOnWorld, 
  508.                                _meshProjected.verticesOnScreen, 
  509.                                _meshProjected.texCoord);
  510.         graphics.clear();
  511.         graphics.beginBitmapFill(texture, null, false, true);
  512.         graphics.drawTriangles(_meshProjected.verticesOnScreen, indices, _meshProjected.texCoord);
  513.         graphics.endFill();
  514.         return this;
  515.     }
  516. }
  518. /** Point3D */
  519. class Point3D extends Vector3D {
  520.     public var world:Vector3D;
  521.     function Point3D(x:Number=0, y:Number=0, z:Number=0, w:Number=1) { super(x,y,z,w); world=clone(); }
  522. }
  524. /** Face */
  525. class Face {
  526.     public var i0:int, i1:int, i2:int, i3:int, pvi:int, mat:int, normal:Point3D;
  527.     static private var _freeList:Vector.<Face> = new Vector.<Face>();
  528.     static public function free(face:Face) : void { _freeList.push(face); }
  529.     static public function alloc(i0:int, i1:int, i2:int, i3:int, mat:int) : Face { 
  530.         var f:Face = _freeList.pop() || new Face();
  531.         f.i0=i0; f.i1=i1; f.i2=i2; f.i3=i3; f.pvi=0; f.mat=mat;
  532.         return f;
  533.     }
  534. }
  536. /** Mesh */
  537. class Mesh {
  538.     public var materials:Vector.<Material>;                 // material list
  539.     public var verticesCount:int;
  540.     public var vertices:Vector.<Number>;                    // vertex
  541.     public var verticesOnWorld:Vector.<Number>;             // vertex on camera coordinate
  542.     public var verticesOnScreen:Vector.<Number>;            // vertex on screen
  543.     public var texCoord:Vector.<Number>;                    // texture coordinate
  544.     public var faces:Vector.<Face> = new Vector.<Face>();   // face list
  545.     public var vnormals:Vector.<Vector3D>;                  // vertex normal
  546.     
  547.     /** constructor */
  548.     function Mesh(materials:Vector.<Material>) {
  549.         this.materials = materials;
  550.         this.vertices = new Vector.<Number>();
  551.         this.texCoord = new Vector.<Number>();
  552.         this.verticesOnWorld = new Vector.<Number>();
  553.         this.verticesOnScreen = new Vector.<Number>();
  554.         this.vnormals = null;
  555.         this.verticesCount = 0;
  556.     }
  557.     
  558.     /** clear all faces */
  559.     public function clear() : Mesh {
  560.         for each (var face:Face in faces) Face.free(face);
  561.         faces.length = 0;
  562.         return this;
  563.     }
  564.     
  565.     /** register face */
  566.     public function face(i0:int, i1:int, i2:int, mat:int=0) : Mesh {
  567.         faces.push(Face.alloc(i0, i1, i2, -1, mat));
  568.         return this;
  569.     }
  570.     
  571.     /** register quadrangle face. set div=true to divide into 2 triangles. */
  572.     public function qface(i0:int, i1:int, i2:int, i3:int, mat:int=0, div:Boolean=true) : Mesh {
  573.         if (div) faces.push(Face.alloc(i0, i1, i2, -1, mat), Face.alloc(i3, i2, i1, -1, mat));
  574.         else     faces.push(Face.alloc(i0, i1, i3, i2, mat));
  575.         return this;
  576.     }
  577.     
  578.     /** update face gravity point and normal */
  579.     public function updateFaces() : Mesh {
  580.         verticesCount = vertices.length/3;
  581.         var vs:Vector.<Number> = vertices;
  582.         for each (var f:Face in faces) {
  583.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2;
  584.             var x01:Number=vs[i1]-vs[i0], x02:Number=vs[i2]-vs[i0];
  585.             f.pvi = vs.length+2;
  586.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  587.             var y01:Number=vs[i1]-vs[i0], y02:Number=vs[i2]-vs[i0];
  588.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  589.             var z01:Number=vs[i1]-vs[i0], z02:Number=vs[i2]-vs[i0];
  590.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  591.             f.normal = new Point3D(y02*z01-y01*z02, z02*x01-z01*x02, x02*y01-x01*y02, 0);
  592.             f.normal.normalize();
  593.             if (f.i3 != -1) {
  594.                 var i3:int = (f.i3<<1)+f.i3;
  595.                 vs[f.pvi-2] = vs[f.pvi-2]*0.75 + vs[i3++]*0.25;
  596.                 vs[f.pvi-1] = vs[f.pvi-1]*0.75 + vs[i3++]*0.25;
  597.                 vs[f.pvi]   = vs[f.pvi]  *0.75 + vs[i3]  *0.25;
  598.             }
  599.         }
  600.         return this;
  601.     }
  602. }
  604. /** Light */
  605. class Light extends Point3D {
  606.     public var halfVector:Vector3D = new Vector3D();
  607.     
  608.     /** constructor (set position) */
  609.     function Light(x:Number=1, y:Number=1, z:Number=1) {
  610.         super(x, y, z, 0);
  611.         normalize();
  612.     }
  614.     /** projection */
  615.     public function transformBy(matrix:Matrix3D) : void {
  616.         world = matrix.deltaTransformVector(this);
  617.         halfVector.x = world.x;
  618.         halfVector.y = world.y;
  619.         halfVector.z = world.z + 1; 
  620.         halfVector.normalize();
  621.     }
  622. }
  624. /** Material */
  625. class Material extends BitmapData {
  626.     public var alpha:Number = 1;    // The alpha value is available for renderSolid()
  627.     public var doubleSided:int = 0; // set doubleSided=-1 if double sided material
  628.     
  629.     /** constructor */
  630.     function Material(dif:int=128, spc:int=128) { super(dif, spc, false); }
  631.     
  632.     /** set color. */
  633.     public function setColor(col:uint, amb:int=64, dif:int=192, spc:int=0,  pow:Number=8) : Material {
  634.         fillRect(rect, col);
  635.         var lmap:LightMap = new LightMap(width, height);
  636.         draw(lmap.diffusion(amb, dif), null, null, "hardlight");
  637.         draw(lmap.specular (spc, pow), null, null, "add");
  638.         lmap.dispose();
  639.         return this;
  640.     }
  641.     
  642.     /** calculate color by light and normal vector. */
  643.     public function getColor(l:Light, n:Vector3D) : uint {
  644.         var dir:Vector3D = l.world, hv:Vector3D = l.halfVector;
  645.         var ln:int = int((dir.x * n.x + dir.y * n.y + dir.z * n.z) * (width-1)),
  646.             hn:int = int((hv.x  * n.x + hv.y  * n.y + hv.z  * n.z) * (height-1));
  647.         if (ln<0) ln = (-ln) & doubleSided;
  648.         if (hn<0) hn = (-hn) & doubleSided;
  649.         return getPixel(ln, hn);
  650.     }
  651. }
  653. class LightMap extends BitmapData {
  654.     function LightMap(dif:int, spc:int) { super(dif, spc, false); }
  655.     
  656.     public function diffusion(amb:int, dif:int) : BitmapData {
  657.         var col:int, rc:Rectangle = new Rectangle(0, 0, 1, height), ipk:Number = 1 / width;
  658.         for (rc.x=0; rc.x<width; rc.x+=1) {
  659.             col = ((rc.x * (dif - amb)) * ipk) + amb;
  660.             fillRect(rc, (col<<16)|(col<<8)|col);
  661.         }
  662.         return this;
  663.     }
  664.     
  665.     public function specular(spc:int, pow:Number) : BitmapData {
  666.         var col:int, rc:Rectangle = new Rectangle(0, 0, width, 1),
  667.             mpk:Number = (pow + 2) * 0.15915494309189534, ipk:Number = 1 / height;
  668.         for (rc.y=0; rc.y<height; rc.y+=1) {
  669.             col = Math.pow(rc.y * ipk, pow) * spc * mpk;
  670.             if (col > 255) col = 255;
  671.             fillRect(rc, (col<<16)|(col<<8)|col);
  672.         }
  673.         return this;
  674.     }
  675. }
  678. // Ambient Occlusion Primitive
  679. class AOPrimitive extends Point3D {
  680.     public var aoPrimitives:Vector.<AOPrimitive> = new Vector.<AOPrimitive>();
  681.     public var aoRadius:Number, ao:Vector.<Number>;
  682.     function AOPrimitive(x:Number=0, y:Number=0, z:Number=0, r:Number=0, vc:int=0) {
  683.         super(x, y, z, 1);
  684.         aoRadius = r;
  685.         ao = new Vector.<Number>(vc, true);
  686.     }
  687. }
noswf

Real time ambient occlusion forked from: Real time ambient occlusion [diff(1)]

  1. // forked from keim_at_Si's Real time ambient occlusion
  2. // gouraud shading based ambient occlusion (PoC)
  3. //   mouse move to move camera, mouse click to stop motion
  4. //   press z key to switch ambient occlusion
  5. //----------------------------------------------------------------------
  6. package {
  7.     import flash.display.*;
  8.     import flash.events.*;
  9.     import flash.geom.*;
  10.     import flash.utils.*;
  12.     [SWF(width='465', height='465', backgroundColor='#000000', frameRate='60')]
  13.     public class main extends Sprite {
  14.         // settings
  15.         private const aoBlendRatio:Number = 0.6; // blending ratio of a.o.
  16.         private const aoRadius:Number = 8;       // pseudo radius for a.o. calculation
  17.         private const divPlane:int = 16;         // partition number of plane
  18.         private const divSphere:int = 24;        // partition number of sphere
  19.         private const hcResolution:int = 3;      // log2 based hemi-cube resolusion 
  20.         
  21.         // 3D renders
  22.         private var _materials:Vector.<Material> = new Vector.<Material>();
  23.         private var _light:Light = new Light(1,1,1);
  24.         private var _meshSphere:Mesh = new Mesh(_materials);
  26.         private var _meshPlane :Mesh = new Mesh(_materials);
  28.         private var _screen:BitmapData = new BitmapData(465, 465, false, 0);
  29.         private var _matscr:Matrix = new Matrix(1, 0, 0, 1, 232.5, 232.5);
  30.         private var gl:Render3D = new Render3D(250);
  31.         // utils
  32.         private var _timer:timer = new timer(10, "Total: ##[ms/frame]", "AO calc: ##[ms/frame]",  "Rendering: ##[ms/frame]");
  33.         
  34.         // objects
  35.         private var camera:Vector3D;
  36.         private var plane:AOPrimitive;
  37.         private var spheres:Vector.<AOPrimitive> = new Vector.<AOPrimitive>(3);
  38.         private var aoShade:Vector.<AOPrimitive> = new Vector.<AOPrimitive>(3);
  39.         private var spheresProjected:Vector.<Point3D> = new Vector.<Point3D>(3);
  40.         private var aoShadeProjected:Vector.<Point3D> = new Vector.<Point3D>(3);
  41.         
  42.         // motions
  43.         private var motionRadius:Vector.<Number> = Vector.<Number>([  10,  -20,   32]);
  44.         private var motionFreq  :Vector.<Number> = Vector.<Number>([0.20, 0.07,-0.12]);
  45.         private var motionFreqY :Vector.<Number> = Vector.<Number>([0.12, 0.25, 0.05]);
  46.         private var vertexCount:int;
  47.         private var frame:int = 0;
  48.         private var frameStep:int = 1;
  49.         private var aoSwitch:Boolean = true;
  50.         
  51.         // entry point
  52.         function main() {
  53.             var sphereVerticesCount:int = ((divSphere>>1)-1)*divSphere+2,
  54.                 planeVerticesCount:int  = (divPlane+1)*(divPlane+1);
  55.             vertexCount = planeVerticesCount + sphereVerticesCount*3;
  56.             _timer.title = "Vertices: " + String(vertexCount) + "\n";
  57.             
  58.             camera = new Vector3D(0, -5, -50);
  59.             plane  = new AOPrimitive(0, 0, 0, 0, planeVerticesCount);
  60.             spheresProjected[0] = spheres[0] = new AOPrimitive(0, 5, 0, aoRadius, sphereVerticesCount);
  61.             spheresProjected[1] = spheres[1] = new AOPrimitive(0, 5, 0, aoRadius, sphereVerticesCount);
  62.             spheresProjected[2] = spheres[2] = new AOPrimitive(0, 5, 0, aoRadius, sphereVerticesCount);
  63.             aoShadeProjected[0] = aoShade[0] = new AOPrimitive(0,-6, 0, aoRadius);
  64.             aoShadeProjected[1] = aoShade[1] = new AOPrimitive(0,-6, 0, aoRadius);
  65.             aoShadeProjected[2] = aoShade[2] = new AOPrimitive(0,-6, 0, aoRadius);
  66.             plane.aoPrimitives.push(spheres[0], spheres[1], spheres[2]);
  67.             spheres[0].aoPrimitives.push(aoShade[0], spheres[1], spheres[2]);
  68.             spheres[1].aoPrimitives.push(spheres[0], aoShade[1], spheres[2]);
  69.             spheres[2].aoPrimitives.push(spheres[0], spheres[1], aoShade[2]);
  71.             _materials.push((new Material()).setColor(0xffffff, 0, 128, 32, 80));
  72.             _createSphere(_meshSphere, 5, divSphere>>1, divSphere);
  73.             _createPlane(_meshPlane, 80, 80, divPlane, divPlane);
  74.             
  75.             addChild(gl).visible = false;
  76.             addChild(new Bitmap(_screen));
  77.             addChild(_timer);
  78.             addEventListener("enterFrame", _onEnterFrame);
  79.             stage.addEventListener("click", _onClick);
  80.             stage.addEventListener("keyUp", _onKeyUp);
  81.         }
  83.         private function _onEnterFrame(e:Event) : void {
  84.             // motion
  85.             for (var i:int=0; i<3; i++) {
  86.                 spheres[i].x = Math.cos(frame*motionFreq[i]) * motionRadius[i];
  87.                 spheres[i].y = Math.sin(frame*motionFreqY[i]) * 5 + 10;
  88.                 spheres[i].z = Math.sin(frame*motionFreq[i]) * motionRadius[i];
  89.                 aoShade[i].x = spheres[i].x;
  90.                 aoShade[i].y = -5;
  91.                 aoShade[i].z = spheres[i].z;
  92.             }
  93.             
  94.             _timer.start(0);
  95.             // clear screen
  96.             _screen.fillRect(_screen.rect, 0);
  97.             // camera
  98.             gl.id().tv(camera).rx((400-mouseY)*0.15).ry((232-mouseX)*0.5);
  99.             _light.transformBy(gl.matrix);
  100.             // project all primitives
  101.             gl.projectPoint3D(spheresProjected);
  102.             gl.projectPoint3D(aoShadeProjected);
  103.             spheresProjected.sort(function(v1:Point3D, v2:Point3D) : Number { return v1.world.z - v2.world.z; });
  104.             // plane
  105.             gl.push().tv(plane).project(_meshPlane);
  106.             calculateVertexNormal(_meshPlane);
  107.             if (frameStep) calculateAmbientOcclusion(_meshPlane, plane.aoPrimitives, plane.ao);
  108.             calculateTexCoordByVertexNormal(_meshPlane, _light, plane.ao);
  109.             _timer.start(2); 
  110.             _screen.draw(gl.renderTexture(_materials[0]), _matscr);
  111.             _timer.pause(2);
  112.             gl.pop();
  113.             // spheres
  114.             for each (var v:Point3D in spheresProjected) {
  115.                 var p:AOPrimitive = AOPrimitive(v);
  116.                 gl.push().tv(p).project(_meshSphere);
  117.                 calculateVertexNormal(_meshSphere);
  118.                 if (frameStep) calculateAmbientOcclusion(_meshSphere, p.aoPrimitives, p.ao);
  119.                 calculateTexCoordByVertexNormal(_meshSphere, _light, p.ao);
  120.                 _timer.start(2);
  121.                 _screen.draw(gl.renderTexture(_materials[0]), _matscr);
  122.                 _timer.pause(2);
  123.                 gl.pop();
  124.             }
  125.             _timer.pause(0);
  126.             
  127.             frame += frameStep;
  128.         }
  129.         
  130.         private function _onClick(e:Event) : void {
  131.             frameStep = 1 - frameStep;
  132.         }
  133.         
  134.         private function _onKeyUp(e:KeyboardEvent) : void {
  135.             var inkey:String = String.fromCharCode(e.keyCode);
  136.             if (inkey == "Z") aoSwitch = !aoSwitch;
  137.         }
  138.         
  139.         private function _createSphere(mesh:Mesh, radius:Number, dlat:int, dlong:int) : Mesh {
  140.             var ilat:int, ilong:int, lat:Number, long:Number, r:Number, vidx:int, 
  141.             slat:Number = 3.141592653589793/dlat, slong:Number  = 6.283185307179586/dlong;
  142.             mesh.vertices.push(0, radius, 0);
  143.             mesh.texCoord.push(0, 0, 0);
  144.             for (ilat=1, lat=slat; ilat<dlat; ilat++, lat+=slat) {
  145.                 r = Math.sin(lat) * radius;
  146.                 for (ilong=0, long=-ilat*slong*0.5; ilong<dlong; ilong++, long+=slong) {
  147.                     mesh.vertices.push(Math.cos(long) * r, Math.cos(lat) * radius, Math.sin(long) * r);
  148.                     mesh.texCoord.push(0, 0, 0);
  149.                 }
  150.             }
  151.             mesh.vertices.push(0, -radius, 0);
  152.             mesh.texCoord.push(0, 0, 0);
  153.             for (ilat=0; ilat<dlat-2; ilat++) {
  154.                 vidx = ilat * dlong + 1;
  155.                 for (ilong=1; ilong<dlong; ilong++, vidx++) {
  156.                     mesh.qface(vidx+1, vidx, vidx+dlong+1, vidx+dlong, 0, true);
  157.                 }
  158.                 mesh.qface(vidx-dlong+1, vidx, vidx+1, vidx+dlong, 0, true);
  159.             }
  160.             vidx = dlong * (dlat-1) + 1;
  161.             for (ilong=0; ilong<dlong-1; ilong++) {
  162.                 mesh.face(0, ilong+1, ilong+2, 0);
  163.                 mesh.face(vidx, vidx-(ilong+1), vidx-(ilong+2), 0);
  164.             }
  165.             mesh.face(0, ilong+1, 1, 0);
  166.             mesh.face(vidx, vidx-(ilong+1), vidx-1, 0);
  167.             mesh.updateFaces();
  168.             
  169.             mesh.vnormals = new Vector.<Vector3D>(mesh.verticesCount, true);
  170.             for (var i:int=0; i<mesh.verticesCount; i++) mesh.vnormals[i] = new Vector3D();
  171.             return mesh;
  172.         }
  173.         
  174.         private function _createPlane(mesh:Mesh, w:Number, h:Number, divx:int, divy:int) : Mesh {
  175.             var x:Number, y:Number, ix:int, iy:int, i:int, j:int, 
  176.                 hw:Number=w*0.5, hh:Number=h*0.5, dx:Number=1/divx, dy:Number=1/divy;
  177.             for (y=0, iy=0; iy<=divy; y+=dy, iy++) {
  178.                 for (x=0, ix=0; ix<=divx; x+=dx, ix++) {
  179.                     mesh.vertices.push(x*w-hw, 0, y*h-hh);
  180.                     mesh.texCoord.push(x, y, 0);
  181.                 }
  182.             }
  183.             for (iy=0; iy<divy; iy++) {
  184.                 for (ix=0; ix<divx; ix++) {
  185.                     i = iy*(divy+1)+ix;
  186.                     j = i + divy+1;
  187.                     mesh.qface(i, i+1, j, j+1, 0, true);
  188.                 }
  189.             }
  190.             mesh.updateFaces();
  191.             
  192.             mesh.vnormals = new Vector.<Vector3D>(mesh.verticesCount, true);
  193.             for (i=0; i<mesh.verticesCount; i++) mesh.vnormals[i] = new Vector3D();
  194.             return mesh;
  195.         }
  196.         
  197.         public function calculateVertexNormal(mesh:Mesh) : void {
  198.             var i:int, v:Vector3D, fn:Vector3D, n:Number, vnormals:Vector.<Vector3D>=mesh.vnormals;
  199.             for each (v in vnormals) {
  200.                 v.x = v.y = v.z = v.w = 0;
  201.             }
  202.             for each (var face:Face in mesh.faces) {
  203.                 fn = face.normal.world;
  204.                 v = vnormals[face.i0]; v.x += fn.x; v.y += fn.y; v.z += fn.z; v.w += 1;
  205.                 v = vnormals[face.i1]; v.x += fn.x; v.y += fn.y; v.z += fn.z; v.w += 1;
  206.                 v = vnormals[face.i2]; v.x += fn.x; v.y += fn.y; v.z += fn.z; v.w += 1;
  207.             }
  208.             for each (v in vnormals) {
  209.                 if (v.w == 0) continue;
  210.                 n = 1/v.w;
  211.                 v.x *= n;
  212.                 v.y *= n;
  213.                 v.z *= n;
  214.             }
  215.             mesh.vnormals = vnormals;
  216.         }
  217.         
  218.         private const bmdw:int = 1<<hcResolution;
  219.         private var v0:Vector3D = new Vector3D(), v1:Vector3D = new Vector3D(), v:Vector3D = new Vector3D();
  220.         private var hc0:BitmapData = new BitmapData(bmdw,bmdw,false);
  221.         private var hcx:Vector.<BitmapData> = Vector.<BitmapData>([
  222.             new BitmapData(bmdw, bmdw>>1, false), 
  223.             new BitmapData(bmdw, bmdw>>1, false)
  224.         ]);
  225.         private var hcy:Vector.<BitmapData> = Vector.<BitmapData>([
  226.             new BitmapData(bmdw, bmdw>>1, false), 
  227.             new BitmapData(bmdw, bmdw>>1, false)
  228.         ]);
  229.         private var rect:Rectangle = new Rectangle();
  230.         public function calculateAmbientOcclusion(mesh:Mesh, prims:Vector.<AOPrimitive>, aoBuffer:Vector.<Number>) : void {
  231.             var x:Number, y:Number, z:Number, w:Number, t:Number, v2:Vector3D, p:AOPrimitive, 
  232.                 i:int=0, j:int=0, k:int, hci:int, ao:int, ix:int, iy:int, 
  233.                 hhc:int = bmdw>>1, hc0s:int = bmdw*bmdw, hcxs:int = hc0s>>1, hcxf:int = bmdw-1, 
  234.                 vnormals:Vector.<Vector3D> = mesh.vnormals, 
  235.                 vertices:Vector.<Number> = mesh.verticesOnWorld;
  236.             _timer.start(1);
  237.             for each (v2 in vnormals) {
  238.                 v1.x = 0.0;
  239.                 v1.y = 0.0;
  240.                 v1.z = 0.0;
  241.                      if ((v2.y < 0.6) && (v2.y > -0.6)) v1.y = -1.0;
  242.                 else if ((v2.z < 0.6) && (v2.z > -0.6)) v1.z = 1.0;
  243.                 else v1.x = 1.0;
  244.                 v0.x = v1.y * v2.z - v1.z * v2.y;
  245.                 v0.y = v1.z * v2.x - v1.x * v2.z;
  246.                 v0.z = v1.x * v2.y - v1.y * v2.x;
  247.                 v0.normalize();
  248.                 v1.x = v2.y * v0.z - v2.z * v0.y;
  249.                 v1.y = v2.z * v0.x - v2.x * v0.z;
  250.                 v1.z = v2.x * v0.y - v2.y * v0.x;
  251.                 v1.normalize();
  252.                 // render on hemi-cubes
  253.                 hc0.fillRect(hc0.rect, 1);
  254.                 hcx[0].fillRect(hcx[0].rect, 1);
  255.                 hcx[1].fillRect(hcx[1].rect, 1);
  256.                 hcy[0].fillRect(hcy[0].rect, 1);
  257.                 hcy[1].fillRect(hcy[1].rect, 1);
  258.                 for each (p in prims) {
  259.                     x = p.world.x - vertices[i];
  260.                     y = p.world.y - vertices[i+1];
  261.                     z = p.world.z - vertices[i+2];
  262.                     v.x = x * v0.x + y * v0.y + z * v0.z;
  263.                     v.y = x * v1.x + y * v1.y + z * v1.z;
  264.                     v.z = x * v2.x + y * v2.y + z * v2.z;
  265.                     // hemi-cube front
  266.                     if (v.z > 0) {
  267.                         t = hhc/v.z;
  268.                         w = p.aoRadius * 0.8 * t;
  269.                         rect.x = v.x * t - w + hhc;
  270.                         rect.y = v.y * t - w + hhc;
  271.                         rect.width = w + w;
  272.                         rect.height = w + w;
  273.                         hc0.fillRect(rect, 0);
  274.                     }
  275.                     // hemi-cube x direction
  276.                     if (v.x != 0) {
  277.                         if (v.x > 0) { hci = 0; t =  hhc/v.x; }
  278.                         else         { hci = 1; t = -hhc/v.x; }
  279.                         w = p.aoRadius * 0.65 * t;
  280.                         rect.x = v.y * t - w + hhc;
  281.                         rect.y = v.z * t - w;
  282.                         rect.width = w + w;
  283.                         rect.height = w + w;
  284.                         hcx[hci].fillRect(rect, 0);
  285.                     }
  286.                     // hemi-cube y direction
  287.                     if (v.y != 0) {
  288.                         if (v.y > 0) { hci = 0; t =  hhc/v.y; }
  289.                         else         { hci = 1; t = -hhc/v.y; }
  290.                         w = p.aoRadius * 0.65 * t;
  291.                         rect.x = v.x * t - w + hhc;
  292.                         rect.y = v.z * t - w;
  293.                         rect.width = w + w;
  294.                         rect.height = w + w;
  295.                         hcy[hci].fillRect(rect, 0);
  296.                     }
  297.                 }
  298.                 ao = 0;
  299.                 for (k=0; k<hc0s; k++) {
  300.                     ao += hc0.getPixel(k&hcxf, k>>hcResolution);
  301.                 }
  302.                 for (k=0; k<hcxs; k++) {
  303.                     ix = k & hcxf;
  304.                     iy = k >> hcResolution;
  305.                     ao += hcx[0].getPixel(ix, iy) + hcx[1].getPixel(ix, iy) +
  306.                           hcy[0].getPixel(ix, iy) + hcy[1].getPixel(ix, iy);
  307.                 }
  308.                 aoBuffer[j] = ao * 0.005208333333333333;
  309.                 i+=3;
  310.                 j++;
  311.             }
  312.             _timer.pause(1);
  313.         }
  314.         
  315.         public function calculateTexCoordByVertexNormal(mesh:Mesh, light:Light, aoBuffer:Vector.<Number>) : void {
  316.             var x:Number, y:Number, v:Vector3D, i:int=0, j:int=0, vnormals:Vector.<Vector3D>=mesh.vnormals,
  317.                 dir:Vector3D=light, hv:Vector3D=light.halfVector, 
  318.                 t:Number = aoBlendRatio, it:Number = 1-aoBlendRatio, offset:Number = 0;
  319.             if (!aoSwitch) {
  320.                 t = 0;
  321.                 offset = aoBlendRatio*0.8;
  322.                 it = 1-offset;
  323.             }
  324.             for each (v in vnormals) {
  325.                 x = dir.x * v.x + dir.y * v.y + dir.z * v.z;
  326.                 y = hv.x  * v.x + hv.y  * v.y + hv.z  * v.z;
  327.                 if (x<0) x = 0;
  328.                 if (y<0) y = 0;
  329.                 mesh.texCoord[i] = x*it + aoBuffer[j]*t + offset; i++; j++;
  330.                 mesh.texCoord[i] = y; i+=2;
  331.             }
  332.         }
  333.     }
  334. }
  336. import flash.display.*;
  337. import flash.text.*;
  338. import flash.geom.*;
  339. import flash.events.*;
  341. import flash.utils.getTimer;
  343. class timer extends TextField {
  344.     public var title:String = "";
  345.     private var _time:Vector.<int>;
  346.     private var _sum :Vector.<int>;
  347.     private var _stat:Vector.<String>;
  348.     private var _cnt :int;
  349.     private var _avc:int;
  350.     function timer(averagingCount:int, ...stat) : void {
  351.         _avc  = averagingCount;
  352.         _stat = Vector.<String>(stat);
  353.         _time = new Vector.<int>(stat.length, true);
  354.         _sum  = new Vector.<int>(stat.length, true);
  355.         _cnt  = new Vector.<int>(stat.length, true);
  356.         background = true;
  357.         backgroundColor = 0x00ff00;
  358.         autoSize = "left";
  359.         multiline = true;
  360.         addEventListener("enterFrame", _onEnterFrame);
  361.     }
  362.     public function start(slot:int=0) : void { _time[slot] = getTimer(); }
  363.     public function pause(slot:int=0) : void { _sum[slot] += getTimer() - _time[slot]; }
  364.     public function _onEnterFrame(e:Event) : void {
  365.         if (++_cnt == _avc) {
  366.             _cnt = 0;
  367.             var str:String = "", line:String;
  368.             for (var slot:int = 0; slot<_sum.length; slot++) {
  369.                 line = _stat[slot].replace("##", String(_sum[slot] / _avc));
  370.                 str += line + "\n";
  371.                 _sum[slot] = 0;
  372.             }
  373.             text = title + str;
  374.         }
  375.     }
  376. }
  379. // 3D Engine
  380. //----------------------------------------------------------------------------------------------------
  381. /** Core */
  382. class Render3D extends Shape {
  383.     /** model view matrix */
  384.     public var matrix:Matrix3D;
  385.     private var _meshProjected:Mesh = null;                              // projecting mesh
  386.     private var _facesProjected:Vector.<Face> = new Vector.<Face>();     // projecting face
  387.     private var _projectionMatrix:Matrix3D;                              // projection matrix
  388.     private var _matrixStac:Vector.<Matrix3D> = new Vector.<Matrix3D>(); // matrix stac
  389.     private var _cmdTriangle:Vector.<int> = Vector.<int>([1,2,2]);       // commands to draw triangle
  390.     private var _cmdQuadrangle:Vector.<int> = Vector.<int>([1,2,2,2]);   // commands to draw quadrangle
  391.     private var _data:Vector.<Number> = new Vector.<Number>(8, true);    // data to draw shape
  392.     private var _clippingZ:Number;                                       // z value of clipping plane
  393.     
  394.     /** constructor */
  395.     function Render3D(focus:Number=300, clippingZ:Number=0) {
  396.         var projector:PerspectiveProjection = new PerspectiveProjection()
  397.         projector.focalLength = focus;
  398.         _projectionMatrix = projector.toMatrix3D();
  399.         _clippingZ = -clippingZ;
  400.         matrix = new Matrix3D();
  401.         _matrixStac.length = 1;
  402.         _matrixStac[0] = matrix;
  403.     }
  405.     // control matrix
  406.     //--------------------------------------------------
  407.     public function clear() : Render3D { matrix = _matrixStac[0]; _matrixStac.length = 1; return this; }
  408.     public function push() : Render3D { _matrixStac.push(matrix.clone()); return this; }
  409.     public function pop() : Render3D { matrix = (_matrixStac.length == 1) ? matrix : _matrixStac.pop(); return this; }
  410.     public function id() : Render3D { matrix.identity(); return this; }
  411.     public function t(x:Number, y:Number, z:Number) : Render3D { matrix.prependTranslation(x, y, z); return this; }
  412.     public function tv(v:Vector3D) : Render3D { matrix.prependTranslation(v.x, v.y, v.z); return this; }
  413.     public function s(x:Number, y:Number, z:Number) : Render3D { matrix.prependScale(x, y, z); return this; }
  414.     public function sv(v:Vector3D) : Render3D { matrix.prependScale(v.x, v.y, v.z); return this; }
  415.     public function r(angle:Number, axis:Vector3D) : Render3D { matrix.prependRotation(angle, axis); return this; }
  416.     public function rv(v:Vector3D) : Render3D { matrix.prependRotation(v.w, v); return this; }
  417.     public function rx(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.X_AXIS); return this; }
  418.     public function ry(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Y_AXIS); return this; }
  419.     public function rz(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Z_AXIS); return this; }
  420.     
  421.     // projections
  422.     //--------------------------------------------------
  423.     /** project */
  424.     public function project(mesh:Mesh) : Render3D {
  425.         matrix.transformVectors(mesh.vertices, mesh.verticesOnWorld);
  426.         var fn:Point3D, vs:Vector.<Number> = mesh.verticesOnWorld;
  427.         var m:Vector.<Number> = matrix.rawData, 
  428.             m00:Number = m[0], m01:Number = m[1], m02:Number = m[2], 
  429.             m10:Number = m[4], m11:Number = m[5], m12:Number = m[6], 
  430.             m20:Number = m[8], m21:Number = m[9], m22:Number = m[10];
  431.         _facesProjected.length = 0;
  432.         for each (var f:Face in mesh.faces) {
  433.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2,
  434.                 x0:Number=vs[i0++], x1:Number=vs[i1++], x2:Number=vs[i2++],
  435.                 y0:Number=vs[i0++], y1:Number=vs[i1++], y2:Number=vs[i2++],
  436.                 z0:Number=vs[i0],   z1:Number=vs[i1],   z2:Number=vs[i2];
  437.             if (z0<_clippingZ && z1<_clippingZ && z2<_clippingZ) {
  438.                 fn = f.normal;
  439.                 fn.world.x = fn.x * m00 + fn.y * m10 + fn.z * m20;
  440.                 fn.world.y = fn.x * m01 + fn.y * m11 + fn.z * m21;
  441.                 fn.world.z = fn.x * m02 + fn.y * m12 + fn.z * m22;
  442.                 if (vs[f.pvi-2]*fn.world.x + vs[f.pvi-1]*fn.world.y + vs[f.pvi]*fn.world.z <= 0) {
  443.                     _facesProjected.push(f);
  444.                 }
  445.             }
  446.         }
  447.         _facesProjected.sort(function(f1:Face, f2:Face):Number{ return vs[f2.pvi] - vs[f1.pvi]; });
  448.         _meshProjected = mesh;
  449.         return this;
  450.     }
  451.     
  452.     /** project slower than transformVectors() but Vector3D.w considerable. */
  453.     public function projectPoint3D(points:Vector.<Point3D>) : Render3D {
  454.         var m:Vector.<Number> = matrix.rawData, p:Point3D, 
  455.             m00:Number = m[0],  m01:Number = m[1],  m02:Number = m[2], 
  456.             m10:Number = m[4],  m11:Number = m[5],  m12:Number = m[6], 
  457.             m20:Number = m[8],  m21:Number = m[9],  m22:Number = m[10], 
  458.             m30:Number = m[12], m31:Number = m[13], m32:Number = m[14];
  459.         for each (p in points) {
  460.             p.world.x = p.x * m00 + p.y * m10 + p.z * m20 + p.w * m30;
  461.             p.world.y = p.x * m01 + p.y * m11 + p.z * m21 + p.w * m31;
  462.             p.world.z = p.x * m02 + p.y * m12 + p.z * m22 + p.w * m32;
  463.         }
  464.         return this;
  465.     }
  467.     // rendering
  468.     //--------------------------------------------------
  469.     /** render solid */
  470.     public function renderSolid(light:Light) : Render3D {
  471.         var idx:int, mat:Material, materials:Vector.<Material> = _meshProjected.materials,
  472.             vout:Vector.<Number> = _meshProjected.verticesOnScreen;
  473.         Utils3D.projectVectors(_projectionMatrix, _meshProjected.verticesOnWorld, vout, _meshProjected.texCoord);
  474.         graphics.clear();
  475.         for each (var face:Face in _facesProjected) {
  476.             mat = materials[face.mat];
  477.             graphics.beginFill(mat.getColor(light, face.normal.world), mat.alpha);
  478.             idx = face.i0<<1;
  479.             _data[0] = vout[idx]; idx++;
  480.             _data[1] = vout[idx];
  481.             idx = face.i1<<1;
  482.             _data[2] = vout[idx]; idx++;
  483.             _data[3] = vout[idx];
  484.             idx = face.i2<<1;
  485.             _data[4] = vout[idx]; idx++;
  486.             _data[5] = vout[idx];
  487.             if (face.i3 == -1) {
  488.                 graphics.drawPath(_cmdTriangle, _data);
  489.             } else {
  490.                 idx = face.i3<<1;
  491.                 _data[6] = vout[idx]; idx++;
  492.                 _data[7] = vout[idx];
  493.                 graphics.drawPath(_cmdQuadrangle, _data);
  494.             }
  495.             graphics.endFill();
  496.         }
  497.         return this;
  498.     }
  499.     
  500.     /** render with texture */
  501.     private var _indices:Vector.<int> = new Vector.<int>(); // temporary index list
  502.     public function renderTexture(texture:BitmapData) : Render3D {
  503.         var idx:int, mat:Material, indices:Vector.<int> = _indices;
  504.         indices.length = 0;
  505.         for each (var face:Face in _facesProjected) { indices.push(face.i0, face.i1, face.i2); }
  506.         Utils3D.projectVectors(_projectionMatrix, 
  507.                                _meshProjected.verticesOnWorld, 
  508.                                _meshProjected.verticesOnScreen, 
  509.                                _meshProjected.texCoord);
  510.         graphics.clear();
  511.         graphics.beginBitmapFill(texture, null, false, true);
  512.         graphics.drawTriangles(_meshProjected.verticesOnScreen, indices, _meshProjected.texCoord);
  513.         graphics.endFill();
  514.         return this;
  515.     }
  516. }
  518. /** Point3D */
  519. class Point3D extends Vector3D {
  520.     public var world:Vector3D;
  521.     function Point3D(x:Number=0, y:Number=0, z:Number=0, w:Number=1) { super(x,y,z,w); world=clone(); }
  522. }
  524. /** Face */
  525. class Face {
  526.     public var i0:int, i1:int, i2:int, i3:int, pvi:int, mat:int, normal:Point3D;
  527.     static private var _freeList:Vector.<Face> = new Vector.<Face>();
  528.     static public function free(face:Face) : void { _freeList.push(face); }
  529.     static public function alloc(i0:int, i1:int, i2:int, i3:int, mat:int) : Face { 
  530.         var f:Face = _freeList.pop() || new Face();
  531.         f.i0=i0; f.i1=i1; f.i2=i2; f.i3=i3; f.pvi=0; f.mat=mat;
  532.         return f;
  533.     }
  534. }
  536. /** Mesh */
  537. class Mesh {
  538.     public var materials:Vector.<Material>;                 // material list
  539.     public var verticesCount:int;
  540.     public var vertices:Vector.<Number>;                    // vertex
  541.     public var verticesOnWorld:Vector.<Number>;             // vertex on camera coordinate
  542.     public var verticesOnScreen:Vector.<Number>;            // vertex on screen
  543.     public var texCoord:Vector.<Number>;                    // texture coordinate
  544.     public var faces:Vector.<Face> = new Vector.<Face>();   // face list
  545.     public var vnormals:Vector.<Vector3D>;                  // vertex normal
  546.     
  547.     /** constructor */
  548.     function Mesh(materials:Vector.<Material>) {
  549.         this.materials = materials;
  550.         this.vertices = new Vector.<Number>();
  551.         this.texCoord = new Vector.<Number>();
  552.         this.verticesOnWorld = new Vector.<Number>();
  553.         this.verticesOnScreen = new Vector.<Number>();
  554.         this.vnormals = null;
  555.         this.verticesCount = 0;
  556.     }
  557.     
  558.     /** clear all faces */
  559.     public function clear() : Mesh {
  560.         for each (var face:Face in faces) Face.free(face);
  561.         faces.length = 0;
  562.         return this;
  563.     }
  564.     
  565.     /** register face */
  566.     public function face(i0:int, i1:int, i2:int, mat:int=0) : Mesh {
  567.         faces.push(Face.alloc(i0, i1, i2, -1, mat));
  568.         return this;
  569.     }
  570.     
  571.     /** register quadrangle face. set div=true to divide into 2 triangles. */
  572.     public function qface(i0:int, i1:int, i2:int, i3:int, mat:int=0, div:Boolean=true) : Mesh {
  573.         if (div) faces.push(Face.alloc(i0, i1, i2, -1, mat), Face.alloc(i3, i2, i1, -1, mat));
  574.         else     faces.push(Face.alloc(i0, i1, i3, i2, mat));
  575.         return this;
  576.     }
  577.     
  578.     /** update face gravity point and normal */
  579.     public function updateFaces() : Mesh {
  580.         verticesCount = vertices.length/3;
  581.         var vs:Vector.<Number> = vertices;
  582.         for each (var f:Face in faces) {
  583.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2;
  584.             var x01:Number=vs[i1]-vs[i0], x02:Number=vs[i2]-vs[i0];
  585.             f.pvi = vs.length+2;
  586.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  587.             var y01:Number=vs[i1]-vs[i0], y02:Number=vs[i2]-vs[i0];
  588.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  589.             var z01:Number=vs[i1]-vs[i0], z02:Number=vs[i2]-vs[i0];
  590.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  591.             f.normal = new Point3D(y02*z01-y01*z02, z02*x01-z01*x02, x02*y01-x01*y02, 0);
  592.             f.normal.normalize();
  593.             if (f.i3 != -1) {
  594.                 var i3:int = (f.i3<<1)+f.i3;
  595.                 vs[f.pvi-2] = vs[f.pvi-2]*0.75 + vs[i3++]*0.25;
  596.                 vs[f.pvi-1] = vs[f.pvi-1]*0.75 + vs[i3++]*0.25;
  597.                 vs[f.pvi]   = vs[f.pvi]  *0.75 + vs[i3]  *0.25;
  598.             }
  599.         }
  600.         return this;
  601.     }
  602. }
  604. /** Light */
  605. class Light extends Point3D {
  606.     public var halfVector:Vector3D = new Vector3D();
  607.     
  608.     /** constructor (set position) */
  609.     function Light(x:Number=1, y:Number=1, z:Number=1) {
  610.         super(x, y, z, 0);
  611.         normalize();
  612.     }
  614.     /** projection */
  615.     public function transformBy(matrix:Matrix3D) : void {
  616.         world = matrix.deltaTransformVector(this);
  617.         halfVector.x = world.x;
  618.         halfVector.y = world.y;
  619.         halfVector.z = world.z + 1; 
  620.         halfVector.normalize();
  621.     }
  622. }
  624. /** Material */
  625. class Material extends BitmapData {
  626.     public var alpha:Number = 1;    // The alpha value is available for renderSolid()
  627.     public var doubleSided:int = 0; // set doubleSided=-1 if double sided material
  628.     
  629.     /** constructor */
  630.     function Material(dif:int=128, spc:int=128) { super(dif, spc, false); }
  631.     
  632.     /** set color. */
  633.     public function setColor(col:uint, amb:int=64, dif:int=192, spc:int=0,  pow:Number=8) : Material {
  634.         fillRect(rect, col);
  635.         var lmap:LightMap = new LightMap(width, height);
  636.         draw(lmap.diffusion(amb, dif), null, null, "hardlight");
  637.         draw(lmap.specular (spc, pow), null, null, "add");
  638.         lmap.dispose();
  639.         return this;
  640.     }
  641.     
  642.     /** calculate color by light and normal vector. */
  643.     public function getColor(l:Light, n:Vector3D) : uint {
  644.         var dir:Vector3D = l.world, hv:Vector3D = l.halfVector;
  645.         var ln:int = int((dir.x * n.x + dir.y * n.y + dir.z * n.z) * (width-1)),
  646.             hn:int = int((hv.x  * n.x + hv.y  * n.y + hv.z  * n.z) * (height-1));
  647.         if (ln<0) ln = (-ln) & doubleSided;
  648.         if (hn<0) hn = (-hn) & doubleSided;
  649.         return getPixel(ln, hn);
  650.     }
  651. }
  653. class LightMap extends BitmapData {
  654.     function LightMap(dif:int, spc:int) { super(dif, spc, false); }
  655.     
  656.     public function diffusion(amb:int, dif:int) : BitmapData {
  657.         var col:int, rc:Rectangle = new Rectangle(0, 0, 1, height), ipk:Number = 1 / width;
  658.         for (rc.x=0; rc.x<width; rc.x+=1) {
  659.             col = ((rc.x * (dif - amb)) * ipk) + amb;
  660.             fillRect(rc, (col<<16)|(col<<8)|col);
  661.         }
  662.         return this;
  663.     }
  664.     
  665.     public function specular(spc:int, pow:Number) : BitmapData {
  666.         var col:int, rc:Rectangle = new Rectangle(0, 0, width, 1),
  667.             mpk:Number = (pow + 2) * 0.15915494309189534, ipk:Number = 1 / height;
  668.         for (rc.y=0; rc.y<height; rc.y+=1) {
  669.             col = Math.pow(rc.y * ipk, pow) * spc * mpk;
  670.             if (col > 255) col = 255;
  671.             fillRect(rc, (col<<16)|(col<<8)|col);
  672.         }
  673.         return this;
  674.     }
  675. }
  678. // Ambient Occlusion Primitive
  679. class AOPrimitive extends Point3D {
  680.     public var aoPrimitives:Vector.<AOPrimitive> = new Vector.<AOPrimitive>();
  681.     public var aoRadius:Number, ao:Vector.<Number>;
  682.     function AOPrimitive(x:Number=0, y:Number=0, z:Number=0, r:Number=0, vc:int=0) {
  683.         super(x, y, z, 1);
  684.         aoRadius = r;
  685.         ao = new Vector.<Number>(vc, true);
  686.     }
  687. }
noswf

Real time ambient occlusion forked from: Real time ambient occlusion [diff(6)]

  1. // forked from keim_at_Si's Real time ambient occlusion
  2. // gouraud shading based ambient occlusion (PoC)
  3. //   mouse move to move camera, mouse click to stop motion
  4. //   press z key to switch ambient occlusion
  5. //----------------------------------------------------------------------
  6. package {
  7.     import flash.display.*;
  8.     import flash.events.*;
  9.     import flash.geom.*;
  10.     import flash.utils.*;
  12.     [SWF(width='465', height='465', backgroundColor='#000000', frameRate='30')]
  13.     public class main extends Sprite {
  14.         // settings
  15.         private const aoBlendRatio:Number = 0.4; // blending ratio of a.o.
  16.         private const aoRadius:Number = 12;       // pseudo radius for a.o. calculation
  17.         private const divPlane:int = 16;         // partition number of plane
  18.         private const divSphere:int = 6;        // partition number of sphere
  19.         private const hcResolution:int = 2;      // log2 based hemi-cube resolusion 
  20.         
  21.         // 3D renders
  22.         private var _materials:Vector.<Material> = new Vector.<Material>();
  23.         private var _light:Light = new Light(1,1,1);
  24.         private var _meshSphere:Mesh = new Mesh(_materials);
  26.         private var _meshPlane :Mesh = new Mesh(_materials);
  28.         private var _screen:BitmapData = new BitmapData(465, 465, false, 0);
  29.         private var _matscr:Matrix = new Matrix(1, 0, 0, 1, 232.5, 232.5);
  30.         private var gl:Render3D = new Render3D(250);
  31.         // utils
  32.         private var _timer:timer = new timer(10, "Total: ##[ms/frame]", "AO calc: ##[ms/frame]",  "Rendering: ##[ms/frame]");
  33.         
  34.         // objects
  35.         private var camera:Vector3D;
  36.         private var plane:AOPrimitive;
  37.         private var spheres:Vector.<AOPrimitive> = new Vector.<AOPrimitive>(3);
  38.         private var aoShade:Vector.<AOPrimitive> = new Vector.<AOPrimitive>(3);
  39.         private var spheresProjected:Vector.<Point3D> = new Vector.<Point3D>(3);
  40.         private var aoShadeProjected:Vector.<Point3D> = new Vector.<Point3D>(3);
  41.         
  42.         // motions
  43.         private var motionRadius:Vector.<Number> = Vector.<Number>([  10,  -20,   32]);
  44.         private var motionFreq  :Vector.<Number> = Vector.<Number>([0.20, 0.07,-0.12]);
  45.         private var motionFreqY :Vector.<Number> = Vector.<Number>([0.12, 0.25, 0.05]);
  46.         private var vertexCount:int;
  47.         private var frame:int = 0;
  48.         private var frameStep:int = 1;
  49.         private var aoSwitch:Boolean = true;
  50.         
  51.         // entry point
  52.         function main() {
  53.             var sphereVerticesCount:int = ((divSphere>>1)-1)*divSphere+2,
  54.                 planeVerticesCount:int  = (divPlane+1)*(divPlane+1);
  55.             vertexCount = planeVerticesCount + sphereVerticesCount*3;
  56.             _timer.title = "Vertices: " + String(vertexCount) + "\n";
  57.             
  58.             camera = new Vector3D(0, -5, -50);
  59.             plane  = new AOPrimitive(0, 0, 0, 0, planeVerticesCount);
  60.             spheresProjected[0] = spheres[0] = new AOPrimitive(0, 5, 0, aoRadius, sphereVerticesCount);
  61.             spheresProjected[1] = spheres[1] = new AOPrimitive(0, 5, 0, aoRadius, sphereVerticesCount);
  62.             spheresProjected[2] = spheres[2] = new AOPrimitive(0, 5, 0, aoRadius, sphereVerticesCount);
  63.             aoShadeProjected[0] = aoShade[0] = new AOPrimitive(0,-6, 0, aoRadius);
  64.             aoShadeProjected[1] = aoShade[1] = new AOPrimitive(0,-6, 0, aoRadius);
  65.             aoShadeProjected[2] = aoShade[2] = new AOPrimitive(0,-6, 0, aoRadius);
  66.             plane.aoPrimitives.push(spheres[0], spheres[1], spheres[2]);
  67.             spheres[0].aoPrimitives.push(aoShade[0], spheres[1], spheres[2]);
  68.             spheres[1].aoPrimitives.push(spheres[0], aoShade[1], spheres[2]);
  69.             spheres[2].aoPrimitives.push(spheres[0], spheres[1], aoShade[2]);
  71.             _materials.push((new Material()).setColor(0xffffff, 0, 128, 32, 80));
  72.             _createSphere(_meshSphere, 5, divSphere>>1, divSphere);
  73.             _createPlane(_meshPlane, 80, 80, divPlane, divPlane);
  74.             
  75.             addChild(gl).visible = false;
  76.             addChild(new Bitmap(_screen));
  77.             addChild(_timer);
  78.             addEventListener("enterFrame", _onEnterFrame);
  79.             stage.addEventListener("click", _onClick);
  80.             stage.addEventListener("keyUp", _onKeyUp);
  81.         }
  83.         private function _onEnterFrame(e:Event) : void {
  84.             // motion
  85.             for (var i:int=0; i<3; i++) {
  86.                 spheres[i].x = Math.cos(frame*motionFreq[i]) * motionRadius[i];
  87.                 spheres[i].y = Math.sin(frame*motionFreqY[i]) * 5 + 10;
  88.                 spheres[i].z = Math.sin(frame*motionFreq[i]) * motionRadius[i];
  89.                 aoShade[i].x = spheres[i].x;
  90.                 aoShade[i].y = -5;
  91.                 aoShade[i].z = spheres[i].z;
  92.             }
  93.             
  94.             _timer.start(0);
  95.             // clear screen
  96.             _screen.fillRect(_screen.rect, 0);
  97.             // camera
  98.             gl.id().tv(camera).rx((400-mouseY)*0.15).ry((232-mouseX)*0.5);
  99.             _light.transformBy(gl.matrix);
  100.             // project all primitives
  101.             gl.projectPoint3D(spheresProjected);
  102.             gl.projectPoint3D(aoShadeProjected);
  103.             spheresProjected.sort(function(v1:Point3D, v2:Point3D) : Number { return v1.world.z - v2.world.z; });
  104.             // plane
  105.             gl.push().tv(plane).project(_meshPlane);
  106.             calculateVertexNormal(_meshPlane);
  107.             if (frameStep) calculateAmbientOcclusion(_meshPlane, plane.aoPrimitives, plane.ao);
  108.             calculateTexCoordByVertexNormal(_meshPlane, _light, plane.ao);
  109.             _timer.start(2); 
  110.             _screen.draw(gl.renderTexture(_materials[0]), _matscr);
  111.             _timer.pause(2);
  112.             gl.pop();
  113.             // spheres
  114.             for each (var v:Point3D in spheresProjected) {
  115.                 var p:AOPrimitive = AOPrimitive(v);
  116.                 gl.push().tv(p).project(_meshSphere);
  117.                 calculateVertexNormal(_meshSphere);
  118.                 if (frameStep) calculateAmbientOcclusion(_meshSphere, p.aoPrimitives, p.ao);
  119.                 calculateTexCoordByVertexNormal(_meshSphere, _light, p.ao);
  120.                 _timer.start(2);
  121.                 _screen.draw(gl.renderTexture(_materials[0]), _matscr);
  122.                 _timer.pause(2);
  123.                 gl.pop();
  124.             }
  125.             _timer.pause(0);
  126.             
  127.             frame += frameStep;
  128.         }
  129.         
  130.         private function _onClick(e:Event) : void {
  131.             frameStep = 1 - frameStep;
  132.         }
  133.         
  134.         private function _onKeyUp(e:KeyboardEvent) : void {
  135.             var inkey:String = String.fromCharCode(e.keyCode);
  136.             if (inkey == "Z") aoSwitch = !aoSwitch;
  137.         }
  138.         
  139.         private function _createSphere(mesh:Mesh, radius:Number, dlat:int, dlong:int) : Mesh {
  140.             var ilat:int, ilong:int, lat:Number, long:Number, r:Number, vidx:int, 
  141.             slat:Number = 3.141592653589793/dlat, slong:Number  = 6.283185307179586/dlong;
  142.             mesh.vertices.push(0, radius, 0);
  143.             mesh.texCoord.push(0, 0, 0);
  144.             for (ilat=1, lat=slat; ilat<dlat; ilat++, lat+=slat) {
  145.                 r = Math.sin(lat) * radius;
  146.                 for (ilong=0, long=-ilat*slong*0.5; ilong<dlong; ilong++, long+=slong) {
  147.                     mesh.vertices.push(Math.cos(long) * r, Math.cos(lat) * radius, Math.sin(long) * r);
  148.                     mesh.texCoord.push(0, 0, 0);
  149.                 }
  150.             }
  151.             mesh.vertices.push(0, -radius, 0);
  152.             mesh.texCoord.push(0, 0, 0);
  153.             for (ilat=0; ilat<dlat-2; ilat++) {
  154.                 vidx = ilat * dlong + 1;
  155.                 for (ilong=1; ilong<dlong; ilong++, vidx++) {
  156.                     mesh.qface(vidx+1, vidx, vidx+dlong+1, vidx+dlong, 0, true);
  157.                 }
  158.                 mesh.qface(vidx-dlong+1, vidx, vidx+1, vidx+dlong, 0, true);
  159.             }
  160.             vidx = dlong * (dlat-1) + 1;
  161.             for (ilong=0; ilong<dlong-1; ilong++) {
  162.                 mesh.face(0, ilong+1, ilong+2, 0);
  163.                 mesh.face(vidx, vidx-(ilong+1), vidx-(ilong+2), 0);
  164.             }
  165.             mesh.face(0, ilong+1, 1, 0);
  166.             mesh.face(vidx, vidx-(ilong+1), vidx-1, 0);
  167.             mesh.updateFaces();
  168.             
  169.             mesh.vnormals = new Vector.<Vector3D>(mesh.verticesCount, true);
  170.             for (var i:int=0; i<mesh.verticesCount; i++) mesh.vnormals[i] = new Vector3D();
  171.             return mesh;
  172.         }
  173.         
  174.         private function _createPlane(mesh:Mesh, w:Number, h:Number, divx:int, divy:int) : Mesh {
  175.             var x:Number, y:Number, ix:int, iy:int, i:int, j:int, 
  176.                 hw:Number=w*0.5, hh:Number=h*0.5, dx:Number=1/divx, dy:Number=1/divy;
  177.             for (y=0, iy=0; iy<=divy; y+=dy, iy++) {
  178.                 for (x=0, ix=0; ix<=divx; x+=dx, ix++) {
  179.                     mesh.vertices.push(x*w-hw, 0, y*h-hh);
  180.                     mesh.texCoord.push(x, y, 0);
  181.                 }
  182.             }
  183.             for (iy=0; iy<divy; iy++) {
  184.                 for (ix=0; ix<divx; ix++) {
  185.                     i = iy*(divy+1)+ix;
  186.                     j = i + divy+1;
  187.                     mesh.qface(i, i+1, j, j+1, 0, true);
  188.                 }
  189.             }
  190.             mesh.updateFaces();
  191.             
  192.             mesh.vnormals = new Vector.<Vector3D>(mesh.verticesCount, true);
  193.             for (i=0; i<mesh.verticesCount; i++) mesh.vnormals[i] = new Vector3D();
  194.             return mesh;
  195.         }
  196.         
  197.         public function calculateVertexNormal(mesh:Mesh) : void {
  198.             var i:int, v:Vector3D, fn:Vector3D, n:Number, vnormals:Vector.<Vector3D>=mesh.vnormals;
  199.             for each (v in vnormals) {
  200.                 v.x = v.y = v.z = v.w = 0;
  201.             }
  202.             for each (var face:Face in mesh.faces) {
  203.                 fn = face.normal.world;
  204.                 v = vnormals[face.i0]; v.x += fn.x; v.y += fn.y; v.z += fn.z; v.w += 1;
  205.                 v = vnormals[face.i1]; v.x += fn.x; v.y += fn.y; v.z += fn.z; v.w += 1;
  206.                 v = vnormals[face.i2]; v.x += fn.x; v.y += fn.y; v.z += fn.z; v.w += 1;
  207.             }
  208.             for each (v in vnormals) {
  209.                 if (v.w == 0) continue;
  210.                 n = 1/v.w;
  211.                 v.x *= n;
  212.                 v.y *= n;
  213.                 v.z *= n;
  214.             }
  215.             mesh.vnormals = vnormals;
  216.         }
  217.         
  218.         private const bmdw:int = 1<<hcResolution;
  219.         private var v0:Vector3D = new Vector3D(), v1:Vector3D = new Vector3D(), v:Vector3D = new Vector3D();
  220.         private var hc0:BitmapData = new BitmapData(bmdw,bmdw,false);
  221.         private var hcx:Vector.<BitmapData> = Vector.<BitmapData>([
  222.             new BitmapData(bmdw, bmdw>>1, false), 
  223.             new BitmapData(bmdw, bmdw>>1, false)
  224.         ]);
  225.         private var hcy:Vector.<BitmapData> = Vector.<BitmapData>([
  226.             new BitmapData(bmdw, bmdw>>1, false), 
  227.             new BitmapData(bmdw, bmdw>>1, false)
  228.         ]);
  229.         private var rect:Rectangle = new Rectangle();
  230.         public function calculateAmbientOcclusion(mesh:Mesh, prims:Vector.<AOPrimitive>, aoBuffer:Vector.<Number>) : void {
  231.             var x:Number, y:Number, z:Number, w:Number, t:Number, v2:Vector3D, p:AOPrimitive, 
  232.                 i:int=0, j:int=0, k:int, hci:int, ao:int, ix:int, iy:int, 
  233.                 hhc:int = bmdw>>1, hc0s:int = bmdw*bmdw, hcxs:int = hc0s>>1, hcxf:int = bmdw-1, 
  234.                 vnormals:Vector.<Vector3D> = mesh.vnormals, 
  235.                 vertices:Vector.<Number> = mesh.verticesOnWorld;
  236.             _timer.start(1);
  237.             for each (v2 in vnormals) {
  238.                 v1.x = 0.0;
  239.                 v1.y = 0.0;
  240.                 v1.z = 0.0;
  241.                      if ((v2.y < 0.6) && (v2.y > -0.6)) v1.y = -1.0;
  242.                 else if ((v2.z < 0.6) && (v2.z > -0.6)) v1.z = 1.0;
  243.                 else v1.x = 1.0;
  244.                 v0.x = v1.y * v2.z - v1.z * v2.y;
  245.                 v0.y = v1.z * v2.x - v1.x * v2.z;
  246.                 v0.z = v1.x * v2.y - v1.y * v2.x;
  247.                 v0.normalize();
  248.                 v1.x = v2.y * v0.z - v2.z * v0.y;
  249.                 v1.y = v2.z * v0.x - v2.x * v0.z;
  250.                 v1.z = v2.x * v0.y - v2.y * v0.x;
  251.                 v1.normalize();
  252.                 // render on hemi-cubes
  253.                 hc0.fillRect(hc0.rect, 1);
  254.                 hcx[0].fillRect(hcx[0].rect, 1);
  255.                 hcx[1].fillRect(hcx[1].rect, 1);
  256.                 hcy[0].fillRect(hcy[0].rect, 1);
  257.                 hcy[1].fillRect(hcy[1].rect, 1);
  258.                 for each (p in prims) {
  259.                     x = p.world.x - vertices[i];
  260.                     y = p.world.y - vertices[i+1];
  261.                     z = p.world.z - vertices[i+2];
  262.                     v.x = x * v0.x + y * v0.y + z * v0.z;
  263.                     v.y = x * v1.x + y * v1.y + z * v1.z;
  264.                     v.z = x * v2.x + y * v2.y + z * v2.z;
  265.                     // hemi-cube front
  266.                     if (v.z > 0) {
  267.                         t = hhc/v.z;
  268.                         w = p.aoRadius * 0.8 * t;
  269.                         rect.x = v.x * t - w + hhc;
  270.                         rect.y = v.y * t - w + hhc;
  271.                         rect.width = w + w;
  272.                         rect.height = w + w;
  273.                         hc0.fillRect(rect, 0);
  274.                     }
  275.                     // hemi-cube x direction
  276.                     if (v.x != 0) {
  277.                         if (v.x > 0) { hci = 0; t =  hhc/v.x; }
  278.                         else         { hci = 1; t = -hhc/v.x; }
  279.                         w = p.aoRadius * 0.65 * t;
  280.                         rect.x = v.y * t - w + hhc;
  281.                         rect.y = v.z * t - w;
  282.                         rect.width = w + w;
  283.                         rect.height = w + w;
  284.                         hcx[hci].fillRect(rect, 0);
  285.                     }
  286.                     // hemi-cube y direction
  287.                     if (v.y != 0) {
  288.                         if (v.y > 0) { hci = 0; t =  hhc/v.y; }
  289.                         else         { hci = 1; t = -hhc/v.y; }
  290.                         w = p.aoRadius * 0.65 * t;
  291.                         rect.x = v.x * t - w + hhc;
  292.                         rect.y = v.z * t - w;
  293.                         rect.width = w + w;
  294.                         rect.height = w + w;
  295.                         hcy[hci].fillRect(rect, 0);
  296.                     }
  297.                 }
  298.                 ao = 0;
  299.                 for (k=0; k<hc0s; k++) {
  300.                     ao += hc0.getPixel(k&hcxf, k>>hcResolution);
  301.                 }
  302.                 for (k=0; k<hcxs; k++) {
  303.                     ix = k & hcxf;
  304.                     iy = k >> hcResolution;
  305.                     ao += hcx[0].getPixel(ix, iy) + hcx[1].getPixel(ix, iy) +
  306.                           hcy[0].getPixel(ix, iy) + hcy[1].getPixel(ix, iy);
  307.                 }
  308.                 aoBuffer[j] = ao * 0.005208333333333333;
  309.                 i+=3;
  310.                 j++;
  311.             }
  312.             _timer.pause(1);
  313.         }
  314.         
  315.         public function calculateTexCoordByVertexNormal(mesh:Mesh, light:Light, aoBuffer:Vector.<Number>) : void {
  316.             var x:Number, y:Number, v:Vector3D, i:int=0, j:int=0, vnormals:Vector.<Vector3D>=mesh.vnormals,
  317.                 dir:Vector3D=light, hv:Vector3D=light.halfVector, 
  318.                 t:Number = aoBlendRatio, it:Number = 1-aoBlendRatio, offset:Number = 0;
  319.             if (!aoSwitch) {
  320.                 t = 0;
  321.                 offset = aoBlendRatio*0.8;
  322.                 it = 1-offset;
  323.             }
  324.             for each (v in vnormals) {
  325.                 x = dir.x * v.x + dir.y * v.y + dir.z * v.z;
  326.                 y = hv.x  * v.x + hv.y  * v.y + hv.z  * v.z;
  327.                 if (x<0) x = 0;
  328.                 if (y<0) y = 0;
  329.                 mesh.texCoord[i] = x*it + aoBuffer[j]*t + offset; i++; j++;
  330.                 mesh.texCoord[i] = y; i+=2;
  331.             }
  332.         }
  333.     }
  334. }
  336. import flash.display.*;
  337. import flash.text.*;
  338. import flash.geom.*;
  339. import flash.events.*;
  341. import flash.utils.getTimer;
  343. class timer extends TextField {
  344.     public var title:String = "";
  345.     private var _time:Vector.<int>;
  346.     private var _sum :Vector.<int>;
  347.     private var _stat:Vector.<String>;
  348.     private var _cnt :int;
  349.     private var _avc:int;
  350.     function timer(averagingCount:int, ...stat) : void {
  351.         _avc  = averagingCount;
  352.         _stat = Vector.<String>(stat);
  353.         _time = new Vector.<int>(stat.length, true);
  354.         _sum  = new Vector.<int>(stat.length, true);
  355.         _cnt  = new Vector.<int>(stat.length, true);
  356.         background = true;
  357.         backgroundColor = 0x00ff00;
  358.         autoSize = "left";
  359.         multiline = true;
  360.         addEventListener("enterFrame", _onEnterFrame);
  361.     }
  362.     public function start(slot:int=0) : void { _time[slot] = getTimer(); }
  363.     public function pause(slot:int=0) : void { _sum[slot] += getTimer() - _time[slot]; }
  364.     public function _onEnterFrame(e:Event) : void {
  365.         if (++_cnt == _avc) {
  366.             _cnt = 0;
  367.             var str:String = "", line:String;
  368.             for (var slot:int = 0; slot<_sum.length; slot++) {
  369.                 line = _stat[slot].replace("##", String(_sum[slot] / _avc));
  370.                 str += line + "\n";
  371.                 _sum[slot] = 0;
  372.             }
  373.             text = title + str;
  374.         }
  375.     }
  376. }
  379. // 3D Engine
  380. //----------------------------------------------------------------------------------------------------
  381. /** Core */
  382. class Render3D extends Shape {
  383.     /** model view matrix */
  384.     public var matrix:Matrix3D;
  385.     private var _meshProjected:Mesh = null;                              // projecting mesh
  386.     private var _facesProjected:Vector.<Face> = new Vector.<Face>();     // projecting face
  387.     private var _projectionMatrix:Matrix3D;                              // projection matrix
  388.     private var _matrixStac:Vector.<Matrix3D> = new Vector.<Matrix3D>(); // matrix stac
  389.     private var _cmdTriangle:Vector.<int> = Vector.<int>([1,2,2]);       // commands to draw triangle
  390.     private var _cmdQuadrangle:Vector.<int> = Vector.<int>([1,2,2,2]);   // commands to draw quadrangle
  391.     private var _data:Vector.<Number> = new Vector.<Number>(8, true);    // data to draw shape
  392.     private var _clippingZ:Number;                                       // z value of clipping plane
  393.     
  394.     /** constructor */
  395.     function Render3D(focus:Number=300, clippingZ:Number=0) {
  396.         var projector:PerspectiveProjection = new PerspectiveProjection()
  397.         projector.focalLength = focus;
  398.         _projectionMatrix = projector.toMatrix3D();
  399.         _clippingZ = -clippingZ;
  400.         matrix = new Matrix3D();
  401.         _matrixStac.length = 1;
  402.         _matrixStac[0] = matrix;
  403.     }
  405.     // control matrix
  406.     //--------------------------------------------------
  407.     public function clear() : Render3D { matrix = _matrixStac[0]; _matrixStac.length = 1; return this; }
  408.     public function push() : Render3D { _matrixStac.push(matrix.clone()); return this; }
  409.     public function pop() : Render3D { matrix = (_matrixStac.length == 1) ? matrix : _matrixStac.pop(); return this; }
  410.     public function id() : Render3D { matrix.identity(); return this; }
  411.     public function t(x:Number, y:Number, z:Number) : Render3D { matrix.prependTranslation(x, y, z); return this; }
  412.     public function tv(v:Vector3D) : Render3D { matrix.prependTranslation(v.x, v.y, v.z); return this; }
  413.     public function s(x:Number, y:Number, z:Number) : Render3D { matrix.prependScale(x, y, z); return this; }
  414.     public function sv(v:Vector3D) : Render3D { matrix.prependScale(v.x, v.y, v.z); return this; }
  415.     public function r(angle:Number, axis:Vector3D) : Render3D { matrix.prependRotation(angle, axis); return this; }
  416.     public function rv(v:Vector3D) : Render3D { matrix.prependRotation(v.w, v); return this; }
  417.     public function rx(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.X_AXIS); return this; }
  418.     public function ry(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Y_AXIS); return this; }
  419.     public function rz(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Z_AXIS); return this; }
  420.     
  421.     // projections
  422.     //--------------------------------------------------
  423.     /** project */
  424.     public function project(mesh:Mesh) : Render3D {
  425.         matrix.transformVectors(mesh.vertices, mesh.verticesOnWorld);
  426.         var fn:Point3D, vs:Vector.<Number> = mesh.verticesOnWorld;
  427.         var m:Vector.<Number> = matrix.rawData, 
  428.             m00:Number = m[0], m01:Number = m[1], m02:Number = m[2], 
  429.             m10:Number = m[4], m11:Number = m[5], m12:Number = m[6], 
  430.             m20:Number = m[8], m21:Number = m[9], m22:Number = m[10];
  431.         _facesProjected.length = 0;
  432.         for each (var f:Face in mesh.faces) {
  433.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2,
  434.                 x0:Number=vs[i0++], x1:Number=vs[i1++], x2:Number=vs[i2++],
  435.                 y0:Number=vs[i0++], y1:Number=vs[i1++], y2:Number=vs[i2++],
  436.                 z0:Number=vs[i0],   z1:Number=vs[i1],   z2:Number=vs[i2];
  437.             if (z0<_clippingZ && z1<_clippingZ && z2<_clippingZ) {
  438.                 fn = f.normal;
  439.                 fn.world.x = fn.x * m00 + fn.y * m10 + fn.z * m20;
  440.                 fn.world.y = fn.x * m01 + fn.y * m11 + fn.z * m21;
  441.                 fn.world.z = fn.x * m02 + fn.y * m12 + fn.z * m22;
  442.                 if (vs[f.pvi-2]*fn.world.x + vs[f.pvi-1]*fn.world.y + vs[f.pvi]*fn.world.z <= 0) {
  443.                     _facesProjected.push(f);
  444.                 }
  445.             }
  446.         }
  447.         _facesProjected.sort(function(f1:Face, f2:Face):Number{ return vs[f2.pvi] - vs[f1.pvi]; });
  448.         _meshProjected = mesh;
  449.         return this;
  450.     }
  451.     
  452.     /** project slower than transformVectors() but Vector3D.w considerable. */
  453.     public function projectPoint3D(points:Vector.<Point3D>) : Render3D {
  454.         var m:Vector.<Number> = matrix.rawData, p:Point3D, 
  455.             m00:Number = m[0],  m01:Number = m[1],  m02:Number = m[2], 
  456.             m10:Number = m[4],  m11:Number = m[5],  m12:Number = m[6], 
  457.             m20:Number = m[8],  m21:Number = m[9],  m22:Number = m[10], 
  458.             m30:Number = m[12], m31:Number = m[13], m32:Number = m[14];
  459.         for each (p in points) {
  460.             p.world.x = p.x * m00 + p.y * m10 + p.z * m20 + p.w * m30;
  461.             p.world.y = p.x * m01 + p.y * m11 + p.z * m21 + p.w * m31;
  462.             p.world.z = p.x * m02 + p.y * m12 + p.z * m22 + p.w * m32;
  463.         }
  464.         return this;
  465.     }
  467.     // rendering
  468.     //--------------------------------------------------
  469.     /** render solid */
  470.     public function renderSolid(light:Light) : Render3D {
  471.         var idx:int, mat:Material, materials:Vector.<Material> = _meshProjected.materials,
  472.             vout:Vector.<Number> = _meshProjected.verticesOnScreen;
  473.         Utils3D.projectVectors(_projectionMatrix, _meshProjected.verticesOnWorld, vout, _meshProjected.texCoord);
  474.         graphics.clear();
  475.         for each (var face:Face in _facesProjected) {
  476.             mat = materials[face.mat];
  477.             graphics.beginFill(mat.getColor(light, face.normal.world), mat.alpha);
  478.             idx = face.i0<<1;
  479.             _data[0] = vout[idx]; idx++;
  480.             _data[1] = vout[idx];
  481.             idx = face.i1<<1;
  482.             _data[2] = vout[idx]; idx++;
  483.             _data[3] = vout[idx];
  484.             idx = face.i2<<1;
  485.             _data[4] = vout[idx]; idx++;
  486.             _data[5] = vout[idx];
  487.             if (face.i3 == -1) {
  488.                 graphics.drawPath(_cmdTriangle, _data);
  489.             } else {
  490.                 idx = face.i3<<1;
  491.                 _data[6] = vout[idx]; idx++;
  492.                 _data[7] = vout[idx];
  493.                 graphics.drawPath(_cmdQuadrangle, _data);
  494.             }
  495.             graphics.endFill();
  496.         }
  497.         return this;
  498.     }
  499.     
  500.     /** render with texture */
  501.     private var _indices:Vector.<int> = new Vector.<int>(); // temporary index list
  502.     public function renderTexture(texture:BitmapData) : Render3D {
  503.         var idx:int, mat:Material, indices:Vector.<int> = _indices;
  504.         indices.length = 0;
  505.         for each (var face:Face in _facesProjected) { indices.push(face.i0, face.i1, face.i2); }
  506.         Utils3D.projectVectors(_projectionMatrix, 
  507.                                _meshProjected.verticesOnWorld, 
  508.                                _meshProjected.verticesOnScreen, 
  509.                                _meshProjected.texCoord);
  510.         graphics.clear();
  511.         graphics.beginBitmapFill(texture, null, false, true);
  512.         graphics.drawTriangles(_meshProjected.verticesOnScreen, indices, _meshProjected.texCoord);
  513.         graphics.endFill();
  514.         return this;
  515.     }
  516. }
  518. /** Point3D */
  519. class Point3D extends Vector3D {
  520.     public var world:Vector3D;
  521.     function Point3D(x:Number=0, y:Number=0, z:Number=0, w:Number=1) { super(x,y,z,w); world=clone(); }
  522. }
  524. /** Face */
  525. class Face {
  526.     public var i0:int, i1:int, i2:int, i3:int, pvi:int, mat:int, normal:Point3D;
  527.     static private var _freeList:Vector.<Face> = new Vector.<Face>();
  528.     static public function free(face:Face) : void { _freeList.push(face); }
  529.     static public function alloc(i0:int, i1:int, i2:int, i3:int, mat:int) : Face { 
  530.         var f:Face = _freeList.pop() || new Face();
  531.         f.i0=i0; f.i1=i1; f.i2=i2; f.i3=i3; f.pvi=0; f.mat=mat;
  532.         return f;
  533.     }
  534. }
  536. /** Mesh */
  537. class Mesh {
  538.     public var materials:Vector.<Material>;                 // material list
  539.     public var verticesCount:int;
  540.     public var vertices:Vector.<Number>;                    // vertex
  541.     public var verticesOnWorld:Vector.<Number>;             // vertex on camera coordinate
  542.     public var verticesOnScreen:Vector.<Number>;            // vertex on screen
  543.     public var texCoord:Vector.<Number>;                    // texture coordinate
  544.     public var faces:Vector.<Face> = new Vector.<Face>();   // face list
  545.     public var vnormals:Vector.<Vector3D>;                  // vertex normal
  546.     
  547.     /** constructor */
  548.     function Mesh(materials:Vector.<Material>) {
  549.         this.materials = materials;
  550.         this.vertices = new Vector.<Number>();
  551.         this.texCoord = new Vector.<Number>();
  552.         this.verticesOnWorld = new Vector.<Number>();
  553.         this.verticesOnScreen = new Vector.<Number>();
  554.         this.vnormals = null;
  555.         this.verticesCount = 0;
  556.     }
  557.     
  558.     /** clear all faces */
  559.     public function clear() : Mesh {
  560.         for each (var face:Face in faces) Face.free(face);
  561.         faces.length = 0;
  562.         return this;
  563.     }
  564.     
  565.     /** register face */
  566.     public function face(i0:int, i1:int, i2:int, mat:int=0) : Mesh {
  567.         faces.push(Face.alloc(i0, i1, i2, -1, mat));
  568.         return this;
  569.     }
  570.     
  571.     /** register quadrangle face. set div=true to divide into 2 triangles. */
  572.     public function qface(i0:int, i1:int, i2:int, i3:int, mat:int=0, div:Boolean=true) : Mesh {
  573.         if (div) faces.push(Face.alloc(i0, i1, i2, -1, mat), Face.alloc(i3, i2, i1, -1, mat));
  574.         else     faces.push(Face.alloc(i0, i1, i3, i2, mat));
  575.         return this;
  576.     }
  577.     
  578.     /** update face gravity point and normal */
  579.     public function updateFaces() : Mesh {
  580.         verticesCount = vertices.length/3;
  581.         var vs:Vector.<Number> = vertices;
  582.         for each (var f:Face in faces) {
  583.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2;
  584.             var x01:Number=vs[i1]-vs[i0], x02:Number=vs[i2]-vs[i0];
  585.             f.pvi = vs.length+2;
  586.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  587.             var y01:Number=vs[i1]-vs[i0], y02:Number=vs[i2]-vs[i0];
  588.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  589.             var z01:Number=vs[i1]-vs[i0], z02:Number=vs[i2]-vs[i0];
  590.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  591.             f.normal = new Point3D(y02*z01-y01*z02, z02*x01-z01*x02, x02*y01-x01*y02, 0);
  592.             f.normal.normalize();
  593.             if (f.i3 != -1) {
  594.                 var i3:int = (f.i3<<1)+f.i3;
  595.                 vs[f.pvi-2] = vs[f.pvi-2]*0.75 + vs[i3++]*0.25;
  596.                 vs[f.pvi-1] = vs[f.pvi-1]*0.75 + vs[i3++]*0.25;
  597.                 vs[f.pvi]   = vs[f.pvi]  *0.75 + vs[i3]  *0.25;
  598.             }
  599.         }
  600.         return this;
  601.     }
  602. }
  604. /** Light */
  605. class Light extends Point3D {
  606.     public var halfVector:Vector3D = new Vector3D();
  607.     
  608.     /** constructor (set position) */
  609.     function Light(x:Number=1, y:Number=1, z:Number=1) {
  610.         super(x, y, z, 0);
  611.         normalize();
  612.     }
  614.     /** projection */
  615.     public function transformBy(matrix:Matrix3D) : void {
  616.         world = matrix.deltaTransformVector(this);
  617.         halfVector.x = world.x;
  618.         halfVector.y = world.y;
  619.         halfVector.z = world.z + 1; 
  620.         halfVector.normalize();
  621.     }
  622. }
  624. /** Material */
  625. class Material extends BitmapData {
  626.     public var alpha:Number = 1;    // The alpha value is available for renderSolid()
  627.     public var doubleSided:int = 0; // set doubleSided=-1 if double sided material
  628.     
  629.     /** constructor */
  630.     function Material(dif:int=128, spc:int=128) { super(dif, spc, false); }
  631.     
  632.     /** set color. */
  633.     public function setColor(col:uint, amb:int=64, dif:int=192, spc:int=0,  pow:Number=8) : Material {
  634.         fillRect(rect, col);
  635.         var lmap:LightMap = new LightMap(width, height);
  636.         draw(lmap.diffusion(amb, dif), null, null, "hardlight");
  637.         draw(lmap.specular (spc, pow), null, null, "add");
  638.         lmap.dispose();
  639.         return this;
  640.     }
  641.     
  642.     /** calculate color by light and normal vector. */
  643.     public function getColor(l:Light, n:Vector3D) : uint {
  644.         var dir:Vector3D = l.world, hv:Vector3D = l.halfVector;
  645.         var ln:int = int((dir.x * n.x + dir.y * n.y + dir.z * n.z) * (width-1)),
  646.             hn:int = int((hv.x  * n.x + hv.y  * n.y + hv.z  * n.z) * (height-1));
  647.         if (ln<0) ln = (-ln) & doubleSided;
  648.         if (hn<0) hn = (-hn) & doubleSided;
  649.         return getPixel(ln, hn);
  650.     }
  651. }
  653. class LightMap extends BitmapData {
  654.     function LightMap(dif:int, spc:int) { super(dif, spc, false); }
  655.     
  656.     public function diffusion(amb:int, dif:int) : BitmapData {
  657.         var col:int, rc:Rectangle = new Rectangle(0, 0, 1, height), ipk:Number = 1 / width;
  658.         for (rc.x=0; rc.x<width; rc.x+=1) {
  659.             col = ((rc.x * (dif - amb)) * ipk) + amb;
  660.             fillRect(rc, (col<<16)|(col<<8)|col);
  661.         }
  662.         return this;
  663.     }
  664.     
  665.     public function specular(spc:int, pow:Number) : BitmapData {
  666.         var col:int, rc:Rectangle = new Rectangle(0, 0, width, 1),
  667.             mpk:Number = (pow + 2) * 0.15915494309189534, ipk:Number = 1 / height;
  668.         for (rc.y=0; rc.y<height; rc.y+=1) {
  669.             col = Math.pow(rc.y * ipk, pow) * spc * mpk;
  670.             if (col > 255) col = 255;
  671.             fillRect(rc, (col<<16)|(col<<8)|col);
  672.         }
  673.         return this;
  674.     }
  675. }
  678. // Ambient Occlusion Primitive
  679. class AOPrimitive extends Point3D {
  680.     public var aoPrimitives:Vector.<AOPrimitive> = new Vector.<AOPrimitive>();
  681.     public var aoRadius:Number, ao:Vector.<Number>;
  682.     function AOPrimitive(x:Number=0, y:Number=0, z:Number=0, r:Number=0, vc:int=0) {
  683.         super(x, y, z, 1);
  684.         aoRadius = r;
  685.         ao = new Vector.<Number>(vc, true);
  686.     }
  687. }
noswf

Real time ambient occlusion forked from: Real time ambient occlusion [diff(1)]

  1. // forked from keim_at_Si's Real time ambient occlusion
  2. // gouraud shading based ambient occlusion (PoC)
  3. //   mouse move to move camera, mouse click to stop motion
  4. //   press z key to switch ambient occlusion
  5. //----------------------------------------------------------------------
  6. package {
  7.     import flash.display.*;
  8.     import flash.events.*;
  9.     import flash.geom.*;
  10.     import flash.utils.*;
  12.     [SWF(width='465', height='465', backgroundColor='#000000', frameRate='60')]
  13.     public class main extends Sprite {
  14.         // settings
  15.         private const aoBlendRatio:Number = 0.6; // blending ratio of a.o.
  16.         private const aoRadius:Number = 8;       // pseudo radius for a.o. calculation
  17.         private const divPlane:int = 16;         // partition number of plane
  18.         private const divSphere:int = 24;        // partition number of sphere
  19.         private const hcResolution:int = 3;      // log2 based hemi-cube resolusion 
  20.         
  21.         // 3D renders
  22.         private var _materials:Vector.<Material> = new Vector.<Material>();
  23.         private var _light:Light = new Light(1,1,1);
  24.         private var _meshSphere:Mesh = new Mesh(_materials);
  26.         private var _meshPlane :Mesh = new Mesh(_materials);
  28.         private var _screen:BitmapData = new BitmapData(465, 465, false, 0);
  29.         private var _matscr:Matrix = new Matrix(1, 0, 0, 1, 232.5, 232.5);
  30.         private var gl:Render3D = new Render3D(250);
  31.         // utils
  32.         private var _timer:timer = new timer(10, "Total: ##[ms/frame]", "AO calc: ##[ms/frame]",  "Rendering: ##[ms/frame]");
  33.         
  34.         // objects
  35.         private var camera:Vector3D;
  36.         private var plane:AOPrimitive;
  37.         private var spheres:Vector.<AOPrimitive> = new Vector.<AOPrimitive>(3);
  38.         private var aoShade:Vector.<AOPrimitive> = new Vector.<AOPrimitive>(3);
  39.         private var spheresProjected:Vector.<Point3D> = new Vector.<Point3D>(3);
  40.         private var aoShadeProjected:Vector.<Point3D> = new Vector.<Point3D>(3);
  41.         
  42.         // motions
  43.         private var motionRadius:Vector.<Number> = Vector.<Number>([  10,  -20,   32]);
  44.         private var motionFreq  :Vector.<Number> = Vector.<Number>([0.20, 0.07,-0.12]);
  45.         private var motionFreqY :Vector.<Number> = Vector.<Number>([0.12, 0.25, 0.05]);
  46.         private var vertexCount:int;
  47.         private var frame:int = 0;
  48.         private var frameStep:int = 1;
  49.         private var aoSwitch:Boolean = true;
  50.         
  51.         // entry point
  52.         function main() {
  53.             var sphereVerticesCount:int = ((divSphere>>1)-1)*divSphere+2,
  54.                 planeVerticesCount:int  = (divPlane+1)*(divPlane+1);
  55.             vertexCount = planeVerticesCount + sphereVerticesCount*3;
  56.             _timer.title = "Vertices: " + String(vertexCount) + "\n";
  57.             
  58.             camera = new Vector3D(0, -5, -50);
  59.             plane  = new AOPrimitive(0, 0, 0, 0, planeVerticesCount);
  60.             spheresProjected[0] = spheres[0] = new AOPrimitive(0, 5, 0, aoRadius, sphereVerticesCount);
  61.             spheresProjected[1] = spheres[1] = new AOPrimitive(0, 5, 0, aoRadius, sphereVerticesCount);
  62.             spheresProjected[2] = spheres[2] = new AOPrimitive(0, 5, 0, aoRadius, sphereVerticesCount);
  63.             aoShadeProjected[0] = aoShade[0] = new AOPrimitive(0,-6, 0, aoRadius);
  64.             aoShadeProjected[1] = aoShade[1] = new AOPrimitive(0,-6, 0, aoRadius);
  65.             aoShadeProjected[2] = aoShade[2] = new AOPrimitive(0,-6, 0, aoRadius);
  66.             plane.aoPrimitives.push(spheres[0], spheres[1], spheres[2]);
  67.             spheres[0].aoPrimitives.push(aoShade[0], spheres[1], spheres[2]);
  68.             spheres[1].aoPrimitives.push(spheres[0], aoShade[1], spheres[2]);
  69.             spheres[2].aoPrimitives.push(spheres[0], spheres[1], aoShade[2]);
  71.             _materials.push((new Material()).setColor(0xffffff, 0, 128, 32, 80));
  72.             _createSphere(_meshSphere, 5, divSphere>>1, divSphere);
  73.             _createPlane(_meshPlane, 80, 80, divPlane, divPlane);
  74.             
  75.             addChild(gl).visible = false;
  76.             addChild(new Bitmap(_screen));
  77.             addChild(_timer);
  78.             addEventListener("enterFrame", _onEnterFrame);
  79.             stage.addEventListener("click", _onClick);
  80.             stage.addEventListener("keyUp", _onKeyUp);
  81.         }
  83.         private function _onEnterFrame(e:Event) : void {
  84.             // motion
  85.             for (var i:int=0; i<3; i++) {
  86.                 spheres[i].x = Math.cos(frame*motionFreq[i]) * motionRadius[i];
  87.                 spheres[i].y = Math.sin(frame*motionFreqY[i]) * 5 + 10;
  88.                 spheres[i].z = Math.sin(frame*motionFreq[i]) * motionRadius[i];
  89.                 aoShade[i].x = spheres[i].x;
  90.                 aoShade[i].y = -5;
  91.                 aoShade[i].z = spheres[i].z;
  92.             }
  93.             
  94.             _timer.start(0);
  95.             // clear screen
  96.             _screen.fillRect(_screen.rect, 0);
  97.             // camera
  98.             gl.id().tv(camera).rx((400-mouseY)*0.15).ry((232-mouseX)*0.5);
  99.             _light.transformBy(gl.matrix);
  100.             // project all primitives
  101.             gl.projectPoint3D(spheresProjected);
  102.             gl.projectPoint3D(aoShadeProjected);
  103.             spheresProjected.sort(function(v1:Point3D, v2:Point3D) : Number { return v1.world.z - v2.world.z; });
  104.             // plane
  105.             gl.push().tv(plane).project(_meshPlane);
  106.             calculateVertexNormal(_meshPlane);
  107.             if (frameStep) calculateAmbientOcclusion(_meshPlane, plane.aoPrimitives, plane.ao);
  108.             calculateTexCoordByVertexNormal(_meshPlane, _light, plane.ao);
  109.             _timer.start(2); 
  110.             _screen.draw(gl.renderTexture(_materials[0]), _matscr);
  111.             _timer.pause(2);
  112.             gl.pop();
  113.             // spheres
  114.             for each (var v:Point3D in spheresProjected) {
  115.                 var p:AOPrimitive = AOPrimitive(v);
  116.                 gl.push().tv(p).project(_meshSphere);
  117.                 calculateVertexNormal(_meshSphere);
  118.                 if (frameStep) calculateAmbientOcclusion(_meshSphere, p.aoPrimitives, p.ao);
  119.                 calculateTexCoordByVertexNormal(_meshSphere, _light, p.ao);
  120.                 _timer.start(2);
  121.                 _screen.draw(gl.renderTexture(_materials[0]), _matscr);
  122.                 _timer.pause(2);
  123.                 gl.pop();
  124.             }
  125.             _timer.pause(0);
  126.             
  127.             frame += frameStep;
  128.         }
  129.         
  130.         private function _onClick(e:Event) : void {
  131.             frameStep = 1 - frameStep;
  132.         }
  133.         
  134.         private function _onKeyUp(e:KeyboardEvent) : void {
  135.             var inkey:String = String.fromCharCode(e.keyCode);
  136.             if (inkey == "Z") aoSwitch = !aoSwitch;
  137.         }
  138.         
  139.         private function _createSphere(mesh:Mesh, radius:Number, dlat:int, dlong:int) : Mesh {
  140.             var ilat:int, ilong:int, lat:Number, long:Number, r:Number, vidx:int, 
  141.             slat:Number = 3.141592653589793/dlat, slong:Number  = 6.283185307179586/dlong;
  142.             mesh.vertices.push(0, radius, 0);
  143.             mesh.texCoord.push(0, 0, 0);
  144.             for (ilat=1, lat=slat; ilat<dlat; ilat++, lat+=slat) {
  145.                 r = Math.sin(lat) * radius;
  146.                 for (ilong=0, long=-ilat*slong*0.5; ilong<dlong; ilong++, long+=slong) {
  147.                     mesh.vertices.push(Math.cos(long) * r, Math.cos(lat) * radius, Math.sin(long) * r);
  148.                     mesh.texCoord.push(0, 0, 0);
  149.                 }
  150.             }
  151.             mesh.vertices.push(0, -radius, 0);
  152.             mesh.texCoord.push(0, 0, 0);
  153.             for (ilat=0; ilat<dlat-2; ilat++) {
  154.                 vidx = ilat * dlong + 1;
  155.                 for (ilong=1; ilong<dlong; ilong++, vidx++) {
  156.                     mesh.qface(vidx+1, vidx, vidx+dlong+1, vidx+dlong, 0, true);
  157.                 }
  158.                 mesh.qface(vidx-dlong+1, vidx, vidx+1, vidx+dlong, 0, true);
  159.             }
  160.             vidx = dlong * (dlat-1) + 1;
  161.             for (ilong=0; ilong<dlong-1; ilong++) {
  162.                 mesh.face(0, ilong+1, ilong+2, 0);
  163.                 mesh.face(vidx, vidx-(ilong+1), vidx-(ilong+2), 0);
  164.             }
  165.             mesh.face(0, ilong+1, 1, 0);
  166.             mesh.face(vidx, vidx-(ilong+1), vidx-1, 0);
  167.             mesh.updateFaces();
  168.             
  169.             mesh.vnormals = new Vector.<Vector3D>(mesh.verticesCount, true);
  170.             for (var i:int=0; i<mesh.verticesCount; i++) mesh.vnormals[i] = new Vector3D();
  171.             return mesh;
  172.         }
  173.         
  174.         private function _createPlane(mesh:Mesh, w:Number, h:Number, divx:int, divy:int) : Mesh {
  175.             var x:Number, y:Number, ix:int, iy:int, i:int, j:int, 
  176.                 hw:Number=w*0.5, hh:Number=h*0.5, dx:Number=1/divx, dy:Number=1/divy;
  177.             for (y=0, iy=0; iy<=divy; y+=dy, iy++) {
  178.                 for (x=0, ix=0; ix<=divx; x+=dx, ix++) {
  179.                     mesh.vertices.push(x*w-hw, 0, y*h-hh);
  180.                     mesh.texCoord.push(x, y, 0);
  181.                 }
  182.             }
  183.             for (iy=0; iy<divy; iy++) {
  184.                 for (ix=0; ix<divx; ix++) {
  185.                     i = iy*(divy+1)+ix;
  186.                     j = i + divy+1;
  187.                     mesh.qface(i, i+1, j, j+1, 0, true);
  188.                 }
  189.             }
  190.             mesh.updateFaces();
  191.             
  192.             mesh.vnormals = new Vector.<Vector3D>(mesh.verticesCount, true);
  193.             for (i=0; i<mesh.verticesCount; i++) mesh.vnormals[i] = new Vector3D();
  194.             return mesh;
  195.         }
  196.         
  197.         public function calculateVertexNormal(mesh:Mesh) : void {
  198.             var i:int, v:Vector3D, fn:Vector3D, n:Number, vnormals:Vector.<Vector3D>=mesh.vnormals;
  199.             for each (v in vnormals) {
  200.                 v.x = v.y = v.z = v.w = 0;
  201.             }
  202.             for each (var face:Face in mesh.faces) {
  203.                 fn = face.normal.world;
  204.                 v = vnormals[face.i0]; v.x += fn.x; v.y += fn.y; v.z += fn.z; v.w += 1;
  205.                 v = vnormals[face.i1]; v.x += fn.x; v.y += fn.y; v.z += fn.z; v.w += 1;
  206.                 v = vnormals[face.i2]; v.x += fn.x; v.y += fn.y; v.z += fn.z; v.w += 1;
  207.             }
  208.             for each (v in vnormals) {
  209.                 if (v.w == 0) continue;
  210.                 n = 1/v.w;
  211.                 v.x *= n;
  212.                 v.y *= n;
  213.                 v.z *= n;
  214.             }
  215.             mesh.vnormals = vnormals;
  216.         }
  217.         
  218.         private const bmdw:int = 1<<hcResolution;
  219.         private var v0:Vector3D = new Vector3D(), v1:Vector3D = new Vector3D(), v:Vector3D = new Vector3D();
  220.         private var hc0:BitmapData = new BitmapData(bmdw,bmdw,false);
  221.         private var hcx:Vector.<BitmapData> = Vector.<BitmapData>([
  222.             new BitmapData(bmdw, bmdw>>1, false), 
  223.             new BitmapData(bmdw, bmdw>>1, false)
  224.         ]);
  225.         private var hcy:Vector.<BitmapData> = Vector.<BitmapData>([
  226.             new BitmapData(bmdw, bmdw>>1, false), 
  227.             new BitmapData(bmdw, bmdw>>1, false)
  228.         ]);
  229.         private var rect:Rectangle = new Rectangle();
  230.         public function calculateAmbientOcclusion(mesh:Mesh, prims:Vector.<AOPrimitive>, aoBuffer:Vector.<Number>) : void {
  231.             var x:Number, y:Number, z:Number, w:Number, t:Number, v2:Vector3D, p:AOPrimitive, 
  232.                 i:int=0, j:int=0, k:int, hci:int, ao:int, ix:int, iy:int, 
  233.                 hhc:int = bmdw>>1, hc0s:int = bmdw*bmdw, hcxs:int = hc0s>>1, hcxf:int = bmdw-1, 
  234.                 vnormals:Vector.<Vector3D> = mesh.vnormals, 
  235.                 vertices:Vector.<Number> = mesh.verticesOnWorld;
  236.             _timer.start(1);
  237.             for each (v2 in vnormals) {
  238.                 v1.x = 0.0;
  239.                 v1.y = 0.0;
  240.                 v1.z = 0.0;
  241.                      if ((v2.y < 0.6) && (v2.y > -0.6)) v1.y = -1.0;
  242.                 else if ((v2.z < 0.6) && (v2.z > -0.6)) v1.z = 1.0;
  243.                 else v1.x = 1.0;
  244.                 v0.x = v1.y * v2.z - v1.z * v2.y;
  245.                 v0.y = v1.z * v2.x - v1.x * v2.z;
  246.                 v0.z = v1.x * v2.y - v1.y * v2.x;
  247.                 v0.normalize();
  248.                 v1.x = v2.y * v0.z - v2.z * v0.y;
  249.                 v1.y = v2.z * v0.x - v2.x * v0.z;
  250.                 v1.z = v2.x * v0.y - v2.y * v0.x;
  251.                 v1.normalize();
  252.                 // render on hemi-cubes
  253.                 hc0.fillRect(hc0.rect, 1);
  254.                 hcx[0].fillRect(hcx[0].rect, 1);
  255.                 hcx[1].fillRect(hcx[1].rect, 1);
  256.                 hcy[0].fillRect(hcy[0].rect, 1);
  257.                 hcy[1].fillRect(hcy[1].rect, 1);
  258.                 for each (p in prims) {
  259.                     x = p.world.x - vertices[i];
  260.                     y = p.world.y - vertices[i+1];
  261.                     z = p.world.z - vertices[i+2];
  262.                     v.x = x * v0.x + y * v0.y + z * v0.z;
  263.                     v.y = x * v1.x + y * v1.y + z * v1.z;
  264.                     v.z = x * v2.x + y * v2.y + z * v2.z;
  265.                     // hemi-cube front
  266.                     if (v.z > 0) {
  267.                         t = hhc/v.z;
  268.                         w = p.aoRadius * 0.8 * t;
  269.                         rect.x = v.x * t - w + hhc;
  270.                         rect.y = v.y * t - w + hhc;
  271.                         rect.width = w + w;
  272.                         rect.height = w + w;
  273.                         hc0.fillRect(rect, 0);
  274.                     }
  275.                     // hemi-cube x direction
  276.                     if (v.x != 0) {
  277.                         if (v.x > 0) { hci = 0; t =  hhc/v.x; }
  278.                         else         { hci = 1; t = -hhc/v.x; }
  279.                         w = p.aoRadius * 0.65 * t;
  280.                         rect.x = v.y * t - w + hhc;
  281.                         rect.y = v.z * t - w;
  282.                         rect.width = w + w;
  283.                         rect.height = w + w;
  284.                         hcx[hci].fillRect(rect, 0);
  285.                     }
  286.                     // hemi-cube y direction
  287.                     if (v.y != 0) {
  288.                         if (v.y > 0) { hci = 0; t =  hhc/v.y; }
  289.                         else         { hci = 1; t = -hhc/v.y; }
  290.                         w = p.aoRadius * 0.65 * t;
  291.                         rect.x = v.x * t - w + hhc;
  292.                         rect.y = v.z * t - w;
  293.                         rect.width = w + w;
  294.                         rect.height = w + w;
  295.                         hcy[hci].fillRect(rect, 0);
  296.                     }
  297.                 }
  298.                 ao = 0;
  299.                 for (k=0; k<hc0s; k++) {
  300.                     ao += hc0.getPixel(k&hcxf, k>>hcResolution);
  301.                 }
  302.                 for (k=0; k<hcxs; k++) {
  303.                     ix = k & hcxf;
  304.                     iy = k >> hcResolution;
  305.                     ao += hcx[0].getPixel(ix, iy) + hcx[1].getPixel(ix, iy) +
  306.                           hcy[0].getPixel(ix, iy) + hcy[1].getPixel(ix, iy);
  307.                 }
  308.                 aoBuffer[j] = ao * 0.005208333333333333;
  309.                 i+=3;
  310.                 j++;
  311.             }
  312.             _timer.pause(1);
  313.         }
  314.         
  315.         public function calculateTexCoordByVertexNormal(mesh:Mesh, light:Light, aoBuffer:Vector.<Number>) : void {
  316.             var x:Number, y:Number, v:Vector3D, i:int=0, j:int=0, vnormals:Vector.<Vector3D>=mesh.vnormals,
  317.                 dir:Vector3D=light, hv:Vector3D=light.halfVector, 
  318.                 t:Number = aoBlendRatio, it:Number = 1-aoBlendRatio, offset:Number = 0;
  319.             if (!aoSwitch) {
  320.                 t = 0;
  321.                 offset = aoBlendRatio*0.8;
  322.                 it = 1-offset;
  323.             }
  324.             for each (v in vnormals) {
  325.                 x = dir.x * v.x + dir.y * v.y + dir.z * v.z;
  326.                 y = hv.x  * v.x + hv.y  * v.y + hv.z  * v.z;
  327.                 if (x<0) x = 0;
  328.                 if (y<0) y = 0;
  329.                 mesh.texCoord[i] = x*it + aoBuffer[j]*t + offset; i++; j++;
  330.                 mesh.texCoord[i] = y; i+=2;
  331.             }
  332.         }
  333.     }
  334. }
  336. import flash.display.*;
  337. import flash.text.*;
  338. import flash.geom.*;
  339. import flash.events.*;
  341. import flash.utils.getTimer;
  343. class timer extends TextField {
  344.     public var title:String = "";
  345.     private var _time:Vector.<int>;
  346.     private var _sum :Vector.<int>;
  347.     private var _stat: