フィルタについて

import flash.filters.BlurFilter;
import flash.filters.BitmapFilterQuality;

// BlurFilter オブジェクトを作成する
var blur_filter:BlurFilter = new BlurFilter(
	4,	// 水平方向ぼかし量
	4,	// 垂直方向ぼかし量
	BitmapFilterQuality.LOW	// 品質
);

import flash.display.Sprite;
import flash.display.Graphics;
import flash.filters.BlurFilter;
import flash.filters.BitmapFilterQuality;

// ------------------------------------------------------------
// スプライトを作成
// ------------------------------------------------------------
var sprite:Sprite = new Sprite();

// ステージに配置
stage.addChild(sprite);

// 矩形を描画
var g:Graphics = sprite.graphics;
g.lineStyle (5, 0xAA0000, 1.0);
g.beginFill (0xFF4444, 1.0);
g.drawRect (-50,-50,100,100);

// 位置を設定
sprite.x = 100;
sprite.y = 100;

// ------------------------------------------------------------
// BlurFilter オブジェクトを作成する
// ------------------------------------------------------------
var blur_filter:BlurFilter = new BlurFilter();

// ------------------------------------------------------------
// プロパティを設定する
// ------------------------------------------------------------
blur_filter.blurX = 10;		// 水平方向ぼかし量
blur_filter.blurY = 10;		// 垂直方向ぼかし量
blur_filter.quality = BitmapFilterQuality.LOW;	// 品質

// ------------------------------------------------------------
// スプライトにフィルタを適用する
// ------------------------------------------------------------
sprite.filters = [blur_filter];

import flash.filters.BevelFilter;
import flash.filters.BitmapFilterQuality;
import flash.filters.BitmapFilterType;

// BevelFilter オブジェクトを作成する
var bevel_filter:BevelFilter = new BevelFilter(
	4,		// オフセットの距離
	45,		// 角度
	0xFF0000,	// ハイライトカラー
	1.0,		// ハイライトカラーの透明度
	0x0000FF,	// シャドウカラーを指定
	1.0,		// シャドウカラーの透明度
	4,		// 水平方向ぼかし量
	4,		// 垂直方向ぼかし量
	1.0,		// インプリントやスプレッドの長さ
	BitmapFilterQuality.LOW,	// フィルタを適用する回数
	BitmapFilterType.INNER,		// ベベルの種類
	false		// ノックアウト効果の有無
);

import flash.display.Sprite;
import flash.display.Graphics;
import flash.filters.BevelFilter;
import flash.filters.BitmapFilterQuality;
import flash.filters.BitmapFilterType;

// ------------------------------------------------------------
// スプライトを作成
// ------------------------------------------------------------
var sprite:Sprite = new Sprite();

// ステージに配置
stage.addChild(sprite);

// 矩形を描画
var g:Graphics = sprite.graphics;
g.lineStyle (5, 0xAA0000, 1.0);
g.beginFill (0xFF4444, 1.0);
g.drawRect (-50,-50,100,100);

// 位置を設定
sprite.x = 100;
sprite.y = 100;

// ------------------------------------------------------------
// BevelFilter オブジェクトを作成する
// ------------------------------------------------------------
var bevel_filter:BevelFilter = new BevelFilter();

// ------------------------------------------------------------
// プロパティを設定する
// ------------------------------------------------------------
bevel_filter.distance = 4;			// オフセットの距離
bevel_filter.angle = 45.0;			// 角度
bevel_filter.highlightColor = 0xFFC0C0;	// ハイライトカラー
bevel_filter.highlightAlpha = 1.0;		// ハイライトカラーの透明度
bevel_filter.shadowColor = 0x000040;		// シャドウカラーを指定
bevel_filter.shadowAlpha = 1.0;		// シャドウカラーの透明度
bevel_filter.blurX = 10;			// 水平方向ぼかし量
bevel_filter.blurY = 10;			// 垂直方向ぼかし量
bevel_filter.strength = 5;			// インプリントやスプレッドの長さ
bevel_filter.quality = BitmapFilterQuality.MEDIUM;	// フィルタを適用する回数
bevel_filter.type = BitmapFilterType.INNER;		// ベベルの種類
bevel_filter.knockout = false;			// ノックアウト効果の有無

// ------------------------------------------------------------
// スプライトにフィルタを適用する
// ------------------------------------------------------------
sprite.filters = [bevel_filter];

import flash.filters.GradientBevelFilter;
import flash.filters.BitmapFilterQuality;
import flash.filters.BitmapFilterType;

// ------------------------------------------------------------
// グラデーション情報
// ------------------------------------------------------------
var colors:Array = [ 0x000000, 0x000000, 0x808080, 0xFFFFFF, 0xFFFFFF ];
var alphas:Array = [      1.0,      0.0,      0.0,      0.0,      1.0 ];
var ratios:Array = [        0,      127,      128,      129,      255 ];

// ------------------------------------------------------------
// GradientBevelFilter オブジェクトを作成する
// ------------------------------------------------------------
var gradient_bevel_filter:GradientBevelFilter = new GradientBevelFilter(
	4,		// オフセットの距離
	45,		// 角度
	colors,		// グラデーションのカラー
	alphas,		// グラデーションの透明度
	ratios,		// グラデーションの配分
	4,		// 水平方向ぼかし量
	4,		// 垂直方向ぼかし量
	1.0,		// インプリントやスプレッドの長さ
	BitmapFilterQuality.LOW,	// フィルタを適用する回数
	BitmapFilterType.INNER,		// ベベルの種類
	false		// ノックアウト効果の有無
);

var highlight_color:uint = 0xFF0000;	// ハイライトカラー
var shadow_color:uint = 0x0000FF;	// シャドウカラー
var highlight_alpha:Number = 1.0;	// ハイライトの透明度
var shadow_alpha:Number = 1.0;		// シャドウの透明度

