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

flash on 2009-5-30 forked from: flash on 2009-5-30 [diff(23)]

  1. // forked from sebleedelisle's flash on 2009-5-30
  2. package
  3. {
  4.    import flash.display.Graphics;
  5.    import flash.display.Sprite;
  6.    import flash.events.MouseEvent;
  7.    import flash.geom.Point;
  8.    import flash.geom.Rectangle;
  9.    import flash.text.TextField;
  10.    import flash.text.TextFormat;
  11.    import flash.utils.getTimer;
  12.    [SWF(frameRate="100", backgroundColor="0x000000", width="500", height="500")]
  14.    public class TriangleAABBSpeedTest extends Sprite
  15.    {
  16.       
  17.       
  18.       public var outputText : TextField;
  19.       
  20.       public function TriangleAABBSpeedTest()
  21.       {
  22.          super();
  23.          outputText = new TextField(); 
  24.          x = y = 250; 
  25.          outputText.defaultTextFormat = new TextFormat("Arial"); 
  26.          outputText.textColor = 0xffffff; 
  27.          outputText.text = "Click to start test"; 
  28.          outputText.x = outputText.y = -250; 
  29.          outputText.width = 500; 
  30.          
  31.          addChild(outputText); 
  32.          
  33.          stage.addEventListener(MouseEvent.MOUSE_DOWN, startTest); 
  34.          
  35.       }
  36.    
  37.       // I'm thinking that storing these values as properties rather than declaring them as local vars 
  38.       // should be faster...
  39.          
  40.       private  var x0 : Number; 
  41.       private  var y0 : Number; 
  42.       private  var x1 : Number; 
  43.       private  var y1 : Number; 
  44.       private  var x2 : Number; 
  45.       private  var y2 : Number; 
  46.       private  var l : Number; 
  47.       private  var r : Number; 
  48.       private  var t : Number; 
  49.       private  var b : Number; 
  50.       
  51.       private  var top_intersection:Number ;
  52.       private  var bottom_intersection : Number; 
  53.       private  var toptrianglepoint : Number; 
  54.       private  var bottomtrianglepoint : Number; 
  55.       
  56.       private  var m: Number;
  57.       private var c : Number   
  58.    
  59.    
  60.       // THESE ARE THE TWO FUNCTIONS YOU CAN OPTIMISE. 
  61.       // I realise that you could inline the lineRectangleIntersect method, but I'd rather not do that just yet... 
  62.       // I'm looking for maths/logic improvements. 
  63.    
  64.       public function triangleAABBIntersectionTest(rect:Rectangle,  vertex0:Point, vertex1:Point, vertex2:Point ) : Boolean
  65.       {
  66.          // YOU MUST LEAVE THESE DECLARATIONS; they simulate necessary data exchange within PV3D
  67.          l = rect.left; 
  68.          r = rect.right; 
  69.          t = rect.top; 
  70.          b = rect.bottom; 
  71.          
  72.          x0 = vertex0.x; 
  73.          y0 = vertex0.y; 
  74.          x1 = vertex1.x; 
  75.          y1 = vertex1.y; 
  76.          x2 = vertex2.x; 
  77.          y2 = vertex2.y; 
  78.          
  79.          
  80.          return lineRectangleIntersect(x0,y0,x1,y1) 
  81.                ||   lineRectangleIntersect(x1,y1,x2,y2) 
  82.                ||   lineRectangleIntersect(x2,y2,x0,y0);
  83.       
  84.       
  85.          
  86.       }
  87.       
  88.       
  89.       public function lineRectangleIntersect(x0: Number,y0: Number,x1: Number,y1: Number):Boolean //, left:Number, right:Number, top:Number, bottom:Number) : Boolean
  90.       {
  91.             
  92.             // Calculate m and c for the equation for the line (y = mx+c)
  93.             m = (y1-y0) / (x1-x0); 
  94.             c = y0 -(m*x0); 
  96.             // if the line is going up from right to left then the top intersect point is on the left
  97.             if(m>0)
  98.             {
  99.                top_intersection = (m*l  + c); 
  100.                bottom_intersection = (m*r  + c);
  101.             } 
  102.             // otherwise it's on the right
  103.             else 
  104.             {
  105.                top_intersection = (m*r  + c); 
  106.                bottom_intersection = (m*l  + c); 
  107.             }
  108.             
  109.             // work out the top and bottom extents for the triangle
  110.             if(y0<y1)
  111.             {
  112.                toptrianglepoint = y0; 
  113.                bottomtrianglepoint = y1; 
  114.             }
  115.             else
  116.             {
  117.                toptrianglepoint = y1; 
  118.                bottomtrianglepoint = y0; 
  119.             }
  120.             
  121.             var topoverlap : Number; 
  122.             var botoverlap : Number; 
  123.             
  124.             // and calculate the overlap between those two bounds
  125.             topoverlap = top_intersection>toptrianglepoint ? top_intersection : toptrianglepoint; 
  126.             botoverlap = bottom_intersection<bottomtrianglepoint ? bottom_intersection : bottomtrianglepoint; 
  127.             
  128.             // (topoverlap<botoverlap) : 
  129.             // if the intersection isn't the right way up then we have no overlap
  130.             
  131.             // (!((botoverlap<t) || (topoverlap>b)) :
  132.             // If the bottom overlap is higher than the top of the rectangle or the top overlap is 
  133.             // lower than the bottom of the rectangle we don't have intersection. So return the negative 
  134.             // of that. Much faster than checking each of the points is within the bounds of the rectangle. 
  135.             return (topoverlap<botoverlap) && (!((botoverlap<t) || (topoverlap>b)));
  136.          
  137.       }   
  138.    
  139.       public function startTest(e:MouseEvent = null) : void
  140.       {
  141.          var g : Graphics = graphics; 
  142.          g.clear(); 
  143.          var cullingRect : Rectangle = new Rectangle(-100,-100,200,200); 
  144.          
  145.          var iterations : int = 1; 
  146.          var timerIntersecting : int = 0 ; 
  147.          var timerNotIntersecting : int = 0 ; 
  148.                         var intersectCount : int = 0; 
  149.                         
  150.          var v0 : Point = new Point(); 
  151.          var v1 : Point = new Point(); 
  152.          var v2 : Point = new Point(); 
  153.          
  154.          var i : int = iterations; 
  155.          
  156.          while(--i>-1)
  157.          {
  158.              /*
  159.             v0.x = Math.random()*400 - 200; 
  160.             v0.y = Math.random()*400 - 200; 
  161.             v1.x = v0.x+ (Math.random()*300 -150); 
  162.             v1.y = v0.y+ (Math.random()*300 -150); 
  163.             v2.x = v0.x+ (Math.random()*300 -150); 
  164.             v2.y = v0.y+ (Math.random()*300 -150);             
  165.             */
  166.             
  167.             v0.x = -150; 
  168.             v0.y = 50; 
  169.             v1.x = 10; 
  170.             v1.y = -150;
  171.             v2.x = 150;
  172.             v2.y = 50; 
  173.             
  174.             var startTimer : int = getTimer(); 
  175.             var intersecting : Boolean = triangleAABBIntersectionTest(cullingRect, v0, v1, v2); 
  176.             if(intersecting)
  177.             {
  178.                timerIntersecting += (getTimer() - startTimer);
  179.                intersectCount++; 
  180.             }
  181.             else 
  182.             {
  183.                timerNotIntersecting += (getTimer() - startTimer);
  184.             }
  185.             if(i<300)
  186.             {
  187.                g.lineStyle(0,0x000000); 
  188.                g.beginFill(intersecting ? 0x006600 : 0x660000,0.5); 
  189.                g.moveTo(x0,y0); 
  190.                g.lineTo(x1,y1); 
  191.                g.lineTo(x2,y2); 
  192.                g.lineTo(x0,y0); 
  193.                g.endFill(); 
  194.             }
  195.          }
  196.          
  197.          g.lineStyle(0,0xffffff,0.5); 
  198.          g.drawRect(cullingRect.x, cullingRect.y, cullingRect.width, cullingRect.height); 
  199.          outputText.text = "Average time per triangle : "+(timerIntersecting+timerNotIntersecting)/iterations; 
  200.          outputText.appendText("\nAverage time per intersecting triangle : "+(timerIntersecting)/intersectCount); 
  201.          outputText.appendText("\nAverage time per non-intersecting triangle : "+(timerNotIntersecting)/(iterations-intersectCount)); 
  203.                   
  204.       }
  205.    
  206.    
  207.       
  208.       
  209.    }
  210. }
