※現在、「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

Code based Structure Synth forked from: Code based Structure Synth [diff(1)]

  1. // forked from keim_at_Si's Code based Structure Synth
  2. // Code based Structure Synth
  3. //  Structure Synth; http://structuresynth.sourceforge.net/
  4. //------------------------------------------------------------
  5. package {
  6.     import flash.display.*;
  7.     import flash.events.*;
  8.     import flash.geom.*;
  9.     import flash.utils.*;
  11.     [SWF(width='465', height='465', backgroundColor='#000000', frameRate='30')]
  12.     public class main extends Sprite {
  13.         // 3D renders
  14.         private var _materials:Vector.<Material> = new Vector.<Material>();
  15.         private var _light:Light = new Light(1,0.2,0.4);
  16.         private var _meshSS:Mesh = new Mesh(_materials);
  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 gl:Render3D = new Render3D(300,1);
  21.         private var ss:StructureSynth;
  22.         
  23.         // objects
  24.         private var camera:Vector3D;
  25.         
  26.         // entry point
  27.         function main() {
  28.             var i:int;
  29.             
  30.             camera = new Vector3D(0, -5, -50);
  31.             _materials.push((new Material()).setColor(0x80c0ff, 64, 192, 32, 80));
  32.             
  33.             addChild(gl).visible = false;
  34.             addChild(new Bitmap(_screen));
  35.             addEventListener("enterFrame", _onEnterFrame);
  36.             
  37.             // create mesh by Structure Synth
  38.             ss = new StructureSynth(gl);
  39.             ss.mesh("box", _createHexahedron(new Mesh(), 1));
  40.             ss.rule("r1", function() : void {
  41.                 ss.call("box");
  42.                 ss.call("{z 6 x 0.3 rx -45.6 s 1 0.99 0.99} r1");
  43.             });
  44.             ss.rule("r2", function() : void {
  45.                 ss.call("box");
  46.                 ss.call("{rx 45.6 z -6 x -0.3 s 1 0.99 0.99} r2");
  47.             });
  48.             ss.init(_meshSS, 200).call("r1");
  49.             ss.init(_meshSS, 199).call("{rx 45.6 z -6 x -0.3 s 1 0.99 0.99} r2");
  50.             _meshSS.updateFaces();
  51.         }
  53.         private function _onEnterFrame(e:Event) : void {
  54.             _screen.fillRect(_screen.rect, 0);
  55.             _light.transformBy(gl.id().tv(camera).rx((400-mouseY)*0.15).ry((232-mouseX)*0.75).matrix);
  56.             _screen.draw(gl.push().t(0, 0, 0).project(_meshSS).renderSolid(_light).pop(), _matscr);
  57.         }
  58.         
  59.         // create regular solids
  60.         //--------------------------------------------------
  61.         private function _createHexahedron(mesh:Mesh, size:Number) : Mesh {
  62.             for (var i:int=0; i<8; i++) mesh.vertices.push((i&1)?size:-size, ((i>>1)&1)?size:-size, (i>>2)?size:-size);
  63.             mesh.qface(0,1,2,3,0,false).qface(1,0,5,4,0,false).qface(0,2,4,6,0,false);
  64.             mesh.qface(2,3,6,7,0,false).qface(3,1,7,5,0,false).qface(5,4,7,6,0,false);
  65.             mesh.updateFaces();
  66.             return mesh;
  67.         }
  68.     }
  69. }
  72. import flash.display.*;
  73. import flash.geom.*;
  76. // Structure Synth
  77. //----------------------------------------------------------------------------------------------------
  78. class StructureSynth {
  79.     private var _mesh:Mesh;
  80.     private var _functions:* = new Object();
  81.     private var _meshes:* = new Object();
  82.     private var _maxDepth:int;
  83.     private var _depth:int;
  84.     private var _core:Render3D;
  85.     static private var _rexLine:RegExp = /((\d+)\s*\*)?\s*({(.*?)})?\s*([^{}\s]+)/;
  86.     static private var _rexOperate:RegExp = /(r?[x-z]|s)\s*([\-\d.]+)\s*([\-\d.]+)?\s*([\-\d.]+)?/g;
  87.     
  88.     function StructureSynth(core:Render3D) { 
  89.         _core = core;
  90.     }
  91.     
  92.     /** register mesh to call in CFDG.
  93.      *  @param name Mesh name to call.
  94.      *  @param mesh Mesh data.
  95.      */
  96.     public function mesh(name:String, mesh:Mesh) : StructureSynth {
  97.         _meshes[name] = mesh;
  98.         return this;
  99.     }
  100.     
  101.     /** register rule.
  102.      *  @param name Rule name to call.
  103.      *  @param func Function to execute. The type is "function(depth:int) : void".
  104.      *  @param option Option["w"/"weight"] to set weight and the option["md"/"maxdepth"] to set maxdepth.
  105.      */
  106.     public function rule(name:String, func:Function, option:*=null) : StructureSynth {
  107.         if (!(name in _functions)) _functions[name] = new SSFunctionList();
  108.         _functions[name].rule(func, option||new Object());
  109.         return this;
  110.     }
  111.     
  112.     /** initialize to constructing structure */
  113.     public function init(mesh:Mesh, maxDepth:int=512) : StructureSynth {
  114.         for each (var func:SSFunctionList in _functions) func.init();
  115.         _maxDepth = maxDepth;
  116.         _depth = 0;
  117.         _mesh = mesh;
  118.         _core.id();
  119.         return this;
  120.     }
  121.     
  122.     /** command 1 line in CFDG. */
  123.     public function call(line:String) : StructureSynth {
  124.         var i:int, imax:int, res:*;
  125.         res = _rexLine.exec(line);
  126.         if (res) {
  127.             _core.push();
  128.             imax = (res[2]) ? int(res[2]) : 1;
  129.             for (i=0; i<imax; i++) {
  130.                 operate(res[4]);
  131.                 if (res[5] in _functions) {
  132.                     if (++_depth <= _maxDepth) _functions[res[5]].call();
  133.                     _depth--;
  134.                 } else 
  135.                 if (res[5] in _meshes) {
  136.                     _core.project(_meshes[res[5]]);
  137.                     _mesh.put(_meshes[res[5]]);
  138.                 }
  139.             }
  140.             _core.pop();
  141.         }
  142.         return this;
  143.     }
  144.     
  145.     /** opreate matrix */
  146.     public function operate(ope:String) : void {
  147.         //_rexOperate.lastIndex = 0;
  148.         var res:* = _rexOperate.exec(ope);
  149.         while(res) {
  150.             var n:Number = Number(res[2]);
  151.             switch (res[1]) {
  152.             case 'x':  _core.t(n,0,0); break;
  153.             case 'y':  _core.t(0,n,0); break;
  154.             case 'z':  _core.t(0,0,n); break;
  155.             case 'rx': _core.rx(n);    break;
  156.             case 'ry': _core.ry(n);    break;
  157.             case 'rz': _core.rz(n);    break;
  158.             case 's':
  159.                 if (res[3]) _core.s(n, Number(res[3]), Number(res[4]));
  160.                 else _core.s(n, n, n);
  161.                 break;
  162.             }
  163.             res = _rexOperate.exec(ope);
  164.         }
  165.     }
  166. }
  168. class SSFunctionList {
  169.     private var _totalWeight:Number = 0;
  170.     private var _functions:Vector.<SSFunction> = new Vector.<SSFunction>();
  171.     
  172.     public function rule(func:Function, option:*) : void {
  173.         var ssf:SSFunction = new SSFunction(func, option);
  174.         _functions.push(ssf);
  175.         _totalWeight += ssf.weight;
  176.     }
  178.     public function init() : void {
  179.         for each (var ssf:SSFunction in _functions) ssf.depth = 0;
  180.     }
  181.     
  182.     public function call() : void {
  183.         var w:Number = 0, rand:Number = Math.random() * _totalWeight;
  184.         for each (var ssf:SSFunction in _functions) {
  185.             w += ssf.weight;
  186.             if (rand <= w) {
  187.                 if (++ssf.depth <= ssf.maxdepth) ssf.func();
  188.                 ssf.depth--;
  189.                 return;
  190.             }
  191.         }
  192.     }
  193. }
  195. class SSFunction {
  196.     public var func:Function;
  197.     public var weight:Number;
  198.     public var maxdepth:int;
  199.     public var depth:int = 0;
  200.     
  201.     function SSFunction(func:Function, option:*) {
  202.         this.func = func;
  203.         this.weight = option["w"] || option["weight"] || 1;
  204.         this.maxdepth = option["md"] || option["maxdepth"] || int.MAX_VALUE;
  205.     }
  206. }
  209. // 3D Engine
  210. //----------------------------------------------------------------------------------------------------
  211. /** Core */
  212. class Render3D extends Shape {
  213.     /** model view matrix */
  214.     public var matrix:Matrix3D;
  215.     private var _meshProjected:Mesh = null;                              // projecting mesh
  216.     private var _facesProjected:Vector.<Face> = new Vector.<Face>();     // projecting face
  217.     private var _projectionMatrix:Matrix3D;                              // projection matrix
  218.     private var _matrixStac:Vector.<Matrix3D> = new Vector.<Matrix3D>(); // matrix stac
  219.     private var _cmdTriangle:Vector.<int> = Vector.<int>([1,2,2]);       // commands to draw triangle
  220.     private var _cmdQuadrangle:Vector.<int> = Vector.<int>([1,2,2,2]);   // commands to draw quadrangle
  221.     private var _data:Vector.<Number> = new Vector.<Number>(8, true);    // data to draw shape
  222.     private var _clippingZ:Number;                                       // z value of clipping plane
  223.     
  224.     /** constructor */
  225.     function Render3D(focus:Number=300, clippingZ:Number=0.1) {
  226.         var projector:PerspectiveProjection = new PerspectiveProjection()
  227.         projector.focalLength = focus;
  228.         _projectionMatrix = projector.toMatrix3D();
  229.         _clippingZ = -clippingZ;
  230.         matrix = new Matrix3D();
  231.         _matrixStac.length = 1;
  232.         _matrixStac[0] = matrix;
  233.     }
  235.     // control matrix
  236.     //--------------------------------------------------
  237.     public function clear() : Render3D { matrix = _matrixStac[0]; _matrixStac.length = 1; return this; }
  238.     public function push() : Render3D { _matrixStac.push(matrix.clone()); return this; }
  239.     public function pop() : Render3D { matrix = (_matrixStac.length == 1) ? matrix : _matrixStac.pop(); return this; }
  240.     public function id() : Render3D { matrix.identity(); return this; }
  241.     public function t(x:Number, y:Number, z:Number) : Render3D { matrix.prependTranslation(x, y, z); return this; }
  242.     public function tv(v:Vector3D) : Render3D { matrix.prependTranslation(v.x, v.y, v.z); return this; }
  243.     public function s(x:Number, y:Number, z:Number) : Render3D { matrix.prependScale(x, y, z); return this; }
  244.     public function sv(v:Vector3D) : Render3D { matrix.prependScale(v.x, v.y, v.z); return this; }
  245.     public function r(angle:Number, axis:Vector3D) : Render3D { matrix.prependRotation(angle, axis); return this; }
  246.     public function rv(v:Vector3D) : Render3D { matrix.prependRotation(v.w, v); return this; }
  247.     public function rx(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.X_AXIS); return this; }
  248.     public function ry(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Y_AXIS); return this; }
  249.     public function rz(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Z_AXIS); return this; }
  250.     
  251.     // projections
  252.     //--------------------------------------------------
  253.     /** project */
  254.     public function project(mesh:Mesh) : Render3D {
  255.         matrix.transformVectors(mesh.vertices, mesh.verticesOnWorld);
  256.         var fn:Point3D, vs:Vector.<Number> = mesh.verticesOnWorld;
  257.         var m:Vector.<Number> = matrix.rawData, 
  258.             m00:Number = m[0], m01:Number = m[1], m02:Number = m[2], 
  259.             m10:Number = m[4], m11:Number = m[5], m12:Number = m[6], 
  260.             m20:Number = m[8], m21:Number = m[9], m22:Number = m[10];
  261.         _facesProjected.length = 0;
  262.         for each (var f:Face in mesh.faces) {
  263.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2,
  264.                 x0:Number=vs[i0++], x1:Number=vs[i1++], x2:Number=vs[i2++],
  265.                 y0:Number=vs[i0++], y1:Number=vs[i1++], y2:Number=vs[i2++],
  266.                 z0:Number=vs[i0],   z1:Number=vs[i1],   z2:Number=vs[i2];
  267.             if (z0<_clippingZ && z1<_clippingZ && z2<_clippingZ) {
  268.                 fn = f.normal;
  269.                 fn.world.x = fn.x * m00 + fn.y * m10 + fn.z * m20;
  270.                 fn.world.y = fn.x * m01 + fn.y * m11 + fn.z * m21;
  271.                 fn.world.z = fn.x * m02 + fn.y * m12 + fn.z * m22;
  272.                 if (vs[f.pvi-2]*fn.world.x + vs[f.pvi-1]*fn.world.y + vs[f.pvi]*fn.world.z <= 0) {
  273.                     _facesProjected.push(f);
  274.                 }
  275.             }
  276.         }
  277.         _facesProjected.sort(function(f1:Face, f2:Face):Number{ return vs[f1.pvi] - vs[f2.pvi]; });
  278.         _meshProjected = mesh;
  279.         return this;
  280.     }
  281.     
  282.     /** project slower than transformVectors() but Vector3D.w considerable. */
  283.     public function projectPoint3D(points:Vector.<Point3D>) : Render3D {
  284.         var m:Vector.<Number> = matrix.rawData, p:Point3D, 
  285.             m00:Number = m[0],  m01:Number = m[1],  m02:Number = m[2], 
  286.             m10:Number = m[4],  m11:Number = m[5],  m12:Number = m[6], 
  287.             m20:Number = m[8],  m21:Number = m[9],  m22:Number = m[10], 
  288.             m30:Number = m[12], m31:Number = m[13], m32:Number = m[14];
  289.         for each (p in points) {
  290.             p.world.x = p.x * m00 + p.y * m10 + p.z * m20 + p.w * m30;
  291.             p.world.y = p.x * m01 + p.y * m11 + p.z * m21 + p.w * m31;
  292.             p.world.z = p.x * m02 + p.y * m12 + p.z * m22 + p.w * m32;
  293.         }
  294.         return this;
  295.     }
  297.     // rendering
  298.     //--------------------------------------------------
  299.     /** render solid */
  300.     public function renderSolid(light:Light) : Render3D {
  301.         var idx:int, mat:Material, materials:Vector.<Material> = _meshProjected.materials,
  302.             vout:Vector.<Number> = _meshProjected.verticesOnScreen;
  303.         Utils3D.projectVectors(_projectionMatrix, _meshProjected.verticesOnWorld, vout, _meshProjected.texCoord);
  304.         graphics.clear();
  305.         for each (var face:Face in _facesProjected) {
  306.             mat = materials[face.mat];
  307.             graphics.beginFill(mat.getColor(light, face.normal.world), mat.alpha);
  308.             idx = face.i0<<1;
  309.             _data[0] = vout[idx]; idx++;
  310.             _data[1] = vout[idx];
  311.             idx = face.i1<<1;
  312.             _data[2] = vout[idx]; idx++;
  313.             _data[3] = vout[idx];
  314.             idx = face.i2<<1;
  315.             _data[4] = vout[idx]; idx++;
  316.             _data[5] = vout[idx];
  317.             if (face.i3 == -1) {
  318.                 graphics.drawPath(_cmdTriangle, _data);
  319.             } else {
  320.                 idx = face.i3<<1;
  321.                 _data[6] = vout[idx]; idx++;
  322.                 _data[7] = vout[idx];
  323.                 graphics.drawPath(_cmdQuadrangle, _data);
  324.             }
  325.             graphics.endFill();
  326.         }
  327.         return this;
  328.     }
  329.     
  330.     /** render with texture */
  331.     private var _indices:Vector.<int> = new Vector.<int>(); // temporary index list
  332.     public function renderTexture(texture:BitmapData) : Render3D {
  333.         var idx:int, mat:Material, indices:Vector.<int> = _indices;
  334.         indices.length = 0;
  335.         for each (var face:Face in _facesProjected) { indices.push(face.i0, face.i1, face.i2); }
  336.         Utils3D.projectVectors(_projectionMatrix, 
  337.                                _meshProjected.verticesOnWorld, 
  338.                                _meshProjected.verticesOnScreen, 
  339.                                _meshProjected.texCoord);
  340.         graphics.clear();
  341.         graphics.beginBitmapFill(texture, null, false, true);
  342.         graphics.drawTriangles(_meshProjected.verticesOnScreen, indices, _meshProjected.texCoord);
  343.         graphics.endFill();
  344.         return this;
  345.     }
  346. }
  348. /** Point3D */
  349. class Point3D extends Vector3D {
  350.     public var world:Vector3D;
  351.     function Point3D(x:Number=0, y:Number=0, z:Number=0, w:Number=1) { super(x,y,z,w); world=clone(); }
  352. }
  354. /** Face */
  355. class Face {
  356.     public var i0:int, i1:int, i2:int, i3:int, pvi:int, mat:int, normal:Point3D;
  357.     static private var _freeList:Vector.<Face> = new Vector.<Face>();
  358.     static public function free(face:Face) : void { _freeList.push(face); }
  359.     static public function alloc(i0:int, i1:int, i2:int, i3:int, mat:int) : Face { 
  360.         var f:Face = _freeList.pop() || new Face();
  361.         f.i0=i0; f.i1=i1; f.i2=i2; f.i3=i3; f.pvi=0; f.mat=mat;
  362.         return f;
  363.     }
  364. }
  366. /** Mesh */
  367. class Mesh {
  368.     public var materials:Vector.<Material>;                 // material list
  369.     public var vertices:Vector.<Number>;                    // vertex
  370.     public var verticesOnWorld:Vector.<Number>;             // vertex on camera coordinate
  371.     public var verticesOnScreen:Vector.<Number>;            // vertex on screen
  372.     public var verticesCount:int;                           // vertex count
  373.     public var texCoord:Vector.<Number>;                    // texture coordinate
  374.     public var faces:Vector.<Face> = new Vector.<Face>();   // face list
  375.     public var vnormals:Vector.<Vector3D>;                  // vertex normal
  376.     
  377.     /** constructor */
  378.     function Mesh(materials:Vector.<Material>=null) {
  379.         this.materials = materials;
  380.         this.vertices = new Vector.<Number>();
  381.         this.texCoord = new Vector.<Number>();
  382.         this.verticesOnWorld = new Vector.<Number>();
  383.         this.verticesOnScreen = new Vector.<Number>();
  384.         this.vnormals = null;
  385.         this.verticesCount = 0;
  386.     }
  387.     
  388.     /** clear all faces */
  389.     public function clear() : Mesh {
  390.         for each (var face:Face in faces) Face.free(face);
  391.         faces.length = 0;
  392.         return this;
  393.     }
  394.     
  395.     /** register face */
  396.     public function face(i0:int, i1:int, i2:int, mat:int=0) : Mesh {
  397.         faces.push(Face.alloc(i0, i1, i2, -1, mat));
  398.         return this;
  399.     }
  400.     
  401.     /** register quadrangle face. set div=true to divide into 2 triangles. */
  402.     public function qface(i0:int, i1:int, i2:int, i3:int, mat:int=0, div:Boolean=true) : Mesh {
  403.         if (div) faces.push(Face.alloc(i0, i1, i2, -1, mat), Face.alloc(i3, i2, i1, -1, mat));
  404.         else     faces.push(Face.alloc(i0, i1, i3, i2, mat));
  405.         return this;
  406.     }
  407.     
  408.     /** put mesh on model coordinate. */
  409.     public function put(src:Mesh, mat:int=-1) : Mesh {
  410.         var i0:int = vertices.length, imax:int, i:int;
  411.         imax = (src.verticesCount<<1) + src.verticesCount;
  412.         vertices.length += imax;
  413.         for (i=0; i<imax; i++) vertices[i0+i] = src.verticesOnWorld[i];
  414.         i0 /= 3;
  415.         for each (var f:Face in src.faces) {
  416.             i = (mat == -1) ? f.mat : mat;
  417.             if (f.i3==-1) face (f.i0+i0, f.i1+i0, f.i2+i0, i);
  418.             else          qface(f.i0+i0, f.i1+i0, f.i3+i0, f.i2+i0, i, false);
  419.         }
  420.         return this;
  421.     }
  422.     
  423.     /** update face gravity point and normal */
  424.     public function updateFaces() : Mesh {
  425.         verticesCount = vertices.length/3;
  426.         var vs:Vector.<Number> = vertices;
  427.         for each (var f:Face in faces) {
  428.             f.pvi = vs.length+2;
  429.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2;
  430.             var x01:Number=vs[i1]-vs[i0], x02:Number=vs[i2]-vs[i0];
  431.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  432.             var y01:Number=vs[i1]-vs[i0], y02:Number=vs[i2]-vs[i0];
  433.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  434.             var z01:Number=vs[i1]-vs[i0], z02:Number=vs[i2]-vs[i0];
  435.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  436.             f.normal = new Point3D(y02*z01-y01*z02, z02*x01-z01*x02, x02*y01-x01*y02, 0);
  437.             f.normal.normalize();
  438.             if (f.i3 != -1) {
  439.                 var i3:int = (f.i3<<1)+f.i3;
  440.                 vs[f.pvi-2] = vs[f.pvi-2]*0.75 + vs[i3++]*0.25;
  441.                 vs[f.pvi-1] = vs[f.pvi-1]*0.75 + vs[i3++]*0.25;
  442.                 vs[f.pvi]   = vs[f.pvi]  *0.75 + vs[i3]  *0.25;
  443.             }
  444.         }
  445.         return this;
  446.     }
  447. }
  449. /** Light */
  450. class Light extends Point3D {
  451.     public var halfVector:Vector3D = new Vector3D();
  452.     
  453.     /** constructor (set position) */
  454.     function Light(x:Number=1, y:Number=1, z:Number=1) {
  455.         super(x, y, z, 0);
  456.         normalize();
  457.     }
  459.     /** projection */
  460.     public function transformBy(matrix:Matrix3D) : void {
  461.         world = matrix.deltaTransformVector(this);
  462.         halfVector.x = world.x;
  463.         halfVector.y = world.y;
  464.         halfVector.z = world.z + 1; 
  465.         halfVector.normalize();
  466.     }
  467. }
  469. /** Material */
  470. class Material extends BitmapData {
  471.     public var alpha:Number = 1;    // The alpha value is available for renderSolid()
  472.     public var doubleSided:int = 0; // set doubleSided=-1 if double sided material
  473.     
  474.     /** constructor */
  475.     function Material(dif:int=128, spc:int=128) { super(dif, spc, false); }
  476.     
  477.     /** set color. */
  478.     public function setColor(col:uint, amb:int=64, dif:int=192, spc:int=0,  pow:Number=8) : Material {
  479.         fillRect(rect, col);
  480.         var lmap:LightMap = new LightMap(width, height);
  481.         draw(lmap.diffusion(amb, dif), null, null, "hardlight");
  482.         draw(lmap.specular (spc, pow), null, null, "add");
  483.         lmap.dispose();
  484.         return this;
  485.     }
  486.     
  487.     /** calculate color by light and normal vector. */
  488.     public function getColor(l:Light, n:Vector3D) : uint {
  489.         var dir:Vector3D = l.world, hv:Vector3D = l.halfVector;
  490.         var ln:int = int((dir.x * n.x + dir.y * n.y + dir.z * n.z) * (width-1)),
  491.             hn:int = int((hv.x  * n.x + hv.y  * n.y + hv.z  * n.z) * (height-1));
  492.         if (ln<0) ln = (-ln) & doubleSided;
  493.         if (hn<0) hn = (-hn) & doubleSided;
  494.         return getPixel(ln, hn);
  495.     }
  496. }
  498. class LightMap extends BitmapData {
  499.     function LightMap(dif:int, spc:int) { super(dif, spc, false); }
  500.     
  501.     public function diffusion(amb:int, dif:int) : BitmapData {
  502.         var col:int, rc:Rectangle = new Rectangle(0, 0, 1, height), ipk:Number = 1 / width;
  503.         for (rc.x=0; rc.x<width; rc.x+=1) {
  504.             col = ((rc.x * (dif - amb)) * ipk) + amb;
  505.             fillRect(rc, (col<<16)|(col<<8)|col);
  506.         }
  507.         return this;
  508.     }
  509.     
  510.     public function specular(spc:int, pow:Number) : BitmapData {
  511.         var col:int, rc:Rectangle = new Rectangle(0, 0, width, 1),
  512.             mpk:Number = (pow + 2) * 0.15915494309189534, ipk:Number = 1 / height;
  513.         for (rc.y=0; rc.y<height; rc.y+=1) {
  514.             col = Math.pow(rc.y * ipk, pow) * spc * mpk;
  515.             if (col > 255) col = 255;
  516.             fillRect(rc, (col<<16)|(col<<8)|col);
  517.         }
  518.         return this;
  519.     }
  520. }
