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


forked from : keim_at_Si's Code based Structure Synth [diff(167)]

embed

noswf download fullscreen
flash swf thumbnail play
download fullscreen
FAVORITE BY
:
:
StructureSynth3Dportage structure synth
:
3d
:
:
:
3d3d
:
:
3D
:
Structure Synthをオリジナルで実装。
:
PV3D使っていないんですか！？
:
it's geting better and better
:
かっこいー
:
3dすごい！
:
しゅごーい
FORKED
>sort

Regular Solid Structures forked from: Regular Solid Structures [diff(1)]

  1. // forked from keim_at_Si's Regular Solid Structures
  2. // forked from keim_at_Si's Code based Structure Synth
  3. // Code based Structure Synth
  4. //  Structure Synth; http://structuresynth.sourceforge.net/
  5. //------------------------------------------------------------
  6. package {
  7.     import flash.display.*;
  8.     import flash.events.*;
  9.     import flash.geom.*;
  10.     import flash.utils.*;
  11.     import flash.text.*;
  13.     [SWF(width='465', height='465', backgroundColor='#000000', frameRate='30')]
  14.     public class main extends Sprite {
  15.         // 3D renders
  16.         private var _materials:Vector.<Material> = new Vector.<Material>();
  17.         private var _light:Light = new Light(1,1,1);
  18.         private var _screen:BitmapData = new BitmapData(465, 465, false, 0);
  19.         private var _matscr:Matrix = new Matrix(1, 0, 0, 1, 232.5, 232.5);
  20.         private var _tf:TextField = new TextField();
  21.         private var gl:Render3D = new Render3D(300,1);
  22.         private var ss:StructureSynth = new StructureSynth(gl);
  23.         
  25.         // objects
  26.         private var camera:Vector3D;
  27.         private var structure:Vector.<Mesh> = new Vector.<Mesh>(5, true);
  28.         private var structName:Array = ["tetrahedrons","hexahedrons","octahedrons","dodecahedrons","icosahedrons"];
  29.         
  30.         // motions
  31.         private var structNum:int = 0;
  32.         
  33.         // entry point
  34.         function main() {
  35.             var i:int;
  36.             _tf.autoSize = "left";
  37.             camera = new Vector3D(0, -5, -50);
  38.             _materials.push((new Material()).setColor(0xff8080, 64, 192, 32, 80),
  39.                             (new Material()).setColor(0xd0d080, 64, 192, 32, 80),
  40.                             (new Material()).setColor(0x80ff80, 64, 192, 32, 80),
  41.                             (new Material()).setColor(0x80c0c0, 64, 192, 48, 80),
  42.                             (new Material()).setColor(0x8080ff, 64, 192, 64, 80));
  43.             for (i=0; i<5; i++) structure[i] = new Mesh(_materials);
  44.             addChild(gl).visible = false;
  45.             addChild(new Bitmap(_screen));
  46.             addChild(_tf);
  47.             addEventListener("enterFrame", _onEnterFrame);
  48.             stage.addEventListener("click", _onClick);
  49.             
  50.             // register meshes
  51.             ss.mesh("tetra",  SolidFactory.tetrahedron (new Mesh(), 1, 0));  // 4vertices/4triangles
  52.             ss.mesh("box",    SolidFactory.hexahedron  (new Mesh(), 1, 1, false));  // 8vertices/12triangles
  53.             ss.mesh("octa",   SolidFactory.octahedron  (new Mesh(), 1, 2));  // 6vertices/8triangles
  54.             ss.mesh("dodeca", SolidFactory.dodecahedron(new Mesh(), 1, 3));  // 12vertices/36triangles
  55.             ss.mesh("icosa",  SolidFactory.icosahedron (new Mesh(), 1, 4));  // 20vertices/20triangles
  56.            
  57.             // create mesh by Structure Synth
  58.             // structure[0]
  59.             ss.rule("s0r1", function() : void {
  60.                 ss.call("{rz 6 x -2.5} s0r2");
  61.                 ss.call("{ry 60} s0r1");
  62.             }, {md:6});
  63.             ss.rule("s0r2", function() : void {
  64.                 ss.call("{rz -54.73561032 ry 45} tetra");
  65.                 ss.call("{rz 6 x -2.5} s0r2");
  66.             }, {md:28});
  67.             ss.init(structure[0]).call("{y 30} s0r1");
  68.             ss.init(structure[0]).call("{y 0 ry 30} s0r1");
  69.             structure[0].updateFaces();
  71.             // structure[1]
  72.             ss.rule("s1r1", function() : void {
  73.                 ss.call("s1r2");
  74.                 ss.call("{rx 20 z 4} s1r1");
  75.             }, {md:18});
  76.             ss.rule("s1r2", function() : void {
  77.                 ss.call("box");
  78.                 ss.call("{x 2.4 y -1 z -1 s 1 0.94 0.94} s1r2");
  79.             }, {md:32});
  80.             ss.init(structure[1]).call("{x -36 y 11} s1r1");
  81.             structure[1].updateFaces();
  82.             
  83.             // structure[2]
  84.             ss.rule("s2r1", function() : void {
  85.                 ss.call("3 * {y 2 rx 5} octa");
  86.                 ss.call("{y 6 rz 30 ry 45 s 0.8} s2r1"); 
  87.                 ss.call("{y 6 rz -30 ry 45 s 0.8} s2r1");
  88.             });
  89.             ss.rule("s2r1", function() : void {
  90.                 ss.call("3 * {y 2 rx -5} octa");
  91.                 ss.call("{y 6 rz 30 ry 45 s 0.8} s2r1"); 
  92.                 ss.call("{y 6 rz -30 ry 45 s 0.8} s2r1");
  93.             });
  94.             ss.init(structure[2], 8).call("{s 1.5} s2r1");
  95.             structure[2].updateFaces();
  96.             
  97.             // structure[3]
  98.             ss.rule("s3r1", function() : void {
  99.                 ss.call("s3r2");
  100.                 ss.call("{s 1.5} s3r1");
  101.             }, {md:6});
  102.             ss.rule("s3r2", function() : void {
  103.                 ss.call("{y -4} dodeca");
  104.                 ss.call("5 * {ry 72} s3r3");
  105.             });
  106.             ss.rule("s3r3", function() : void {
  107.                 ss.call("{rz 65 y -4} dodeca");
  108.             });
  109.             ss.init(structure[3]).call("s3r1");
  110.             ss.init(structure[3]).call("{rz 180} s3r1");
  111.             structure[3].updateFaces();
  112.             
  113.             // structure[4]
  114.             ss.rule("s4rx", function() : void {
  115.                 ss.call("icosa");
  116.                 ss.call("{z 3 x 3} s4rz");
  117.                 ss.call("{y 3 z 3} s4ry");
  118.                 ss.call("{x 3 y 3} s4rx");
  119.             });
  120.             ss.rule("s4ry", function() : void {
  121.                 ss.call("icosa");
  122.                 ss.call("{z 3 x 3} s4rz");
  123.                 ss.call("{y 3 z 3} s4ry");
  124.             });
  125.             ss.rule("s4rz", function() : void {
  126.                 ss.call("icosa");
  127.                 ss.call("{z 3 x 3} s4rz");
  128.             });
  129.             ss.init(structure[4], 8).call("{x -21.2132 y -21.2132 z -21.2132 s 2} s4rx"); 
  130.             structure[4].updateFaces();
  131.             
  132.             structNum = -1;
  133.             _onClick(null);
  134.         }
  136.         private function _onEnterFrame(e:Event) : void {
  137.             _screen.fillRect(_screen.rect, 0);
  138.             _light.transformBy(gl.id().tv(camera).rx((400-mouseY)*0.25).ry((232-mouseX)*0.75).matrix);
  139.             _screen.draw(gl.push().t(0, 0, 0).project(structure[structNum]).renderSolid(_light).pop(), _matscr);
  140.         }
  141.         
  142.         private function _onClick(e:Event) : void {
  143.             if (++structNum == structure.length) structNum = 0;
  144.             _tf.htmlText = "<font color='#ffffff' face='_typewriter'>Click to change the structure[" + structName[structNum] + "]</font>";
  145.         }
  146.     }
  147. }
  150. import flash.display.*;
  151. import flash.geom.*;
  154. // Solid Factory
  155. //----------------------------------------------------------------------------------------------------
  156. class SolidFactory {
  157.     // regular solids
  158.     //--------------------------------------------------
  159.     static public function tetrahedron(mesh:Mesh, size:Number, mat:int=0) : Mesh {
  160.         mesh.vertices.push(size,size,size, size,-size,-size, -size,size,-size, -size,-size,size);
  161.         mesh.qface(0,2,1,3,mat).qface(1,3,0,2,mat);
  162.         return mesh.updateFaces();
  163.     }
  164.     
  165.     static public function hexahedron(mesh:Mesh, size:Number, mat:int=0, div:Boolean=true) : Mesh {
  166.         for (var i:int=0; i<8; i++) mesh.vertices.push((i&1)?size:-size, ((i>>1)&1)?size:-size, (i>>2)?size:-size);
  167.         mesh.qface(0,1,2,3,mat,div).qface(1,0,5,4,mat,div).qface(0,2,4,6,mat,div);
  168.         mesh.qface(2,3,6,7,mat,div).qface(3,1,7,5,mat,div).qface(5,4,7,6,mat,div);
  169.         return mesh.updateFaces();
  170.     }
  171.     
  172.     static public function octahedron(mesh:Mesh, size:Number, mat:int=0) : Mesh {
  173.         mesh.vertices.push(0,0,-size, -size,0,0, 0,-size,0, size,0,0, 0,size,0, 0,0,size);
  174.         mesh.qface(0,1,2,5,mat).qface(0,2,3,5,mat).qface(0,3,4,5,mat).qface(0,4,1,5,mat);
  175.         return mesh.updateFaces();
  176.     }
  177.     
  178.     static public function dodecahedron(mesh:Mesh, size:Number, mat:int=0, div:Boolean=true) : Mesh {
  179.         var a:Number=size*0.149071198, b:Number=size*0.241202266, c:Number=size*0.283550269, 
  180.             d:Number=size*0.390273464, e:Number=size*0.458793973, f:Number=size*0.631475730, 
  181.             g:Number=size*0.742344243;
  182.         mesh.vertices.push(c,f,d, e,f,-a, 0,f,-b-b, -e,f,-a, -c,f,d);
  183.         mesh.vertices.push(e,a,f, g,a,-b, 0,a,-d-d, -g,a,-b, -e,a,f);
  184.         mesh.vertices.push(0,-a,d+d, g,-a,b, e,-a,-f, -e,-a,-f, -g,-a,b);
  185.         mesh.vertices.push(0,-f,b+b, e,-f,a, c,-f,-d, -c,-f,-d, -e,-f,a);
  186.         mesh.qface(0,3,1,2,mat,div).face(0,4,3,mat).qface(4,5,9,10,mat,div).face(4,0,5,mat);
  187.         mesh.qface(0,6,5,11,mat,div).face(0,1,6,mat).qface(1,7,6,12,mat,div).face(1,2,7,mat);
  188.         mesh.qface(2,8,7,13,mat,div).face(2,3,8,mat).qface(3,9,8,14,mat,div).face(3,4,9,mat);
  189.         mesh.qface(17,11,12,6,mat,div).face(17,16,11,mat).qface(16,10,11,5,mat,div).face(16,15,10,mat);
  190.         mesh.qface(15,14,10,9,mat,div).face(15,19,14,mat).qface(19,13,14,8,mat,div).face(19,18,13,mat);
  191.         mesh.qface(18,12,13,7,mat,div).face(18,17,12,mat).qface(16,18,15,19,mat,div).face(16,17,18,mat);
  192.         return mesh.updateFaces();
  193.     }
  194.     
  195.     static public function icosahedron(mesh:Mesh, size:Number, mat:int=0) : Mesh {
  196.         var a:Number=size*0.276393202, b:Number=size*0.447213595, c:Number=size*0.525731112, 
  197.             d:Number=size*0.723606798, e:Number=size*0.850650808;
  198.         mesh.vertices.push(0,size,0, 0,b,b+b, e,b,a, c,b,-d, -c,b,-d, -e,b,a);
  199.         mesh.vertices.push(e,-b,-a, c,-b,d, -c,-b,d, -e,-b,-a, 0,-b,-b-b, 0,-size,0);
  200.         mesh.qface(0,2,1,7,mat).qface(0,3,2,6,mat).qface(0,4,3,10,mat).qface(0,5,4,9,mat).qface(0,1,5,8,mat);
  201.         mesh.qface(1,7,8,11,mat).qface(2,6,7,11,mat).qface(3,10,6,11,mat).qface(4,9,10,11,mat).qface(5,8,9,11,mat);
  202.         return mesh.updateFaces();
  203.     }
  204. }
  207. // Structure Synth
  208. //----------------------------------------------------------------------------------------------------
  209. class StructureSynth {
  210.     private var _mesh:Mesh;
  211.     private var _functions:* = new Object();
  212.     private var _meshes:* = new Object();
  213.     private var _maxDepth:int;
  214.     private var _depth:int;
  215.     private var _core:Render3D;
  216.     static private var _rexLine:RegExp = /((\d+)\s*\*)?\s*({(.*?)})?\s*([^{}\s]+)/;
  217.     static private var _rexOperate:RegExp = /(r?[x-z]|s)\s*([\-\d.]+)\s*([\-\d.]+)?\s*([\-\d.]+)?/g;
  218.     
  219.     function StructureSynth(core:Render3D) { 
  220.         _core = core;
  221.     }
  222.     
  223.     /** register mesh to call in CFDG.
  224.      *  @param name Mesh name to call.
  225.      *  @param mesh Mesh data.
  226.      */
  227.     public function mesh(name:String, mesh:Mesh) : StructureSynth {
  228.         _meshes[name] = mesh;
  229.         return this;
  230.     }
  231.     
  232.     /** register rule.
  233.      *  @param name Rule name to call.
  234.      *  @param func Function to execute. The type is "function(depth:int) : void".
  235.      *  @param option Option["w"/"weight"] to set weight and the option["md"/"maxdepth"] to set maxdepth.
  236.      */
  237.     public function rule(name:String, func:Function, option:*=null) : StructureSynth {
  238.         if (!(name in _functions)) _functions[name] = new SSFunctionList();
  239.         _functions[name].rule(func, option||new Object());
  240.         return this;
  241.     }
  242.     
  243.     /** initialize to constructing structure */
  244.     public function init(mesh:Mesh, maxDepth:int=512) : StructureSynth {
  245.         for each (var func:SSFunctionList in _functions) func.init();
  246.         _maxDepth = maxDepth;
  247.         _depth = 0;
  248.         _mesh = mesh;
  249.         _core.id();
  250.         return this;
  251.     }
  252.     
  253.     /** command 1 line in CFDG. */
  254.     public function call(line:String) : StructureSynth {
  255.         var i:int, imax:int, res:*;
  256.         res = _rexLine.exec(line);
  257.         if (res) {
  258.             _core.push();
  259.             imax = (res[2]) ? int(res[2]) : 1;
  260.             for (i=0; i<imax; i++) {
  261.                 operate(res[4]);
  262.                 if (res[5] in _functions) {
  263.                     if (++_depth <= _maxDepth) _functions[res[5]].call();
  264.                     _depth--;
  265.                 } else 
  266.                 if (res[5] in _meshes) {
  267.                     _core.project(_meshes[res[5]]);
  268.                     _mesh.put(_meshes[res[5]]);
  269.                 }
  270.             }
  271.             _core.pop();
  272.         }
  273.         return this;
  274.     }
  275.     
  276.     /** opreate matrix */
  277.     public function operate(ope:String) : void {
  278.         //_rexOperate.lastIndex = 0;
  279.         var res:* = _rexOperate.exec(ope);
  280.         while(res) {
  281.             var n:Number = Number(res[2]);
  282.             switch (res[1]) {
  283.             case 'x':  _core.t(n,0,0); break;
  284.             case 'y':  _core.t(0,n,0); break;
  285.             case 'z':  _core.t(0,0,n); break;
  286.             case 'rx': _core.rx(n);    break;
  287.             case 'ry': _core.ry(n);    break;
  288.             case 'rz': _core.rz(n);    break;
  289.             case 's':
  290.                 if (res[3]) _core.s(n, Number(res[3]), Number(res[4]));
  291.                 else _core.s(n, n, n);
  292.                 break;
  293.             }
  294.             res = _rexOperate.exec(ope);
  295.         }
  296.     }
  297. }
  299. class SSFunctionList {
  300.     private var _totalWeight:Number = 0;
  301.     private var _functions:Vector.<SSFunction> = new Vector.<SSFunction>();
  302.     
  303.     public function rule(func:Function, option:*) : void {
  304.         var ssf:SSFunction = new SSFunction(func, option);
  305.         _functions.push(ssf);
  306.         _totalWeight += ssf.weight;
  307.     }
  309.     public function init() : void {
  310.         for each (var ssf:SSFunction in _functions) ssf.depth = 0;
  311.     }
  312.     
  313.     public function call() : void {
  314.         var w:Number = 0, rand:Number = Math.random() * _totalWeight;
  315.         for each (var ssf:SSFunction in _functions) {
  316.             w += ssf.weight;
  317.             if (rand <= w) {
  318.                 if (++ssf.depth <= ssf.maxdepth) ssf.func();
  319.                 ssf.depth--;
  320.                 return;
  321.             }
  322.         }
  323.     }
  324. }
  326. class SSFunction {
  327.     public var func:Function;
  328.     public var weight:Number;
  329.     public var maxdepth:int;
  330.     public var depth:int = 0;
  331.     
  332.     function SSFunction(func:Function, option:*) {
  333.         this.func = func;
  334.         this.weight = option["w"] || option["weight"] || 1;
  335.         this.maxdepth = option["md"] || option["maxdepth"] || int.MAX_VALUE;
  336.     }
  337. }
  340. // 3D Engine
  341. //----------------------------------------------------------------------------------------------------
  342. /** Core */
  343. class Render3D extends Shape {
  344.     /** model view matrix */
  345.     public var matrix:Matrix3D;
  346.     private var _meshProjected:Mesh = null;                              // projecting mesh
  347.     private var _facesProjected:Vector.<Face> = new Vector.<Face>();     // projecting face
  348.     private var _projectionMatrix:Matrix3D;                              // projection matrix
  349.     private var _matrixStac:Vector.<Matrix3D> = new Vector.<Matrix3D>(); // matrix stac
  350.     private var _cmdTriangle:Vector.<int> = Vector.<int>([1,2,2]);       // commands to draw triangle
  351.     private var _cmdQuadrangle:Vector.<int> = Vector.<int>([1,2,2,2]);   // commands to draw quadrangle
  352.     private var _data:Vector.<Number> = new Vector.<Number>(8, true);    // data to draw shape
  353.     private var _clippingZ:Number;                                       // z value of clipping plane
  354.     
  355.     /** constructor */
  356.     function Render3D(focus:Number=300, clippingZ:Number=-0.1) {
  357.         var projector:PerspectiveProjection = new PerspectiveProjection()
  358.         projector.focalLength = focus;
  359.         _projectionMatrix = projector.toMatrix3D();
  360.         _clippingZ = -clippingZ;
  361.         matrix = new Matrix3D();
  362.         _matrixStac.length = 1;
  363.         _matrixStac[0] = matrix;
  364.     }
  366.     // control matrix
  367.     //--------------------------------------------------
  368.     public function clear() : Render3D { matrix = _matrixStac[0]; _matrixStac.length = 1; return this; }
  369.     public function push() : Render3D { _matrixStac.push(matrix.clone()); return this; }
  370.     public function pop() : Render3D { matrix = (_matrixStac.length == 1) ? matrix : _matrixStac.pop(); return this; }
  371.     public function id() : Render3D { matrix.identity(); return this; }
  372.     public function t(x:Number, y:Number, z:Number) : Render3D { matrix.prependTranslation(x, y, z); return this; }
  373.     public function tv(v:Vector3D) : Render3D { matrix.prependTranslation(v.x, v.y, v.z); return this; }
  374.     public function s(x:Number, y:Number, z:Number) : Render3D { matrix.prependScale(x, y, z); return this; }
  375.     public function sv(v:Vector3D) : Render3D { matrix.prependScale(v.x, v.y, v.z); return this; }
  376.     public function r(angle:Number, axis:Vector3D) : Render3D { matrix.prependRotation(angle, axis); return this; }
  377.     public function rv(v:Vector3D) : Render3D { matrix.prependRotation(v.w, v); return this; }
  378.     public function rx(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.X_AXIS); return this; }
  379.     public function ry(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Y_AXIS); return this; }
  380.     public function rz(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Z_AXIS); return this; }
  381.     
  382.     // projections
  383.     //--------------------------------------------------
  384.     /** project */
  385.     public function project(mesh:Mesh) : Render3D {
  386.         matrix.transformVectors(mesh.vertices, mesh.verticesOnWorld);
  387.         var fn:Point3D, vs:Vector.<Number> = mesh.verticesOnWorld;
  388.         var m:Vector.<Number> = matrix.rawData, 
  389.             m00:Number = m[0], m01:Number = m[1], m02:Number = m[2], 
  390.             m10:Number = m[4], m11:Number = m[5], m12:Number = m[6], 
  391.             m20:Number = m[8], m21:Number = m[9], m22:Number = m[10];
  392.         _facesProjected.length = 0;
  393.         for each (var f:Face in mesh.faces) {
  394.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2,
  395.                 x0:Number=vs[i0++], x1:Number=vs[i1++], x2:Number=vs[i2++],
  396.                 y0:Number=vs[i0++], y1:Number=vs[i1++], y2:Number=vs[i2++],
  397.                 z0:Number=vs[i0],   z1:Number=vs[i1],   z2:Number=vs[i2];
  398.             if (z0<_clippingZ && z1<_clippingZ && z2<_clippingZ) {
  399.                 fn = f.normal;
  400.                 fn.world.x = fn.x * m00 + fn.y * m10 + fn.z * m20;
  401.                 fn.world.y = fn.x * m01 + fn.y * m11 + fn.z * m21;
  402.                 fn.world.z = fn.x * m02 + fn.y * m12 + fn.z * m22;
  403.                 if (vs[f.pvi-2]*fn.world.x + vs[f.pvi-1]*fn.world.y + vs[f.pvi]*fn.world.z <= 0) {
  404.                     _facesProjected.push(f);
  405.                 }
  406.             }
  407.         }
  408.         _facesProjected.sort(function(f1:Face, f2:Face):Number{ return vs[f1.pvi] - vs[f2.pvi]; });
  409.         _meshProjected = mesh;
  410.         return this;
  411.     }
  412.     
  413.     /** project slower than transformVectors() but Vector3D.w considerable. */
  414.     public function projectPoint3D(points:Vector.<Point3D>) : Render3D {
  415.         var m:Vector.<Number> = matrix.rawData, p:Point3D, 
  416.             m00:Number = m[0],  m01:Number = m[1],  m02:Number = m[2], 
  417.             m10:Number = m[4],  m11:Number = m[5],  m12:Number = m[6], 
  418.             m20:Number = m[8],  m21:Number = m[9],  m22:Number = m[10], 
  419.             m30:Number = m[12], m31:Number = m[13], m32:Number = m[14];
  420.         for each (p in points) {
  421.             p.world.x = p.x * m00 + p.y * m10 + p.z * m20 + p.w * m30;
  422.             p.world.y = p.x * m01 + p.y * m11 + p.z * m21 + p.w * m31;
  423.             p.world.z = p.x * m02 + p.y * m12 + p.z * m22 + p.w * m32;
  424.         }
  425.         return this;
  426.     }
  428.     // rendering
  429.     //--------------------------------------------------
  430.     /** render solid */
  431.     public function renderSolid(light:Light) : Render3D {
  432.         var idx:int, mat:Material, materials:Vector.<Material> = _meshProjected.materials,
  433.             vout:Vector.<Number> = _meshProjected.verticesOnScreen;
  434.         Utils3D.projectVectors(_projectionMatrix, _meshProjected.verticesOnWorld, vout, _meshProjected.texCoord);
  435.         graphics.clear();
  436.         for each (var face:Face in _facesProjected) {
  437.             mat = materials[face.mat];
  438.             graphics.beginFill(mat.getColor(light, face.normal.world), mat.alpha);
  439.             idx = face.i0<<1;
  440.             _data[0] = vout[idx]; idx++;
  441.             _data[1] = vout[idx];
  442.             idx = face.i1<<1;
  443.             _data[2] = vout[idx]; idx++;
  444.             _data[3] = vout[idx];
  445.             idx = face.i2<<1;
  446.             _data[4] = vout[idx]; idx++;
  447.             _data[5] = vout[idx];
  448.             if (face.i3 == -1) {
  449.                 graphics.drawPath(_cmdTriangle, _data);
  450.             } else {
  451.                 idx = face.i3<<1;
  452.                 _data[6] = vout[idx]; idx++;
  453.                 _data[7] = vout[idx];
  454.                 graphics.drawPath(_cmdQuadrangle, _data);
  455.             }
  456.             graphics.endFill();
  457.         }
  458.         return this;
  459.     }
  460.     
  461.     /** render with texture */
  462.     private var _indices:Vector.<int> = new Vector.<int>(); // temporary index list
  463.     public function renderTexture(texture:BitmapData) : Render3D {
  464.         var idx:int, mat:Material, indices:Vector.<int> = _indices;
  465.         indices.length = 0;
  466.         for each (var face:Face in _facesProjected) { indices.push(face.i0, face.i1, face.i2); }
  467.         Utils3D.projectVectors(_projectionMatrix, 
  468.                                _meshProjected.verticesOnWorld, 
  469.                                _meshProjected.verticesOnScreen, 
  470.                                _meshProjected.texCoord);
  471.         graphics.clear();
  472.         graphics.beginBitmapFill(texture, null, false, true);
  473.         graphics.drawTriangles(_meshProjected.verticesOnScreen, indices, _meshProjected.texCoord);
  474.         graphics.endFill();
  475.         return this;
  476.     }
  477. }
  479. /** Point3D */
  480. class Point3D extends Vector3D {
  481.     public var world:Vector3D;
  482.     function Point3D(x:Number=0, y:Number=0, z:Number=0, w:Number=1) { super(x,y,z,w); world=clone(); }
  483. }
  485. /** Face */
  486. class Face {
  487.     public var i0:int, i1:int, i2:int, i3:int, pvi:int, mat:int, normal:Point3D;
  488.     static private var _freeList:Vector.<Face> = new Vector.<Face>();
  489.     static public function free(face:Face) : void { _freeList.push(face); }
  490.     static public function alloc(i0:int, i1:int, i2:int, i3:int, mat:int) : Face { 
  491.         var f:Face = _freeList.pop() || new Face();
  492.         f.i0=i0; f.i1=i1; f.i2=i2; f.i3=i3; f.pvi=0; f.mat=mat;
  493.         return f;
  494.     }
  495. }
  497. /** Mesh */
  498. class Mesh {
  499.     public var materials:Vector.<Material>;                 // material list
  500.     public var vertices:Vector.<Number>;                    // vertex
  501.     public var verticesOnWorld:Vector.<Number>;             // vertex on camera coordinate
  502.     public var verticesOnScreen:Vector.<Number>;            // vertex on screen
  503.     public var verticesCount:int;                           // vertex count
  504.     public var texCoord:Vector.<Number>;                    // texture coordinate
  505.     public var faces:Vector.<Face> = new Vector.<Face>();   // face list
  506.     public var vnormals:Vector.<Vector3D>;                  // vertex normal
  507.     
  508.     /** constructor */
  509.     function Mesh(materials:Vector.<Material>=null) {
  510.         this.materials = materials;
  511.         this.vertices = new Vector.<Number>();
  512.         this.texCoord = new Vector.<Number>();
  513.         this.verticesOnWorld = new Vector.<Number>();
  514.         this.verticesOnScreen = new Vector.<Number>();
  515.         this.vnormals = null;
  516.         this.verticesCount = 0;
  517.     }
  518.     
  519.     /** clear all faces */
  520.     public function clear() : Mesh {
  521.         for each (var face:Face in faces) Face.free(face);
  522.         faces.length = 0;
  523.         return this;
  524.     }
  525.     
  526.     /** register face */
  527.     public function face(i0:int, i1:int, i2:int, mat:int=0) : Mesh {
  528.         faces.push(Face.alloc(i0, i1, i2, -1, mat));
  529.         return this;
  530.     }
  531.     
  532.     /** register quadrangle face. set div=true to divide into 2 triangles. */
  533.     public function qface(i0:int, i1:int, i2:int, i3:int, mat:int=0, div:Boolean=true) : Mesh {
  534.         if (div) faces.push(Face.alloc(i0, i1, i2, -1, mat), Face.alloc(i3, i2, i1, -1, mat));
  535.         else     faces.push(Face.alloc(i0, i1, i3, i2, mat));
  536.         return this;
  537.     }
  538.     
  539.     /** put mesh on world coordinate. */
  540.     public function put(src:Mesh, mat:int=-1) : Mesh {
  541.         var i0:int = vertices.length, imax:int, i:int;
  542.         imax = (src.verticesCount<<1) + src.verticesCount;
  543.         vertices.length += imax;
  544.         for (i=0; i<imax; i++) vertices[i0+i] = src.verticesOnWorld[i];
  545.         i0 /= 3;
  546.         for each (var f:Face in src.faces) {
  547.             i = (mat == -1) ? f.mat : mat;
  548.             if (f.i3==-1) face (f.i0+i0, f.i1+i0, f.i2+i0, i);
  549.             else          qface(f.i0+i0, f.i1+i0, f.i3+i0, f.i2+i0, i, false);
  550.         }
  551.         return this;
  552.     }
  553.     
  554.     /** update face gravity point and normal */
  555.     public function updateFaces() : Mesh {
  556.         verticesCount = vertices.length/3;
  557.         var vs:Vector.<Number> = vertices;
  558.         for each (var f:Face in faces) {
  559.             f.pvi = vs.length+2;
  560.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2;
  561.             var x01:Number=vs[i1]-vs[i0], x02:Number=vs[i2]-vs[i0];
  562.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  563.             var y01:Number=vs[i1]-vs[i0], y02:Number=vs[i2]-vs[i0];
  564.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  565.             var z01:Number=vs[i1]-vs[i0], z02:Number=vs[i2]-vs[i0];
  566.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  567.             f.normal = new Point3D(y02*z01-y01*z02, z02*x01-z01*x02, x02*y01-x01*y02, 0);
  568.             f.normal.normalize();
  569.             if (f.i3 != -1) {
  570.                 var i3:int = (f.i3<<1)+f.i3;
  571.                 vs[f.pvi-2] = vs[f.pvi-2]*0.75 + vs[i3++]*0.25;
  572.                 vs[f.pvi-1] = vs[f.pvi-1]*0.75 + vs[i3++]*0.25;
  573.                 vs[f.pvi]   = vs[f.pvi]  *0.75 + vs[i3]  *0.25;
  574.             }
  575.         }
  576.         return this;
  577.     }
  578. }
  580. /** Light */
  581. class Light extends Point3D {
  582.     public var halfVector:Vector3D = new Vector3D();
  583.     
  584.     /** constructor (set position) */
  585.     function Light(x:Number=1, y:Number=1, z:Number=1) {
  586.         super(x, y, z, 0);
  587.         normalize();
  588.     }
  590.     /** projection */
  591.     public function transformBy(matrix:Matrix3D) : void {
  592.         world = matrix.deltaTransformVector(this);
  593.         halfVector.x = world.x;
  594.         halfVector.y = world.y;
  595.         halfVector.z = world.z + 1; 
  596.         halfVector.normalize();
  597.     }
  598. }
  600. /** Material */
  601. class Material extends BitmapData {
  602.     public var alpha:Number = 1;    // The alpha value is available for renderSolid()
  603.     public var doubleSided:int = 0; // set doubleSided=-1 if double sided material
  604.     
  605.     /** constructor */
  606.     function Material(dif:int=128, spc:int=128) { super(dif, spc, false); }
  607.     
  608.     /** set color. */
  609.     public function setColor(col:uint, amb:int=64, dif:int=192, spc:int=0,  pow:Number=8) : Material {
  610.         fillRect(rect, col);
  611.         var lmap:LightMap = new LightMap(width, height);
  612.         draw(lmap.diffusion(amb, dif), null, null, "hardlight");
  613.         draw(lmap.specular (spc, pow), null, null, "add");
  614.         lmap.dispose();
  615.         return this;
  616.     }
  617.     
  618.     /** calculate color by light and normal vector. */
  619.     public function getColor(l:Light, n:Vector3D) : uint {
  620.         var dir:Vector3D = l.world, hv:Vector3D = l.halfVector;
  621.         var ln:int = int((dir.x * n.x + dir.y * n.y + dir.z * n.z) * (width-1)),
  622.             hn:int = int((hv.x  * n.x + hv.y  * n.y + hv.z  * n.z) * (height-1));
  623.         if (ln<0) ln = (-ln) & doubleSided;
  624.         if (hn<0) hn = (-hn) & doubleSided;
  625.         return getPixel(ln, hn);
  626.     }
  627. }
  629. class LightMap extends BitmapData {
  630.     function LightMap(dif:int, spc:int) { super(dif, spc, false); }
  631.     
  632.     public function diffusion(amb:int, dif:int) : BitmapData {
  633.         var col:int, rc:Rectangle = new Rectangle(0, 0, 1, height), ipk:Number = 1 / width;
  634.         for (rc.x=0; rc.x<width; rc.x+=1) {
  635.             col = ((rc.x * (dif - amb)) * ipk) + amb;
  636.             fillRect(rc, (col<<16)|(col<<8)|col);
  637.         }
  638.         return this;
  639.     }
  640.     
  641.     public function specular(spc:int, pow:Number) : BitmapData {
  642.         var col:int, rc:Rectangle = new Rectangle(0, 0, width, 1),
  643.             mpk:Number = (pow + 2) * 0.15915494309189534, ipk:Number = 1 / height;
  644.         for (rc.y=0; rc.y<height; rc.y+=1) {
  645.             col = Math.pow(rc.y * ipk, pow) * spc * mpk;
  646.             if (col > 255) col = 255;
  647.             fillRect(rc, (col<<16)|(col<<8)|col);
  648.         }
  649.         return this;
  650.     }
  651. }
