TwoLines first implementation of Trilateral CornerContour in haxe flash - 25 September 2017

compile.hxml

-main Test
-swf-version 9
-swf test.swf
-swf-header 1000:500:60:000000
-cmd open test.swf

Test.hx

package;
import TwoLines;
import flash.display.Graphics;
class Test {    
    static function main() {
         var cur = flash.Lib.current;         
         var sp = new flash.display.Sprite();
         cur.addChild(sp);
         var g = sp.graphics;
         TwoLines.testColors = true; // sets some default colors.
         // setup the drawing function 
         TwoLines.drawTri = function(   p0: Point, p1: Point, p2: Point
                                    ,   col: Int, alpha: Float
                                    ,   lineCol: Int, lineAlpha: Float ):Void {
             g.lineStyle( 0, col, alpha );
             g.beginFill( lineCol, lineAlpha );
             g.moveTo( p0.x, p0.y );
             g.lineTo( p1.x, p1.y );
             g.lineTo( p2.x, p2.y );
             g.lineTo( p0.x, p0.y );
             g.endFill();
         }
         TwoLines.createTriangles( TwoLines.horizontalWavePoints( 10, 5, 100, 50, 60, 3 ) );
         TwoLines.createPolyTriangles( TwoLines.polyPoints( 150, 300, 100, 60 ) );
         TwoLines.createPolyTriangles( TwoLines.polyPoints( 450, 300, 100, 60 ) );
         TwoLines.createPolyTriangles( TwoLines.polyPoints( 750, 300, 100, 60 ) );
         TwoLines.createPolyTriangles( TwoLines.polyPoints( 850, 200, 100, 6 ) );
         TwoLines.createPolyTriangles( TwoLines.boxPoints( 100, 100, 200, 200 ) );
         TwoLines.createPolyTriangles( TwoLines.equalTriPoints( 570, 240, 100, 0 ) );
    }

}

TwoLines.hx