// グラデーション情報
var colors:Array = [ shadow_color , shadow_color , 0 , highlight_color , highlight_color ];
var alphas:Array = [ shadow_alpha , 0.0 , 0.0 , 0.0 , highlight_alpha];
var ratios:Array = [ 0 , 127 , 128 , 129 , 255];

import flash.display.Sprite;
import flash.display.Graphics;
import flash.filters.GradientBevelFilter;
import flash.filters.BitmapFilterQuality;
import flash.filters.BitmapFilterType;

// ------------------------------------------------------------
// スプライトを作成
// ------------------------------------------------------------
var sprite:Sprite = new Sprite();

// ステージに配置
stage.addChild(sprite);

// 矩形を描画
var g:Graphics = sprite.graphics;
g.beginFill (0xFF4444, 1.0);
g.drawRect (-50,-50,100,100);

// 位置を設定
sprite.x = 100;
sprite.y = 100;

// ------------------------------------------------------------
// GradientBevelFilter オブジェクトを作成する
// ------------------------------------------------------------
var gradient_bevel_filter:GradientBevelFilter = new GradientBevelFilter();

// ------------------------------------------------------------
// グラデーション情報
// ------------------------------------------------------------
var colors:Array = [ 0x000000, 0x000000, 0x808080, 0xFFFFFF, 0xFFFFFF ];
var alphas:Array = [      1.0,      0.0,      0.0,      0.0,      1.0 ];
var ratios:Array = [        0,      127,      128,      129,      255 ];

// ------------------------------------------------------------
// プロパティを設定する
// ------------------------------------------------------------
gradient_bevel_filter.distance = 4;		// オフセットの距離
gradient_bevel_filter.angle = 45.0;		// 角度
gradient_bevel_filter.colors = colors;		// グラデーションのカラー
gradient_bevel_filter.alphas = alphas;		// グラデーションの透明度
gradient_bevel_filter.ratios = ratios;		// グラデーションの配分
gradient_bevel_filter.blurX = 10;		// 水平方向ぼかし量
gradient_bevel_filter.blurY = 10;		// 垂直方向ぼかし量
gradient_bevel_filter.strength = 1;		// インプリントやスプレッドの長さ
gradient_bevel_filter.quality = BitmapFilterQuality.LOW;	// フィルタを適用する回数
gradient_bevel_filter.type = BitmapFilterType.INNER;		// ベベルの種類
gradient_bevel_filter.knockout = false;	// ノックアウト効果の有無

// ------------------------------------------------------------
// スプライトにフィルタを適用する
// ------------------------------------------------------------
sprite.filters = [gradient_bevel_filter];

import flash.filters.GlowFilter;
import flash.filters.BitmapFilterQuality;

// ------------------------------------------------------------
// GlowFilter オブジェクトを作成する
// ------------------------------------------------------------
var glow_filter:GlowFilter = new GlowFilter(
	0xFF0000,	// カラー
	1.0,		// 透明度
	6,		// 水平方向ぼかし量
	6,		// 垂直方向ぼかし量
	2.0,		// インプリントやスプレッドの長さ
	BitmapFilterQuality.LOW,	// フィルタを適用する回数
	false,		// 内部グローを使用するか？
	false		// ノックアウト効果の有無
);

import flash.display.Sprite;
import flash.display.Graphics;
import flash.filters.GlowFilter;
import flash.filters.BitmapFilterQuality;

// ------------------------------------------------------------
// スプライトを作成
// ------------------------------------------------------------
var sprite:Sprite = new Sprite();

// ステージに配置
stage.addChild(sprite);

// 矩形を描画
var g:Graphics = sprite.graphics;
g.beginFill (0xFF4444, 1.0);
g.drawRect (-50,-50,100,100);

// 位置を設定
sprite.x = 100;
sprite.y = 100;

// ------------------------------------------------------------
// GlowFilter オブジェクトを作成する
// ------------------------------------------------------------
var glow_filter:GlowFilter = new GlowFilter();

// ------------------------------------------------------------
// プロパティを設定する
// ------------------------------------------------------------
glow_filter.color = 0xFF0000;	// カラー
glow_filter.alpha = 1.0;	// 透明度
glow_filter.blurX = 10;		// 水平方向ぼかし量
glow_filter.blurY = 10;		// 垂直方向ぼかし量
glow_filter.strength = 1;	// インプリントやスプレッドの長さ
glow_filter.quality = BitmapFilterQuality.LOW;	// フィルタを適用する回数
glow_filter.inner = false;	// 内部グローを使用するか？
glow_filter.knockout = false;	// ノックアウト効果の有無

// ------------------------------------------------------------
// スプライトにフィルタを適用する
// ------------------------------------------------------------
sprite.filters = [glow_filter];

import flash.filters.GradientGlowFilter;
import flash.filters.BitmapFilterQuality;
import flash.filters.BitmapFilterType;

// ------------------------------------------------------------
// グラデーション情報
// ------------------------------------------------------------
var colors:Array = [ 0x0000FF, 0x00FF00, 0xFF0000 ];
var alphas:Array = [      0.0,      1.0,      0.0 ];
var ratios:Array = [        0,      128,      255 ];

// ------------------------------------------------------------
// GradientGlowFilter オブジェクトを作成する
// ------------------------------------------------------------
var gradient_glow_filter:GradientGlowFilter = new GradientGlowFilter(
	0,		// オフセットの距離
	0,		// 角度
	colors,		// グラデーションのカラー
	alphas,		// グラデーションの透明度
	ratios,		// グラデーションの配分
	4,		// 水平方向ぼかし量
	4,		// 垂直方向ぼかし量
	1.0,		// インプリントやスプレッドの長さ
	BitmapFilterQuality.LOW,	// フィルタを適用する回数
	BitmapFilterType.INNER,		// グローの種類
	false		// ノックアウト効果の有無
);