noswf

flash on 2009-5-30 forked from: flash on 2009-5-30 [diff(1)]

  1. // forked from sebleedelisle's flash on 2009-5-30
  2. package
  3. {
  4.    import flash.display.Graphics;
  5.    import flash.display.Sprite;
  6.    import flash.events.MouseEvent;
  7.    import flash.geom.Point;
  8.    import flash.geom.Rectangle;
  9.    import flash.text.TextField;
  10.    import flash.text.TextFormat;
  11.    import flash.utils.getTimer;
  12.    [SWF(frameRate="100", backgroundColor="0x000000", width="500", height="500")]
  14.    public class TriangleAABBSpeedTest extends Sprite
  15.    {
  16.       
  17.       
  18.       public var outputText : TextField;
  19.       
  20.       public function TriangleAABBSpeedTest()
  21.       {
  22.          super();
  23.          outputText = new TextField(); 
  24.          x = y = 250; 
  25.          outputText.defaultTextFormat = new TextFormat("Arial"); 
  26.          outputText.textColor = 0xffffff; 
  27.          outputText.text = "Click to start test"; 
  28.          outputText.x = outputText.y = -250; 
  29.          outputText.width = 500; 
  30.          
  31.          addChild(outputText); 
  32.          
  33.          stage.addEventListener(MouseEvent.MOUSE_DOWN, startTest); 
  34.          
  35.       }
  36.    
  37.       // I'm thinking that storing these values as properties rather than declaring them as local vars 
  38.       // should be faster...
  39.          
  40.       private  var x0 : Number; 
  41.       private  var y0 : Number; 
  42.       private  var x1 : Number; 
  43.       private  var y1 : Number; 
  44.       private  var x2 : Number; 
  45.       private  var y2 : Number; 
  46.       private  var l : Number; 
  47.       private  var r : Number; 
  48.       private  var t : Number; 
  49.       private  var b : Number; 
  50.       
  51.       private  var top_intersection:Number ;
  52.       private  var bottom_intersection : Number; 
  53.       private  var toptrianglepoint : Number; 
  54.       private  var bottomtrianglepoint : Number; 
  55.       
  56.       private  var m: Number;
  57.       private var c : Number   
  58.    
  59.    
  60.       // THESE ARE THE TWO FUNCTIONS YOU CAN OPTIMISE. 
  61.       // I realise that you could inline the lineRectangleIntersect method, but I'd rather not do that just yet... 
  62.       // I'm looking for maths/logic improvements. 
  63.    
  64.       public function triangleAABBIntersectionTest(rect:Rectangle,  vertex0:Point, vertex1:Point, vertex2:Point ) : Boolean
  65.       {
  66.          // YOU MUST LEAVE THESE DECLARATIONS; they simulate necessary data exchange within PV3D
  67.          l = rect.left; 
  68.          r = rect.right; 
  69.          t = rect.top; 
  70.          b = rect.bottom; 
  71.          
  72.          x0 = vertex0.x; 
  73.          y0 = vertex0.y; 
  74.          x1 = vertex1.x; 
  75.          y1 = vertex1.y; 
  76.          x2 = vertex2.x; 
  77.          y2 = vertex2.y; 
  78.          
  79.          
  80.          return lineRectangleIntersect(x0,y0,x1,y1) 
  81.                ||   lineRectangleIntersect(x1,y1,x2,y2) 
  82.                ||   lineRectangleIntersect(x2,y2,x0,y0);
  83.       
  84.       
  85.          
  86.       }
  87.       
  88.       
  89.       public function lineRectangleIntersect(x0: Number,y0: Number,x1: Number,y1: Number):Boolean //, left:Number, right:Number, top:Number, bottom:Number) : Boolean
  90.       {
  91.             
  92.             // Calculate m and c for the equation for the line (y = mx+c)
  93.             m = (y1-y0) / (x1-x0); 
  94.             c = y0 -(m*x0); 
  96.             // if the line is going up from right to left then the top intersect point is on the left
  97.             if(m>0)
  98.             {
  99.                top_intersection = (m*l  + c); 
  100.                bottom_intersection = (m*r  + c);
  101.             } 
  102.             // otherwise it's on the right
  103.             else 
  104.             {
  105.                top_intersection = (m*r  + c); 
  106.                bottom_intersection = (m*l  + c); 
  107.             }
  108.             
  109.             // work out the top and bottom extents for the triangle
  110.             if(y0<y1)
  111.             {
  112.                toptrianglepoint = y0; 
  113.                bottomtrianglepoint = y1; 
  114.             }
  115.             else
  116.             {
  117.                toptrianglepoint = y1; 
  118.                bottomtrianglepoint = y0; 
  119.             }
  120.             
  121.             var topoverlap : Number; 
  122.             var botoverlap : Number; 
  123.             
  124.             // and calculate the overlap between those two bounds
  125.             topoverlap = top_intersection>toptrianglepoint ? top_intersection : toptrianglepoint; 
  126.             botoverlap = bottom_intersection<bottomtrianglepoint ? bottom_intersection : bottomtrianglepoint; 
  127.             
  128.             // (topoverlap<botoverlap) : 
  129.             // if the intersection isn't the right way up then we have no overlap
  130.             
  131.             // (!((botoverlap<t) || (topoverlap>b)) :
  132.             // If the bottom overlap is higher than the top of the rectangle or the top overlap is 
  133.             // lower than the bottom of the rectangle we don't have intersection. So return the negative 
  134.             // of that. Much faster than checking each of the points is within the bounds of the rectangle. 
  135.             return (topoverlap<botoverlap) && (!((botoverlap<t) || (topoverlap>b)));
  136.          
  137.       }
  138.    
  147.    
  148.    
  149.       public function startTest(e:MouseEvent = null) : void
  150.       {
  151.          var g : Graphics = graphics; 
  152.          g.clear(); 
  153.          var cullingRect : Rectangle = new Rectangle(-100,-75,200,150); 
  154.          
  155.          var iterations : int = 100000; 
  156.          var timerIntersecting : int = 0 ; 
  157.          var timerNotIntersecting : int = 0 ; 
  158.                         var intersectCount : int = 0; 
  159.                         
  160.          var v0 : Point = new Point(); 
  161.          var v1 : Point = new Point(); 
  162.          var v2 : Point = new Point(); 
  163.          
  164.          var i : int = iterations; 
  165.          
  166.          while(--i>-1)
  167.          {
  168.             v0.x = Math.random()*400 - 200; 
  169.             v0.y = Math.random()*400 - 200; 
  170.             v1.x = v0.x+ (Math.random()*300 -150); 
  171.             v1.y = v0.y+ (Math.random()*300 -150); 
  172.             v2.x = v0.x+ (Math.random()*300 -150); 
  173.             v2.y = v0.y+ (Math.random()*300 -150);             
  174.             
  175.             var startTimer : int = getTimer(); 
  176.             var intersecting : Boolean = triangleAABBIntersectionTest(cullingRect, v0, v1, v2); 
  177.             if(intersecting)
  178.             {
  179.                timerIntersecting += (getTimer() - startTimer);
  180.                intersectCount++; 
  181.             }
  182.             else 
  183.             {
  184.                timerNotIntersecting += (getTimer() - startTimer);
  185.             }
  186.             if(i<300)
  187.             {
  188.                g.lineStyle(0,0x000000); 
  189.                g.beginFill(intersecting ? 0x006600 : 0x660000,0.5); 
  190.                g.moveTo(x0,y0); 
  191.                g.lineTo(x1,y1); 
  192.                g.lineTo(x2,y2); 
  193.                g.lineTo(x0,y0); 
  194.                g.endFill(); 
  195.             }
  196.          }
  197.          
  198.          g.lineStyle(0,0xffffff,0.5); 
  199.          g.drawRect(cullingRect.x, cullingRect.y, cullingRect.width, cullingRect.height); 
  200.          outputText.text = "Average time per triangle : "+(timerIntersecting+timerNotIntersecting)/iterations; 
  201.          outputText.appendText("\nAverage time per intersecting triangle : "+(timerIntersecting)/intersectCount); 
  202.          outputText.appendText("\nAverage time per non-intersecting triangle : "+(timerNotIntersecting)/(iterations-intersectCount)); 
  204.                   
  205.       }
  206.    
  207.    
  208.       
  209.       
  210.    }
  211. }