noswf

Code based Structure Synth Regular Solid Structures [diff(167)]

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

Code based Structure Synth forked from: Code based Structure Synth [diff(111)]

  1. // forked from keim_at_Si's Code based Structure Synth
  2. // Code based Structure Synth
  3. //  Structure Synth; http://structuresynth.sourceforge.net/
  4. //------------------------------------------------------------
  5. package {
  6.     import flash.display.*;
  7.     import flash.events.*;
  8.     import flash.geom.*;
  9.     import flash.utils.*;
  11.     [SWF(width='465', height='465', backgroundColor='#000000', frameRate='30')]
  12.     public class main extends Sprite {
  13.         // 3D renders
  14.         private var _materials:Vector.<Material> = new Vector.<Material>();
  15.         private var _light:Light = new Light(1,0.2,0.4);
  16.         private var _solid:Vector.<Mesh> = new Vector.<Mesh>(5, true);
  17.         private var _meshSS:Mesh = new Mesh(_materials);
  19.         private var _screen:BitmapData = new BitmapData(465, 465, false, 0);
  20.         private var _matscr:Matrix = new Matrix(1, 0, 0, 1, 232.5, 232.5);
  21.         private var gl:Render3D = new Render3D(300,1);
  22.         private var ss:StructureSynth;
  23.         
  24.         // objects
  25.         private var camera:Vector3D;
  26.         
  27.         // motions
  28.         private var frame:int = 0;
  29.         private var frameStep:int = 1;
  30.         
  31.         // entry point
  32.         function main() {
  33.             var i:int;
  34.             
  35.             camera = new Vector3D(0, -5, -50);
  36.             _materials.push((new Material()).setColor(0x80c0ff, 64, 192, 32, 80));
  37.             for (i=0; i<5; i++) _solid[i] = new Mesh();
  38.             _createHexahedron(_solid[1], 1);
  39.             
  40.             addChild(gl).visible = false;
  41.             addChild(new Bitmap(_screen));
  42.             addEventListener("enterFrame", _onEnterFrame);
  43.             
  44.             // create mesh by Structure Synth
  45.             ss = new StructureSynth(gl, 200);
  46.             ss.rule("r1", function(depth:int) : void {
  47.                 gl.t(6,0,0.3).rz(45.6).s(0.99,0.99,1);
  48.                 ss.put(_solid[1]).call("r1");
  49.             });
  50.             ss.rule("r2", function(depth:int) : void {
  51.                 gl.rz(-45.6).t(-6,0,-0.3).s(0.99,0.99,1);
  52.                 ss.put(_solid[1]).call("r2");
  53.             });
  54.             ss.begin(_meshSS).put(_solid[1]).end();
  55.             ss.begin(_meshSS).call("r1").end();
  56.             ss.begin(_meshSS).call("r2").end();
  57.             _meshSS.updateFaces();
  58.         }
  60.         private function _onEnterFrame(e:Event) : void {
  61.             _screen.fillRect(_screen.rect, 0);
  62.             _light.transformBy(gl.id().tv(camera).rx((400-mouseY)*0.15).ry((232-mouseX)*0.75).matrix);
  63.             _screen.draw(gl.push().t(0, 0, 0).project(_meshSS).renderSolid(_light).pop(), _matscr);
  64.             frame += frameStep;
  65.         }
  66.         
  67.         // create regular solids
  68.         //--------------------------------------------------
  69.         private function _createHexahedron(mesh:Mesh, size:Number) : void {
  70.             for (var i:int=0; i<8; i++) mesh.vertices.push((i&1)?size:-size, ((i>>1)&1)?size:-size, (i>>2)?size:-size);
  71.             mesh.qface(0,1,2,3,0,false).qface(1,0,5,4,0,false).qface(0,2,4,6,0,false);
  72.             mesh.qface(2,3,6,7,0,false).qface(3,1,7,5,0,false).qface(5,4,7,6,0,false);
  73.             mesh.updateFaces();
  74.         }
  75.     }
  76. }
  79. import flash.display.*;
  80. import flash.geom.*;
  82. class StructureSynth {
  83.     private var _mesh:Mesh;
  84.     private var _functions:* = new Object();
  85.     private var _maxDepth:int;
  86.     private var _depth:int;
  87.     private var _core:Render3D;
  88.     
  89.     function StructureSynth(core:Render3D, maxDepth:int=100) { 
  90.         _core = core;
  91.         _maxDepth = maxDepth;
  92.     }
  93.     
  94.     /** register rule.
  95.      *  @param name rule name to call.
  96.      *  @param func Function to execute. The type is "function(depth:int) : void".
  97.      *  @param option option["w"/"weight"] to set weight and the option["md"/"maxdepth"] to set maxdepth.
  98.      */
  99.     public function rule(name:String, func:Function, option:*=null) : StructureSynth {
  100.         if (!(name in _functions)) _functions[name] = new SSFunctionList();
  101.         _functions[name].rule(func, option||new Object());
  102.         return this;
  103.     }
  104.     
  105.     /** begin constructing structure */
  106.     public function begin(mesh:Mesh) : StructureSynth {
  107.         for each (var func:SSFunctionList in _functions) func.init();
  108.         _depth = 0;
  109.         _mesh = mesh;
  110.         _core.push().id();
  111.         return this;
  112.     }
  113.     
  114.     /** call rule to construct structure */
  115.     public function call(name:String) : StructureSynth {
  116.         if (name in _functions) {
  117.             if (++_depth < _maxDepth) {
  118.                 _core.push();
  119.                 _functions[name].call();
  120.                 _core.pop();
  121.             }
  122.             _depth--;
  123.         }
  124.         return this;
  125.     }
  126.     
  127.     /** put mesh to construct structure */
  128.     public function put(src:Mesh) : StructureSynth {
  129.         var i0:int = _mesh.vertices.length, imax:int, i:int;
  130.         _core.project(src);
  131.         imax = (src.verticesCount<<1) + src.verticesCount;
  132.         _mesh.vertices.length += imax;
  133.         for (i=0; i<imax; i++) _mesh.vertices[i0+i] = src.verticesOnWorld[i];
  134.         i0 /= 3;
  135.         for each (var f:Face in src.faces) {
  136.             if (f.i3==-1) _mesh.face (f.i0+i0, f.i1+i0, f.i2+i0, f.mat);
  137.             else          _mesh.qface(f.i0+i0, f.i1+i0, f.i3+i0, f.i2+i0, f.mat, false);
  138.         }
  139.         return this;
  140.     }
  141.     
  142.     /** end constructing structure */
  143.     public function end() : StructureSynth {
  144.         _core.pop();
  145.         return this;
  146.     }
  147. }
  149. class SSFunctionList {
  150.     private var _totalWeight:Number = 0;
  151.     private var _functions:Vector.<SSFunction> = new Vector.<SSFunction>();
  152.     
  153.     public function rule(func:Function, option:*) : void {
  154.         var ssf:SSFunction = new SSFunction(func, option);
  155.         _functions.push(ssf);
  156.         _totalWeight += ssf.weight;
  157.     }
  159.     public function init() : void {
  160.         for each (var ssf:SSFunction in _functions) ssf.depth = 0;
  161.     }
  162.     
  163.     public function call() : void {
  164.         var w:Number = 0, rand:Number = Math.random() * _totalWeight;
  165.         for each (var ssf:SSFunction in _functions) {
  166.             w += ssf.weight;
  167.             if (rand <= w) {
  168.                 if (++ssf.depth <= ssf.maxdepth) ssf.func(ssf.depth-1);
  169.             }
  170.         }
  171.     }
  172. }
  174. class SSFunction {
  175.     public var func:Function;
  176.     public var weight:Number;
  177.     public var maxdepth:int;
  178.     public var depth:int = 0;
  179.     
  180.     function SSFunction(func:Function, option:*) {
  181.         this.func = func;
  182.         this.weight = option["w"] || option["weight"] || 0;
  183.         this.maxdepth = option["md"] || option["maxdepth"] || int.MAX_VALUE;
  184.     }
  185. }
  188. // 3D Engine
  189. //----------------------------------------------------------------------------------------------------
  190. /** Core */
  191. class Render3D extends Shape {
  192.     /** model view matrix */
  193.     public var matrix:Matrix3D;
  194.     private var _meshProjected:Mesh = null;                              // projecting mesh
  195.     private var _facesProjected:Vector.<Face> = new Vector.<Face>();     // projecting face
  196.     private var _projectionMatrix:Matrix3D;                              // projection matrix
  197.     private var _matrixStac:Vector.<Matrix3D> = new Vector.<Matrix3D>(); // matrix stac
  198.     private var _cmdTriangle:Vector.<int> = Vector.<int>([1,2,2]);       // commands to draw triangle
  199.     private var _cmdQuadrangle:Vector.<int> = Vector.<int>([1,2,2,2]);   // commands to draw quadrangle
  200.     private var _data:Vector.<Number> = new Vector.<Number>(8, true);    // data to draw shape
  201.     private var _clippingZ:Number;                                       // z value of clipping plane
  202.     
  203.     /** constructor */
  204.     function Render3D(focus:Number=300, clippingZ:Number=-0.1) {
  205.         var projector:PerspectiveProjection = new PerspectiveProjection()
  206.         projector.focalLength = focus;
  207.         _projectionMatrix = projector.toMatrix3D();
  208.         _clippingZ = -clippingZ;
  209.         matrix = new Matrix3D();
  210.         _matrixStac.length = 1;
  211.         _matrixStac[0] = matrix;
  212.     }
  214.     // control matrix
  215.     //--------------------------------------------------
  216.     public function clear() : Render3D { matrix = _matrixStac[0]; _matrixStac.length = 1; return this; }
  217.     public function push() : Render3D { _matrixStac.push(matrix.clone()); return this; }
  218.     public function pop() : Render3D { matrix = (_matrixStac.length == 1) ? matrix : _matrixStac.pop(); return this; }
  219.     public function id() : Render3D { matrix.identity(); return this; }
  220.     public function t(x:Number, y:Number, z:Number) : Render3D { matrix.prependTranslation(x, y, z); return this; }
  221.     public function tv(v:Vector3D) : Render3D { matrix.prependTranslation(v.x, v.y, v.z); return this; }
  222.     public function s(x:Number, y:Number, z:Number) : Render3D { matrix.prependScale(x, y, z); return this; }
  223.     public function sv(v:Vector3D) : Render3D { matrix.prependScale(v.x, v.y, v.z); return this; }
  224.     public function r(angle:Number, axis:Vector3D) : Render3D { matrix.prependRotation(angle, axis); return this; }
  225.     public function rv(v:Vector3D) : Render3D { matrix.prependRotation(v.w, v); return this; }
  226.     public function rx(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.X_AXIS); return this; }
  227.     public function ry(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Y_AXIS); return this; }
  228.     public function rz(angle:Number) : Render3D { matrix.prependRotation(angle, Vector3D.Z_AXIS); return this; }
  229.     
  230.     // projections
  231.     //--------------------------------------------------
  232.     /** project */
  233.     public function project(mesh:Mesh) : Render3D {
  234.         matrix.transformVectors(mesh.vertices, mesh.verticesOnWorld);
  235.         var fn:Point3D, vs:Vector.<Number> = mesh.verticesOnWorld;
  236.         var m:Vector.<Number> = matrix.rawData, 
  237.             m00:Number = m[0], m01:Number = m[1], m02:Number = m[2], 
  238.             m10:Number = m[4], m11:Number = m[5], m12:Number = m[6], 
  239.             m20:Number = m[8], m21:Number = m[9], m22:Number = m[10];
  240.         _facesProjected.length = 0;
  241.         for each (var f:Face in mesh.faces) {
  242.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2,
  243.                 x0:Number=vs[i0++], x1:Number=vs[i1++], x2:Number=vs[i2++],
  244.                 y0:Number=vs[i0++], y1:Number=vs[i1++], y2:Number=vs[i2++],
  245.                 z0:Number=vs[i0],   z1:Number=vs[i1],   z2:Number=vs[i2];
  246.             if (z0<_clippingZ && z1<_clippingZ && z2<_clippingZ) {
  247.                 fn = f.normal;
  248.                 fn.world.x = fn.x * m00 + fn.y * m10 + fn.z * m20;
  249.                 fn.world.y = fn.x * m01 + fn.y * m11 + fn.z * m21;
  250.                 fn.world.z = fn.x * m02 + fn.y * m12 + fn.z * m22;
  251.                 if (vs[f.pvi-2]*fn.world.x + vs[f.pvi-1]*fn.world.y + vs[f.pvi]*fn.world.z <= 0) {
  252.                     _facesProjected.push(f);
  253.                 }
  254.             }
  255.         }
  256.         _facesProjected.sort(function(f1:Face, f2:Face):Number{ return vs[f1.pvi] - vs[f2.pvi]; });
  257.         _meshProjected = mesh;
  258.         return this;
  259.     }
  260.     
  261.     /** project slower than transformVectors() but Vector3D.w considerable. */
  262.     public function projectPoint3D(points:Vector.<Point3D>) : Render3D {
  263.         var m:Vector.<Number> = matrix.rawData, p:Point3D, 
  264.             m00:Number = m[0],  m01:Number = m[1],  m02:Number = m[2], 
  265.             m10:Number = m[4],  m11:Number = m[5],  m12:Number = m[6], 
  266.             m20:Number = m[8],  m21:Number = m[9],  m22:Number = m[10], 
  267.             m30:Number = m[12], m31:Number = m[13], m32:Number = m[14];
  268.         for each (p in points) {
  269.             p.world.x = p.x * m00 + p.y * m10 + p.z * m20 + p.w * m30;
  270.             p.world.y = p.x * m01 + p.y * m11 + p.z * m21 + p.w * m31;
  271.             p.world.z = p.x * m02 + p.y * m12 + p.z * m22 + p.w * m32;
  272.         }
  273.         return this;
  274.     }
  276.     // rendering
  277.     //--------------------------------------------------
  278.     /** render solid */
  279.     public function renderSolid(light:Light) : Render3D {
  280.         var idx:int, mat:Material, materials:Vector.<Material> = _meshProjected.materials,
  281.             vout:Vector.<Number> = _meshProjected.verticesOnScreen;
  282.         Utils3D.projectVectors(_projectionMatrix, _meshProjected.verticesOnWorld, vout, _meshProjected.texCoord);
  283.         graphics.clear();
  284.         for each (var face:Face in _facesProjected) {
  285.             mat = materials[face.mat];
  286.             graphics.beginFill(mat.getColor(light, face.normal.world), mat.alpha);
  287.             idx = face.i0<<1;
  288.             _data[0] = vout[idx]; idx++;
  289.             _data[1] = vout[idx];
  290.             idx = face.i1<<1;
  291.             _data[2] = vout[idx]; idx++;
  292.             _data[3] = vout[idx];
  293.             idx = face.i2<<1;
  294.             _data[4] = vout[idx]; idx++;
  295.             _data[5] = vout[idx];
  296.             if (face.i3 == -1) {
  297.                 graphics.drawPath(_cmdTriangle, _data);
  298.             } else {
  299.                 idx = face.i3<<1;
  300.                 _data[6] = vout[idx]; idx++;
  301.                 _data[7] = vout[idx];
  302.                 graphics.drawPath(_cmdQuadrangle, _data);
  303.             }
  304.             graphics.endFill();
  305.         }
  306.         return this;
  307.     }
  308.     
  309.     /** render with texture */
  310.     private var _indices:Vector.<int> = new Vector.<int>(); // temporary index list
  311.     public function renderTexture(texture:BitmapData) : Render3D {
  312.         var idx:int, mat:Material, indices:Vector.<int> = _indices;
  313.         indices.length = 0;
  314.         for each (var face:Face in _facesProjected) { indices.push(face.i0, face.i1, face.i2); }
  315.         Utils3D.projectVectors(_projectionMatrix, 
  316.                                _meshProjected.verticesOnWorld, 
  317.                                _meshProjected.verticesOnScreen, 
  318.                                _meshProjected.texCoord);
  319.         graphics.clear();
  320.         graphics.beginBitmapFill(texture, null, false, true);
  321.         graphics.drawTriangles(_meshProjected.verticesOnScreen, indices, _meshProjected.texCoord);
  322.         graphics.endFill();
  323.         return this;
  324.     }
  325. }
  327. /** Point3D */
  328. class Point3D extends Vector3D {
  329.     public var world:Vector3D;
  330.     function Point3D(x:Number=0, y:Number=0, z:Number=0, w:Number=1) { super(x,y,z,w); world=clone(); }
  331. }
  333. /** Face */
  334. class Face {
  335.     public var i0:int, i1:int, i2:int, i3:int, pvi:int, mat:int, normal:Point3D;
  336.     static private var _freeList:Vector.<Face> = new Vector.<Face>();
  337.     static public function free(face:Face) : void { _freeList.push(face); }
  338.     static public function alloc(i0:int, i1:int, i2:int, i3:int, mat:int) : Face { 
  339.         var f:Face = _freeList.pop() || new Face();
  340.         f.i0=i0; f.i1=i1; f.i2=i2; f.i3=i3; f.pvi=0; f.mat=mat;
  341.         return f;
  342.     }
  343. }
  345. /** Mesh */
  346. class Mesh {
  347.     public var materials:Vector.<Material>;                 // material list
  348.     public var verticesCount:int;
  349.     public var vertices:Vector.<Number>;                    // vertex
  350.     public var verticesOnWorld:Vector.<Number>;             // vertex on camera coordinate
  351.     public var verticesOnScreen:Vector.<Number>;            // vertex on screen
  352.     public var texCoord:Vector.<Number>;                    // texture coordinate
  353.     public var faces:Vector.<Face> = new Vector.<Face>();   // face list
  354.     public var vnormals:Vector.<Vector3D>;                  // vertex normal
  355.     
  356.     /** constructor */
  357.     function Mesh(materials:Vector.<Material>=null) {
  358.         this.materials = materials;
  359.         this.vertices = new Vector.<Number>();
  360.         this.texCoord = new Vector.<Number>();
  361.         this.verticesOnWorld = new Vector.<Number>();
  362.         this.verticesOnScreen = new Vector.<Number>();
  363.         this.vnormals = null;
  364.         this.verticesCount = 0;
  365.     }
  366.     
  367.     /** clear all faces */
  368.     public function clear() : Mesh {
  369.         for each (var face:Face in faces) Face.free(face);
  370.         faces.length = 0;
  371.         return this;
  372.     }
  373.     
  374.     /** register face */
  375.     public function face(i0:int, i1:int, i2:int, mat:int=0) : Mesh {
  376.         faces.push(Face.alloc(i0, i1, i2, -1, mat));
  377.         return this;
  378.     }
  379.     
  380.     /** register quadrangle face. set div=true to divide into 2 triangles. */
  381.     public function qface(i0:int, i1:int, i2:int, i3:int, mat:int=0, div:Boolean=true) : Mesh {
  382.         if (div) faces.push(Face.alloc(i0, i1, i2, -1, mat), Face.alloc(i3, i2, i1, -1, mat));
  383.         else     faces.push(Face.alloc(i0, i1, i3, i2, mat));
  384.         return this;
  385.     }
  386.     
  387.     /** update face gravity point and normal */
  388.     public function updateFaces() : Mesh {
  389.         verticesCount = vertices.length/3;
  390.         var vs:Vector.<Number> = vertices;
  391.         for each (var f:Face in faces) {
  392.             f.pvi = vs.length+2;
  393.             var i0:int=(f.i0<<1)+f.i0, i1:int=(f.i1<<1)+f.i1, i2:int=(f.i2<<1)+f.i2;
  394.             var x01:Number=vs[i1]-vs[i0], x02:Number=vs[i2]-vs[i0];
  395.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  396.             var y01:Number=vs[i1]-vs[i0], y02:Number=vs[i2]-vs[i0];
  397.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  398.             var z01:Number=vs[i1]-vs[i0], z02:Number=vs[i2]-vs[i0];
  399.             vs.push((vs[i0++] + vs[i1++] + vs[i2++]) * 0.333333333333);
  400.             f.normal = new Point3D(y02*z01-y01*z02, z02*x01-z01*x02, x02*y01-x01*y02, 0);
  401.             f.normal.normalize();
  402.             if (f.i3 != -1) {
  403.                 var i3:int = (f.i3<<1)+f.i3;
  404.                 vs[f.pvi-2] = vs[f.pvi-2]*0.75 + vs[i3++]*0.25;
  405.                 vs[f.pvi-1] = vs[f.pvi-1]*0.75 + vs[i3++]*0.25;
  406.                 vs[f.pvi]   = vs[f.pvi]  *0.75 + vs[i3]  *0.25;
  407.             }
  408.         }
  409.         return this;
  410.     }
  411. }
  413. /** Light */
  414. class Light extends Point3D {
  415.     public var halfVector:Vector3D = new Vector3D();
  416.     
  417.     /** constructor (set position) */
  418.     function Light(x:Number=1, y:Number=1, z:Number=1) {
  419.         super(x, y, z, 0);
  420.         normalize();
  421.     }
  423.     /** projection */
  424.     public function transformBy(matrix:Matrix3D) : void {
  425.         world = matrix.deltaTransformVector(this);
  426.         halfVector.x = world.x;
  427.         halfVector.y = world.y;
  428.         halfVector.z = world.z + 1; 
  429.         halfVector.normalize();
  430.     }
  431. }
  433. /** Material */
  434. class Material extends BitmapData {
  435.     public var alpha:Number = 1;    // The alpha value is available for renderSolid()
  436.     public var doubleSided:int = 0; // set doubleSided=-1 if double sided material
  437.     
  438.     /** constructor */
  439.     function Material(dif:int=128, spc:int=128) { super(dif, spc, false); }
  440.     
  441.     /** set color. */
  442.     public function setColor(col:uint, amb:int=64, dif:int=192, spc:int=0,  pow:Number=8) : Material {
  443.         fillRect(rect, col);
  444.         var lmap:LightMap = new LightMap(width, height);
  445.         draw(lmap.diffusion(amb, dif), null, null, "hardlight");
  446.         draw(lmap.specular (spc, pow), null, null, "add");
  447.         lmap.dispose();
  448.         return this;
  449.     }
  450.     
  451.     /** calculate color by light and normal vector. */
  452.     public function getColor(l:Light, n:Vector3D) : uint {
  453.         var dir:Vector3D = l.world, hv:Vector3D = l.halfVector;
  454.         var ln:int = int((dir.x * n.x + dir.y * n.y + dir.z * n.z) * (width-1)),
  455.             hn:int = int((hv.x  * n.x + hv.y  * n.y + hv.z  * n.z) * (height-1));
  456.         if (ln<0) ln = (-ln) & doubleSided;
  457.         if (hn<0) hn = (-hn) & doubleSided;
  458.         return getPixel(ln, hn);
  459.     }
  460. }
  462. class LightMap extends BitmapData {
  463.     function LightMap(dif:int, spc:int) { super(dif, spc, false); }
  464.     
  465.     public function diffusion(amb:int, dif:int) : BitmapData {
  466.         var col:int, rc:Rectangle = new Rectangle(0, 0, 1, height), ipk:Number = 1 / width;
  467.         for (rc.x=0; rc.x<width; rc.x+=1) {
  468.             col = ((rc.x * (dif - amb)) * ipk) + amb;
  469.             fillRect(rc, (col<<16)|(col<<8)|col);
  470.         }
  471.         return this;
  472.     }
  473.     
  474.     public function specular(spc:int, pow:Number) : BitmapData {
  475.         var col:int, rc:Rectangle = new Rectangle(0, 0, width, 1),
  476.             mpk:Number = (pow + 2) * 0.15915494309189534, ipk:Number = 1 / height;
  477.         for (rc.y=0; rc.y<height; rc.y+=1) {
  478.             col = Math.pow(rc.y * ipk, pow) * spc * mpk;
  479.             if (col > 255) col = 255;
  480.             fillRect(rc, (col<<16)|(col<<8)|col);
  481.         }
  482.         return this;
  483.     }
  484. }
noswf
Get Adobe Flash Player