CustomFont3D.as

package {
    import com.nitoyon.potras.*;
    import org.papervision3d.typography.Font3D;
    import flash.display.BitmapData;
    import flash.geom.Point;
    import flash.text.TextField;
    import flash.text.TextFormat;
    public class CustomFont3D extends Font3D
    {

        private static var __motifs:Object = {};
        private static var __widths:Object = {};
        private static var __height:Number = 119;
        private var _initialized:Boolean = false;

        private var _text:String;
        private var _font:String;
        private var _size:uint;

        public function CustomFont3D(text:String, font:String="_ゴシック", size:uint=72)
        {
            _text = text;
            _font = font;
            _size = size;
        }

        private function initialize():void {
            if(!_initialized)
            {
                initializeMotifsAndWidths();
                _initialized = true;
            }
        }

        ////////////////////////////////////////////
        override public function get motifs():Object
        {
            if(!_initialized)initialize();
            return __motifs;
        }

        override public function get widths():Object
        {
            if(!_initialized)initialize();
            return __widths;
        }

        override public function get height():Number
        {
            if(!_initialized)initialize();
            return __height;
        }
        ////////////////////////////////////////////

        private function initializeMotifsAndWidths():void
        {
            var arr:Array = _text.split("");
            var result:Array;
            for(var i:uint=0,max:uint=arr.length; i<max; i++)
            {
                if(!__motifs[arr[i]])
                {
                    result = getMotifsAndWidths(arr[i]);
                    __motifs[arr[i]] = result[0];
                    __widths[arr[i]] = result[1];
                }
            }
        }

        private function getMotifsAndWidths(str:String):Array
        {
            var arr:Array = [];
            var pathList:ClosedPathList = CustomFont.traceLetter(str, _size, _font);
            for each(var path:ClosedPath in pathList.$a)
            {
                arr = arr.concat(getPoints(path.$a));
            }
            var data:Array = [
                arr,
                _size
            ];
            return data;
        }

        /**
         * PotrAs(traceLetter) edited
         */
        public static function traceLetter(letter:String, fontSize:int, font:String="_ゴシック"):ClosedPathList
        {
            var tf:TextFormat = new TextFormat();
            tf.font = font;
            tf.size = fontSize;

            var text:TextField = new TextField();
            text.defaultTextFormat = tf;
            text.autoSize = "left";
            text.text = letter;

            // We have to use threshold method to binarize, because Mac OS draws antialiased text.
            var bmdtmp:BitmapData = new BitmapData(fontSize * letter.length, fontSize * 1.2, true);
            var bitmapdata:BitmapData = bmdtmp.clone();
            bmdtmp.draw(text);
            bitmapdata.threshold(bmdtmp, bmdtmp.rect, new Point(), "<", 0xffdddddd, 0xff000000);

            var pathList:Array = PathList.create(bitmapdata);
            var c:ClosedPathList = ProcessPath.processPath(pathList);

            bmdtmp.dispose();
            bitmapdata.dispose();
            return c;
        }
        /**
         * ClosedPath(draw) edited
         */
        public function getPoints($a:Array):Array
        {
            var arr:Array = [];
            var pt:Point = $a[$a.length - 1].c[2];
            arr.push(['M', [pt.x, pt.y]]);

            for(var i:int = 0; i < $a.length; i++)
            {
                var c:Curve = $a[i];

                if(c.tag == ProcessPath.POTRACE_CORNER)
                {
                    arr.push(['L', [c.c[1].x, c.c[1].y]]);
                    arr.push(['L', [c.c[2].x, c.c[2].y]]);
                }
                else
                {
                    for(var t:Number = 0; t < 1.0; t += 0.02)
                    {
                        var p:Point = getBezierPoint(pt, c.c[0], c.c[1], c.c[2], t);
                        arr.push(['L', [p.x, p.y]]);
                    }
                    arr.push(['L', [c.c[2].x, c.c[2].y]]);
                }
                pt = c.c[2];
            }
            return arr;
        }
        /**
         * ClosedPath(getBezierPoint) edited
         */
        protected function getBezierPoint(p0:Point, p1:Point, p2:Point, p3:Point, t:Number):Point
        {
            return new Point(Math.pow(1 - t, 3)  * p0.x + 3 * t * Math.pow(1 - t, 2) * p1.x
                        + 3 * t * t * (1 - t) * p2.x + t * t * t * p3.x,
                        Math.pow(1 - t, 3)  * p0.y + 3 * t * Math.pow(1 - t, 2) * p1.y
                        + 3 * t * t * (1 - t) * p2.y + t * t * t * p3.y);
        }
    }
}