POPSブログ

FLASH-SLIDESHOW-1

60

  Category:  flash2012/03/22 pops 

FLASH AS3 による、画像をスライスした表示するスライドショーです。JSとは違い軽快です。


FLASH-SLIDESHOW-1

FlashTest162c.swf

フルスクリーン対応「簡単なスライドショー」サンプル表示


FLASH表示テスト 専用のSWF FlashTest162c.swf 640x320


注意、FlashTest162c.swf は「BaserCMS」で使用する専用です。画像は /main/images/xxxx.jpg


簡単な説明

「ページャー」等の無い「簡単なスライドショー」タイプです。

  • FlashDevelopで作りました。AS3表記です。
  • スクリプトだけの資料です。書き換えなどは自由です。
  • 画像URLはスクリプト内部に記載します。
  • ランダムに設定された条件で作動しますので、合わないものもでます。ご了承ください。
  • 動作も速くなったり、遅くなったりします。
  • 当方のFlashDevelopの設定により、as swf クラスの名前は同じです。環境にあわせてください。

簡単なスクリプト説明


次の数値を変更してください、

[SWF(width="640", height="320", frameRate="30", backgroundColor="0x000000")]

//コンテナ大きさ
private var boxWidth:Number = 640;
private var boxHeight:Number = 320;

//main-imageのおおきさ
private var image_W:Number = 640;
private var image_H:Number = 320;

//delay速度の率
private var delay_rate:Number = 0.1;

//IN-OUT
private var showModes:Array = ["in","out","in","out"];

//sliceTYPE
private var sliceTypes:Array = ["slice", "slice", "slice", "plate", "4door", "2door", "zipper", "bar", "cross", "free", "free", "free"];

//SLICE標準分割.縦横5x5
private var split_v_st:Number = 8;
private var split_h_st:Number = 4;
//要素の標準Tweentime時間 1-1.8
private var tweentime_st:Number = 1.4;
//長いdelay遅延時間/1-3
private var delay_time:Number = 2;

//自動/Timer-time
private var autoTimer:Timer;
private var auto_time:Number = 8000;//5000-10000