noswf

flash on 2009-5-30 forked from: flash on 2009-5-30 [diff(16)]

  1. // forked from sebleedelisle's flash on 2009-5-30
  2. package
  3. {
  4.    import flash.display.Graphics;
  5.    import flash.display.Sprite;
  6.    import flash.events.MouseEvent;
  7.    import flash.geom.Point;
  8.    import flash.geom.Rectangle;
  9.    import flash.text.TextField;
  10.    import flash.text.TextFormat;
  11.    import flash.utils.getTimer;
  12.    [SWF(frameRate="100", backgroundColor="0x000000", width="500", height="500")]
  14.    public class TriangleAABBSpeedTest extends Sprite
  15.    {
  16.       
  17.       
  18.       public var outputText : TextField;
  19.       
  20.       public function TriangleAABBSpeedTest()
  21.       {
  22.          super();
  23.          outputText = new TextField(); 
  24.          x = y = 250; 
  25.          outputText.defaultTextFormat = new TextFormat("Arial"); 
  26.          outputText.textColor = 0xffffff; 
  27.          outputText.text = "Click to start test"; 
  28.          outputText.x = outputText.y = -250; 
  29.          outputText.width = 500; 
  30.          
  31.          addChild(outputText); 
  32.          
  33.          stage.addEventListener(MouseEvent.MOUSE_DOWN, startTest); 
  34.          
  35.       }
  36.    
  37.       // I'm thinking that storing these values as properties rather than declaring them as local vars 
  38.       // should be faster...
  39.          
  40.       private  var x0 : Number; 
  41.       private  var y0 : Number; 
  42.       private  var x1 : Number; 
  43.       private  var y1 : Number; 
  44.       private  var x2 : Number; 
  45.       private  var y2 : Number; 
  46.       private  var l : Number; 
  47.       private  var r : Number; 
  48.       private  var t : Number; 
  49.       private  var b : Number; 
  50.       
  51.       private  var top_intersection:Number ;
  52.       private  var bottom_intersection : Number; 
  53.       private  var toptrianglepoint : Number; 
  54.       private  var bottomtrianglepoint : Number; 
  55.       
  56.       private  var m: Number;
  57.       private var c : Number   
  58.    
  59.    
  60.       // THESE ARE THE TWO FUNCTIONS YOU CAN OPTIMISE. 
  61.       // I realise that you could inline the lineRectangleIntersect method, but I'd rather not do that just yet... 
  62.       // I'm looking for maths/logic improvements. 
  63.    
  64.       public function triangleAABBIntersectionTest(rect:Rectangle,  vertex0:Point, vertex1:Point, vertex2:Point ) : Boolean
  65.       {
  66.          // YOU MUST LEAVE THESE DECLARATIONS; they simulate necessary data exchange within PV3D
  67.          l = rect.left; 
  68.          r = rect.right; 
  69.          t = rect.top; 
  70.          b = rect.bottom; 
  71.          
  72.          x0 = vertex0.x; 
  73.          y0 = vertex0.y; 
  74.          x1 = vertex1.x; 
  75.          y1 = vertex1.y; 
  76.          x2 = vertex2.x; 
  77.          y2 = vertex2.y; 
  78.          
  79.          //if all points of the triangle are on one side of the rect 
  80.          if((l>x0 && l>x1 && l>x2)
  81.          || (r<x0 && r<x1 && r<x2)
  82.          || (t>y0 && t>y1 && t>y2)
  83.          || (b<y0 && b<y1 && b<y2)
  84.          ){
  85.              return false;
  86.          }
  87.          //if there is a point of the triangle inside the rect
  88.          if((l<x0 && x0<r && t<y0 && y0<b)
  89.          || (l<x1 && x1<r && t<y1 && y1<b)
  90.          || (l<x2 && x2<r && t<y2 && y2<b)
  91.          ){
  92.              return true;
  93.          }
  94.          
  95.          return lineRectangleIntersect(x0,y0,x1,y1) 
  96.                ||   lineRectangleIntersect(x1,y1,x2,y2) 
  97.                ||   lineRectangleIntersect(x2,y2,x0,y0);
  98.       
  99.       
  100.          
  101.       }
  102.       
  103.       
  104.       public function lineRectangleIntersect(x0: Number,y0: Number,x1: Number,y1: Number):Boolean //, left:Number, right:Number, top:Number, bottom:Number) : Boolean
  105.       {
  106.             
  107.             // Calculate m and c for the equation for the line (y = mx+c)
  108.             m = (y1-y0) / (x1-x0); 
  109.             c = y0 -(m*x0); 
  111.             // if the line is going up from right to left then the top intersect point is on the left
  112.             if(m>0)
  113.             {
  114.                top_intersection = (m*l  + c); 
  115.                bottom_intersection = (m*r  + c);
  116.             } 
  117.             // otherwise it's on the right
  118.             else 
  119.             {
  120.                top_intersection = (m*r  + c); 
  121.                bottom_intersection = (m*l  + c); 
  122.             }
  123.             
  124.             // work out the top and bottom extents for the triangle
  125.             if(y0<y1)
  126.             {
  127.                toptrianglepoint = y0; 
  128.                bottomtrianglepoint = y1; 
  129.             }
  130.             else
  131.             {
  132.                toptrianglepoint = y1; 
  133.                bottomtrianglepoint = y0; 
  134.             }
  135.             
  136.             var topoverlap : Number; 
  137.             var botoverlap : Number; 
  138.             
  139.             // and calculate the overlap between those two bounds
  140.             topoverlap = top_intersection>toptrianglepoint ? top_intersection : toptrianglepoint; 
  141.             botoverlap = bottom_intersection<bottomtrianglepoint ? bottom_intersection : bottomtrianglepoint; 
  142.             
  143.             // (topoverlap<botoverlap) : 
  144.             // if the intersection isn't the right way up then we have no overlap
  145.             
  146.             // (!((botoverlap<t) || (topoverlap>b)) :
  147.             // If the bottom overlap is higher than the top of the rectangle or the top overlap is 
  148.             // lower than the bottom of the rectangle we don't have intersection. So return the negative 
  149.             // of that. Much faster than checking each of the points is within the bounds of the rectangle. 
  150.             return (topoverlap<botoverlap) && (!((botoverlap<t) || (topoverlap>b)));
  151.          
  152.       }
  153.    
  162.    
  163.    
  164.       public function startTest(e:MouseEvent = null) : void
  165.       {
  166.          var g : Graphics = graphics; 
  167.          g.clear(); 
  168.          var cullingRect : Rectangle = new Rectangle(-100,-75,200,150); 
  169.          
  170.          var iterations : int = 100000; 
  171.          var timerIntersecting : int = 0 ; 
  172.          var timerNotIntersecting : int = 0 ; 
  173.                         var intersectCount : int = 0; 
  174.                         
  175.          var v0 : Point = new Point(); 
  176.          var v1 : Point = new Point(); 
  177.          var v2 : Point = new Point(); 
  178.          
  179.          var i : int = iterations; 
  180.          
  181.          while(--i>-1)
  182.          {
  183.             v0.x = Math.random()*400 - 200; 
  184.             v0.y = Math.random()*400 - 200; 
  185.             v1.x = v0.x+ (Math.random()*300 -150); 
  186.             v1.y = v0.y+ (Math.random()*300 -150); 
  187.             v2.x = v0.x+ (Math.random()*300 -150); 
  188.             v2.y = v0.y+ (Math.random()*300 -150);             
  189.             
  190.             var startTimer : int = getTimer(); 
  191.             var intersecting : Boolean = triangleAABBIntersectionTest(cullingRect, v0, v1, v2); 
  192.             if(intersecting)
  193.             {
  194.                timerIntersecting += (getTimer() - startTimer);
  195.                intersectCount++; 
  196.             }
  197.             else 
  198.             {
  199.                timerNotIntersecting += (getTimer() - startTimer);
  200.             }
  201.             if(i<300)
  202.             {
  203.                g.lineStyle(0,0x000000); 
  204.                g.beginFill(intersecting ? 0x006600 : 0x660000,0.5); 
  205.                g.moveTo(x0,y0); 
  206.                g.lineTo(x1,y1); 
  207.                g.lineTo(x2,y2); 
  208.                g.lineTo(x0,y0); 
  209.                g.endFill(); 
  210.             }
  211.          }
  212.          
  213.          g.lineStyle(0,0xffffff,0.5); 
  214.          g.drawRect(cullingRect.x, cullingRect.y, cullingRect.width, cullingRect.height); 
  215.          outputText.text = "Average time per triangle : "+(timerIntersecting+timerNotIntersecting)/iterations; 
  216.          outputText.appendText("\nAverage time per intersecting triangle : "+(timerIntersecting)/intersectCount); 
  217.          outputText.appendText("\nAverage time per non-intersecting triangle : "+(timerNotIntersecting)/(iterations-intersectCount)); 
  219.                   
  220.       }
  221.    
  222.    
  223.       
  224.       
  225.    }
  226. }