var color:uint = 0xFF0000;	// カラー
var alpha:Number = 1.0;		// 透明度

// グラデーション情報
var colors:Array = [ color , color ];
var alphas:Array = [ alpha , 0.0 ];
var ratios:Array = [ 0 , 255 ];

var color:uint = 0xFF0000;	// カラー
var alpha:Number = 1.0;		// 透明度

// グラデーション情報
var colors:Array = [ color , color ];
var alphas:Array = [ 0.0 , alpha ];
var ratios:Array = [ 0 , 255 ];

import flash.display.Sprite;
import flash.display.Graphics;
import flash.filters.GradientGlowFilter;
import flash.filters.BitmapFilterQuality;
import flash.filters.BitmapFilterType;

// ------------------------------------------------------------
// スプライトを作成
// ------------------------------------------------------------
var sprite:Sprite = new Sprite();

// ステージに配置
stage.addChild(sprite);

// 矩形を描画
var g:Graphics = sprite.graphics;
g.beginFill (0x808080, 1.0);
g.drawRect (-50,-50,100,100);

// 位置を設定
sprite.x = 100;
sprite.y = 100;

// ------------------------------------------------------------
// GradientGlowFilter オブジェクトを作成する
// ------------------------------------------------------------
var gradient_glow_filter:GradientGlowFilter = new GradientGlowFilter();

// ------------------------------------------------------------
// グラデーション情報
// ------------------------------------------------------------
var colors:Array = [ 0x0000FF, 0x0000FF, 0xFF0000, 0xFF0000 ];
var alphas:Array = [      0.0,      1.0,      1.0,      0.0 ];
var ratios:Array = [        0,      128,      129,      255 ];

// ------------------------------------------------------------
// プロパティを設定する
// ------------------------------------------------------------
gradient_glow_filter.distance = 0;	// オフセットの距離
gradient_glow_filter.angle = 0;		// 角度
gradient_glow_filter.colors = colors;	// グラデーションのカラー
gradient_glow_filter.alphas = alphas;	// グラデーションの透明度
gradient_glow_filter.ratios = ratios;	// グラデーションの配分
gradient_glow_filter.blurX = 32;	// 水平方向ぼかし量
gradient_glow_filter.blurY = 32;	// 垂直方向ぼかし量
gradient_glow_filter.strength = 1;	// インプリントやスプレッドの長さ
gradient_glow_filter.quality = BitmapFilterQuality.LOW;	// フィルタを適用する回数
gradient_glow_filter.type = BitmapFilterType.FULL;		// グローの種類
gradient_glow_filter.knockout = false;	// ノックアウト効果の有無

// ------------------------------------------------------------
// スプライトにフィルタを適用する
// ------------------------------------------------------------
sprite.filters = [gradient_glow_filter];

import flash.filters.DropShadowFilter;
import flash.filters.BitmapFilterQuality;

// ------------------------------------------------------------
// DropShadowFilter オブジェクトを作成する
// ------------------------------------------------------------
var drop_shadow_filter:DropShadowFilter = new DropShadowFilter(
	4,		// オフセットの距離
	45,		// 角度
	0x000000,	// カラー
	1.0,		// 透明度
	4,		// 水平方向ぼかし量
	4,		// 垂直方向ぼかし量
	1.0,		// インプリントやスプレッドの長さ
	BitmapFilterQuality.LOW,	// フィルタを適用する回数
	false,		// 内部ドロップシャドウを使用するか？
	false,		// ノックアウト効果の有無
	false		// オブジェクトを描画しないか？
);

import flash.display.Sprite;
import flash.display.Graphics;
import flash.filters.DropShadowFilter;
import flash.filters.BitmapFilterQuality;

// ------------------------------------------------------------
// スプライトを作成
// ------------------------------------------------------------
var sprite:Sprite = new Sprite();

// ステージに配置
stage.addChild(sprite);

// 矩形を描画
var g:Graphics = sprite.graphics;
g.beginFill (0xFF4444, 1.0);
g.drawRect (-50,-50,100,100);

// 位置を設定
sprite.x = 100;
sprite.y = 100;

// ------------------------------------------------------------
// DropShadowFilter オブジェクトを作成する
// ------------------------------------------------------------
var drop_shadow_filter:DropShadowFilter = new DropShadowFilter();

// ------------------------------------------------------------
// プロパティを設定する
// ------------------------------------------------------------
drop_shadow_filter.distance = 10;	// オフセットの距離
drop_shadow_filter.angle = 45;		// 角度
drop_shadow_filter.color = 0x000000;	// カラー
drop_shadow_filter.alpha = 0.65;	// 透明度
drop_shadow_filter.blurX = 5;		// 水平方向ぼかし量
drop_shadow_filter.blurY = 5;		// 垂直方向ぼかし量
drop_shadow_filter.strength = 1;	// インプリントやスプレッドの長さ
drop_shadow_filter.quality = BitmapFilterQuality.LOW;	// フィルタを適用する回数
drop_shadow_filter.inner = false;	// 内部ドロップシャドウを使用するか？
drop_shadow_filter.knockout = false;	// ノックアウト効果の有無
drop_shadow_filter.hideObject = false;	// オブジェクトを描画しないか？

// ------------------------------------------------------------
// スプライトにフィルタを適用する
// ------------------------------------------------------------
sprite.filters = [drop_shadow_filter];

 0   1   2   3   4
 5   6   7   8   9
10  11  12  13  14
15  16  17  18  19

新しい赤色 = 現在の赤色 * [ 0] + 現在の緑色 * [ 1] + 現在の青色 * [ 2] + 現在の透過 * [ 3] + [ 4];
新しい緑色 = 現在の赤色 * [ 5] + 現在の緑色 * [ 6] + 現在の青色 * [ 7] + 現在の透過 * [ 8] + [ 9];
新しい青色 = 現在の赤色 * [10] + 現在の緑色 * [11] + 現在の青色 * [12] + 現在の透過 * [13] + [14];
新しい透過 = 現在の赤色 * [15] + 現在の緑色 * [16] + 現在の青色 * [17] + 現在の透過 * [18] + [19];