package;
typedef Point = { x: Float, y: Float }
class TwoLines {
    var p0: Point;
    var p1: Point;
    var p2: Point;
    public var p3: Point;
    public var p4: Point;
    public var halfA: Float;
    var angleA: Float; // smallest angle between lines
    var cosA: Float;
    var b2: Float;
    var c2: Float;
    var a2: Float;
    var b: Float; // first line length
    var c: Float; // second line length
    var a: Float;
    var angleD: Float;
    var beta: Float;
    var r: Float;
    var _theta: Float;
    var angle1: Float;
    var angle2: Float;
    public function new( p0_: Point, p1_: Point, p2_: Point, thick: Float ){
        p0 = p0_;
        p1 = p1_;
        p2 = p2_;
        b2 = dist2( p0, p1 ); 
        c2 = dist2( p1, p2 );
        a2 = dist2( p0, p2 );
        b = Math.sqrt( b2 );
        c = Math.sqrt( c2 );
        a = Math.sqrt( a2 );
        cosA = ( b2 + c2 - a2 )/ ( 2*b*c );
        angleA = Math.acos( cosA );
        angleD = Math.PI - angleA;
        halfA = angleA/2;
        beta = Math.PI/2 - halfA;
        r = ( thick/2 )/Math.cos( beta );
        calculateP3p4();
    }
    public inline function calculateP3p4(){
        _theta = theta( p0, p1 );
        if( _theta > 0 ){
            if( halfA < 0 ){
                angle2 = _theta + halfA + Math.PI/2;
                angle1 =  _theta - halfA; 
            }else {
                angle1 =  _theta + halfA - Math.PI;
                angle2 =  _theta + halfA; 
            }
        } else {
            if( halfA > 0 ){
                angle1 =  _theta + halfA - Math.PI;
                angle2 =  _theta + halfA; 
            } else {
                angle2 = _theta + halfA + Math.PI/2;
                angle1 =  _theta - halfA; 
            }
        }
        p3 = { x: p1.x + r * Math.cos( angle1 ), y: p1.y + r * Math.sin( angle1 ) };
        p4 = { x: p1.x + r * Math.cos( angle2 ), y: p1.y + r * Math.sin( angle2 ) };
    }
    public function rebuildAsPoly( p2_: Point ){
        p0 = p1;
        p1 = p2;
        p2 = p2_;
        calculateP3p4();
    }    
    private function theta( p0: Point, p1: Point ): Float {
        var dx: Float = p0.x - p1.x;
        var dy: Float = p0.y - p1.y;
        return Math.atan2( dy, dx );
    }
    private function dist2( p0: Point, p1: Point  ): Float {
        var dx: Float = p0.x - p1.x;
        var dy: Float = p0.y - p1.y;
        return dx*dx + dy*dy; 
    }
    private static var q0: Point;
    private static var q1: Point;
    public static var col: Int;
    public static var alpha: Float;
    public static var lineCol: Int;
    public static var lineAlpha: Float;
    public static var col2: Int;
    public static var alpha2: Float;
    public static var lineCol2: Int;
    public static var lineAlpha2: Float;
    public static function setupSingleColors( col_: Int, alpha_: Float, lineCol_: Int, lineAlpha_: Float ){
        col = col_;
        col2 = col_;
        alpha = alpha_;
        alpha2 = alpha_;
        lineCol = lineCol_;
        lineCol2 = lineCol_;
        lineAlpha = lineAlpha_;
        lineAlpha2 = lineAlpha_;
    }
    public static var testColors( null, set ):Bool;
    public static function set_testColors( val: Bool ): Bool{
        col = 0xffff00;
        col2 = 0xff00ff;
        lineCol = col;
        lineCol2 = col2;
        alpha = 0.5;
        alpha2 = alpha;
        lineAlpha = 0.7;
        lineAlpha2 = lineAlpha;   
        return val;
    }
    // p1, p2, p3
    // , colour, alpha default 1, optional line color depending on support, optional line alpha depending on support
    public static var drawTri: Point -> Point -> Point -> Int -> Float -> Int -> Float -> Void;
    public static inline function createPolyTriangles( p: Array<Point> ){
         q0 = p[0]; 
         q1 = p[0];
         var twoLines: TwoLines = firstQuad( p, 0 );
         for( i in 1...( p.length - 2 ) ) drawOtherQuad( p, twoLines, i );
    }
    public static inline function createTriangles( p: Array<Point> ){
         q0 = p[0]; 
         q1 = p[0];
         for( i in 0...( p.length - 2 ) ) drawQuad( p, i );
    }
    private static inline function firstQuad( p: Array<Point>, i: Int ): TwoLines {
        var twoLines = new TwoLines( p[ i ], p[ i + 1 ], p[ i + 2 ], 50 );
        var q3 = twoLines.p3;
        var q4 = twoLines.p4;
        q0 = q3;
        q1 = q4;
        return twoLines;
    }
    // assumes that firstQuad is drawn.
    private static inline function drawOtherQuad( p: Array<Point>, twoLines: TwoLines, i: Int ){
        twoLines.rebuildAsPoly( p[ i + 2 ]);
        var q3 = twoLines.p3;
        var q4 = twoLines.p4;
        drawTri( q0, q3, q1, col, alpha, lineCol, lineAlpha );
        drawTri( q1, q3, q4, col2, alpha2, lineCol2, lineAlpha2 );
        q0 = q3;
        q1 = q4;
        return twoLines;
    }
    private static inline function drawQuad( p: Array<Point>, i: Int ){
        var twoLines = new TwoLines( p[ i ], p[ i + 1 ], p[ i + 2 ], 50 );
        var q3 = twoLines.p3;
        var q4 = twoLines.p4;
        if( i != 0 ){
            drawTri( q0, q3, q1, col, alpha, lineCol, lineAlpha );
            drawTri( q1, q3, q4, col2, alpha2, lineCol2, lineAlpha2 );
        }
        q0 = q3;
        q1 = q4;
        return twoLines;
    }
    public static inline function boxPoints( x: Float,y: Float, wid: Float, hi: Float ): Array<Point>{
        var p: Array<Point> = [     { x: x, y: y }
                                ,   { x: x+wid, y: y }
                                ,   { x: x+wid, y: y+hi }
                                ,   { x: x, y: y+hi }
                                ,   { x: x, y: y }
                                ,   { x: x+wid, y: y }
                                ,   { x: x+wid, y: y+hi }
                                ];
        p.reverse();
        return p;
    }
    public static inline function equalTriPoints( dx: Float, dy: Float, radius: Float, ?rotation: Float = 0 ):Array<Point>{
        var p: Array<Point> = new Array<Point>();         
        var angle: Float = 0;
        var offset: Float = - 2.5*Math.PI*2/6 - Math.PI + rotation;
        for( i in 0...6 ){
            angle = i*(Math.PI*2)/3 - offset; 
            p.push( { x: dx + radius * Math.cos( angle ), y: dy + radius * Math.sin( angle ) });
        } 
        p.reverse();
        return p;
    }
    public static inline function polyPoints( dx: Float, dy: Float, radius: Float, sides: Int ):Array<Point>{
        var p: Array<Point> = new Array<Point>();         
        var angle: Float = 0;
        var angleInc: Float = (Math.PI*2)/sides;
        for( i in 0...( sides + 3 ) ){
            angle = i*angleInc; 
            p.push( { x: dx + radius * Math.cos( angle ), y: dy + radius * Math.sin( angle ) });
        } 
        p.reverse();
        return p;
    }
    public static inline function horizontalWavePoints( x_: Float, dx_: Float, y_: Float, amplitude: Float, sides: Int, repeats: Float ):Array<Point>{         
        var p: Array<Point> = new Array<Point>(); 
        var dx: Float = 0;
        var angleInc: Float = (Math.PI*2)/sides;
        var len: Int = Std.int( sides*repeats );
        for( i in 0...len ) p.push( { x: x_ + (dx+=dx_), y: y_ + amplitude * Math.sin( i*angleInc ) });
        return p;
    }
}