noswf

flash on 2009-5-30 forked from: flash on 2009-5-30 [diff(170)]

  1. package
  2. {
  3.    import flash.display.Graphics;
  4.    import flash.display.Sprite;
  5.    import flash.events.MouseEvent;
  6.    import flash.geom.Point;
  7.    import flash.geom.Rectangle;
  8.    import flash.text.TextField;
  9.    import flash.text.TextFormat;
  10.    import flash.utils.getTimer;
  11.    [SWF(frameRate="100", backgroundColor="0x000000", width="500", height="500")]
  12.  
  13.    public class TriangleSpeedTest2 extends Sprite
  14.    {
  15.  
  16.  
  17.       public var outputText : TextField;
  18.  
  19.       public function TriangleSpeedTest2()
  20.       {
  21.          super();
  22.          outputText = new TextField(); 
  23.          x = y = 250; 
  24.          outputText.defaultTextFormat = new TextFormat("Arial"); 
  25.          outputText.textColor = 0xffffff; 
  26.          outputText.text = "Click to start test"; 
  27.          outputText.x = outputText.y = -250; 
  28.          outputText.width = 500; 
  29.  
  30.          addChild(outputText); 
  31.  
  32.          stage.addEventListener(MouseEvent.MOUSE_DOWN, startTest); 
  33.  
  34.       }
  35.  
  36.       // I'm thinking that storing these values as properties rather than declaring them as local vars 
  37.       // should be faster...
  38.  
  39.       private  var x0 : Number; 
  40.       private  var y0 : Number; 
  41.       private  var x1 : Number; 
  42.       private  var y1 : Number; 
  43.       private  var x2 : Number; 
  44.       private  var y2 : Number; 
  45.       private  var l : Number; 
  46.       private  var r : Number; 
  47.       private  var t : Number; 
  48.       private  var b : Number; 
  49.       
  50.       private var t0 : int;
  51.       private var t1 : int;
  52.       private var t2 : int;
  53.       
  54.       private var s : Number
  55.       
  56.        private var lm0 : Number
  57.       private var lm1 : Number
  58.       private var lm2 : Number
  59.       
  61.        private var rm0 : Number
  62.       private var rm1 : Number
  63.       private var rm2 : Number
  64.       
  65.       private var b0    :int;
  66.       private var b1    :int;
  67.       private var b2    :int;
  68.       
  69.        private var i0    :int;
  70.       private var i1    :int;
  71.       private var i2    :int;
  72.       
  73.       private  var top_intersection:Number ;
  74.       private  var bottom_intersection : Number; 
  75.       private  var toptrianglepoint : Number; 
  76.       private  var bottomtrianglepoint : Number; 
  77.  
  78.        private  var m: Number;
  79.       private var c : Number  
  80.       private  var m0: Number;
  81.       private var c0 : Number  
  82.       private  var m1: Number;
  83.       private var c1 : Number  
  84.       private  var m2: Number;
  85.       private var c2 : Number  
  86.  
  87.  
  88.       // THESE ARE THE TWO FUNCTIONS YOU CAN OPTIMISE. 
  89.       // I realise that you could inline the lineRectangleIntersect method, but I'd rather not do that just yet... 
  90.       // I'm looking for maths/logic improvements. 
  91.  
  92.       public function triangleTest(rect:Rectangle,  vertex0:Point, vertex1:Point, vertex2:Point ) : Boolean
  93.       {
  94.          // YOU MUST LEAVE THESE DECLARATIONS; they simulate necessary data exchange within PV3D
  95.          l = rect.left; 
  96.          r = rect.right; 
  97.          t = rect.top; 
  98.          b = rect.bottom; 
  99.  
  100.          x0 = vertex0.x; 
  101.          y0 = vertex0.y; 
  102.          x1 = vertex1.x; 
  103.          y1 = vertex1.y; 
  104.          x2 = vertex2.x; 
  105.          y2 = vertex2.y; 
  106.          
  107.         
  108.          
  109.          b0 =  int(x0 > l) | int(y0 > t) << 1 | int (x0 > r) << 2 | int (y0 > b) << 3;
  110.          if (b0 == 3) return true;
  111.          b1 =  int(x1 > l) | int(y1 > t) << 1 | int (x1 > r) << 2 | int (y1 > b) << 3;
  112.          if (b1 == 3) return true;
  113.          b2 =  int(x2 > l) | int(y2 > t) << 1 | int (x2 > r) << 2 | int (y2 > b) << 3;
  114.          if (b2 == 3) return true;
  115.          
  116.          
  117.         
  118.         i0 = b0 ^ b1
  119.         if (i0 != 0)
  120.         {
  121.             m = (y1-y0) / (x1-x0); 
  122.             c = y0 -(m * x0);
  123.             if (Boolean(i0 & 1)) { s = m * l + c; if ( s > t && s < b) return true; }
  124.             if (Boolean(i0 & 2)) { s = (t - c) / m; if ( s > l && s < r) return true; }
  125.             if (Boolean(i0 & 4)) { s = m * r + c; if ( s > t && s < b) return true; }
  126.             if (Boolean(i0 & 8)) { s = (b - c) / m; if ( s > l && s < r) return true; }
  127.         }
  128.         
  129.         i1 = b1 ^ b2
  130.         if (i1 != 0)
  131.         {
  132.             m = (y2-y1) / (x2-x1); 
  133.             c = y1 -(m * x1);
  134.             if (Boolean(i1 & 1)) { s = m * l + c; if ( s > t && s < b) return true; }
  135.             if (Boolean(i1 & 2)) { s = (t - c) / m; if ( s > l && s < r) return true; }
  136.             if (Boolean(i1 & 4)) { s = m * r + c; if ( s > t && s < b) return true; }
  137.             if (Boolean(i1 & 8)) { s = (b - c) / m; if ( s > l && s < r) return true; }
  138.         }
  139.         
  140.         i2 = b0 ^ b2
  141.         if (i2 != 0)
  142.         {
  143.             m = (y2-y0) / (x2-x0); 
  144.             c = y0 -(m * x0);
  145.             if (Boolean(i2 & 1)) { s = m * l + c; if ( s > t && s < b) return true; }
  146.             if (Boolean(i2 & 2)) { s = (t - c) / m; if ( s > l && s < r) return true; }
  147.             if (Boolean(i2 & 4)) { s = m * r + c; if ( s > t && s < b) return true; }
  148.             if (Boolean(i2 & 8)) { s = (b - c) / m; if ( s > l && s < r) return true; }
  149.         }
  150.         
  151.         return false;
  152.       }
  153.        
  154.       public function startTest(e:MouseEvent = null) : void
  155.       {
  156.          var g : Graphics = graphics; 
  157.          g.clear(); 
  158.          var cullingRect : Rectangle = new Rectangle(-100,-75,200,150); 
  159.  
  160.          var iterations : int = 100000; 
  161.          var timerIntersecting : int = 0 ; 
  162.          var timerNotIntersecting : int = 0 ; 
  163.                         var intersectCount : int = 0; 
  164.  
  165.          var v0 : Point = new Point(); 
  166.          var v1 : Point = new Point(); 
  167.          var v2 : Point = new Point(); 
  168.  
  169.          var i : int = iterations; 
  170.  
  171.          while(--i>-1)
  172.          {
  173.             v0.x = Math.random()*400 - 200; 
  174.             v0.y = Math.random()*400 - 200; 
  175.             v1.x = v0.x+ (Math.random()*300 -150); 
  176.             v1.y = v0.y+ (Math.random()*300 -150); 
  177.             v2.x = v0.x+ (Math.random()*300 -150); 
  178.             v2.y = v0.y+ (Math.random()*300 -150);             
  179.  
  180.             var startTimer : int = getTimer(); 
  181.             var intersecting : Boolean = triangleTest(cullingRect, v0, v1, v2); 
  182.             if(intersecting)
  183.             {
  184.                timerIntersecting += (getTimer() - startTimer);
  185.                intersectCount++; 
  186.             }
  187.             else 
  188.             {
  189.                timerNotIntersecting += (getTimer() - startTimer);
  190.             }
  191.             if(i<300)
  192.             {
  193.                g.lineStyle(0,0x000000); 
  194.                g.beginFill(intersecting ? 0x006600 : 0x660000,0.5); 
  195.                g.moveTo(x0,y0); 
  196.                g.lineTo(x1,y1); 
  197.                g.lineTo(x2,y2); 
  198.                g.lineTo(x0,y0); 
  199.                g.endFill(); 
  200.             }
  201.          }
  202.  
  203.          g.lineStyle(0,0xffffff,0.5); 
  204.          g.drawRect(cullingRect.x, cullingRect.y, cullingRect.width, cullingRect.height); 
  205.          outputText.text = "Average time per triangle : "+(timerIntersecting+timerNotIntersecting)/iterations; 
  206.          outputText.appendText("\nAverage time per intersecting triangle : "+(timerIntersecting)/intersectCount); 
  207.          outputText.appendText("\nAverage time per non-intersecting triangle : "+(timerNotIntersecting)/(iterations-intersectCount)); 
  208.  
  209.       }
  210.  
  211.    }
  212. }