// カラーマトリックス
var color_matrix:Array = [
	1.0, 0.0, 0.0, 0.0, 0.0,
	0.0, 1.0, 0.0, 0.0, 0.0,
	0.0, 0.0, 1.0, 0.0, 0.0,
	0.0, 0.0, 0.0, 1.0, 0.0
];

// カラーマトリックス
var color_matrix:Array = [
	0.0, 0.0, 1.0, 0.0, 0.0,
	1.0, 0.0, 0.0, 0.0, 0.0,
	0.0, 1.0, 0.0, 0.0, 0.0,
	0.0, 0.0, 0.0, 1.0, 0.0
];

import flash.display.Sprite;
import flash.display.Graphics;
import flash.filters.ColorMatrixFilter;

// ------------------------------------------------------------
// スプライトを作成
// ------------------------------------------------------------
var sprite:Sprite = new Sprite();

// ステージに配置
stage.addChild(sprite);

// 矩形を描画
var g:Graphics = sprite.graphics;
g.lineStyle (5, 0xAA0000, 1.0);
g.beginFill (0xFF8844, 1.0);
g.drawRect (-50,-50,100,100);

// 位置を設定
sprite.x = 100;
sprite.y = 100;

// ------------------------------------------------------------
// カラーマトリックス（モノクロ）
// ------------------------------------------------------------
var color_matrix:Array = [
	1/3, 1/3, 1/3, 0.0, 0.0,
	1/3, 1/3, 1/3, 0.0, 0.0,
	1/3, 1/3, 1/3, 0.0, 0.0,
	0.0, 0.0, 0.0, 1.0, 0.0
];

// ------------------------------------------------------------
// ColorMatrixFilter オブジェクトを作成する
// ------------------------------------------------------------
var color_matrix_filter:ColorMatrixFilter = new ColorMatrixFilter(color_matrix);

// ------------------------------------------------------------
// スプライトにフィルタを適用する
// ------------------------------------------------------------
sprite.filters = [color_matrix_filter];

import flash.filters.ColorMatrixFilter;

// ------------------------------------------------------------
// カラーマトリックスを作成
// ------------------------------------------------------------
var color_matrix:Array = [
	1/3, 1/3, 1/3, 0.0, 0.0,
	1/3, 1/3, 1/3, 0.0, 0.0,
	1/3, 1/3, 1/3, 0.0, 0.0,
	0.0, 0.0, 0.0, 1.0, 0.0
];

// ------------------------------------------------------------
// ColorMatrixFilter オブジェクトを作成する
// ------------------------------------------------------------
var color_matrix_filter:ColorMatrixFilter = new ColorMatrixFilter(color_matrix);

import flash.filters.ColorMatrixFilter;

// ------------------------------------------------------------
// ColorMatrixFilter オブジェクトを作成する
// ------------------------------------------------------------
var color_matrix_filter:ColorMatrixFilter = new ColorMatrixFilter();

(function():void{

	// ------------------------------------------------------------
	// 明度 (-1.0 〜 1.0)
	// ------------------------------------------------------------
	var BRIGHTNESS:Number = 1.0;

	// ------------------------------------------------------------
	// カラー調整の明度を再現
	// ------------------------------------------------------------
	var a:Number = 100 * BRIGHTNESS;

	// ------------------------------------------------------------
	// カラーマトリックスを作成
	// ------------------------------------------------------------
	color_matrix_filter.matrix = [
		1, 0, 0, 0, a,
		0, 1, 0, 0, a,
		0, 0, 1, 0, a,
		0, 0, 0, 1, 0
	];

})();

import flash.filters.ColorMatrixFilter;

// ------------------------------------------------------------
// ColorMatrixFilter オブジェクトを作成する
// ------------------------------------------------------------
var color_matrix_filter:ColorMatrixFilter = new ColorMatrixFilter();

(function():void{

	// ------------------------------------------------------------
	// 彩度 (-1.0 〜 1.0)
	// ------------------------------------------------------------
	var COLORFULNESS:Number = 1.0;

	// ------------------------------------------------------------
	// カラー調整の彩度を再現
	// ------------------------------------------------------------
	var a:Number,b:Number,c:Number,f:Number,g:Number,m:Number;
	if(COLORFULNESS >= 0){
		a = ( 3.0742 - 1.0) * COLORFULNESS + 1.0;
		b = (-1.8282 - 0.0) * COLORFULNESS + 0.0;
		c = (-0.2460 - 0.0) * COLORFULNESS + 0.0;
		f = (-0.9258 - 0.0) * COLORFULNESS + 0.0;
		g = ( 2.1718 - 1.0) * COLORFULNESS + 1.0;
		m = ( 3.7540 - 1.0) * COLORFULNESS + 1.0;
	}else{
		a = (1.0 - 0.3086) * COLORFULNESS + 1.0;
		b = (0.0 - 0.6094) * COLORFULNESS + 0.0;
		c = (0.0 - 0.0820) * COLORFULNESS + 0.0;
		f = (0.0 - 0.3086) * COLORFULNESS + 0.0;
		g = (1.0 - 0.6094) * COLORFULNESS + 1.0;
		m = (1.0 - 0.0820) * COLORFULNESS + 1.0;
	}

	// ------------------------------------------------------------
	// カラーマトリックスを作成
	// ------------------------------------------------------------
	color_matrix_filter.matrix = [
		a, b, c, 0, 0,
		f, g, c, 0, 0,
		f, b, m, 0, 0,
		0, 0, 0, 1, 0
	];

})();

 0   1   2
 3   4   5
 6   7   8

 0   1   2   3   4
 5   6   7   8   9
