cast.as

著名的flash 3d引擎 away 3d的源代码

            if (data is Class)
            {
                try
                {
                    data = new data;
                }
                catch (bitmaperror:ArgumentError)
                {
                    data = new data(0,0);
                }
            }

            if (data is BitmapData)
                return data;
			
			if (data is Bitmap)
            	if ((data as Bitmap).hasOwnProperty("bitmapData")) // if (data is BitmapAsset)
                	return (data as Bitmap).bitmapData;

            if (data is DisplayObject)
            {
                var ds:DisplayObject = data as DisplayObject;
                var bmd:BitmapData = new BitmapData(ds.width, ds.height, true, 0x00FFFFFF);
                var mat:Matrix = ds.transform.matrix.clone();
                mat.tx = 0;
                mat.ty = 0;
                bmd.draw(ds, mat, ds.transform.colorTransform, ds.blendMode, bmd.rect, true);
                return bmd;
            }

            throw new CastError("Can't cast to bitmap: "+data);
        }

        private static var notclasses:Dictionary = new Dictionary();
        private static var classes:Dictionary = new Dictionary();

        public static function tryclass(name:String):Object
        {
            if (notclasses[name])
                return name;

            var result:Class = classes[name];

            if (result != null)
                return result;

            try
            {
                result = getDefinitionByName(name) as Class;
                classes[name] = result;
                return result;
            }
            catch (error:ReferenceError) {}

            notclasses[name] = true;
            return name;
        }

        public static function material(data:*):ITriangleMaterial
        {
            if (data == null)
                return null;

            if (data is String)
                data = tryclass(data);

            if (data is Class)
            {
                try
                {
                    data = new data;
                }
                catch (materialerror:ArgumentError)
                {
                    data = new data(0,0);
                }
            }

            if (data is IMaterial)
                return data;

            if (data is int) 
                return new ColorMaterial(data);

            if (data is MovieClip) 
                return new MovieMaterial(data);

            if (data is String)
            {
                if (data == "")
                    return null;

                var hash:Array;

                if ((data as String).indexOf("#") != -1)
                {
                    hash = (data as String).split("#");
                    if (hash[1] == "")
                        return new WireColorMaterial(color(hash[0]));

                    if (hash[1].indexOf("|") == -1)
                    {
                        if (hash[0] == "")
                            return new WireframeMaterial(color(hash[1]));
                        else
                           return new WireColorMaterial(color(hash[0]), {wirecolor:color(hash[1])});
                    }
                    else
                    {
                        var line:Array = hash[1].split("|");
                        if (hash[0] == "")
                            return new WireframeMaterial(color(line[0]), {width:parseFloat(line[1])});
                        else
                            return new WireColorMaterial(color(hash[0]), {wirecolor:color(line[0]), width:parseFloat(line[1])});
                    }
                }
                else
                if ((data as String).indexOf("@") != -1)
                {
                    hash = (data as String).split("@");
                    if (hash[1] == "")
                        return new ShadingColorMaterial({color:color(hash[0])});
                }
                else
                {
                    return new ColorMaterial(color(data));
                }

            }

            try
            {
                var bmd:BitmapData = Cast.bitmap(data);
                return new BitmapMaterial(bmd);
            }
            catch (error:CastError) {}

            if (data is Object)
            {
                var ini:Init = Init.parse(data);
                var bitmap:BitmapData = ini.getBitmap("bitmap");
                var color:uint = ini.getColor("color", 0xFFFFFFFF);
                var alpha:Number = ini.getNumber("alpha", 1, {min:0, max:1});
                var lighting:Boolean = ini.getBoolean("lighting", false);
                var wire:WireframeMaterial = wirematerial(ini.getObject("wire")) as WireframeMaterial;

                if ((bitmap != null) && (color != 0xFFFFFFFF))
                    throw new CastError("Can't create material with color and bitmap: "+data);

                if (bitmap != null)
                {
                    if (wire != null)
                        Debug.warning("Bitmap materials do not support wire");
                        
                    var smooth:Boolean = ini.getBoolean("smooth", false);
                    var precision:Number = ini.getNumber("precision", 0);
                    if (precision)
                    {
                        if (lighting)
                            return new WhiteShadingBitmapMaterial(bitmap, {smooth:smooth, precision:precision});

                        if (alpha < 1)
                            Debug.warning("Can't create precise bitmap material with alpha (yet)");

                        return new BitmapMaterial(bitmap, {smooth:smooth, precision:precision});
                    }
                        
                    if (lighting)
                    {
                        if (alpha < 1)
                            Debug.warning("Can't create bitmap material with lighting and alpha (yet)");

                        return new WhiteShadingBitmapMaterial(bitmap, {smooth:smooth, alpha:alpha});
                    }

                    return new BitmapMaterial(bitmap, {smooth:smooth});
                }

                if (color != 0xFFFFFFFF)
                {
                    if (lighting)
                    {
                        if (wire != null)
                            Debug.warning("Can't create shading material with wire");

                        return new ShadingColorMaterial({color:color, alpha:alpha});
                    }

                    if (wire == null)
                        return new ColorMaterial(color, {alpha:alpha});
                    else
                        return new WireColorMaterial(color, {alpha:alpha, wirecolor:wire.color, wirealpha:wire.alpha, width:wire.width});
                }

                if (wire != null)
                    return wire;
            }

            throw new CastError("Can't cast to material: "+data);
        }

        public static function wirematerial(data:*):ISegmentMaterial
        {
            if (data == null)
                return null;

            if (data is ISegmentMaterial)
                return data;

            if (data is int) 
                return new WireframeMaterial(data);

            if (data is String)
            {
                if (data == "")
                    return null;

                if ((data as String).indexOf("#") == 0)
                    data = (data as String).substring(1);

                if ((data as String).indexOf("|") == -1)
                    return new WireframeMaterial(color(data));

                var line:Array = (data as String).split("|");
                return new WireframeMaterial(color(line[0]), {width:parseFloat(line[1])});
            }

            if (data is Object)
            {
                var dat:Init = Init.parse(data);
                var color:uint = dat.getColor("color", 0);
                var alpha:Number = dat.getNumber("alpha", 1, {min:0, max:1});
                var width:Number = dat.getNumber("width", 1, {min:0});

                return new WireframeMaterial(color, {alpha:alpha, width:width});
            }

            throw new CastError("Can't cast to wirematerial: "+data);
        }

    }
}