// 画像URL-SET
private function loadImage_Url_Set():void
{
	//画像URL
	imageUrls = [
		"images/photo1m.jpg",
		"images/photo2m.jpg",
		"images/photo3m.jpg",
		"images/photo4m.jpg",
		"images/photo5m.jpg",
		"images/photo6m.jpg"
	];
	//画像説明文
	imageMess = [
		"画像説明 1",
		"画像説明 2",
		"画像説明 3",
		"画像説明 4",
		"画像説明 5",
		"画像説明 6",
	];

---------------------------------------------

上の設定、delay速度の率は
private var delay_rate:Number = 0.1;

delayパターンの値はそのまま使用するには大きい数値ですが、現在そのまま使用されてはいません
delay速度の値が大きいために、補正する必要があります、delay_rateは、そのための変数です

794行目前後でランダム設定
//delay速度の率/0.25-0.1
delay_rate =1 / ((Math.floor(Math.random() * 4) + 1) * 2 + 2);

ランダムにするために、すり替わっています、必要の無い場合は削除して、delay_rate好みの値を設定する

sliceTypes:Arrayでスライスタイプの出現率を制御できます、あるいは

//SLICE-TYPE
//crossはfreeの処理でおこなわれる
slicetype = sliceTypes[Math.floor(Math.random() * sliceTypes.length)];
//slice slide plate 2door 4door zipper bar cross free
slicetype = "slice";

にすれば slice 専用になります、

当方画像のURLは BaserCMS 使用のため /main/images/photo1m.jpg となっています、

---------------------------------------------

FLASH、コンテナ大きさ、が2重になっているのは、メニューボタンなどを追加できるようにしているため

FLASHの場合、スライスされた画像は横方向にならんでゆきます。JSの場合は縦にならんでゆきます、
よって、もしもdelayパターンをJSに転用する場合は修正が必要です

長い時間、使用しても重くならないように、画像は BitmapData で上書きするようにしています

使用していない変数などもあります、ご了承ください、

Tweenは軽いためTweenMaxを使用していますがBetweenAS3等の使用も可能です

複数画像のLOADはライブラリを使用していません、自分なりの読み込み方法です、ライブラリを使用
する場合はかきかえてください


AS3

as FlashTest162c.as

FlashDevelopで制作しました。中には使用していない変数もあります。画像URLなどは環境に合わせてください。


//SlideShow_s2/SlideShowテンプレート
//FlashTest162c
//自由分割/自動設定/MENU無
//画像一括読み込み形式、container収容
//新パターン使用、switch文にした、他は同じ

package
{

	import flash.display.*;
	import flash.events.*;
	import flash.net.*;
	import flash.geom.*;
	import flash.system.*;
	import flash.utils.*;
	import flash.text.*;
	//虹色用
	import frocessing.color.ColorHSV;
	//Tween
	import com.greensock.*;
	import com.greensock.easing.*;

	[SWF(width="640", height="320", frameRate="30", backgroundColor="0x000000")]

	public class FlashTest162c extends Sprite
	{
		//layer
		private var layer1:Sprite;
		private var layer2:Sprite;
		private var layer3:Sprite;

		//コンテナ画像BOX
		private var container:Sprite;
		private var backImageBox:Sprite;//layer1
		private var backImage:Sprite;//BACK画像
		private var keepImage:BitmapData;
		//clip収容コンテナ/Mask
		private var clipContainer:Sprite;
		private var clipContainerMask:Sprite;
		//textlayer
		private var textlayer:Sprite;
		private var square2:Sprite;
		private var square3:Sprite;

		//TEXT1.2
		private var tf:TextField;
		private var tf2:TextField;
		private var mvtf:TextField;

		//コンテナ大きさ
		private var boxWidth:Number = 640;
		private var boxHeight:Number = 320;
		
		//LOADER
		private var loader:Loader;
		//Loading
		private var indicator:DisplayObject;

		//main
		private var mainImages:Array = [];//Array-Bitmap
		//main-imageのおおきさ
		private var image_W:Number = 640;
		private var image_H:Number = 320;
		private var show_no:int = 0;//現在表示番号
		private var photomax:int = 0;
		private var countImage:int = 0;//現在表示配列番号
		
		private var bitmapImages:Array = [];//Array-Bitmap未使用
		private var imageUrls:Array = [];

		//フエードの種類/1右から 2左から
		private var fadeflag:int = 1;
		//分割の要素の大きさ
		private const SIZE:Number = 80;//W H 未使用
		//縦横の分割要素の大きさ指定、注意constではない あとで決定
		private var size_X:Number;//W方向
		private var size_Y:Number;//H方向
		//要素中心補正位置 あとで決定
		private var cx_v:Number;
		private var cy_v:Number;
		//縦横の分割数
		private var split_v:Number;
		private var split_h:Number;
		//rotattion配分 0が多い
		private var rotat_No:Array = [0,0,0,0,0,0,0,0,1,2,3,-1,-2,-3];
		//スケール基準値
		private var scale_No:Array = [0,0,0,0.5,-0.5,-1];
		//縦横の並べ方向 、横=0 縦=1
		private var hvflag:Number = 0;
		//in.out/show_mode
		private var movemode:Number = 0;//未使用
		//delay速度の率
		private var delay_rate:Number = 0.1;
		//IN-OUT
		private var showModes:Array = ["in","out","in","out"];
		private var show_mode:String = "in";
		//sliceTYPE
		private var sliceTypes:Array = ["slice", "slice", "slice", "plate", "4door", "2door", "zipper", "bar", "cross", "free", "free", "free"];
		//slice=5x5
		private var slicetype:String = "slice";
		//スライス要素
		private var sliceBoxs:Array = [];
		//スライス要素標準位置の代入配列 x y
		private var st_pos_x:Array = [];
		private var st_pos_y:Array = [];
		//位置の代入配列 x y r
		private var position_x:Array = [];
		private var position_y:Array = [];
		private var slices_rot:Array = [];
		//コーナーのポイント位置代入配列/未使用
		private var corner_px:Array;
		private var corner_py:Array;
		//スケール配列XY
		private var scaleXs:Array = [];
		private var scaleYs:Array = [];
		//generation配列
		private var delays:Array = [];
		//交互遅延
		private var delay_times:Array = [];
		//start
		private var startflag:Boolean = true;//最初の判定
		//縦分割が偶数Even
		private var even_v:int = 1;
		//Pattn
		private var startPattn:Number = 0;
		
		//SLICE標準分割.縦横5x5
		private var split_v_st:Number = 8;
		private var split_h_st:Number = 4;
		//要素の標準Tweentime時間 1-1.8
		private var tweentime_st:Number = 1.4;
		//長いdelay遅延時間/1-3
		private var delay_time:Number = 2;

		private var split_total:Number = split_v * split_h;//分割合計
		private var twn_count:int = 0;//分割合計カウント比較
		private var tweenflag:Boolean = false;//tweenの終了判定
		private var ptn_no:int = 0;// パターン番号

		//自動/Timer-time
		private var autoTimer:Timer;
		private var auto_time:Number = 8000;//5000-10000
		
		//画像の説明文の保存
		private var imageMess:Array = [];
		
		//FullScreenButton
		private var fullScreenBtn:Sprite;

		public function FlashTest162c():void
		{
			//ステージ、layer等の基本構造のレイアウト
			stage.align = StageAlign.TOP_LEFT;
			stage.quality = StageQuality.HIGH;
			//stage.scaleMode = StageScaleMode.NO_SCALE;//スライドカバーが機能しなくなるので使用しない
			stage.fullScreenSourceRect = new Rectangle(0, 0, stage.stageWidth, stage.stageHeight);

			//BASE/黒背景
			var square:Sprite = new Sprite();
			square.graphics.beginFill(0x000000);//0x000000
			square.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
			square.graphics.endFill();
			addChild(square);
			
			//create グラデ背景Sprite/0xB18D8D,0x000000
			var grad_square:Sprite = draw_grad_box(stage.stageWidth, stage.stageHeight, 0x25B7C0, 0x000000);
			addChild(grad_square);

			//container/backImageBoxを収容
			container = createSquare(0, 0, boxWidth, boxHeight, 0x000000, 0);
			addChild(container);
			container.x = (stage.stageWidth - boxWidth) / 2;
			container.y = 0;
			//container.visible = false;
			//clipContainerMask
			clipContainerMask = new Sprite();
			clipContainerMask = createSquare(0, 0, boxWidth, boxHeight, 0xFF0000, 1);	
			clipContainerMask.x = 0;
			clipContainerMask.y = 0;
			clipContainerMask.visible = false;
			container.addChild(clipContainerMask);
			//backImageBox
			backImageBox = createSquare(0, 0, boxWidth, boxHeight, 0x000000, 1);
			container.addChild(backImageBox);
			//BACK画像
			backImage = createSquare(0, 0, boxWidth, boxHeight, 0x000000, 1);
			backImageBox.addChild(backImage);
			
			//LOADING
			indicator = new Indicator();
			indicator.x = 12;
			indicator.y = 15;
			indicator.addEventListener(Event.ENTER_FRAME, step);//回転Listener
			addChild(indicator);
			indicator.visible = false;
			
			//textlayer-hover収容BOX
			textlayer = new Sprite();
			addChild(textlayer);
			textlayer.visible = false;
			
			//TEXT背景Spriteボックス作成1/alpha=0.4
			square2 = createSquare(0, 0, stage.stageWidth, 30, 0x000000, 0.4);
			textlayer.addChild(square2);
			//TEXT背景Spriteボックス作成2/alpha=0.4
			square3 = createSquare(0, 0, stage.stageWidth, 30, 0x000000, 0.4);
			//下に表示
			square3.y = stage.stageHeight - 30;
			textlayer.addChild(square3);
			
			//text
			tf = createTextField(5, 5, stage.stageWidth - 10, 20);
			tf.textColor = 0xFFFFFF;
			tf.text = "---";
			tf.selectable = false;
			square2.addChild(tf);
			//text2
			tf2 = createTextField(5, 5, stage.stageWidth - 50, 20);
			tf2.textColor = 0xFFFFFF;
			tf2.text = "SlideShow";
			tf2.selectable = false;
			square3.addChild(tf2);
			
			//title
			mvtf = new TextField();
			addChild(mvtf);

			//FullScreenButton/square3
			fullScreenBtn = createFullScreenButton();
			fullScreenBtn.x = stage.stageWidth - 35;
			fullScreenBtn.y = 2;
			square3.addChild(fullScreenBtn);

			//FULLSCREEN-Listener
			fullScreenBtn.addEventListener(MouseEvent.CLICK, fullClickHandler);
			
			//textlayer-Listener
			stage.addEventListener(MouseEvent.MOUSE_OVER, openTextLayer);
			stage.addEventListener(MouseEvent.MOUSE_OUT, closeTextLayer);
			
			//GOTO-Url_Set
			loadImage_Url_Set();
		}

		// 画像URL-SET
		private function loadImage_Url_Set():void
		{
			//画像URL
			imageUrls = [
				"images/photo1m.jpg",
				"images/photo2m.jpg",
				"images/photo3m.jpg",
				"images/photo4m.jpg",
				"images/photo5m.jpg",
				"images/photo6m.jpg"
			];
			//画像説明文
			imageMess = [
				"画像説明 1",
				"画像説明 2",
				"画像説明 3",
				"画像説明 4",
				"画像説明 5",
				"画像説明 6",
			];
			/**
				"/main/images/photo1m.jpg",
				"/main/images/photo2m.jpg",
				"/main/images/photo3m.jpg",
				"/main/images/photo4m.jpg",
				"/main/images/photo5m.jpg",
				"/main/images/photo6m.jpg"
			**/
			//カウント
			countImage = 0;
			//画像数
			photomax = imageUrls.length;
			//LOADING表示
			indicator.visible = true;
			//GOTO-loadImage
			loadImage();
		}
		// 画像をロード
		private function loadImage():void
		{
			//
			loader = new Loader();
			var imageName:String = imageUrls[countImage];
			loader.contentLoaderInfo.addEventListener(Event.COMPLETE, onComplete_img);//
			loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);//Error
			loader.load(new URLRequest(imageName));//loader
		}
		//Complete BitmapDataの保存
		private function onComplete_img(event:Event):void
		{
			loader.contentLoaderInfo.removeEventListener(Event.COMPLETE, onComplete_img);
			tf.text = "画像読み込み中";
			
			//main-imageの加工保存
			//Matrixを使用した場合
			var mainloader:Loader = event.currentTarget.loader;
			var ratio:Number = image_W / loader.width;//縮尺比率
			var matrix:Matrix = new Matrix();
			matrix.scale(ratio, ratio);
			var bd2:BitmapData = new BitmapData(image_W, image_H, false);
			bd2.draw(mainloader, matrix);//Matrixを適応
			mainImages.push(bd2);
			
			countImage ++;
			
			//全て読み込んだらinitにまだなら残り画像をロードする
			if (countImage >= photomax) {
				//LOADING非表示
				indicator.visible = false;
				//画像をロード終了goto-init
				init();
			} else {
				//残り画像をLoad
				loadImage();
			}
		}

		//INIT
		private function init():void
		{
			//init
			//タイマーセット
			timer_set();
			//最初の画像を表示
			//loadImage2(0);
			show_image(0);
			//goto-main
			main_action();
		}
				
		//MAIN-ACTION
		private function main_action():void
		{
			
			//main_action as3 hear
			var msg:String="POPS WEB KOUBOU";
			var mvtextColor:uint;
			var nAngle:Number = Math.PI * 2 / msg.length;
			var cAngle:Number = 0;
			//TextFormat
			var tfm:TextFormat = new TextFormat("_sans", 40, 0x666666, true);
			mvtf.defaultTextFormat = tfm;
			mvtf.autoSize = TextFieldAutoSize.LEFT;
			mvtf.text = msg;//msg.substr(i, 1)
			mvtf.textColor = 0x000000;
			mvtf.selectable = false;
			//個別に着色
			for (var i:int = 0; i < msg.length; ++i) {
				//虹色にそめる
				var hsv:ColorHSV = new ColorHSV(0, 1, 1, 1);
				hsv.h = cAngle / Math.PI * 180;
				//虹色を取得受け渡す
				mvtextColor = hsv.value;
				cAngle += nAngle;
				var tfm2:TextFormat = new TextFormat();
				tfm2.color = mvtextColor;
				mvtf.setTextFormat(tfm2, i);
			}
			//位置の確定
			mvtf.x = (stage.stageWidth - mvtf.width) / 2;
			mvtf.y = (stage.stageHeight - mvtf.height) / 2;
			
			//Fade-Out
			TweenMax.to(mvtf, 2, { delay:10, alpha:0, onComplete:function ():void {
				mvtf.y = -200;
				mvtf.visible = false;
			}});
			
		}
		
		//画像表示
		private function show_image(no:int):void
		{

			//tweenの終了判定
			tweenflag = false;
			//画像DATA表示 題目
			tf.text = imageMess[no];
			//tf.text = " 番号 " + no + " / URL " + imageUrls[no];
			
			//受け渡し現在表示番号 / noはローカル
			show_no = no;
			//Tweenカウント比較クリア
			twn_count = 0;
			
			//IN-OUT
			show_mode = showModes[Math.floor(Math.random() * 2)];
			//show_mode = "in";
			//show_mode = "out";
			
			//最初はshow_mode=inに強制的にする、outは面倒なため
			if (startflag) { show_mode = "in"; }
			
			//SLICE-TYPE
			//crossはfreeの処理でおこなわれる
			slicetype = sliceTypes[Math.floor(Math.random() * sliceTypes.length)];
			//slice slide plate 2door 4door zipper bar cross free
			//slicetype = "slice";
			
			startflag = false;//最初では無い
			
			//スタート選定上下左右フラグ
			var hv_star_no:Number = Math.floor(Math.random() * 3);
			hvflag = hv_star_no;
			//delay配列反転flag選定
			var delay_revflg:Number = Math.floor(Math.random() * 7);
			//delay_revflg = 1;
			//交互遅延時間配列クリア
			delay_times = [];
			//slide方向0-3
			var slide_flag:int = Math.floor(Math.random() * 4);
			//bar方向
			var bar_flag:int = Math.floor(Math.random() * 4);
			//bar方向逆転
			var bar_chg:int = Math.floor(Math.random() * 3);
			//rotation
			var start_rotation:Number = 0;//開始回転角
			var end_rotation:Number = 0;//終了回転角
			//スライス要素オブジェクト
			sliceBoxs = [];
			//スライス要素標準位置の代入配列xyクリア
			st_pos_x = [];
			st_pos_y = [];
			//位置の代入配列xyrクリア
			position_x = [];
			position_y = [];
			slices_rot = [];
			//スケール配列XYクリア
			scaleXs = [];
			scaleYs = [];
			//generation配列クリア
			delays = [];
			delays[0] = 0;
			
			//縦横の分割要素の大きさを決定する
			if (hvflag == 0) {
				//縦横分割
				split_v = Math.floor(Math.random() * 9) + 1;
				split_h = Math.floor(Math.random() * 9) + 1;
			}
			if (hvflag == 1) {
				//横分割
				split_v = 1;
				split_h = Math.floor(Math.random() * 9) + 1;
			}
			if (hvflag == 2) {
				//縦分割
				split_h = 1;
				split_v = Math.floor(Math.random() * 9) + 1;
			}
			//SLICE標準補正/標準分割数を代入
			if (slicetype == 'slice') {
				//縦横25分割
				hvflag = 0;
				split_v = split_v_st;
				split_h = split_h_st;
			}
			//4DOOR標準補正
			if (slicetype == '4door') {
				//縦横4分割
				hvflag = 0;
				split_v = 2;
				split_h = 2;
			}
			//2DOOR標準補正
			if (slicetype == '2door') {
				//横2分割
				hvflag = 0;
				split_v = 1;
				split_h = 2;
			}
			//plate.cross標準補正
			if (slicetype == 'plate' || slicetype == 'cross') {
				//縦横1分割
				hvflag = 0;
				split_v = 1;
				split_h = 1;
			}
			//zipper標準補正
			if (slicetype == 'zipper') {
				//縦2分割.横2-10分割
				split_v = 2;
				split_h = Math.floor(Math.random() * 8) + 2;
			}
			//bar標準補正5-10
			if (slicetype == 'bar') {
				if (bar_flag < 2) {
					split_v = 1;
					split_h = Math.floor(Math.random() * 5) + 5;
				}
				if (bar_flag > 1) {
					split_v = Math.floor(Math.random() * 5) + 5;
					split_h = 1; 
				}
			}
			
			//スライス要素の幅高さ計算
			size_X = Math.ceil(boxWidth / split_v);
			size_Y = Math.ceil(boxHeight / split_h);

			//分割合計
			split_total = split_v * split_h;
			split_total = split_total;
			//Even
			if (split_v % 2 != 0) {even_v = 0;}//X奇数
			//要素中心補正位置
			cx_v = size_X / 2;
			cy_v = size_Y / 2;
			
			//clip収容コンテナを配置する/透明
			clipContainer = new Sprite();
			clipContainer = createSquare(0, 0, boxWidth, boxHeight, 0x000000, 0);
			container.addChild(clipContainer);
			clipContainer.mask = clipContainerMask;
			
			//スタート選定位置0-14
			var random_start_no:Number = Math.floor(Math.random() * 15);
			//delayパターン20より選定0-19
			//var startPattn:Number = Math.floor(Math.random() * 20);
			startPattn = Math.floor(Math.random() * 22);//増やした
			
			//delayパターン2/
			var startPattn2:Number = Math.floor(Math.random() * 4);
			//delay遅延フラグ25%
			var delay_flag:int = Math.floor(Math.random() * 8);
			//FADEフラグ
			var fade_flag:int = Math.floor(Math.random() * 3);
			//スライス要素の伸縮方向
			//ランダムス 標準=XY伸縮 0=XY伸縮なし 1=X伸縮 2=Y伸縮 3>=XY伸縮
			var scale_flag:int = Math.floor(Math.random() * 4);
			
			//PLATE.SLICE補正
			if (slicetype == 'slice') {
				//同じ位置
			}
			if (slicetype == 'plate') {
				startPattn = 0;
			}
			
			//要素のTweentime時間に標準を代入 1-1.8
			var tweentime:Number = tweentime_st;
			//tweentime = (Math.random() * 3) + 0.5;//random
			//tweenのspeedをかえる
			var speedflag:int = Math.floor(Math.random() * 3);
			//スケール、透明度、回転
			var start_scale:Number = 0;
			//rotatを決定0が多い
			var rotatflag:Number = Math.floor(Math.random() * 14);
			//INは180=左回転 -180=右回転、OUTは反対になる
			var start_rotat:Number = rotat_No[rotatflag] * 60;
			
			//透明度0
			var start_alpha:Number = 0;//開始
			var end_alpha:Number = 0;//終了
			
			//四隅から出す場合の計算値
			var xp_no:Number = Math.floor(Math.random() * 2);//0 1
			var yp_no:Number = Math.floor(Math.random() * 2);//0 1
			//XY位置の補正係数
			var xy_pos_no:Number = Math.floor(Math.random() * 2);
			if (xy_pos_no == 0) { xy_pos_no = -1};//1 -1
			var angle_v:Number = 0;
			var generation:Number = 1;//delay
			var y:int = 0;//スライス位置x
			var x:int = 0;//スライス位置y
			//マイナスフラグ左右または上下から交互に
			var minusflag_x:Number = -1;
			var minusflag_y:Number = -1;
			
			//door-plate補正
			var door_flag:int = 0;
			if (slicetype == '2door' || slicetype == '4door' || slicetype == 'zipper' || slicetype == 'plate' || slicetype == 'bar') {
				door_flag = 1;
				tweentime *= 0.5;
			}
			if (slicetype == '2ipper') {
				//速度調整
				tweentime *= 0.5;
			}
			//plate.cross標準補正
			if (slicetype == 'cross') {
				//縦横1分割.同じ位置
				random_start_no = 2;
				startPattn = 0;
				start_rotat = 0;
			}
			
			//delay速度の率ランダム計算 0.25-0.1
			delay_rate =1 / ((Math.floor(Math.random() * 4) + 1) * 2 + 2);
			
			//k k2
			var k:int = 0;
			var k2:int = 1;
			var k3:Number = 0;
			var k4:Number = 1;
			var k5:Number = 1;
			var delay1:Number = 0;
			var flag3:int = 1;//市松パターン用
			
			//clippingするBitmapDataの指定
			var clippingData:BitmapData = mainImages[no];
			if (show_mode == 'out') { clippingData = keepImage; }
			
			//Loop
			for (var i:int = 0; i < split_h; ++ i){
				y = i * size_Y;//中央補正しないポジション
				for (var j:int = 0; j < split_v; ++ j) {
					//交互遅延時間配列
					delays[k] = 0;
					delay_times[k] = 0;
					x = j * size_X;//中央補正しないポジション
					//縦方向にカウント
					k3 = j * split_h + i;
					//要素縦横決定
					var yy:int = (boxHeight - y >= size_Y) ? size_Y : boxHeight - y;
					var xx:int = (boxWidth - x >= size_X) ? size_X : boxWidth - x;
					
					//要素が縦横ならべばLoopを抜ける
					if (xx <= 0 || yy <= 0) continue;
					
					//clipping
					var bmp:Bitmap = new Bitmap(clipping(clippingData, x, y, xx, yy, 1.0));
					bmp.x = -cx_v;
					bmp.y = -cy_v;
					//中心補正のため sliceBox:Sprite に入れ込む
					var sliceBox:Sprite = new Sprite();
					sliceBox.width = size_X;
					sliceBox.height = size_Y;
					
					sliceBox.addChild(bmp);
					//layer2階層clip収容コンテナにクリッピングする
					clipContainer.addChild(sliceBox);
					
					//表示設定 配置しているが、現在非表示状態start_scale
					scaleXs[k] = 0;//0
					scaleYs[k] = 0;//0
					//初期透明度 角度
					sliceBox.alpha = start_alpha;
					//rotat配列に保存/未使用
					slices_rot[k] = start_rotat;//回転
					
					//標準スライス要素中心補正位置の保存/配置位置
					st_pos_x[k] = x + cx_v;
					st_pos_y[k] = y + cy_v;
					
					//door以外の場合処理する slice free
					if (!door_flag) {
						//スタート位置
						switch (random_start_no) {
							case 0:
								//見栄えを良くするためスケールを0にする
								scale_flag = 3;
								//0地点 四隅原点から出す 0か1の乗算
								position_x[k] = boxWidth * xp_no;
								position_y[k] = boxHeight * yp_no;
							break;
							case 1:
								//stage中央設定
								position_x[k] = boxWidth / 2;
								position_y[k] = boxHeight / 2;
							break;
							case 2:
								//同じ位置1
								position_x[k] = st_pos_x[k];
								position_y[k] = st_pos_y[k];
							break;
							case 3:
								//同じ位置2
								position_x[k] = st_pos_x[k];
								position_y[k] = st_pos_y[k];
								//展開パターン全て同時に変更
								startPattn = 14;
								//回転強制 0
								slices_rot[k] = 0;//注意
							break;
							case 4:
								//ステージ内よりrandom
								position_x[k] = Math.floor(Math.random() * boxWidth);
								position_y[k] = Math.floor(Math.random() * boxHeight);
							break;
							case 5:
								//Y方向のみズレ +400 -400
								position_x[k] = st_pos_x[k];
								position_y[k] = st_pos_y[k]; + 400 * xy_pos_no;
							break;
							case 6:
								//X方向のみズレ +400 -400
								position_x[k] = st_pos_x[k]; + 400 * xy_pos_no;
								position_y[k] = st_pos_y[k];
							break;
							case 7:
								//左右または上下から交互に
								position_x[k] = st_pos_x[k];
								position_y[k] = st_pos_y[k];
								if (hvflag) {position_x[k] = boxWidth / 2 + 400 * minusflag_x;};//横分割
								if (!hvflag) {position_y[k] = boxHeight / 2 + 400 * minusflag_y;};//縦分割
							break;
							case 8:
								//右から
								position_x[k] = boxWidth + cx_v;
								position_y[k] = st_pos_y[k];
							break;
							case 9:
								//上から
								position_x[k] = st_pos_x[k];
								position_y[k] = 0 - cy_v;
							break;
							case 10:
								//対角2点から
								position_x[k] = -cx_v;
								position_y[k] = -cy_v;
								if (flag3 == -1) {
									position_x[k] = cx_v + boxWidth;
									position_y[k] = cy_v + boxHeight;
								}
							break;
							case 11:
								//内部から2
								position_x[k] = cx_v + Math.floor(Math.random() * boxWidth);
								position_y[k] = cy_v + boxHeight;
							break;
							case 12:
								//ずれた内部2箇所から
								position_x[k] = st_pos_x[k];
								position_y[k] = boxHeight / 4;
								if (flag3 == -1) {position_y[k] = boxHeight * 3 / 4;}
							break;
							default:
								//半径400のXY値を算出
								angle_v = Math.random() * 360;
								position_x[k] = Math.cos(angle_v * 180 / Math.PI) * 400 + (boxWidth / 2);
								position_y[k] = Math.sin(angle_v * 180 / Math.PI) * 400 + (boxHeight / 2);
						}
					}
					
					//上以外の位置の修正
					//4DOOR標準補正
					if (slicetype == '4door') {
						if (k == 0) {position_x[k] = -(boxWidth / 4);position_y[k] = -(boxHeight / 4);}
						if (k == 1) {position_x[k] = boxWidth + (boxWidth / 4);position_y[k] = -(boxHeight / 4);}
						if (k == 2) {position_x[k] = -(boxWidth / 4);position_y[k] = boxHeight + (boxHeight / 4);}
						if (k == 3) {position_x[k] = boxWidth + (boxWidth / 4); position_y[k] = boxHeight + (boxHeight / 4); }
					}
					//2DOOR標準補正
					if (slicetype == '2door') {
						//if (k == 0) {position_x[k] = -(boxWidth / 2);position_y[k] = (boxHeight / 2);}
						//if (k == 1) { position_x[k] = boxWidth + (boxWidth / 2); position_y[k] = (boxHeight / 2); }
						if (k == 0) {position_x[k] = boxWidth / 2;position_y[k] = -(boxHeight / 2);}
						if (k == 1) {position_x[k] = boxWidth / 2;position_y[k] = boxHeight + (boxHeight / 2);}
					}
					//slide方向0-3slide_flag
					if (slicetype == 'plate') {
						if (slide_flag == 0) {position_x[k] = (boxWidth / 2);position_y[k] = -(boxHeight / 2);}//top
						if (slide_flag == 1) {position_x[k] = (boxWidth / 2);position_y[k] = boxHeight + (boxHeight / 2);}//bottom
						if (slide_flag == 2) {position_x[k] = boxWidth + (boxWidth / 2);position_y[k] = (boxHeight / 2);}//right
						if (slide_flag == 3) {position_x[k] = -(boxWidth / 2);position_y[k] = (boxHeight / 2); }//left
					}
					//zipper標準補正縦2分割.横2-10分割
					if (slicetype == 'zipper') {
						if (k4 == 1) {position_x[k] = -cx_v;position_y[k] = y + cy_v;}
						else {position_x[k] = cx_v + boxWidth;position_y[k] = y + cy_v;}
						//同時はさせない
						if (startPattn == 7) {startPattn = 0;}
					}
					//bar標準補正5-10
					if (slicetype == 'bar') {
						//通常
						if (bar_flag == 0) {position_x[k] = cx_v + boxWidth; position_y[k] = y + cy_v;}
						if (bar_flag == 1) {position_x[k] = -cx_v;position_y[k] = y + cy_v;}
						if (bar_flag == 2) {position_x[k] = x + cx_v; position_y[k] = cy_v + boxHeight;}
						if (bar_flag > 2) {position_x[k] = x + cx_v; position_y[k] = -cy_v;}
						//交互逆転補正 k奇数値で判定
						if (bar_chg == 1 && k % 2 != 0) {
							if (bar_flag == 0) { position_x[k] = -cx_v;}
							if (bar_flag == 1) { position_x[k] = cx_v + boxWidth;}
							if (bar_flag == 2) { position_y[k] = -cy_v;}
							if (bar_flag > 2) { position_y[k] = cy_v + boxHeight;}
						}
					}
					
					//スライド形式のものは回転なしスケールは変えない 4door 2door plate zipper bar
					if (door_flag) { start_rotat = 0; scale_flag = 0; }
					
					//ランダムスケール代入 標準=XY伸縮 0=XY伸縮なし 1=X伸縮 2=Y伸縮 3>=XY伸縮
					//スケールの修正
					if (scale_flag == 1) {
						scaleXs[k] = 0;
						scaleYs[k] = 1;
					}
					if (scale_flag == 2) {
						scaleXs[k] = 1;
						scaleYs[k] = 0;
					}
					if (scale_flag == 0) {
						scaleXs[k] = 1;
						scaleYs[k] = 1;
					}
					//plate.cross標準補正
					if (slicetype == 'cross' && fade_flag == 1) {
						scaleXs[k] = 1.5;
						scaleYs[k] = 1.5;
					}
					
					//IN
					if (show_mode == 'in') {
						//位置配列の代入
						sliceBox.x = position_x[k];
						sliceBox.y = position_y[k];
						//rotation/事前に回転させる
						sliceBox.rotation = start_rotat;
						//alpha補正
						if (slicetype == '2door' || slicetype == '4door' || slicetype == 'plate' || slicetype == 'bar') {
							sliceBox.alpha = 1;
						}
					}
					if (show_mode == 'out') {
						//位置配列の代入
						sliceBox.x = st_pos_x[k];
						sliceBox.y = st_pos_y[k];
						//回転0
						sliceBox.rotation = 0;
						sliceBox.alpha = 1;
					}
					
					//パターン新しい修正を加えた/ズレを少なく修正
					//計算の簡易化のため先にマイナス
					var sh:Number = split_h - 1;//横分割
					var sv:Number = split_v - 1;//縦分割
					
					var patn_name:String = "";
					
					//重要、FLASHは横に要素をつくるので、訂正してある
					//delayパターン slice free
					if (!door_flag) {
						//パターン作成/FLASHの場合は時間が重なってもほぼ動いてくれる
						switch (startPattn) {
							case 0:
								delays[k] = Math.abs(i - (sh / 2)) + Math.abs(j - (sv / 2));//中心より広がる
								patn_name = "中心より広がる";
							break;
							case 1:
								delays[k] = k * 0.2;//配列の順序に
								patn_name = "配列の順序に";
							break;
							case 2:
								delays[k] = Math.abs(i + 0.5 - sh / 2) + j * 0.01;//内から外
								patn_name = "内から外";
							break;
							case 3:
								delays[k] = Math.abs(i - j * split_h / split_v);//対角線状に広がる、補正
								delays[k] = Math.abs((i+j)-(sh+sv)/2);
								patn_name = "対角線状に広がる";
							break;
							case 4:
								delays[k] = (j + i) / 4 + j;//左から右へ
								patn_name = "左から右へ";
							break;
							case 5:
								delays[k] = 2;//全て同時
								patn_name = "全て同時";
							break;
							case 6:
								delays[k] = Math.abs(sv - j) + Math.abs(sh - i);//右下から左上へ
								patn_name = "右下から左上へ";
							break;
							case 7:
								delays[k] = 2 + Math.abs(split_v - j);//右から左へ
								patn_name = "右から左へ";
							break;
							case 8:
								delays[k] = (Math.abs(Math.abs(i - sh / 2) - sh) + Math.abs(Math.abs(j - sv / 2) - sv)) * 0.75;//外から中心へ、時間調整
								patn_name = "外から中心へ";
							break;
							case 9:
								delays[k] = Math.abs(j - sv / 2) + i * 0.01;//縦状、内から外2
								patn_name = "縦状、内から外";
							break;
							case 10:
								delays[k] = Math.abs(sh - i);//下から上へ
								patn_name = "下から上へ";
							break;
							case 11:
								delays[k] = 2 + i;//上から下へ
								patn_name = "上から下へ";
							break;
							case 12:
								delays[k] = (2 + i) + (Math.abs(Math.abs(j - sv / 2) - sv));//上から閉じるように
								patn_name = "上から閉じるように";
							break;
							case 13:
								delays[k] = (Math.floor(Math.random() * 20) + 1)/2;//ランダム
								patn_name = "ランダム";
							break;
							case 14:
								delays[k] = Math.abs(k - (split_h * split_v) / 2) / 2;//中から外に3
								patn_name = "中から外に";
							break;
							case 15:
								delays[k] = (split_h * split_v / 2 - Math.abs(i - k / 2)) / 2;//右から左に下からあがる
								patn_name = "右から左に下からあがる";
							break;
							case 16:
								delays[k] = Math.abs(j - (sv / 2)) - Math.abs(i - (sh / 2));//0番 中心からの位相ずれ
								patn_name = "中心からの位相ずれ";
							break;
							case 17:
								delays[k] = Math.abs((sh-sv)/2-(i-j));//だめ
								patn_name = "対角線状に外から内側に2";
							break;
							case 18:
								delays[k] = Math.abs(i + Math.abs(j - sv));//右上から左下に、斜め
								patn_name = "右上から左下に";
							break;
							case 19:
								delays[k] = Math.abs(j + Math.abs(i - sh));//左下から右上に
								patn_name = "左下から右上に";
							break;
							case 20:
								delays[k] = 2 + Math.abs(sh - i) + (Math.abs(Math.abs(j - sv / 2) - sv));//下から閉じるように
								patn_name = "下から閉じるように";
							break;
							default:
								delays[k]  = (i + j) * 0.5;//要素の展開TIMEパターン標準 左上から右下へ、斜め最適化
								patn_name = "デフォルト";
						}
					}
					
					//パターンを崩さない程度に要素に少し時間をくわえて散発的にする
					//設定は自由、値を大きくしないこと0.001-0.01位の範囲かな
					//パターン全て同時の場合はのぞく、同時にならなくなるから
					if (slicetype == 'slice' && startPattn != 5) {
							//delays[k] += (i * 0.002 + j * 0.001);
					}
					//delayは大きくしているので小さくする、条件により変化させる
					//分割を大きくしてもトータルで同じ位の時間で実行するよう修正
					//delays[k] *= 25 / split_total;
					
					//4door補正
					var d_v:Number = 1;
					//4doorの場合おくらせる/以外はそのまま
					if (slicetype == '4door') {d_v = 2;}
					
					//startPattnを使用しない、startPattn2使用/zipper以外
					if (door_flag && slicetype != 'zipper') {
						delays[k] = 1;
						if (startPattn2 == 0) {delays[k] = k * 2 * d_v;}
						if (startPattn2 == 1) {delays[k] = 1;}
						if (startPattn2 >= 2) {
							delays[k] = 1;
							if (flag3 == -1) {delays[k] = 2 * d_v;}
						}
					}
					//zipper startPattn2使用
					if (slicetype == 'zipper') {
						//上から交互
						if (startPattn2 == 0) {delays[k] = k + 1;}
						//上から同時
						if (startPattn2 == 1) {delays[k] = i + 1;}
						//中から開閉
						if (startPattn2 == 2) {delays[k] = Math.abs((i + 0.5) - split_h / 2) * 2;}
						//そのほか
						if (startPattn2 > 2) {delays[k] = (Math.abs(k - split_total / 2) / 2) + j;}
					}
					
					//bar標準delay補正
					if (slicetype == 'bar') {
						delays[k] = k * 2;
					}
					//IN
					if (show_mode == 'in') {
						//generation
						generation = delays[k];
						//スケール代入確定
						sliceBox.scaleX = scaleXs[k];
						sliceBox.scaleY = scaleYs[k];
					}
					//OUT
					if (show_mode == 'out') {
						//generation
						generation = delays[k];
						//スケール代入確定
						sliceBox.scaleX = 1;
						sliceBox.scaleY = 1;
					}
					//長いdelay遅延フラグ適用
					if (delay_flag == 1) {
						if (flag3 == -1) {delay_times[k] = delay_time;}
					}
					if (delay_flag == 5) {
						if (flag3 == -1) {delay_times[k] = delay_time / 2;}
					}
					
					//1-4分割は長いdelay遅延しない、効果がわるいので
					if (split_total < 5) { delay_times[k] = 0; }
					
					//sliceBox
					sliceBoxs[k] = sliceBox;
					//
					minusflag_x *= -1;
					//k横方向にカウント
					k ++;
					flag3 *= -1;
					k4 *= -1;
				}
				minusflag_y *= -1;
				k2 ++;
				if (even_v) {flag3 *=-1;}//偶数なら処理
			}
			
			//keepImage-BitmapDataの保存
			keepImage = mainImages[no];
			
			//delay配列を整える
			k = 0;
			var dd:Number = 0;
			//zipper-delays.tweentime調整
			if (slicetype == 'zipper') { delay_rate *= 1; tweentime *= 1.5; }
			//少数第3位までに修正
			delay_rate = Math.floor(int(delay_rate * 1000)) / 1000;
			
			//delay
			for (i = 0; i < split_h; ++ i){
				for (j = 0; j < split_v; ++ j) {
					dd = (delays[k] * delay_rate) + delay_times[k];
					delays[k] = dd;
					k++;
				}
			}
			
			var reverse_nm:String = "";
			//delay配列reverse反転/確率7分の2
			if (delay_revflg < 2) {
				delays.reverse();
				reverse_nm = "反転";
			}
			//free slice2 5以上でシャッフル/確率7分の1/
			if (slicetype == 'free' || slicetype == 'slice' && split_total > 24) {
				if (delay_revflg == 3) {
					shuffleArray(delays);
				}
			}
			
			//tweenのspeedをかえる/slice free
			if (!door_flag && speedflag == 1) { tweentime *= 0.5; }
			
			//確認
			//tf.text = slicetype + " " + delay_revflg + " / "+ startPattn + " START /No: " + random_start_no + " PATN: " + startPattn + "/ BN: " + split_total + " /パターン " + patn_name + " / " + reverse_nm;
			
			//IN
			if (show_mode == 'in') {
				//rotation
				//事前に回転させてある
				start_rotation = start_rotat;//開始回転角
				end_rotation = 0;//終了回転角
				//Tween/IN
				k = 0;
				//Loop2
				for (i = 0; i < split_h; ++ i){
					for (j = 0; j < split_v; ++ j) {
						//BetweenAS3 Tween/Listenerを追加
						//出現をdelayで制御 generation=g/Elastic.easeOut/Back.easeOut
						TweenMax.to(sliceBoxs[k], tweentime, { delay:delays[k], alpha:1, x:st_pos_x[k], y:st_pos_y[k], scaleX:1, scaleY:1, rotation:end_rotation, onComplete:delay_time_check } );
						//k
						k ++;
					}
				}
			}
			
			//ITweenを正確にするため分離して、必要な数値は配列で渡す
			//OUT/alpha:0
			if (show_mode == 'out') {
			
				//OUT BACK画像流し込み
				backImage.graphics.clear();
				backImage.graphics.beginBitmapFill(mainImages[show_no], null, false, false);
				backImage.graphics.drawRect(0, 0, boxWidth, boxHeight);
				backImage.graphics.endFill();
				
				//rotation
				//回転角度をめざす
				start_rotation = 0;//開始回転角
				end_rotation = start_rotat;//終了回転角
				end_alpha = 0;
				if (slicetype == '2door' || slicetype == '4door' || slicetype == 'plate' || slicetype == 'bar') {
					end_alpha = 1;
				}
				//Tween/
				k = 0;
				//Loop2
				for (i = 0; i < split_h; ++ i){
					for (j = 0; j < split_v; ++ j) {
						TweenMax.to(sliceBoxs[k], tweentime, { delay:delays[k], alpha:end_alpha, x:position_x[k], y:position_y[k], scaleX:scaleXs[k], scaleY:scaleYs[k], rotation:end_rotation , onComplete:delay_time_check } );
						//k
						k ++;
					}
				}
			}
		}

		//画像BitmapDataをMatrix分解
		private function clipping(bd:BitmapData, x1:int, y1:int, width:Number, height:Number, scale:Number):BitmapData
		{
			var matrix:Matrix = new Matrix();
			matrix.translate( -x1, -y1);
			matrix.scale(scale, scale);
			var destbd:BitmapData = new BitmapData(width * scale, height * scale, false);
			destbd.draw(bd, matrix);
			return destbd;
		}

		//TweenonComplete
		private function onFinishTween():void
		{
			//tweenの終了
			tweenflag  = false;
			//tf.text = slicetype + " / " + startPattn + " END/ delay_rate: " + delay_rate +" / IN-OUT: " + show_mode;
			
			//IN BACK画像流し込み/OUTは事前に処理済み
			if (show_mode == 'in') {
				backImage.graphics.clear();
				backImage.graphics.beginBitmapFill(mainImages[show_no], null, false, false);
				backImage.graphics.drawRect(0, 0, boxWidth, boxHeight);
				backImage.graphics.endFill();
			}

			//clip収容コンテナを削除/container.を記述しないとエラーになるので注意
			container.removeChild(clipContainer);
			//タイマースタート
			autoTimer.start();
			
		}
		
		//全てのdelayが終了したかチェック
		private function delay_time_check():void
		{
			//delay終了カウント
			twn_count ++;
			//分割合計に達したらTween終了処理に進む
			if (split_total == twn_count) {
				onFinishTween();
			}
		}
		
		//タイマーセット
		private function timer_set():void
		{
			autoTimer = new Timer(auto_time, 1);
			autoTimer.addEventListener(TimerEvent.TIMER_COMPLETE, completeTimerHandler);
		}
		//タイマーcomplete
		private function completeTimerHandler(e:TimerEvent):void {
			
			//タイマーは1回のみ有効
			autoTimer.stop();
			//次ぎ画像表示に進む 受け渡し現在表示番号のチェック
			//現在番号加算
			show_no ++;
			if (show_no > photomax - 1) { show_no = 0; }
			show_image(show_no);
		}
		
		//TextLayer
		private function openTextLayer(e:MouseEvent):void
		{
			textlayer.visible = true;
		}
		private function closeTextLayer(e:MouseEvent):void
		{
			textlayer.visible = false;
		}
		
		//ERROR
		private function ioErrorHandler(event:IOErrorEvent):void {
			//ERROR処理
			tf.text = "LOADING-EROOR";
			
			//画像が無いとその後の処理が出来なくなるのでダミーをいれて次ぎの処理にすすむ
			//特殊処理大きさ受け渡し、ダミーのBitmapDataを挿入する
			mainImages[countImage] = new BitmapData(image_W, image_H, false, 0x00000000);
			
			//画像ERRORならカウントをすすめて次ぎ画像ロードに進む
			countImage ++;
			loadImage();
		}
		
		//create-GradBox
		private function draw_grad_box(w:uint, h:uint, color1:uint, color2:uint):Sprite {
			var gb:Sprite = new Sprite();
			var colors:Array = [color1, color2];
			var alphas:Array = [1, 1];
			var ratios:Array = [0, 255];
			var matrix:Matrix = new Matrix();
			matrix.createGradientBox(w * 1.5, h * 1.5, 0, -w * 0.25, -h * 0.25);
			gb.graphics.beginGradientFill(GradientType.RADIAL, colors, alphas, ratios, matrix, SpreadMethod.PAD, InterpolationMethod.RGB, 0);
			gb.graphics.drawRect(0, 0, w, h);
			gb.graphics.endFill();
			//addChild(gb);
			return gb;
		}
		//create-box
		private function createSquare(x:Number, y:Number, width:Number, height:Number, color:Number, alpha:Number):Sprite
		{
			var s:Sprite = new Sprite();
			s.graphics.beginFill(color, alpha);
			s.graphics.drawRect(x, y, width, height);
			s.graphics.endFill();
			//addChild(s);
			return s;
		}
		//create-Roundbox
		private function createSquare2(x:Number, y:Number, width:Number, height:Number, color:Number, alpha:Number, round:Number):Sprite
		{
			var rs:Sprite = new Sprite();
			rs.graphics.beginFill(color, alpha);
			rs.graphics.drawRoundRect(x, y, width, height, round);
			rs.graphics.endFill();
			//addChild(rs);
			return rs;
		}
		//create-text
		private function createTextField(x:Number, y:Number, width:Number, height:Number):TextField
		{
			var result:TextField = new TextField();
			result.x = x;
			result.y = y;
			result.width = width;
			result.height = height;
			//addChild(result);
			return result;
		}
		
		//LOADING回転
		private function step(evt:Event):void
		{
			indicator.rotation = (indicator.rotation + 360 / stage.frameRate) % 360;
		}
		//FullScreenBtn CLICK
		private function fullClickHandler(e:MouseEvent):void
		{
			stage.displayState = (StageDisplayState.FULL_SCREEN==stage.displayState)?StageDisplayState.NORMAL:StageDisplayState.FULL_SCREEN
		}
		//FullScreenButton
		private function createFullScreenButton():Sprite
		{
			// 画面右下にボタン配置(YouTube風)
			var margin:Number = 10;
			var b:Sprite = new Sprite();
			b.graphics.lineStyle();
			b.graphics.beginFill(0x4d4d4d);
			b.graphics.drawRoundRect(7, 5, 21, 14, 3);
			b.graphics.beginFill(0xc1c1c1);
			b.graphics.drawRoundRect(8, 6, 10, 6, 2);
			b.graphics.endFill();
			b.buttonMode = true;
			return b;
		}
		//配列をランダムにソートしてシャッフル
		public function shuffleArray(array:Array):Array
		{
			return array.sort(function():int{return int(Math.random()*3)-1});
		}
	}
	
}