10  11  12  13  14
15  16  17  18  19

新しい色 = (
  (相対位置 {-1,-2} の色) * [ 0] + (相対位置 {0,-2} の色) * [ 1] + (相対位置 {+1,-2} の色) * [ 2] + 
  (相対位置 {-1,-1} の色) * [ 3] + (相対位置 {0,-1} の色) * [ 4] + (相対位置 {+1,-1} の色) * [ 5] + 
  (相対位置 {-1, 0} の色) * [ 6] + (相対位置 {0, 0} の色) * [ 7] + (相対位置 {+1, 0} の色) * [ 8] + 
  (相対位置 {-1,+1} の色) * [ 9] + (相対位置 {0,+1} の色) * [10] + (相対位置 {+1,+1} の色) * [11] + 
  (相対位置 {-1,+2} の色) * [12] + (相対位置 {0,+2} の色) * [13] + (相対位置 {+1,+2} の色) * [14]
 ) / divisor + bias;

新しい色 = (
  (相対位置 {-2,-3} の色) * [ 0] + (相対位置 {-1,-3} の色) * [ 1] + (相対位置 {0,-3} の色) * [ 2] + (相対位置 {+1,-3} の色) * [ 3] + 
  (相対位置 {-2,-2} の色) * [ 4] + (相対位置 {-1,-2} の色) * [ 5] + (相対位置 {0,-2} の色) * [ 6] + (相対位置 {+1,-2} の色) * [ 7] + 
  (相対位置 {-2,-1} の色) * [ 8] + (相対位置 {-1,-1} の色) * [ 9] + (相対位置 {0,-1} の色) * [10] + (相対位置 {+1,-1} の色) * [11] + 
  (相対位置 {-2, 0} の色) * [12] + (相対位置 {-1, 0} の色) * [13] + (相対位置 {0, 0} の色) * [14] + (相対位置 {+1, 0} の色) * [15] + 
  (相対位置 {-2,+1} の色) * [16] + (相対位置 {-1,+1} の色) * [17] + (相対位置 {0,+1} の色) * [18] + (相対位置 {+1,+1} の色) * [19] + 
  (相対位置 {-2,+2} の色) * [20] + (相対位置 {-1,+2} の色) * [21] + (相対位置 {0,+2} の色) * [22] + (相対位置 {+1,+2} の色) * [13]
 ) / divisor + bias;

import flash.display.Sprite;
import flash.display.Graphics;
import flash.filters.ConvolutionFilter;

// ------------------------------------------------------------
// スプライトを作成
// ------------------------------------------------------------
var sprite:Sprite = new Sprite();

// ステージに配置
stage.addChild(sprite);

// 矩形を描画
var g:Graphics = sprite.graphics;
g.lineStyle (0, 0xAA0000, 1.0);
g.beginFill (0xFF6666, 1.0);
g.drawRect (-50,-50,100,100);
g.beginFill (0xFF8844, 100);
g.moveTo ( -40 ,   0 );
g.lineTo (   0 ,  40 );
g.lineTo (  40 ,   0 );
g.lineTo (   0 , -40 );
g.endFill();

// 位置を設定
sprite.x = 100;
sprite.y = 100;

// ------------------------------------------------------------
// 畳み込み行列（簡易ぼかし）
// ------------------------------------------------------------
var convolution_matrix:Array = [
	0, 1, 0,
	1, 1, 1,
	0, 1, 0
];

// ------------------------------------------------------------
// ConvolutionFilter オブジェクトを作成する
// ------------------------------------------------------------
var convolution_filter:ConvolutionFilter = new ConvolutionFilter();

// ------------------------------------------------------------
// プロパティを設定する
// ------------------------------------------------------------
convolution_filter.matrixX = 3;			// 畳み込み行列の列数
convolution_filter.matrixY = 3;			// 畳み込み行列の行数
convolution_filter.matrix = convolution_matrix;	// 畳み込み行列
convolution_filter.divisor = 5;		// 畳み込み演算に作用する除算成分
convolution_filter.bias = 0;			// 畳み込み演算に作用する加算成分
convolution_filter.preserveAlpha = true;	// 透過チャンネルも畳み込み演算対象に含める
convolution_filter.clamp = true;		// ソース範囲外の色の取得方法
convolution_filter.color = 0xFF0000;		// ソース範囲外のカラー
convolution_filter.alpha = 1.0;			// ソース範囲外の透明度

// ------------------------------------------------------------
// スプライトにフィルタを適用する
// ------------------------------------------------------------
sprite.filters = [convolution_filter];

import flash.filters.ConvolutionFilter;

// ------------------------------------------------------------
// 畳み込み行列（弱ぼかし）
// ------------------------------------------------------------
var convolution_matrix:Array = [
	0.05090, 0.12381, 0.05090,
	0.12381, 0.30116, 0.12381,
	0.05090, 0.12381, 0.05090
];

// ------------------------------------------------------------
// ConvolutionFilter オブジェクトを作成する
// ------------------------------------------------------------
var convolution_filter:ConvolutionFilter = new ConvolutionFilter(
	3,	// 畳み込み行列の列数
	3,	// 畳み込み行列の行数
	convolution_matrix,	// 畳み込み行列
	1,	// 畳み込み演算に作用する除算成分
	0	// 畳み込み演算に作用する加算成分
);

import flash.filters.ConvolutionFilter;

// ------------------------------------------------------------
// ConvolutionFilter オブジェクトを作成する
// ------------------------------------------------------------
var convolution_filter:ConvolutionFilter = new ConvolutionFilter();