noswf

flash on 2009-5-30 forked from: flash on 2009-5-30 [diff(142)]

  1. package
  2. {
  3.    import flash.display.Graphics;
  4.    import flash.display.Sprite;
  5.    import flash.events.MouseEvent;
  6.    import flash.geom.Point;
  7.    import flash.geom.Rectangle;
  8.    import flash.text.TextField;
  9.    import flash.text.TextFormat;
  10.    import flash.utils.getTimer;
  11.    [SWF(frameRate="100", backgroundColor="0x000000", width="500", height="500")]
  12.  
  13.    public class TriangleSpeedTest extends Sprite
  14.    {
  15.  
  16.  
  17.       public var outputText : TextField;
  18.  
  19.       public function TriangleSpeedTest()
  20.       {
  21.          super();
  22.          outputText = new TextField(); 
  23.          x = y = 250; 
  24.          outputText.defaultTextFormat = new TextFormat("Arial"); 
  25.          outputText.textColor = 0xffffff; 
  26.          outputText.text = "Click to start test"; 
  27.          outputText.x = outputText.y = -250; 
  28.          outputText.width = 500; 
  29.  
  30.          addChild(outputText); 
  31.  
  32.          stage.addEventListener(MouseEvent.MOUSE_DOWN, startTest); 
  33.  
  34.       }
  35.  
  36.       // I'm thinking that storing these values as properties rather than declaring them as local vars 
  37.       // should be faster...
  38.  
  39.       private  var x0 : Number; 
  40.       private  var y0 : Number; 
  41.       private  var x1 : Number; 
  42.       private  var y1 : Number; 
  43.       private  var x2 : Number; 
  44.       private  var y2 : Number; 
  45.       private  var l : Number; 
  46.       private  var r : Number; 
  47.       private  var t : Number; 
  48.       private  var b : Number; 
  49.       
  50.       private var t0 : int;
  51.       private var t1 : int;
  52.       private var t2 : int;
  53.       
  54.       private var lm0 : Number
  55.       private var lm1 : Number
  56.       private var lm2 : Number
  58.        private var rm0 : Number
  59.       private var rm1 : Number
  60.       private var rm2 : Number
  61.       
  62.       private  var top_intersection:Number ;
  63.       private  var bottom_intersection : Number; 
  64.       private  var toptrianglepoint : Number; 
  65.       private  var bottomtrianglepoint : Number; 
  66.  
  67.       private  var m0: Number;
  68.       private var c0 : Number  
  69.       private  var m1: Number;
  70.       private var c1 : Number  
  71.       private  var m2: Number;
  72.       private var c2 : Number  
  73.  
  74.  
  75.       // THESE ARE THE TWO FUNCTIONS YOU CAN OPTIMISE. 
  76.       // I realise that you could inline the lineRectangleIntersect method, but I'd rather not do that just yet... 
  77.       // I'm looking for maths/logic improvements. 
  78.  
  79.       public function triangleTest(rect:Rectangle,  vertex0:Point, vertex1:Point, vertex2:Point ) : Boolean
  80.       {
  81.          // YOU MUST LEAVE THESE DECLARATIONS; they simulate necessary data exchange within PV3D
  82.          l = rect.left; 
  83.          r = rect.right; 
  84.          t = rect.top; 
  85.          b = rect.bottom; 
  86.  
  87.          x0 = vertex0.x; 
  88.          y0 = vertex0.y; 
  89.          x1 = vertex1.x; 
  90.          y1 = vertex1.y; 
  91.          x2 = vertex2.x; 
  92.          y2 = vertex2.y; 
  93.          
  94.          if (x0 > l && x0 < r && y0 > t && y0 < b) return true;
  95.          if (x1 > l && x1 < r && y1 > t && y1 < b) return true;
  96.          if (x2 > l && x2 < r && y2 > t && y2 < b) return true;
  97.          
  98.          return isInsideTriangle(x0, y0, x1, y1, x2, y2);
  99.       }
  100.  
  101.       public function isInsideTriangle(x0: Number,y0: Number,x1: Number,y1: Number,x2: Number,y2: Number):Boolean
  102.       { 
  103.             // Calculate m and c for the equation for the line (y = mx+c)
  104.             m0 = (y2-y1) / (x2-x1); 
  105.             c0 = y2 -(m0 * x2);
  106.             
  107.             m1 = (y2-y0) / (x2-x0); 
  108.             c1 = y0 -(m1 * x0);
  109.             
  110.             m2 = (y1-y0) / (x1-x0); 
  111.             c2 = y0 -(m2 * x0);
  112.             
  113.             t0 = int(x0 * m0 + c0 > y0);
  114.             t1 = int(x1 * m1 + c1 > y1);
  115.             t2 = int(x2 * m2 + c2 > y2);
  116.             
  117.             lm0 = l * m0 + c0;
  118.             lm1 = l * m1 + c1;
  119.             lm2 = l * m2 + c2;
  120.             
  121.             rm0 = r * m0 + c0;
  122.             rm1 = r * m1 + c1;
  123.             rm2 = r * m2 + c2;
  124.             
  125.             if ( !(t0 ^ int( lm0 > t)) && !(t1 ^ int(lm1 > t)) && !(t2 ^ int(lm2 > t))) return true;
  126.             
  127.             if (!(t0 ^ int( lm0 > b)) && !(t1 ^ int(lm1 > b)) && !(t2 ^ int(lm2 > b))) return true;
  128.             
  129.             if ( !(t0 ^ int( rm0 > t)) && !(t1 ^ int(rm1 > t)) && !(t2 ^ int(rm2 > t))) return true;
  130.             
  131.             if (!(t0 ^ int( rm0 > b)) && !(t1 ^ int(rm1 > b)) && !(t2 ^ int(rm2 > b))) return true;
  132.             
  133.             return false;
  134.  
  135.       }
  136.  
  137.       public function startTest(e:MouseEvent = null) : void
  138.       {
  139.          var g : Graphics = graphics; 
  140.          g.clear(); 
  141.          var cullingRect : Rectangle = new Rectangle(-100,-75,200,150); 
  142.  
  143.          var iterations : int = 100000; 
  144.          var timerIntersecting : int = 0 ; 
  145.          var timerNotIntersecting : int = 0 ; 
  146.                         var intersectCount : int = 0; 
  147.  
  148.          var v0 : Point = new Point(); 
  149.          var v1 : Point = new Point(); 
  150.          var v2 : Point = new Point(); 
  151.  
  152.          var i : int = iterations; 
  153.  
  154.          while(--i>-1)
  155.          {
  156.             v0.x = Math.random()*400 - 200; 
  157.             v0.y = Math.random()*400 - 200; 
  158.             v1.x = v0.x+ (Math.random()*300 -150); 
  159.             v1.y = v0.y+ (Math.random()*300 -150); 
  160.             v2.x = v0.x+ (Math.random()*300 -150); 
  161.             v2.y = v0.y+ (Math.random()*300 -150);             
  162.  
  163.             var startTimer : int = getTimer(); 
  164.             var intersecting : Boolean = triangleTest(cullingRect, v0, v1, v2); 
  165.             if(intersecting)
  166.             {
  167.                timerIntersecting += (getTimer() - startTimer);
  168.                intersectCount++; 
  169.             }
  170.             else 
  171.             {
  172.                timerNotIntersecting += (getTimer() - startTimer);
  173.             }
  174.             if(i<300)
  175.             {
  176.                g.lineStyle(0,0x000000); 
  177.                g.beginFill(intersecting ? 0x006600 : 0x660000,0.5); 
  178.                g.moveTo(x0,y0); 
  179.                g.lineTo(x1,y1); 
  180.                g.lineTo(x2,y2); 
  181.                g.lineTo(x0,y0); 
  182.                g.endFill(); 
  183.             }
  184.          }
  185.  
  186.          g.lineStyle(0,0xffffff,0.5); 
  187.          g.drawRect(cullingRect.x, cullingRect.y, cullingRect.width, cullingRect.height); 
  188.          outputText.text = "Average time per triangle : "+(timerIntersecting+timerNotIntersecting)/iterations; 
  189.          outputText.appendText("\nAverage time per intersecting triangle : "+(timerIntersecting)/intersectCount); 
  190.          outputText.appendText("\nAverage time per non-intersecting triangle : "+(timerNotIntersecting)/(iterations-intersectCount)); 
  191.  
  192.       }
  193.  
  194.    }
  195. }
  196. /*
  197. package  
  198. {
  199.     import flash.geom.Point;
  200.     
  201.     public class test 
  202.     {
  203.         
  204.         public function test() 
  205.         {
  206.             
  207.         }
  208.         
  209.         public function isSameSide(p1:Point, p2:Point, p3:Point, pI:Point):Boolean
  210.         {
  211.             var a:Number = (p2.y - p1.y) / (p2.x - p1.x);
  212.             var b:Number = p1.y - a * p1.x;            
  213.             return (int((p3.x * a + b) > 0) ^ int((pI.x * a + b) > 0))
  214.         }
  215.         
  216.         public function isInside(
  217.         
  218.     }
  219.     
  220. }*/
noswf
Get Adobe Flash Player