embed

  1. package
  2. {
  3.     import flash.display.*;
  4.     import flash.events.*;
  5.     import flash.text.*;
  6.     import flash.ui.Keyboard;
  7.     import flash.utils.getTimer;
  8.     
  9.     [SWF(width="465", height="465",
  10.         backgroundColor="0x000000", frameRate="30")]
  11.     public class Donuts02 extends Sprite
  12.     {
  13.         private var _donuts:Donuts;
  14.         private var _matrix:Matrix3D;
  15.         private var _render:Render;
  16.         
  17.         private var _textField:TextField;
  18.         
  19.         private var _rx:Number = 0;
  20.         private var _ry:Number = 0;
  21.         private var _rz:Number = 0;
  22.         
  23.         private var _isAutoPlay:Boolean = false;
  24.         
  25.         private const STAGE_WIDTH:Number = stage.stageWidth;
  26.         private const STAGE_HEIGHT:Number = stage.stageHeight;
  27.         
  28.         public function Donuts02()
  29.         {
  30.             configure();
  31.             
  32.             var pi:Number = Math.PI;
  33.             var start:int;
  34.             var i:int;
  35.             
  36.             _donuts = new Donuts(16, 0.7);
  37.             _matrix = new Matrix3D();
  38.             _render = new Render(graphics, _matrix);
  39.             
  40.             addTextField();
  41.             
  42.             mainLoop(null);
  43.             
  44.             stage.addEventListener(MouseEvent.CLICK, changePlayMode);
  45.             
  46.             _textField.text =
  47.                 "Partitions : " + _donuts.numPartitions + "\n" +
  48.                 "Vertices : " + _donuts.vertices.length + "\n" +
  49.                 "Stretch : " + _donuts.stretch;
  50.         }
  51.         
  52.         private function configure():void
  53.         {
  54.             stage.align = StageAlign.TOP_LEFT;
  55.             stage.scaleMode = StageScaleMode.NO_SCALE;
  56.             stage.showDefaultContextMenu = false;
  57.         }
  58.         
  59.         private function addTextField():void
  60.         {
  61.             _textField = new TextField();
  62.             _textField.defaultTextFormat = new TextFormat(
  63.                 null, null, 0xFFFFFF, null, null, null, null, null, TextFormatAlign.RIGHT);
  64.             _textField.autoSize = TextFieldAutoSize.RIGHT;
  65.             _textField.background = true;
  66.             _textField.backgroundColor = 0x000000;
  67.             _textField.selectable = false;
  68.             _textField.x = STAGE_WIDTH - _textField.width;
  69.             
  70.             addChild(_textField);
  71.             
  72.             var announce:TextField = new TextField();
  73.             announce.defaultTextFormat = new TextFormat(
  74.                 null, null, 0xFFFFFF, null, null, null, null, null, TextFormatAlign.LEFT);
  75.             announce.autoSize = TextFieldAutoSize.LEFT;
  76.             announce.background = true;
  77.             announce.backgroundColor = 0x000000;
  78.             announce.selectable = false;
  79.             announce.text =
  80.                 "\"DOWN\" : Partitions -\n" +
  81.                 "\"UP\" : Partitions +\n" +
  82.                 "\"LEFT\" : Stretch -\n" +
  83.                 "\"RIGHT\" : Stretch +\n" +
  84.                 "\"Z\" : Polygon on/off\n" +
  85.                 "\"X\" : Wireframe on/off";
  86.             announce.y = STAGE_HEIGHT - announce.height;
  87.             
  88.             addChild(announce);
  89.         }
  90.         
  91.         private function mainLoop(event:Event):void
  92.         {
  93.             _matrix.identity();
  94.             _matrix.scale(50, 50, 50);
  95.             _matrix.rotateX(_rx);
  96.             _matrix.rotateY(_ry);
  97.             _matrix.rotateZ(_rz);
  98.             _matrix.translate(STAGE_WIDTH / 2, STAGE_HEIGHT / 2, 0);
  99.             
  100.             graphics.clear();
  101.             
  102.             _render.drawIndexedPrimitive(
  103.                 Render.PRIMITIVE_POLYGON, _donuts.vertices, _donuts.indices);
  104.             
  105.             _rx += 0.04;
  106.             _ry += 0.08;
  107.             _rz += 0.02;
  108.         }
  109.         
  110.         private function changePlayMode(event:MouseEvent):void
  111.         {
  112.             if (_isAutoPlay)
  113.             {
  114.                 removeEventListener(Event.ENTER_FRAME, mainLoop);
  115.                 stage.removeEventListener(KeyboardEvent.KEY_DOWN, changeDonuts);
  116.             }
  117.             else
  118.             {
  119.                 addEventListener(Event.ENTER_FRAME, mainLoop);
  120.                 stage.addEventListener(KeyboardEvent.KEY_DOWN, changeDonuts);
  121.             }
  122.             
  123.             _isAutoPlay = !_isAutoPlay;
  124.         }
  125.         
  126.         private function changeDonuts(event:KeyboardEvent):void
  127.         {
  128.             var numPartitions:int = _donuts.numPartitions;
  129.             
  130.             switch (event.keyCode)
  131.             {
  132.                 case Keyboard.UP:
  133.                     if (numPartitions >= 0)
  134.                     {
  135.                         _donuts.numPartitions += 1;
  136.                     }
  137.                     break;
  138.                 case Keyboard.DOWN:
  139.                     if (numPartitions > 0)
  140.                     {
  141.                         _donuts.numPartitions -= 1;
  142.                     }
  143.                     break;
  144.                 case Keyboard.LEFT:
  145.                     _donuts.stretch -= 0.02;
  146.                     break;
  147.                 case Keyboard.RIGHT:
  148.                     _donuts.stretch += 0.02;
  149.                     break;
  150.                 case 88:
  151.                     //trace("X");
  152.                     _render.wireframeEnabled = !_render.wireframeEnabled;
  153.                     break;
  154.                 case 90:
  155.                     //trace("Z");
  156.                     _render.polygonEnabled = !_render.polygonEnabled;
  157.                     break;
  158.             }
  159.             
  160.             _textField.text =
  161.                 "Partitions : " + _donuts.numPartitions + "\n" +
  162.                 "Vertices : " + _donuts.vertices.length + "\n" +
  163.                 "Stretch : " + _donuts.stretch.toString().substr(0, 4);
  164.         }
  165.     }
  166. }
  168. import flash.display.Graphics;
  170. class Render
  171. {
  172.     public static const PRIMITIVE_POLYGON:int = 1;
  173.     
  174.     private var _graphics:Graphics;
  175.     private var _matrix:Matrix3D;
  176.     private var _mode:int;
  177.     
  178.     private var _polygonEnabled:Boolean = true;
  179.     private var _wireframeEnabled:Boolean = false;
  180.     
  181.     // 光源ベクトル
  182.     private var _light:Vector3D   = new Vector3D( 0.0,  0.0, -1.0);
  183.     
  184.     // アンビエント（環境光）の色
  185.     private var _ambient:Vector3D = new Vector3D( 0.2,  0.2,  0.2);
  186.     // ディフューズ（拡散光）の色
  187.     private var _diffuse:Vector3D = new Vector3D( 0.8,  0.8,  0.8);
  188.     
  189.     /**
  190.     * 新しい Render インスタンスを作成します。
  191.     */
  192.     public function Render(
  193.         graphics:Graphics = null, matrix:Matrix3D = null, mode:int = 1):void
  194.     {
  195.         _graphics = graphics;
  196.         _matrix = matrix;
  197.         _mode = mode;
  198.     }
  199.     
  200.     public function drawIndexedPrimitive(type:int, vertices:Array, indices:Array):void
  201.     {
  202.         var i:int;
  203.         var l:int;
  204.         
  205.         var tv:Array = [];
  206.         
  207.         // 座標を一次変換
  208.         for (i = 0, l = vertices.length; i < l; ++i)
  209.         {
  210.             tv.push(_matrix.transform(vertices[i]));
  211.         }
  212.         
  213.         // ラスタライズ
  214.         switch (type)
  215.         {
  216.             case PRIMITIVE_POLYGON:
  217.                 
  218.                 var triangles:Array = [];
  219.                 
  220.                 for (i = 0, l = indices.length; i < l; i += 3)
  221.                 {
  222.                     triangles.push(new Triangle3D(
  223.                         tv[indices[i    ]],
  224.                         tv[indices[i + 1]],
  225.                         tv[indices[i + 2]]
  226.                     ));
  227.                 }
  228.                 
  229.                 // 深度ソート
  230.                 triangles.sortOn("depth", Array.DESCENDING | Array.NUMERIC);
  231.                 
  232.                 for each (var triangle:Triangle3D in triangles)
  233.                 {
  234.                     drawPolygon(triangle);
  235.                 }
  236.                 
  237.                 break;
  238.         }
  239.     }
  240.     
  241.     private function drawPolygon(triangle:Triangle3D):void
  242.     {
  243.         if (polygonEnabled)
  244.         {
  245.             // 面の法線ベクトルを求める。
  246.             var n:Vector3D = triangle.normal();
  247.             
  248.             // 光源と法線の内積を取る。
  249.             var w:Number = n.dot(_light);
  250.             
  251.             // 背面カリング処理。
  252.             // 内積が負なら背面なので描画しない。（ただしパースをつけた場合は正確な判定方法ではない。）
  253.             if (w < 0)
  254.             {
  255.                 return;
  256.             }
  257.             
  258.             var r:int = (_ambient.x + w * _diffuse.x) * 255;
  259.             var g:int = (_ambient.y + w * _diffuse.y) * 255;
  260.             var b:int = (_ambient.z + w * _diffuse.z) * 255;
  261.             
  262.             r = (r < 0) ? 0 : (r > 255) ? 255 : r;
  263.             g = (g < 0) ? 0 : (g > 255) ? 255 : g;
  264.             b = (b < 0) ? 0 : (b > 255) ? 255 : b;
  265.             
  266.             _graphics.beginFill(r << 16 | g << 8 | b);
  267.         }
  268.         
  269.         if (wireframeEnabled)
  270.         {
  271.             _graphics.lineStyle(0, 0xFF0000);
  272.         }
  273.         
  274.         _graphics.moveTo(triangle.v1.x, triangle.v1.y);
  275.         _graphics.lineTo(triangle.v2.x, triangle.v2.y);
  276.         _graphics.lineTo(triangle.v3.x, triangle.v3.y);
  277.         _graphics.lineTo(triangle.v1.x, triangle.v1.y);
  278.         
  279.         _graphics.endFill();
  280.     }
  281.     
  282.     public function get graphics():Graphics
  283.     {
  284.         return _graphics;
  285.     }
  286.     
  287.     public function set graphics(value:Graphics):void
  288.     {
  289.         _graphics = value;
  290.     }
  291.     
  292.     public function get matrix():Matrix3D
  293.     {
  294.         return _matrix;
  295.     }
  296.     
  297.     public function set matrix(value:Matrix3D):void
  298.     {
  299.         _matrix = value;
  300.     }
  301.     
  302.     public function get polygonEnabled():Boolean
  303.     {
  304.         return _polygonEnabled;
  305.     }
  306.     
  307.     public function set polygonEnabled(value:Boolean):void
  308.     {
  309.         _polygonEnabled = value;
  310.     }
  311.     
  312.     public function get wireframeEnabled():Boolean
  313.     {
  314.         return _wireframeEnabled;
  315.     }
  316.     
  317.     public function set wireframeEnabled(value:Boolean):void
  318.     {
  319.         _wireframeEnabled = value;
  320.     }
  321. }
  323. class Donuts
  324. {
  325.     private var _vertices:Array;
  326.     private var _indices:Array;
  327.     private var _numPartitions:int;
  328.     private var _stretch:Number;
  329.     
  330.     /**
  331.      * @param numPartitions 分割数
  332.      * @param stretch 拡がり
  333.      */
  334.     public function Donuts(numPartitions:int = 16, stretch:Number = 1):void
  335.     {
  336.         _numPartitions = numPartitions;
  337.         _stretch = stretch;
  338.         
  339.         setup(numPartitions, stretch);
  340.     }
  341.     
  342.     /**
  343.      * @private
  344.      */
  345.     private function setup(numPartitions:int, stretch:Number):void
  346.     {
  347.         var n:int = numPartitions;
  348.         
  349.         var i:int;
  350.         var j:int;
  351.         
  352.         var a:Number = 0;
  353.         var c:Number = 0;
  354.         var addc:Number = Math.PI * 2 / n;
  355.         
  356.         var s:Number;
  357.         var z:Number;
  358.         var x:Number;
  359.         var y:Number;
  360.         
  361.         _vertices = [];
  362.         
  363.         for (i = 0; i < n; ++i)
  364.         {
  365.             s = Math.sin(c) + 2;
  366.             z = Math.cos(c);
  367.             
  368.             for (j = 0; j < n; ++j)
  369.             {
  370.                 x = Math.cos(a);
  371.                 y = Math.sin(a);
  372.                 
  373.                 _vertices.push(new Vector3D(
  374.                     x * s * stretch,
  375.                     y * s * stretch,
  376.                     z     * stretch
  377.                 ));
  378.                 
  379.                 a += Math.PI / n * 2;
  380.             }
  381.             
  382.             c += addc;
  383.         }
  384.         
  385.         var m:int = n * n;
  386.         var off:Number;
  387.         
  388.         _indices = [];
  389.         
  390.         for (i = 0; i < n; ++i)
  391.         {
  392.             off = i * n;
  393.             
  394.             for (j = 0; j < n; ++j)
  395.             {
  396.                 _indices.push((off + n) % m + (j + 1) % n);
  397.                 _indices.push( off          + (j + 1) % n);
  398.                 _indices.push( off          +  j         );
  399.                 _indices.push((off + n) % m +  j         );
  400.                 _indices.push((off + n) % m + (j + 1) % n);
  401.                 _indices.push( off          +  j         );
  402.             }
  403.         }
  404.     }
  405.     
  406.     public function get vertices():Array
  407.     {
  408.         return _vertices.concat();
  409.     }
  410.     
  411.     public function get indices():Array
  412.     {
  413.         return _indices.concat();
  414.     }
  415.     
  416.     public function get numPartitions():int
  417.     {
  418.         return _numPartitions;
  419.     }
  420.     
  421.     public function set numPartitions(value:int):void
  422.     {
  423.         _numPartitions = value;
  424.         
  425.         setup(value, stretch);
  426.     }
  427.     
  428.     public function get stretch():Number
  429.     {
  430.         return _stretch;
  431.     }
  432.     
  433.     public function set stretch(value:Number):void
  434.     {
  435.         _stretch = value;
  436.         
  437.         setup(numPartitions, value);
  438.     }
  439. }
  441. class Triangle3D
  442. {
  443.     private var _v1:Vector3D;
  444.     private var _v2:Vector3D;
  445.     private var _v3:Vector3D;
  446.     
  447.     /**
  448.     * 新しい Triangle3D インスタンスを作成します。
  449.     */
  450.     public function Triangle3D(v1:Vector3D, v2:Vector3D, v3:Vector3D):void
  451.     {
  452.         _v1 = v1;
  453.         _v2 = v2;
  454.         _v3 = v3;
  455.     }
  456.     
  457.     public function get v1():Vector3D
  458.     {
  459.         return _v1;
  460.     }
  461.     
  462.     public function set v1(value:Vector3D):void
  463.     {
  464.         _v1 = value;
  465.     }
  466.     
  467.     public function get v2():Vector3D
  468.     {
  469.         return _v2;
  470.     }
  471.     
  472.     public function set v2(value:Vector3D):void
  473.     {
  474.         _v2 = value;
  475.     }
  476.     
  477.     public function get v3():Vector3D
  478.     {
  479.         return _v3;
  480.     }
  481.     
  482.     public function set v3(value:Vector3D):void
  483.     {
  484.         _v3 = value;
  485.     }
  486.     
  487.     /**
  488.      * 各ベクトルの z の値を比較し、最も低い数値を返します。
  489.      * 深度ソート時に Array オブジェクトの sortOn と合わせて使用します。
  490.      */
  491.     public function get depth():Number
  492.     {
  493.         var min:Number = (v1.z < v2.z) ? v1.z : v2.z;
  494.         return (min < v3.z) ? min : v3.z;
  495.     }
  496.     
  497.     /**
  498.      * このトライアングルを面とする法線ベクトルを返します。
  499.      * 
  500.      * @return このトライアングルを面とする法線ベクトル
  501.      */
  502.     public function normal():Vector3D
  503.     {
  504.         var n:Vector3D = new Vector3D();
  505.         n.cross(v1.distance(v2), v1.distance(v3));
  506.         n.normalize();
  507.         
  508.         return n;
  509.     }
  510.     
  511.     /**
  512.      * このトライアングルのストリング表現を返します。
  513.      * 
  514.      * @return このトライアングルのストリング表現
  515.      */
  516.     public function toString():String
  517.     {
  518.         var temp:String = "Triangle3D {\n" +
  519.             "\tv1 : " + v1 + "\n" +
  520.             "\tv2 : " + v2 + "\n" +
  521.             "\tv3 : " + v3 + "\n}";
  522.         
  523.         return temp;
  524.     }
  525. }
  527. class Matrix3D
  528. {
  529.     private var _matrix:Array;
  530.     
  531.     /**
  532.     * 新しい Matrix3D インスタンスを作成します。
  533.     */
  534.     public function Matrix3D():void
  535.     {
  536.         identity();
  537.     }
  538.     
  539.     public function identity():void
  540.     {
  541.         _matrix = [
  542.             1, 0, 0, 0,
  543.             0, 1, 0, 0,
  544.             0, 0, 1, 0,
  545.             0, 0, 0, 1
  546.         ];
  547.     }
  548.     
  549.     public function scale(sx:Number, sy:Number, sz:Number)
  550.     {
  551.         _matrix = _multiply(_matrix, [
  552.             sx,  0,  0,  0,
  553.              0, sy,  0,  0,
  554.              0,  0, sz,  0,
  555.              0,  0,  0,  1
  556.         ]);
  557.     }
  558.     
  559.     public function translate(dx:Number, dy:Number, dz:Number)
  560.     {
  561.         _matrix = _multiply(_matrix, [
  562.              1,  0,  0,  0,
  563.              0,  1,  0,  0,
  564.              0,  0,  1,  0,
  565.             dx, dy, dz,  1
  566.         ]);
  567.     }
  568.     
  569.     public function rotateX(angleRadians:Number)
  570.     {
  571.         var sin = Math.sin(angleRadians);
  572.         var cos = Math.cos(angleRadians);
  573.         
  574.         _matrix = _multiply(_matrix, [
  575.             1,    0,   0, 0,
  576.             0,  cos, sin, 0,
  577.             0, -sin, cos, 0,
  578.             0,    0,   0, 1
  579.         ]);
  580.     }
  581.     
  582.     public function rotateY(angleRadians:Number)
  583.     {
  584.         var sin = Math.sin(angleRadians);
  585.         var cos = Math.cos(angleRadians);
  586.         
  587.         _matrix = _multiply(_matrix, [
  588.             cos, 0, -sin, 0,
  589.               0, 1,    0, 0,
  590.             sin, 0,  cos, 0,
  591.               0, 0,    0, 1
  592.         ]);
  593.     }
  594.     
  595.     public function rotateZ(angleRadians:Number)
  596.     {
  597.         var sin = Math.sin(angleRadians);
  598.         var cos = Math.cos(angleRadians);
  599.         
  600.         _matrix = _multiply(_matrix, [
  601.              cos, sin, 0, 0,
  602.             -sin, cos, 0, 0,
  603.                0,   0, 1, 0,
  604.                0,   0, 0, 1
  605.         ]);
  606.     }
  607.     
  608.     /**
  609.      * このマトリクスで指定のベクトルを一次変換します。
  610.      * 
  611.      * @return 一次変換されたベクトル
  612.      */
  613.     public function transform(v:Vector3D):Vector3D
  614.     {
  615.         var temp:Vector3D = new Vector3D();
  616.         var m:Array = _matrix;
  617.         
  618.         temp.x = m[0] * v.x + m[4] * v.y + m[ 8] * v.z + m[12];
  619.         temp.y = m[1] * v.x + m[5] * v.y + m[ 9] * v.z + m[13];
  620.         temp.z = m[2] * v.x + m[6] * v.y + m[10] * v.z + m[14];
  621.         
  622.         return temp;
  623.     }
  624.     
  625.     /**
  626.      * このマトリクスと指定マトリクスの成分を乗算（合成）します。
  627.      * 
  628.      * @param m 対象の Matrix3D オブジェクト
  629.      */
  630.     public function multiply(m:Matrix3D):void
  631.     {
  632.         _matrix = _multiply(m.toArray(), _matrix);
  633.     }
  634.     
  635.     /**
  636.      * @private
  637.      */
  638.     private function _multiply(m1:Array, m2:Array):Array
  639.     {
  640.         var temp:Array = [];
  641.         var i:int = 0;
  642.         
  643.         for (var y:int = 0; y < 4; ++y)
  644.         {
  645.             for (var x:int = 0; x < 4; ++x)
  646.             {
  647.                 temp[x + i] =
  648.                     m1[i    ] * m2[x     ] +
  649.                     m1[i + 1] * m2[x +  4] +
  650.                     m1[i + 2] * m2[x +  8] +
  651.                     m1[i + 3] * m2[x + 12];
  652.             }
  653.             i += 4;
  654.         }
  655.         
  656.         return temp;
  657.     }
  658.     
  659.     /**
  660.      * このマトリクスの成分配列を返します。
  661.      * 
  662.      * @return このマトリクスの成分配列
  663.      */
  664.     public function toArray():Array
  665.     {
  666.         return _matrix.concat();
  667.     }
  668.     
  669.     /**
  670.      * このマトリクスのストリング表現を返します。
  671.      * 
  672.      * @return このマトリクスのストリング表現
  673.      */
  674.     public function toString():String
  675.     {
  676.         var temp:String = "Matrix3D [\n";
  677.         
  678.         for (var i:int = 0, l:int = _matrix.length; i < l; ++i)
  679.         {
  680.             if (i % 4 == 0)
  681.             {
  682.                 if (i != 0)
  683.                 {
  684.                     temp += "\n";
  685.                 }
  686.                 temp += "\t";
  687.             }
  688.             if (i != l - 1)
  689.             {
  690.                 temp += _matrix[i] + ", ";
  691.             }
  692.             else
  693.             {
  694.                 temp += _matrix[i] + "\n]";
  695.             }
  696.         }
  697.         
  698.         return temp;
  699.     }
  700. }
  702. class Vector3D
  703. {
  704.     private var _x:Number;
  705.     private var _y:Number;
  706.     private var _z:Number;
  707.     
  708.     /**
  709.     * 新しい Vector3D インスタンスを作成します。
  710.     */
  711.     public function Vector3D(x:Number = 0, y:Number = 0, z:Number = 0):void
  712.     {
  713.         _x = x;
  714.         _y = y;
  715.         _z = z;
  716.     }
  717.     
  718.     public function get x():Number
  719.     {
  720.         return _x;
  721.     }
  722.     
  723.     public function set x(value:Number):void
  724.     {
  725.         _x = value;
  726.     }
  727.     
  728.     public function get y():Number
  729.     {
  730.         return _y;
  731.     }
  732.     
  733.     public function set y(value:Number):void
  734.     {
  735.         _y = value;
  736.     }
  737.     
  738.     public function get z():Number
  739.     {
  740.         return _z;
  741.     }
  742.     
  743.     public function set z(value:Number):void
  744.     {
  745.         _z = value;
  746.     }
  747.     
  748.     /**
  749.      * このベクトルを正規化して単位ベクトルにします。
  750.      * 単位ベクトルとは大きさが 1 のベクトルのことです。
  751.      */
  752.     public function normalize():void
  753.     {
  754.         var l:Number = 1 / Math.sqrt(x * x + y * y + z * z);
  755.         
  756.         x *= l;
  757.         y *= l;
  758.         z *= l;
  759.     }
  760.     
  761.     /**
  762.      * 指定された 2 つのベクトルの外積をこのベクトルに設定します。
  763.      * 外積は主に、面に垂直な法線ベクトルを求めるために使用します。
  764.      * 
  765.      * @param v1 1 つ目のベクトル
  766.      * @param v1 2 つ目のベクトル
  767.      */
  768.     public function cross(v1:Vector3D, v2:Vector3D):void
  769.     {
  770.         x = v1.y * v2.z - v1.z * v2.y;
  771.         y = v1.z * v2.x - v1.x * v2.z;
  772.         z = v1.x * v2.y - v1.y * v2.x;
  773.     }
  774.     
  775.     /**
  776.      * このベクトルと指定ベクトルの内積を返します。
  777.      * 内積を取るとベクトルとベクトルのなす角度が求まります。
  778.      * 
  779.      * @param v ベクトル
  780.      * @return このベクトルと指定ベクトルの内積
  781.      */
  782.     public function dot(v:Vector3D):Number
  783.     {
  784.         return x * v.x + y * v.y + z * v.z;
  785.     }
  786.     
  787.     /**
  788.      * 指定された 2 つのベクトルの内積を返します。
  789.      * 内積を取るとベクトルとベクトルのなす角度が求まります。
  790.      * 
  791.      * @param v1 1 つ目のベクトル
  792.      * @param v1 2 つ目のベクトル
  793.      * @return 指定された 2 つのベクトルの内積
  794.      */
  795.     public static function dot(v1:Vector3D, v2:Vector3D):Number
  796.     {
  797.         return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
  798.     }
  799.     
  800.     /**
  801.      * ベクトルを反転します。
  802.      */
  803.     public function invert():void
  804.     {
  805.         x *= -1;
  806.         y *= -1;
  807.         z *= -1;
  808.     }
  809.     
  810.     /**
  811.      * このベクトルと指定ベクトルとの差分を表すベクトルを返します。
  812.      * 
  813.      * @return 差分を表すベクトル
  814.      */
  815.     public function distance(v:Vector3D):Vector3D
  816.     {
  817.         return new Vector3D(x - v.x, y - v.y, z - v.z);
  818.     }
  819.     
  820.     /**
  821.      * このベクトルのコピーを返します。
  822.      * 
  823.      * @return このベクトルのコピー
  824.      */
  825.     public function clone():Vector3D
  826.     {
  827.         return new Vector3D(x, y, z);
  828.     }
  829.     
  830.     /**
  831.      * このベクトルのストリング表現を返します。
  832.      * 
  833.      * @return このベクトルのストリング表現
  834.      */
  835.     public function toString():String
  836.     {
  837.         return "Vector3D {x:" + x + ", y:" + y + ", z:" + z + "}";
  838.     }
  839. }
flash swf thumbnail play
FAVORITE BY
:
:
cool!
:
3d donuts!!
:
rosca3d
:
spinning donut
Get Adobe Flash Player