(function():void{

	// ------------------------------------------------------------
	// ガウスぼかし用の設定
	// ------------------------------------------------------------
	var BLUR_RADIUS:Number = 2.0;	// ガウス半径
	var BLUR_QUALITY:Number = 1;	// 品質 (0 〜 )
	var BLUR_SIGMA:Number = 0.8;	// シグマ値

	// ------------------------------------------------------------
	// 畳み込み行列（ガウスぼかし）
	// ------------------------------------------------------------
	var size:Number = (Math.floor(BLUR_RADIUS) + BLUR_QUALITY) * 2 + 1;
	var matrix:Array = new Array();
	var divisor:Number = 0.0;

	var i:Number,j:Number;
	var cx:Number = size * 0.5 - 0.5;
	var cy:Number = size * 0.5 - 0.5;
	var vx:Number,vy:Number;
	var v:Number;

	for(j=0;j < size;j++){
		vy = j - cy;

		for(i=0;i < size;i++){
			vx = i - cx;
			v = Math.sqrt(vx * vx + vy * vy) / BLUR_RADIUS;
			v = (1 / Math.sqrt(2 * Math.PI * BLUR_SIGMA)) * Math.exp(-(v * v / (2 * BLUR_SIGMA * BLUR_SIGMA)));
			matrix[size * j + i] = v;
			divisor += v;
		}
	}

	// ------------------------------------------------------------
	// プロパティを設定する
	// ------------------------------------------------------------
	convolution_filter.matrixX = size;	// 畳み込み行列の列数
	convolution_filter.matrixY = size;	// 畳み込み行列の行数
	convolution_filter.matrix = matrix;	// 畳み込み行列
	convolution_filter.divisor = divisor;	// 畳み込み演算に作用する除算成分
	convolution_filter.bias = 0;		// 畳み込み演算に作用する加算成分

})();

import flash.filters.ConvolutionFilter;

// ------------------------------------------------------------
// ConvolutionFilter オブジェクトを作成する
// ------------------------------------------------------------
var convolution_filter:ConvolutionFilter = new ConvolutionFilter();

(function():void{

	// ------------------------------------------------------------
	// シャープ強度（0.0 〜 1.0）
	// ------------------------------------------------------------
	var SHARPNESS:Number = 0.75;

	// ------------------------------------------------------------
	// 畳み込み行列（シャープ）
	// ------------------------------------------------------------
	var b:Number = -1.0 * SHARPNESS;
	var e:Number = 4;
	var divisor:Number = b * 4 + e;
	var matrix:Array = [
		0, b, 0,
		b, e, b,
		0, b, 0
	];

	// ------------------------------------------------------------
	// プロパティを設定する
	// ------------------------------------------------------------
	convolution_filter.matrixX = 3;	// 畳み込み行列の列数
	convolution_filter.matrixY = 3;	// 畳み込み行列の行数
	convolution_filter.matrix = matrix;	// 畳み込み行列
	convolution_filter.divisor = divisor;	// 畳み込み演算に作用する除算成分
	convolution_filter.bias = 0;		// 畳み込み演算に作用する加算成分

})();

import flash.filters.ConvolutionFilter;

// ------------------------------------------------------------
// ConvolutionFilter オブジェクトを作成する
// ------------------------------------------------------------
var convolution_filter:ConvolutionFilter = new ConvolutionFilter();

(function():void{

	// ------------------------------------------------------------
	// エンボス強度（0.0 〜 1.0）
	// ------------------------------------------------------------
	var EMBOSS:Number = 0.75;

	// ------------------------------------------------------------
	// 畳み込み行列（エンボス）
	// ------------------------------------------------------------
	var a:Number = 2.0 * EMBOSS;
	var b:Number = 1.0 * EMBOSS;
	var e:Number = 1.0 - EMBOSS;
	var divisor:Number = e;
	var matrix:Array = [
		a,  b,  0,
		b,  e, -b,
		0, -b, -a
	];

	// ------------------------------------------------------------
	// プロパティを設定する
	// ------------------------------------------------------------
	convolution_filter.matrixX = 3;	// 畳み込み行列の列数
	convolution_filter.matrixY = 3;	// 畳み込み行列の行数
	convolution_filter.matrix = matrix;	// 畳み込み行列
	convolution_filter.divisor = divisor;	// 畳み込み演算に作用する除算成分
	convolution_filter.bias = 0;		// 畳み込み演算に作用する加算成分

})();

(相対 x 座標) = (マップの赤色 - 128) * sacleX / 256.0;
(相対 y 座標) = (マップの青色 - 128) * sacleY / 256.0;

import flash.geom.Point;
import flash.geom.Rectangle;
import flash.geom.Matrix;
import flash.display.Sprite;
import flash.display.Graphics;
import flash.display.GradientType;
import flash.display.BitmapData;
import flash.display.BitmapDataChannel;
import flash.filters.DisplacementMapFilter;
import flash.filters.DisplacementMapFilterMode;
import flash.events.Event;
import flash.events.MouseEvent;

// ------------------------------------------------------------
// 親スプライトを作成
// ------------------------------------------------------------
var sprite_parent:Sprite = (function():Sprite{

	// ------------------------------------------------------------
	// スプライトを作成
	// ------------------------------------------------------------
	var sprite:Sprite = new Sprite();

	// ステージに配置
	stage.addChild(sprite);

	// ------------------------------------------------------------
	// 描画矩形範囲を設定
	// ------------------------------------------------------------
	sprite.scrollRect = new Rectangle(0,0,stage.stageWidth,stage.stageHeight);

	return sprite;
})();