//LOADING-Shape
import flash.display.Shape;
class Indicator extends Shape
{
	public function Indicator()
	{
		var i:uint,
		cx:Number, cy:Number,
		numNeedles:uint = 12,
		innerR:Number = 7,
		outerR:Number = 5,
		cAngle:Number = -Math.PI / 2,
		nAngle:Number;

		nAngle = Math.PI * 2 / numNeedles;
		for (i=0; i<numNeedles; i++)
		{
			cAngle += nAngle;
			cx = Math.cos(cAngle) * innerR;
			cy = Math.sin(cAngle) * innerR;
			graphics.moveTo(cx, cy);
			
			cx = Math.cos(cAngle) * outerR;
			cy = Math.sin(cAngle) * outerR;
			graphics.lineStyle(2, 0xffffff, i/numNeedles);
			graphics.lineTo(cx, cy);
		}
	}
}

参考、出典

もっぱらAS3の参考はWonderflで収集しています。
以前、「画像を切り取って等間隔に並べて表示」と言う画像スライスの記事がありました。現在はありません。(探せない)、画像のスライス部分は、それを参考にして作りました。
それとシャッフルには、「1行でArrayをシャッフルする」、Loading MC には「AuroraCrowley」のスクリプトを引用しました。主要な記事はローカルに、書き換えて動作確認して、マトメテあります。