noswf

Regular Solid Structures Depth buffer test [diff(351)]

  1. // forked from keim_at_Si's Regular Solid Structures
  2. // forked from keim_at_Si's Code based Structure Synth
  3. // Code based Structure Synth
  4. //  Structure Synth; http://structuresynth.sourceforge.net/
  5. //------------------------------------------------------------
  6. package {
  7.     import flash.display.*;
  8.     import flash.events.*;
  9.     import flash.geom.*;
  10.     import flash.utils.*;
  11.     import flash.text.*;
  13.     [SWF(width='465', height='465', backgroundColor='#000000', frameRate='30')]
  14.     public class main extends Sprite {
  15.         // 3D renders
  16.         private var _materials:Vector.<Material> = new Vector.<Material>();
  17.         private var _light:Light = new Light(1,0.5,0.25);
  18.         private var _screen:BitmapData = new BitmapData(400, 400, false, 0);
  19.         private var _matbuf:Matrix = new Matrix(1, 0, 0, 1, 200, 200);
  20.         private var _tf:TextField = new TextField();
  21.         private var gl:Render3D = new Render3D(300,1);
  22.         private var ss:StructureSynth = new StructureSynth();
  24.         // objects
  25.         private var camera:Vector3D;
  26.         private var struct:Vector.<Mesh> = new Vector.<Mesh>(5, true);
  27.         private var projected:Vector.<ProjectionMesh> = new Vector.<ProjectionMesh>(5, true);
  28.         
  29.         private var _depth:BitmapData;
  30.         private var _mask :BitmapData;
  31.         private var depthBuffer:Vector.<BitmapData> = new Vector.<BitmapData>(2, true);
  32.         private var pixelBuffer:Vector.<BitmapData> = new Vector.<BitmapData>(2, true);
  33.         
  34.         // motions
  35.         private var clicked:Boolean = false;
  36.         private var frame:int = 0;
  37.         
  38.         // entry point
  39.         function main() {
  40.             stage.quality = "low";
  41.             
  42.             var i:int;
  43.             _tf.autoSize = "left";
  44.             _tf.htmlText = "<font color='#ffffff' face='_typewriter'>Click to view depth buffer.</font>"
  45.             camera = new Vector3D(0, -5, -50);
  46.             _materials.push((new Material()).setColor(0xff8080, 64, 192, 32, 80),
  47.                             (new Material()).setColor(0xd0d080, 64, 192, 32, 80),
  48.                             (new Material()).setColor(0x80ff80, 64, 192, 32, 80),
  49.                             (new Material()).setColor(0x80c0c0, 64, 192, 48, 80),
  50.                             (new Material()).setColor(0x8080ff, 64, 192, 64, 80));
  51.             for (i=0; i<5; i++) struct[i] = new Mesh(_materials);
  52.             addChild(gl).visible = false;
  53.             with(addChild(new Bitmap(_screen))) { x = y = 32; }
  54.             addChild(_tf);
  55.             addEventListener("enterFrame", _onEnterFrame);
  56.             stage.addEventListener("click", _onClick);
  57.             
  58.             // register meshes
  59.             ss.mesh("tetra",  SolidFactory.tetrahedron (new Mesh(), 1, 0));  // 4vertices/4triangles
  60.             ss.mesh("box",    SolidFactory.hexahedron  (new Mesh(), 1, 1));  // 8vertices/12triangles
  61.             ss.mesh("octa",   SolidFactory.octahedron  (new Mesh(), 1, 2));  // 6vertices/8triangles
  62.             ss.mesh("dodeca", SolidFactory.dodecahedron(new Mesh(), 1, 3));  // 12vertices/36triangles
  63.             ss.mesh("icosa",  SolidFactory.icosahedron (new Mesh(), 1, 4));  // 20vertices/20triangles
  64.            
  65.             for (i=0; i<depthBuffer.length; i++) {
  66.                 depthBuffer[i] = new BitmapData(400, 400, false);
  67.                 pixelBuffer[i] = new BitmapData(400, 400, true);
  68.             }
  69.             _depth= new BitmapData(400, 400, false, 0);
  70.             _mask = new BitmapData(400, 400, false, 0);
  71.             
  72.             // create mesh by Structure Synth
  73.             // struct[0]
  74.             ss.rule("r00", function():void{
  75.                 ss.call("2{x6}2{y6}3{z3}box{y9z-3}2{x6}2{z6}box{x9z-3}2{y6}2{z6}box");
  76.             });
  77.             ss.init(struct[0]).call("{s4}{x-9y-9z-6}r00");
  78.             projected[0] = new ProjectionMesh(struct[0].updateFaces());
  80.             // struct[1]
  81.             ss.rule("r10", function():void {
  82.                 ss.call("octa{x-6}2{x4}dodeca{y-6}2{y4}dodeca{z-6}2{z4}dodeca");
  83.             });
  84.             ss.init(struct[1]).call("{s4}{s2.5}r10");
  85.             projected[1] = new ProjectionMesh(struct[1].updateFaces());
  86.         }
  88.         private function _onEnterFrame(e:Event) : void {
  89.             frame++;
  90.             _screen.fillRect(_screen.rect, 0);
  91.             _light.transformBy(gl.id().tv(camera).rx((400-mouseY)*0.25).ry((232-mouseX)*0.75).matrix);
  92.             gl.push().rx(frame).project(projected[0]).pop();
  93.             gl.push().ry(frame*2).project(projected[1]).pop();
  94.             depthTest();
  95.         }
  96.         
  97.         private function _onClick(e:Event) : void { clicked = !clicked; }
  98.         
  99.         private function depthTest() : void {
  100.             var i:int, depthClear:int=0, operation:String="lighten";
  101.             
  102.             // clear buffers
  103.             for (i=0; i<depthBuffer.length; i++) {
  104.                 pixelBuffer[i].fillRect(pixelBuffer[i].rect, 0);
  105.                 depthBuffer[i].fillRect(depthBuffer[i].rect, 0);
  106.             }
  107.             _depth.fillRect(_depth.rect, depthClear);
  108.             
  109.             // render pixel buffer
  110.             pixelBuffer[0].draw(gl.renderSolid(projected[0], _light), _matbuf);
  111.             pixelBuffer[1].draw(gl.renderSolid(projected[1], _light), _matbuf);
  112.             
  113.             // render depth buffer
  114.             var nearZ:Number = -Number.MAX_VALUE, farZ:Number = 0;
  115.             for (i=0; i<2; i++) {
  116.                 if (nearZ < projected[i].nearZ) nearZ = projected[i].nearZ;
  117.                 if (farZ  > projected[i].farZ)  farZ  = projected[i].farZ;
  118.             }
  119.             for (i=0; i<2; i++) {
  120.                 projected[i].nearZ = nearZ+0.001;
  121.                 projected[i].farZ  = farZ-0.001;
  122.                 depthBuffer[i].draw(gl.renderDepth(projected[i]), _matbuf);
  123.                 _depth.draw(depthBuffer[i], null, null, operation);
  124.             }
  125.             if (clicked) {
  126.                 _screen.draw(_depth);
  127.             } else {
  128.                 for (i=0; i<2; i++) {
  129.                     depthBuffer[i].draw(_depth, null, null, "difference");
  130.                     _mask.fillRect(_mask.rect, 0);
  131.                     _mask.threshold(depthBuffer[i], _mask.rect, _mask.rect.topLeft, "==", 0, 0xff0000ff, 0xff);
  132.                     pixelBuffer[i].copyChannel(_mask, _mask.rect, _mask.rect.topLeft, 4, 8);
  133.                     _screen.draw(pixelBuffer[i]);
  134.                 }
  135.             }
  136.         }
  137.     }
  138. }
  141. import flash.display.*;
  142. import flash.geom.*;
  145. // Solid Factory
  146. //----------------------------------------------------------------------------------------------------
  147. class SolidFactory {
  148.     // regular solids
  149.     //--------------------------------------------------
  150.     static public function tetrahedron(mesh:Mesh, size:Number, mat:int=0) : Mesh {
  151.         mesh.vertices.push(size,size,size, size,-size,-size, -size,size,-size, -size,-size,size);
  152.         mesh.qface(0,2,1,3,mat).qface(1,3,0,2,mat);
  153.         return mesh.updateFaces();
  154.     }
  155.     
  156.     static public function hexahedron(mesh:Mesh, size:Number, mat:int=0, div:Boolean=true) : Mesh {
  157.         for (var i:int=0; i<8; i++) mesh.vertices.push((i&1)?size:-size, ((i>>1)&1)?size:-size, (i>>2)?size:-size);
  158.         mesh.qface(0,1,2,3,mat,div).qface(1,0,5,4,mat,div).qface(0,2,4,6,mat,div);
  159.         mesh.qface(2,3,6,7,mat,div).qface(3,1,7,5,mat,div).qface(5,4,7,6,mat,div);
  160.         return mesh.updateFaces();
  161.     }
  162.     
  163.     static public function octahedron(mesh:Mesh, size:Number, mat:int=0) : Mesh {
  164.         mesh.vertices.push(0,0,-size, -size,0,0, 0,-size,0, size,0,0, 0,size,0, 0,0,size);
  165.         mesh.qface(0,1,2,5,mat).qface(0,2,3,5,mat).qface(0,3,4,5,mat).qface(0,4,1,5,mat);
  166.         return mesh.updateFaces();
  167.     }
  168.     
  169.     static public function dodecahedron(mesh:Mesh, size:Number, mat:int=0, div:Boolean=true) : Mesh {
  170.         var a:Number=size*0.149071198, b:Number=size*0.241202266, c:Number=size*0.283550269, 
  171.             d:Number=size*0.390273464, e:Number=size*0.458793973, f:Number=size*0.631475730, 
  172.             g:Number=size*0.742344243;
  173.         mesh.vertices.push(c,f,d, e,f,-a, 0,f,-b-b, -e,f,-a, -c,f,d);
  174.         mesh.vertices.push(e,a,f, g,a,-b, 0,a,-d-d, -g,a,-b, -e,a,f);
  175.         mesh.vertices.push(0,-a,d+d, g,-a,b, e,-a,-f, -e,-a,-f, -g,-a,b);
  176.         mesh.vertices.push(0,-f,b+b, e,-f,a, c,-f,-d, -c,-f,-d, -e,-f,a);
  177.         mesh.qface(0,3,1,2,mat,div).face(0,4,3,mat).qface(4,5,9,10,mat,div).face(4,0,5,mat);
  178.         mesh.qface(0,6,5,11,mat,div).face(0,1,6,mat).qface(1,7,6,12,mat,div).face(1,2,7,mat);
  179.         mesh.qface(2,8,7,13,mat,div).face(2,3,8,mat).qface(3,9,8,14,mat,div).face(3,4,9,mat);
  180.         mesh.qface(17,11,12,6,mat,div).face(17,16,11,mat).qface(16,10,11,5,mat,div).face(16,15,10,mat);
  181.         mesh.qface(15,14,10,9,mat,div).face(15,19,14,mat).qface(19,13,14,8,mat,div).face(19,18,13,mat);
  182.         mesh.qface(18,12,13,7,mat,div).face(18,17,12,mat).qface(16,18,15,19,mat,div).face(16,17,18,mat);
  183.         return mesh.updateFaces();
  184.     }
  185.     
  186.     static public function icosahedron(mesh:Mesh, size:Number, mat:int=0) : Mesh {
  187.         var a:Number=size*0.276393202, b:Number=size*0.447213595, c:Number=size*0.525731112, 
  188.             d:Number=size*0.723606798, e:Number=size*0.850650808;
  189.         mesh.vertices.push(0,size,0, 0,b,b+b, e,b,a, c,b,-d, -c,b,-d, -e,b,a);
  190.         mesh.vertices.push(e,-b,-a, c,-b,d, -c,-b,d, -e,-b,-a, 0,-b,-b-b, 0,-size,0);
  191.         mesh.qface(0,2,1,7,mat).qface(0,3,2,6,mat).qface(0,4,3,10,mat).qface(0,5,4,9,mat).qface(0,1,5,8,mat);
  192.         mesh.qface(1,7,8,11,mat).qface(2,6,7,11,mat).qface(3,10,6,11,mat).qface(4,9,10,11,mat).qface(5,8,9,11,mat);
  193.         return mesh.updateFaces();
  194.     }
  195.     
  196.     static public function sphere(mesh:Mesh, size:Number, mat:int=0) : Mesh {
  197.         return icosahedron(mesh, size, mat);
  198.     }
  199. }
  202. // Structure Synth
  203. //----------------------------------------------------------------------------------------------------
  204. class StructureSynth {
  205.     private var _mesh:Mesh;
  206.     private var _functions:* = new Object(), _meshes:* = new Object();
  207.     private var _maxDepth:int, _depth:int;
  208.     private var _core:Render3D = new Render3D();
  209.     static private var _rexLine   :RegExp = /((\d+)[\s*]*)?\{(.*?)\}\s*|([^{}\s]+)\s*/g;
  210.     static private var _rexOperate:RegExp = /(r?[x-z]|s)\s*([\-\d.]+)\s*([\-\d.]+)?\s*([\-\d.]+)?/g;
  211.     
  212.     /** constructor. do nothing */
  213.     function StructureSynth() {}
  214.     
  215.     /** register mesh to call in CFDG.
  216.      *  @param name Mesh name to call.
  217.      *  @param mesh Mesh data.
  218.      */
  219.     public function mesh(name:String, mesh:Mesh) : StructureSynth {
  220.         _meshes[name] = new ProjectionMesh(mesh);
  221.         return this;
  222.     }
  223.     
  224.     /** register rule.
  225.      *  @param name Rule name to call.
  226.      *  @param func Function to execute. The type is "function() : void".
  227.      *  @param option Option["w"/"weight"] to set weight and the option["md"/"maxdepth"] to set maxdepth.
  228.      */
  229.     public function rule(name:String, func:Function, option:*=null) : StructureSynth {
  230.         if (!(name in _functions)) _functions[name] = new SSFunctionList();
  231.         _functions[name].rule(func, option||new Object());
  232.         return this;
  233.     }
  234.     
  235.     /** initialize to constructing structure */
  236.     public function init(mesh:Mesh, maxDepth:int=512) : StructureSynth {
  237.         for each (var func:SSFunctionList in _functions) func.init();
  238.         _maxDepth = maxDepth;
  239.         _depth = 0;
  240.         _mesh = mesh;
  241.         _core.id();
  242.         return this;
  243.     }
  244.     
  245.     /** command 1 line in CFDG. */
  246.     public function call(line:String) : StructureSynth {
  247.         var res:*, opeList:Array = [], i:int;
  248.         res = _rexLine.exec(line);
  249.         while (res) {
  250.             if (res[3]) opeList.unshift({imax:res[2]||1, mat:calcMatrix(res[3])});
  251.             else if (res[4]) opeList.unshift({imax:0, name:res[4]});
  252.             res = _rexLine.exec(line);
  253.         }
  254.         for (i=opeList.length-1; i>0; i--) i = _repeat(opeList, i);
  255.         return this;
  256.     }
  257.     
  258.     /** opreate matrix */
  259.     public function operate(ope:String) : StructureSynth {
  260.         var res:* = _rexOperate.exec(ope);
  261.         while(res) {
  262.             var n:Number = Number(res[2]);
  263.             switch (res[1]) {
  264.             case 'x':  _core.t(n,0,0); break;
  265.             case 'y':  _core.t(0,n,0); break;
  266.             case 'z':  _core.t(0,0,n); break;
  267.             case 'rx': _core.rx(n);    break;
  268.             case 'ry': _core.ry(n);    break;
  269.             case 'rz': _core.rz(n);    break;
  270.             case 's':
  271.                 if (res[3]) _core.s(n, Number(res[3]), Number(res[4]));
  272.                 else _core.s(n, n, n);
  273.                 break;
  274.             }
  275.             res = _rexOperate.exec(ope);
  276.         }
  277.         return this;
  278.     }
  279.     
  280.     /** calculate opreation matrix */
  281.     public function calcMatrix(ope:String) : Matrix3D {
  282.         _core.push().id();
  283.         operate(ope);
  284.         var mat:Matrix3D = _core.matrix;
  285.         _core.pop();
  286.         return mat;
  287.     }
  288.     
  289.     private function _repeat(opeList:Array, index:int) : int {
  290.         var imax:int = opeList[index].imax, lastIndex:int = index;
  291.         if (imax == 0) {
  292.             var name:String = opeList[index].name;
  293.             if (name in _functions) {
  294.                 if (++_depth <= _maxDepth) _functions[name].call();
  295.                 _depth--;
  296.             } else 
  297.             if (name in _meshes) {
  298.                 _core.project(_meshes[name]);
  299.                 _mesh.put(_meshes[name]);
  300.             }
  301.         } else {
  302.             var i:int, mat:Matrix3D=opeList[index].mat;
  303.             _core.push();
  304.             for (i=0; i<imax; i++) {
  305.                 _core.mult(mat);
  306.                 lastIndex = _repeat(opeList, index-1);
  307.             }
  308.             _core.pop();
  309.         }
  310.         return lastIndex;
  311.     }
  312. }
  314. class SSFunctionList {
  315.     private var _totalWeight:Number = 0;
  316.     private var _functions:Vector.<SSFunction> = new Vector.<SSFunction>();
  317.     
  318.     public function rule(func:Function, option:*) : void {
  319.         var ssf:SSFunction = new SSFunction(func, option);
  320.         _functions.push(ssf);
  321.         _totalWeight += ssf.weight;
  322.     }
  324.     public function init() : void {
  325.         for each (var ssf:SSFunction in _functions) ssf.depth = 0;
  326.     }
  327.     
  328.     public function call() : void {
  329.         var w:Number = 0, rand:Number = Math.random() * _totalWeight;
  330.         for each (var ssf:SSFunction in _functions) {
  331.             w += ssf.weight;
  332.             if (rand <= w) {
  333.                 if (++ssf.depth <= ssf.maxdepth) ssf.func();
  334.                 else ssf.finalFunc();
  335.                 ssf.depth--;
  336.                 return;
  337.             }
  338.         }
  339.     }
  340. }
  342. class SSFunction {
  343.     public var func:Function;
  344.     public var finalFunc:Function;
  345.     public var weight:Number;
  346.     public var maxdepth:int;
  347.     public var depth:int = 0;
  348.     
  349.     function SSFunction(func:Function, option:*) {
  350.         this.func = func;
  351.         this.weight = option["w"] || option["weight"] || 1;
  352.         this.maxdepth = option["md"] || option["maxdepth"] || int.MAX_VALUE;
  353.         this.finalFunc = option["ff"] || option["final"] || function():void{};
  354.     }
  355. }
  358. // 3D Engine
  359. //----------------------------------------------------------------------------------------------------
  360. /** Core */
  361. class Render3D extends Shape {
  362.     /** model view matrix */
  363.     public var matrix:Matrix3D;
  364.     private var _projectionMatrix:Matrix3D;                              // projection matrix
  365.     private var _matrixStac:Vector.<Matrix3D> = new Vector.<Matrix3D>(); // matrix stac
  366.     private var _cmdTriangle:Vector.<int> = Vector.<int>([1,2,2]);       // commands to draw triangle
  367.     private var _cmdQuadrangle:Vector.<int> = Vector.<int>([1,2,2,2]);   // commands to draw quadrangle
  368.     private var _data:Vector.<Number> = new Vector.<Number>(8, true);    // data to draw shape
  369.     private var _clippingZ:Number;                                       // clipping z value
  370.     private var _depthMap:BitmapData = new BitmapData(256, 256, false);  // texture for depth buffer rendering
  371.     
  372.     /** constructor */
  373.     function Render3D(focus:Number=300, clippingZ:Number=-0.1) {
  374.         var projector:PerspectiveProjection = new PerspectiveProjection()
  375.         projector.focalLength = focus;
  376.         _projectionMatrix = projector.toMatrix3D();
  377.         _clippingZ = -clippingZ;
  378.         matrix = new Matrix3D();
  379.         _matrixStac.length = 1;
  380.         _matrixStac[0] = matrix;
  381.         var u:int, v:int;
  382.         for (v=0; v<256; v++) 
  383.             for (u=0; u<256; u++) 
  384.                 //_depthMap.setPixel(255-u, 255-v, (v<<8)|u);
  385.                 _depthMap.setPixel(255-u, 255-v, (u<<16)|(u<<8)|u);
  386.     }
  388.     // control matrix
  389.     //--------------------------------------------------
  390.     public function clear() : Render3D { matrix = _matrixStac[0]; _matrixStac.length = 1; return this; }
  391.     public function push() : Render3D { _matrixStac.push(matrix.clone()); return this; }
  392.     public function pop() : Render3D { matrix = (_matrixStac.length == 1) ? matrix : _matrixStac.pop(); return this; }
  393.     public function id() : Render3D { matrix.identity(); return this; }
  394.     public function t(x:Number, y:Number, z:Number) : Render3D { matrix.prependTranslation(x, y, z); return this; }
  395.     public function tv(v:Vector3D) : Render3D { matrix.prependTranslation(v.x, v.y, v.z); return this; }
  396.     public function s(x:Number, y:Number, z:Number) : Render3D { matrix.prependScale(x, y, z); return this; }
  397.     public function sv(v:Vector3D) : Render3D { matrix.prependScale(v.x, v.y, v.z); return this; }
  398.     public function r(angle:Number, axis:Vector3D) : Render3D { matrix.prependRotation(angle, axis); return this; }
  399.     public function rv(v:Vector3D) : Render3D { matrix.prependRotation(v.w, v); return this; }
  400.     public function rx(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.X_AXIS); return this; }
  401.     public function ry(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Y_AXIS); return this; }
  402.     public function rz(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Z_AXIS); return this; }
  403.     public function mult(mat:Matrix3D) : Render3D { matrix.prepend(mat); return this; }
  404.     
  405.     // projections
  406.     //--------------------------------------------------
  407.     /** project */
  408.     public function project(mesh:ProjectionMesh) : Render3D {
  409.         matrix.transformVectors(mesh.base.vertices, mesh.verticesOnWorld);
  410.         var fn:Vector3D, fnw:Vector3D, vs:Vector.<Number> = mesh.verticesOnWorld,
  411.             nearZ:Number = -Number.MAX_VALUE, farZ:Number = _clippingZ,
  412.             flist:Vector.<Face> = mesh.base.faces;
  413.         var m:Vector.<Number> = matrix.rawData, 
  414.             m00:Number = m[0], m01:Number = m[1], m02:Number = m[2], 
  415.             m10:Number = m[4], m11:Number = m[5], m12:Number = m[6], 
  416.             m20:Number = m[8], m21:Number = m[9], m22:Number = m[10];
  417.         mesh.facesProjected.length = 0;
  418.         for each (var f:Face in flist) {
  419.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2,
  420.                 x0:Number=vs[i0++], x1:Number=vs[i1++], x2:Number=vs[i2++],
  421.                 y0:Number=vs[i0++], y1:Number=vs[i1++], y2:Number=vs[i2++],
  422.                 z0:Number=vs[i0],   z1:Number=vs[i1],   z2:Number=vs[i2];
  423.             if (z0<_clippingZ && z1<_clippingZ && z2<_clippingZ) {
  424.                 fn  = f.normal;
  425.                 fnw = mesh.normalsProjected[f.index];
  426.                 fnw.x = fn.x * m00 + fn.y * m10 + fn.z * m20;
  427.                 fnw.y = fn.x * m01 + fn.y * m11 + fn.z * m21;
  428.                 fnw.z = fn.x * m02 + fn.y * m12 + fn.z * m22;
  429.                 if (vs[f.gpi-2]*fnw.x + vs[f.gpi-1]*fnw.y + vs[f.gpi]*fnw.z <= 0) {
  430.                     if (nearZ < z0) nearZ = z0;
  431.                     if (nearZ < z1) nearZ = z1;
  432.                     if (nearZ < z2) nearZ = z2;
  433.                     if (farZ  > z0) farZ  = z0;
  434.                     if (farZ  > z1) farZ  = z1;
  435.                     if (farZ  > z2) farZ  = z2;
  436.                     mesh.facesProjected.push(f);
  437.                 }
  438.             }
  439.         }
  440.         mesh.nearZ = nearZ;
  441.         mesh.farZ  = farZ;
  442.         mesh.facesProjected.sort(function(f1:Face, f2:Face):Number{ return vs[f1.gpi] - vs[f2.gpi]; });
  443.         mesh.indexDirty = true;
  444.         return this;
  445.     }
  446.     
  447.     /** project slower than transformVectors() but Vector3D.w considerable. */
  448.     public function projectPoint3D(points:Vector.<Point3D>) : Render3D {
  449.         var m:Vector.<Number> = matrix.rawData, p:Point3D, 
  450.             m00:Number = m[0],  m01:Number = m[1],  m02:Number = m[2], 
  451.             m10:Number = m[4],  m11:Number = m[5],  m12:Number = m[6], 
  452.             m20:Number = m[8],  m21:Number = m[9],  m22:Number = m[10], 
  453.             m30:Number = m[12], m31:Number = m[13], m32:Number = m[14];
  454.         for each (p in points) {
  455.             p.world.x = p.x * m00 + p.y * m10 + p.z * m20 + p.w * m30;
  456.             p.world.y = p.x * m01 + p.y * m11 + p.z * m21 + p.w * m31;
  457.             p.world.z = p.x * m02 + p.y * m12 + p.z * m22 + p.w * m32;
  458.         }
  459.         return this;
  460.     }
  462.     // rendering
  463.     //--------------------------------------------------
  464.     /** render solid */
  465.     public function renderSolid(mesh:ProjectionMesh, light:Light) : Render3D {
  466.         var idx:int, mat:Material, materials:Vector.<Material> = mesh.base.materials,
  467.             vout:Vector.<Number> = mesh.verticesOnScreen;
  468.         Utils3D.projectVectors(_projectionMatrix, mesh.verticesOnWorld, vout, mesh.base.texCoord);
  469.         graphics.clear();
  470.         for each (var face:Face in mesh.facesProjected) {
  471.             mat = materials[face.mat];
  472.             graphics.beginFill(mat.getColor(light, mesh.normalsProjected[face.index]), mat.alpha);
  473.             idx = face.i0<<1;
  474.             _data[0] = vout[idx]; idx++;
  475.             _data[1] = vout[idx];
  476.             idx = face.i1<<1;
  477.             _data[2] = vout[idx]; idx++;
  478.             _data[3] = vout[idx];
  479.             idx = face.i2<<1;
  480.             _data[4] = vout[idx]; idx++;
  481.             _data[5] = vout[idx];
  482.             if (face.i3 == -1) {
  483.                 graphics.drawPath(_cmdTriangle, _data);
  484.             } else {
  485.                 idx = face.i3<<1;
  486.                 _data[6] = vout[idx]; idx++;
  487.                 _data[7] = vout[idx];
  488.                 graphics.drawPath(_cmdQuadrangle, _data);
  489.             }
  490.             graphics.endFill();
  491.         }
  492.         return this;
  493.     }
  494.     
  495.     /** render with texture */
  496.     public function renderTexture(mesh:ProjectionMesh, texture:BitmapData) : Render3D {
  497.         Utils3D.projectVectors(_projectionMatrix, 
  498.                                mesh.verticesOnWorld, 
  499.                                mesh.verticesOnScreen, 
  500.                                mesh.base.texCoord);
  501.         graphics.clear();
  502.         graphics.beginBitmapFill(texture, null, false, true);
  503.         graphics.drawTriangles(mesh.verticesOnScreen, mesh.indicesProjected, mesh.base.texCoord);
  504.         graphics.endFill();
  505.         return this;
  506.     }
  508.     /** render depth buffer */
  509.     public function renderDepth(mesh:ProjectionMesh) : Render3D {
  510.         var i:int, imax:int = mesh.vertexImax, 
  511.             nearZ:Number = (_clippingZ < mesh.nearZ) ? _clippingZ : mesh.nearZ,
  512.             r:Number=1/(mesh.farZ - nearZ),
  513.             duvt:Vector.<Number> = _depthUVT;
  514.         duvt.length = 0;
  515.         for (i=2; i<imax; i+=3) duvt.push((mesh.verticesOnWorld[i]-nearZ)*r, 0, 0);
  516.         Utils3D.projectVectors(_projectionMatrix, mesh.verticesOnWorld, mesh.verticesOnScreen, duvt);
  517.         graphics.clear();
  518.         graphics.beginBitmapFill(_depthMap, null, false, true);
  519.         graphics.drawTriangles(mesh.verticesOnScreen, mesh.indicesProjected, duvt);
  520.         graphics.endFill();
  521.         return this;
  522.     }
  523.     private var _depthUVT:Vector.<Number> = new Vector.<Number>();
  524. }
  526. /** Point3D */
  527. class Point3D extends Vector3D {
  528.     public var world:Vector3D;
  529.     function Point3D(x:Number=0, y:Number=0, z:Number=0, w:Number=1) { super(x,y,z,w); world=clone(); }
  530. }
  532. /** Face */
  533. class Face {
  534.     public var index:int, i0:int, i1:int, i2:int, i3:int, gpi:int, mat:int, normal:Vector3D;
  535.     static private var _freeList:Vector.<Face> = new Vector.<Face>();
  536.     static public function free(face:Face) : void { _freeList.push(face); }
  537.     static public function alloc(index:int, i0:int, i1:int, i2:int, i3:int, mat:int) : Face { 
  538.         var f:Face = _freeList.pop() || new Face();
  539.         f.index=index; f.i0=i0; f.i1=i1; f.i2=i2; f.i3=i3; f.gpi=0; f.mat=mat;
  540.         return f;
  541.     }
  542. }
  544. /** Mesh */
  545. class Mesh {
  546.     public var materials:Vector.<Material>;                 // material list
  547.     public var vertices:Vector.<Number>;                    // vertex
  548.     public var verticesCount:int;                           // vertex count
  549.     public var texCoord:Vector.<Number>;                    // texture coordinate
  550.     public var faces:Vector.<Face> = new Vector.<Face>();   // face list
  551.     
  552.     /** constructor */
  553.     function Mesh(materials:Vector.<Material>=null) {
  554.         this.materials = materials;
  555.         this.vertices = new Vector.<Number>();
  556.         this.texCoord = new Vector.<Number>();
  557.         this.verticesCount = 0;
  558.     }
  559.     
  560.     /** clear all faces */
  561.     public function clear() : Mesh {
  562.         for each (var face:Face in faces) Face.free(face);
  563.         faces.length = 0;
  564.         return this;
  565.     }
  566.     
  567.     /** register face */
  568.     public function face(i0:int, i1:int, i2:int, mat:int=0) : Mesh {
  569.         faces.push(Face.alloc(faces.length, i0, i1, i2, -1, mat));
  570.         return this;
  571.     }
  572.     
  573.     /** register quadrangle face. set div=true to divide into 2 triangles. */
  574.     public function qface(i0:int, i1:int, i2:int, i3:int, mat:int=0, div:Boolean=true) : Mesh {
  575.         if (div) {
  576.             faces.push(Face.alloc(faces.length,   i0, i1, i2, -1, mat), 
  577.                        Face.alloc(faces.length+1, i3, i2, i1, -1, mat));
  578.         }
  579.         else faces.push(Face.alloc(faces.length, i0, i1, i3, i2, mat));
  580.         return this;
  581.     }
  582.     
  583.     /** put mesh on world coordinate. */
  584.     public function put(src:ProjectionMesh, mat:int=-1) : Mesh {
  585.         var i0:int=vertices.length, imax:int=src.vertexImax, flist:Vector.<Face>=src.base.faces;
  586.         vertices.length += imax;
  587.         for (var i:int=0; i<imax; i++) vertices[i0+i] = src.verticesOnWorld[i];
  588.         i0 /= 3;
  589.         for each (var f:Face in flist) {
  590.             i = (mat == -1) ? f.mat : mat;
  591.             if (f.i3==-1) face (f.i0+i0, f.i1+i0, f.i2+i0, i);
  592.             else          qface(f.i0+i0, f.i1+i0, f.i3+i0, f.i2+i0, i, false);
  593.         }
  594.         return this;
  595.     }
  596.     
  597.     /** update face gravity point and normal */
  598.     public function updateFaces() : Mesh {
  599.         verticesCount = vertices.length/3;
  600.         var vs:Vector.<Number> = vertices;
  601.         for each (var f:Face in faces) {
  602.             f.gpi = vs.length+2;
  603.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2;
  604.             var x01:Number=vs[i1]-vs[i0], x02:Number=vs[i2]-vs[i0];
  605.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  606.             var y01:Number=vs[i1]-vs[i0], y02:Number=vs[i2]-vs[i0];
  607.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  608.             var z01:Number=vs[i1]-vs[i0], z02:Number=vs[i2]-vs[i0];
  609.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  610.             f.normal = new Point3D(y02*z01-y01*z02, z02*x01-z01*x02, x02*y01-x01*y02, 0);
  611.             f.normal.normalize();
  612.             if (f.i3 != -1) {
  613.                 var i3:int = (f.i3<<1)+f.i3;
  614.                 vs[f.gpi-2] = vs[f.gpi-2]*0.75 + vs[i3++]*0.25;
  615.                 vs[f.gpi-1] = vs[f.gpi-1]*0.75 + vs[i3++]*0.25;
  616.                 vs[f.gpi]   = vs[f.gpi]  *0.75 + vs[i3]  *0.25;
  617.             }
  618.         }
  619.         return this;
  620.     }
  621. }
  623. /** mesh for projection */
  624. class ProjectionMesh {
  625.     public var verticesOnWorld:Vector.<Number>;     // vertex on camera coordinate
  626.     public var verticesOnScreen:Vector.<Number>;    // vertex on screen
  627.     public var facesProjected:Vector.<Face>;        // projected face
  628.     public var normalsProjected:Vector.<Vector3D>;  // projected normals
  629.     public var vnormals:Vector.<Vector3D>;          // vertex normal
  630.     public var nearZ:Number, farZ:Number;           // z buffer range
  631.     private var _projectedFaceIndices:Vector.<int> = new Vector.<int>();
  632.     private var _base:Mesh;
  633.     
  634.     /** indices of projected faces */
  635.     public function get indicesProjected() : Vector.<int> {
  636.         var idx:Vector.<int> = _projectedFaceIndices;
  637.         if (idx.length == 0) for each (var f:Face in facesProjected) idx.push(f.i0, f.i1, f.i2);
  638.         return idx;
  639.     }
  640.     
  641.     public function set indexDirty(b:Boolean) : void {
  642.         if (b) _projectedFaceIndices.length = 0;
  643.     }
  645.     public function get base() : Mesh { return _base; }
  646.     public function set base(m:Mesh) : void {
  647.         if (m && normalsProjected.length < m.faces.length) {
  648.             var i:int = normalsProjected.length, imax:int = m.faces.length;
  649.             normalsProjected.length = imax;
  650.             for (; i<imax; i++) normalsProjected[i] = new Vector3D();
  651.         }
  652.         _base = m;
  653.     }
  654.     
  655.     public function get vertexImax() : int { return (_base.verticesCount<<1) + _base.verticesCount; }
  656.     
  657.     /** constructor */
  658.     function ProjectionMesh(m:Mesh=null) {
  659.         this.verticesOnWorld = new Vector.<Number>();
  660.         this.verticesOnScreen = new Vector.<Number>();
  661.         this.facesProjected = new Vector.<Face>();
  662.         this.normalsProjected= new Vector.<Vector3D>();
  663.         this.vnormals = null;
  664.         this.base = m;
  665.     }
  666. }
  668. /** Light */
  669. class Light extends Point3D {
  670.     public var halfVector:Vector3D = new Vector3D();
  671.     
  672.     /** constructor (set position) */
  673.     function Light(x:Number=1, y:Number=1, z:Number=1) {
  674.         super(x, y, z, 0);
  675.         normalize();
  676.     }
  678.     /** projection */
  679.     public function transformBy(matrix:Matrix3D) : void {
  680.         world = matrix.deltaTransformVector(this);
  681.         halfVector.x = world.x;
  682.         halfVector.y = world.y;
  683.         halfVector.z = world.z + 1; 
  684.         halfVector.normalize();
  685.     }
  686. }
  688. /** Material */
  689. class Material extends BitmapData {
  690.     public var alpha:Number = 1;    // The alpha value is available for renderSolid()
  691.     public var doubleSided:int = 0; // set doubleSided=-1 if double sided material
  692.     
  693.     /** constructor */
  694.     function Material(dif:int=128, spc:int=128) { super(dif, spc, false); }
  695.     
  696.     /** set color. */
  697.     public function setColor(col:uint, amb:int=64, dif:int=192, spc:int=0,  pow:Number=8) : Material {
  698.         fillRect(rect, col);
  699.         var lmap:LightMap = new LightMap(width, height);
  700.         draw(lmap.diffusion(amb, dif), null, null, "hardlight");
  701.         draw(lmap.specular (spc, pow), null, null, "add");
  702.         lmap.dispose();
  703.         return this;
  704.     }
  705.     
  706.     /** calculate color by light and normal vector. */
  707.     public function getColor(l:Light, n:Vector3D) : uint {
  708.         var dir:Vector3D = l.world, hv:Vector3D = l.halfVector;
  709.         var ln:int = int((dir.x * n.x + dir.y * n.y + dir.z * n.z) * (width-1)),
  710.             hn:int = int((hv.x  * n.x + hv.y  * n.y + hv.z  * n.z) * (height-1));
  711.         if (ln<0) ln = (-ln) & doubleSided;
  712.         if (hn<0) hn = (-hn) & doubleSided;
  713.         return getPixel(ln, hn);
  714.     }
  715. }
  717. class LightMap extends BitmapData {
  718.     function LightMap(dif:int, spc:int) { super(dif, spc, false); }
  719.     
  720.     public function diffusion(amb:int, dif:int) : BitmapData {
  721.         var col:int, rc:Rectangle = new Rectangle(0, 0, 1, height), ipk:Number = 1 / width;
  722.         for (rc.x=0; rc.x<width; rc.x+=1) {
  723.             col = ((rc.x * (dif - amb)) * ipk) + amb;
  724.             fillRect(rc, (col<<16)|(col<<8)|col);
  725.         }
  726.         return this;
  727.     }
  728.     
  729.     public function specular(spc:int, pow:Number) : BitmapData {
  730.         var col:int, rc:Rectangle = new Rectangle(0, 0, width, 1),
  731.             mpk:Number = (pow + 2) * 0.15915494309189534, ipk:Number = 1 / height;
  732.         for (rc.y=0; rc.y<height; rc.y+=1) {
  733.             col = Math.pow(rc.y * ipk, pow) * spc * mpk;
  734.             if (col > 255) col = 255;
  735.             fillRect(rc, (col<<16)|(col<<8)|col);
  736.         }
  737.         return this;
  738.     }
  739. }
noswf
Get Adobe Flash Player