// ------------------------------------------------------------
// 子スプライトを作成
// ------------------------------------------------------------
(function():void{

	// ------------------------------------------------------------
	// 子スプライトを作成
	// ------------------------------------------------------------
	var sprite_child:Sprite = new Sprite();

	// 親スプライトに配置
	sprite_parent.addChild(sprite_child);

	// 矩形を描画
	var mtx:Matrix = new Matrix(200/1638.4,0,0,1,0,0);
	var g:Graphics = sprite_child.graphics;
	g.lineStyle (5, 0x505050, 1.0);
	g.beginGradientFill ( GradientType.LINEAR , [0xFF8080,0x8080FF] , [1.0,1.0] , [0,255] , mtx);
	g.drawRect (-100,-50,200,100);

	// 位置を設定
	sprite_child.x = 150;
	sprite_child.y = 150;

	// ------------------------------------------------------------
	// 毎フレーム実行されるイベント
	// ------------------------------------------------------------
	sprite_child.addEventListener(Event.ENTER_FRAME,function(e:Event):void{
		// 少しずつ回転
		sprite_child.rotation += 1.0;
	});

})();

// ------------------------------------------------------------
// マップ用ビットマップデータを作成する
// ------------------------------------------------------------
var red :uint = 0x80 + 8;
var blue:uint = 0x80 + 8;
var map_bmp:BitmapData = new BitmapData( 100 , 100 , false , (red << 16)|(blue << 0) );

// ------------------------------------------------------------
// マップ用座標を作成する
// ------------------------------------------------------------
var map_pos:Point = new Point(0,0);

// ------------------------------------------------------------
// DisplacementMapFilter オブジェクトを作成する
// ------------------------------------------------------------
var displacement_map_filter:DisplacementMapFilter = new DisplacementMapFilter();

// ------------------------------------------------------------
// プロパティを設定する
// ------------------------------------------------------------
displacement_map_filter.mapBitmap = map_bmp;	// マップ用ビットマップデータ
displacement_map_filter.mapPoint = map_pos;	// マップの座標
displacement_map_filter.componentX = BitmapDataChannel.RED;	// 水平方向カラーチャンネル
displacement_map_filter.componentY = BitmapDataChannel.BLUE;	// 垂直方向カラーチャンネル
displacement_map_filter.scaleX = 256;		// 水平方向のソース参照拡大率
displacement_map_filter.scaleY = 256;		// 垂直方向のソース参照拡大率
displacement_map_filter.mode = DisplacementMapFilterMode.IGNORE;	// マップ範囲外の描画モード
displacement_map_filter.color = 0xFF0000;	// マップ範囲外のカラー
displacement_map_filter.alpha = 1.0;		// マップ範囲外の透明度

// ------------------------------------------------------------
// 親スプライトにフィルタを適用する
// ------------------------------------------------------------
sprite_parent.filters = [displacement_map_filter];


// ------------------------------------------------------------
// マウスカーソルを移動するたびに実行されるイベント
// ------------------------------------------------------------
stage.addEventListener(MouseEvent.MOUSE_MOVE,function(e:MouseEvent):void{

	// マップ座標を更新（mapPoint プロパティに再セットしないと反映されない）
	map_pos.x = e.stageX;
	map_pos.y = e.stageY;
	displacement_map_filter.mapPoint = map_pos;

	// 親スプライトにフィルタを適用する（filters プロパティに再セットしないと反映されない）
	sprite_parent.filters = [displacement_map_filter];
});

import flash.geom.Point;
import flash.display.BitmapData;
import flash.display.BitmapDataChannel;
import flash.filters.DisplacementMapFilter;

// ------------------------------------------------------------
// マップ用ビットマップデータを作成する
// ------------------------------------------------------------
var map_bmp:BitmapData = (function():BitmapData{

	// ------------------------------------------------------------
	// モザイク用の設定
	// ------------------------------------------------------------
	var MAP_WIDTH :uint = 256;	// マップの幅
	var MAP_HEIGHT:uint = 256;	// マップの高さ
	var MOZAIC_WIDTH :Number = 8;	// モザイクの幅（1 〜 256）
	var MOZAIC_HEIGHT:Number = 8;	// モザイクの高さ（1 〜 256）

	// ------------------------------------------------------------
	// モザイク用マップを作成 (componentX:RED,componentY:BLUE)
	// ------------------------------------------------------------
	var bmp_data:BitmapData = new BitmapData( MAP_WIDTH , MAP_HEIGHT , false );

	var i:int,j:int;
	var r:int,b:int;
	var gx:Number,gy:Number;
	var cx:Number,cy:Number;

	for(j=0;j < MAP_HEIGHT;j++){
		gy = Math.floor(j / MOZAIC_HEIGHT);
		cy = gy * MOZAIC_HEIGHT + (MOZAIC_HEIGHT * 0.5);

		b = Math.floor(cy - (j + 0.5) + 0.5) + 0x80;
		if(b < 0) b = 0;
		if(b > 0xff) b = 0xff;

		for(i=0;i < MAP_WIDTH;i++){
			gx = Math.floor(i / MOZAIC_WIDTH);
			cx = gx * MOZAIC_WIDTH + (MOZAIC_WIDTH  * 0.5);

			r = Math.floor(cx - (i + 0.5) + 0.5) + 0x80;
			if(r < 0) r = 0;
			if(r > 0xff) r = 0xff;

			bmp_data.setPixel(i,j,(r<<16) | (b<<0))
		}
	}

	return bmp_data;
})();

// ------------------------------------------------------------
// マップ用座標を作成する
// ------------------------------------------------------------
var map_pos:Point = new Point(0,0);

// ------------------------------------------------------------
// DisplacementMapFilter オブジェクトを作成する
// ------------------------------------------------------------
var displacement_map_filter:DisplacementMapFilter = new DisplacementMapFilter(
	map_bmp,	// マップ用ビットマップデータ
	map_pos,	// マップの座標
	BitmapDataChannel.RED,	// 水平方向カラーチャンネル
	BitmapDataChannel.BLUE,	// 垂直方向カラーチャンネル
	256,	// 水平方向のソース参照拡大率
	256	// 垂直方向のソース参照拡大率
);

import flash.geom.Point;
import flash.display.BitmapData;
import flash.display.BitmapDataChannel;
import flash.filters.DisplacementMapFilter;