「画像を切り取って等間隔に並べて表示」は下記のようなコードでした。
(/code/9d0de6889dc7dec6555f1f0f618c08c84d42f13e)


//画像を切り取って等間隔に並べて表示
//ClippingImage
package
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Sprite;
	import flash.display.Loader;
	import flash.events.Event;
	import flash.geom.Point;
	import flash.geom.Rectangle;
	import flash.geom.Matrix;
	import flash.net.URLRequest;
	import flash.system.Security;
	import flash.system.LoaderContext;
	import caurina.transitions.Tweener;
	
	[SWF(width="465", height="465", frameRate="30", backgroundColor="0x000000")]
	
	public class ClippingImage extends Sprite
	{
		private const SIZE:int = 30;
		
		public function ClippingImage()
		{
			//Security.loadPolicyFile("http://farm1.static.flickr.com/crossdomain.xml");
			var loader:Loader = new Loader();
			loader.contentLoaderInfo.addEventListener(Event.INIT, init);
			//loader.load(new URLRequest("images/a301.jpg"), new LoaderContext(true));
			loader.load(new URLRequest("images/a301.jpg"));
		}
		
		private function init(event:Event):void
		{
			var loader:Loader = event.currentTarget.loader;
			var bd:BitmapData = new BitmapData(loader.width, loader.height, false);
			bd.draw(loader);
			
			var delay:Number = 0.1;
			for (var y:int = 0; y < bd.height; y += SIZE)
			{
				for (var x:int = 0; x < bd.width; x += SIZE)
				{
					var yy:int = (bd.height - 1 - y >= SIZE) ? SIZE : bd.height - 1 - y;
					var xx:int = (bd.width  - 1 - x >= SIZE) ? SIZE : bd.width  - 1 - x;
					
					if (xx <= 0 || yy <= 0) continue;
					
					var bitmap:Bitmap = new Bitmap(clipping(bd, x, y, xx, yy, 1.0));
					
					bitmap.x = (Math.random() >= 0.5) ? -100 : stage.stageWidth + 100;
					bitmap.y = (Math.random() >= 0.5) ? -100 : stage.stageHeight + 100;
					addChild(bitmap);
					
					Tweener.addTween(bitmap, { x:x * 1.1, y:y * 1.1, delay:delay, time:2 } );
					delay += 0.1;
				}
			}
		}
		
		private function clipping(bd:BitmapData, x1:int, y1:int, width:int, height:int, scale:Number):BitmapData
		{
			var matrix:Matrix = new Matrix();
			matrix.translate( -x1, -y1);
			matrix.scale(scale, scale);
			var destbd:BitmapData = new BitmapData(width * scale, height * scale, false);
			destbd.draw(bd, matrix);
			
			return destbd;
		}
	}
}

以上です。



[ この記事のURL ]


 

ブログ記事一覧



[1]