// ------------------------------------------------------------
// マップ用ビットマップデータを作成する
// ------------------------------------------------------------
var map_bmp:BitmapData = (function():BitmapData{

	// ------------------------------------------------------------
	// 魚眼用の設定
	// ------------------------------------------------------------
	var MAP_WIDTH :uint = 256;	// マップの幅
	var MAP_HEIGHT:uint = 256;	// マップの高さ
	var FISHEYE_STRENGTH:Number = 1.0;	// 魚眼強度（0.01 〜 1.5）
	var FISHEYE_RADIUS:Number = (MAP_WIDTH < MAP_HEIGHT ? MAP_WIDTH : MAP_HEIGHT) * 0.5;	// 魚眼半径

	// ------------------------------------------------------------
	// 魚眼用マップを作成 (componentX:RED,componentY:BLUE)
	// ------------------------------------------------------------
	var bmp_data:BitmapData = new BitmapData( MAP_WIDTH , MAP_HEIGHT , false );

	var i:int,j:int;
	var r:int,b:int;
	var d:Number;
	var vx:Number,vy:Number;
	var cx:Number = MAP_WIDTH  * 0.5 - 0.5;
	var cy:Number = MAP_HEIGHT * 0.5 - 0.5;
	var s:Number = 1.0 / Math.cos((45 * Math.PI / 180) * FISHEYE_STRENGTH);

	for(j=0;j < MAP_HEIGHT;j++){
		for(i=0;i < MAP_WIDTH;i++){
			vx = i - cx;
			vy = j - cy;
			d = Math.sqrt(vx * vx + vy * vy);
			if(d > FISHEYE_RADIUS){
				r = b = 0x80;
			}else{
				d = Math.cos(Math.atan2(d,FISHEYE_RADIUS) * FISHEYE_STRENGTH);
				vx = cx + vx * d * s;
				vy = cy + vy * d * s;
				r = Math.floor(i - vx + 0.5) + 0x80;
				b = Math.floor(j - vy + 0.5) + 0x80;
				if(r < 0) r = 0;
				if(b < 0) b = 0;
				if(r > 0xff) r = 0xff;
				if(b > 0xff) b = 0xff;
			}

			bmp_data.setPixel(i,j,(r<<16) | (b<<0))
		}
	}

	return bmp_data;
})();

// ------------------------------------------------------------
// マップ用座標を作成する
// ------------------------------------------------------------
var map_pos:Point = new Point(0,0);

// ------------------------------------------------------------
// DisplacementMapFilter オブジェクトを作成する
// ------------------------------------------------------------
var displacement_map_filter:DisplacementMapFilter = new DisplacementMapFilter(
	map_bmp,	// マップ用ビットマップデータ
	map_pos,	// マップの座標
	BitmapDataChannel.RED,	// 水平方向カラーチャンネル
	BitmapDataChannel.BLUE,	// 垂直方向カラーチャンネル
	64,	// 水平方向のソース参照拡大率
	64	// 垂直方向のソース参照拡大率
);

import flash.display.Sprite;
import flash.display.Graphics;
import flash.filters.ShaderFilter;

// ------------------------------------------------------------
// スプライトを作成
// ------------------------------------------------------------
var sprite:Sprite = new Sprite();

// ステージに配置
stage.addChild(sprite);

// 矩形を描画
var g:Graphics = sprite.graphics;
g.lineStyle (0, 0xAA0000, 1.0);
g.beginFill (0xFF6666, 1.0);
g.drawRect (-50,-50,100,100);
g.beginFill (0xFF8844, 100);
g.moveTo ( -40 ,   0 );
g.lineTo (   0 ,  40 );
g.lineTo (  40 ,   0 );
g.lineTo (   0 , -40 );
g.endFill();

// 位置を設定
sprite.x = 100;
sprite.y = 100;

// ------------------------------------------------------------
// Shader オブジェクトを作成する
// ------------------------------------------------------------
var shader_obj:Shader = new Shader();

// ------------------------------------------------------------
// シェーダーバイトコードを設定（pbj ファイルのバイナリ）
// ------------------------------------------------------------
shader_obj.byteCode = (function ():ByteArray{
	var a:ByteArray = new ByteArray();

	var f:Function = a.writeUnsignedInt;
	f(0xa5010000); f(0x00a40900); f(0x4e657746); f(0x696c7465);
	f(0x72a00c6e); f(0x616d6573); f(0x70616365); f(0x004d794e);
	f(0x616d6573); f(0x70616365); f(0x00a00c76); f(0x656e646f);
	f(0x72004d79); f(0x56656e64); f(0x6f7200a0); f(0x08766572);
	f(0x73696f6e); f(0x000100a0); f(0x0c646573); f(0x63726970);
	f(0x74696f6e); f(0x004d7944); f(0x65736372); f(0x69707469);
	f(0x6f6e00a1); f(0x01020000); f(0x0c5f4f75); f(0x74436f6f);
	f(0x726400a3); f(0x00047372); f(0x6300a102); f(0x0401000f);
	f(0x64737400); f(0x300200f1); f(0x00001000); f(0x1d0100f3);
	f(0x02001b00);

	return a;
})();

// ------------------------------------------------------------
// ShaderFilter オブジェクトを作成する
// ------------------------------------------------------------
var shader_filter:ShaderFilter = new ShaderFilter();

// ------------------------------------------------------------
// プロパティを設定する
// ------------------------------------------------------------
shader_filter.shader = shader_obj;	// Shader オブジェクトを指定
shader_filter.topExtension    = 0;	// 上端の拡張余白
shader_filter.bottomExtension = 0;	// 下端の拡張余白
shader_filter.leftExtension   = 0;	// 左端の拡張余白
shader_filter.rightExtension  = 0;	// 右端の拡張余白

// ------------------------------------------------------------
// スプライトにフィルタを適用する
// ------------------------------------------------------------
sprite.filters = [shader_filter];