各位朋友,你们好!你们如果有时间，请在此交流flash 8里
ActionScript2.0类中的
flash.display
flash.external
flash.filters<
flash.geom<
flash.net<br
flash.text的用法与拓展实例，
听说使用上述很好用,所以在此征集英雄帖了.

在此谨代表像我这样的初学者向你们谢谢先了！

[ 本帖最后由 sxl001 于 2006-12-5 12:16 编辑 ]

怎么没人跟帖啊

我就只对flash.filters包有点了解而已..
其余的..都只是...
呵呵...

支持

我发一个用位图类和滤镜类做的一个例子,代码如下:
import flash.filters.BlurFilter;
var d = 400;
var radius = 200;
var p = 2*Math.PI;
var num = 6;
var Ya = 0.001;
for (var i = 0; i<6; i++) {
this.createEmptyMovieClip("theScene"+i, i);
this["theScene"+i]._x = this["theScene"+i]._y=i;
}
var i = 0;
while (i<6) {
this["theScene"+i].createEmptyMovieClip("contents", i);
this["theScene"+i].contents.attachBitmap(flash.display.BitmapData.loadBitmap("image"+i), 1, false, true);
i++;
}
onEnterFrame = function () {
for (var i = 0; i<6; i++) {
  var mc = this["theScene"+i];
  var blurX:Number = 30*Math.cos(Ya-p/num*i);
  var blurY:Number = 30*Math.cos(Ya-p/num*i);
  var quality:Number = 2;
  var filter:BlurFilter = new BlurFilter(blurX, blurY, quality);
  var filterArray:Array = new Array();
  filterArray.push(filter);
  x = Math.sin(Ya-p/num*i)*radius;
  y = 0;
  z = Math.cos(Ya-p/num*i)*radius;
  ratio = d/(d+z);
  mc._x = 300+x*ratio;
  mc._y = 100-y*ratio;
  mc._xscale = mc._yscale=100*ratio;
  mc._xscale *= Math.cos(Ya-p/num*i);
  mc._alpha = 100*ratio;
  mc.swapDepths(10000-z);
  mc.filters = filterArray;
  Ya -= (_xmouse-275)/10000;
}
};

tiger_0309 的这个实例做得与众不同.平常所见此类旋转在图片远离缩小时小图还是清楚的,而tiger_0309 的这个就不同,旋转缩小时达到了真实效果,也就是远离时变模糊了.所以说tiger_0309 做得不错,这也是flash8ActionScript2.0类给我们所带来的惊喜!

看见矩阵，我头晕……

顶！建议置顶！
楼主的提议太好了。只可惜我是菜鸟，不能够提供文章，但我还是要表示支持。
论坛除了帮助解决像我这样的菜鸟提出来的一些初级问题外，是该有点高层次高水平的东西。

//场景上放三个MC,实例名依次为:mc1,mc2,mc3
//测试时,移动鼠标
import flash.filters.*;
onEnterFrame = function () {
mc1.filters = [new BlurFilter(_xmouse/10, _ymouse/10, 2)];//模糊
mc2.filters = [new DropShadowFilter(10, 0, 0x0000FF, 1, _xmouse/10, _ymouse/10)];//投影
mc3.filters = [new GlowFilter(0xFF0000, .5, _xmouse/10, _ymouse/10)];//发光
};

哇哦。。。顶下！
没怎么深入研究过FLASH的AS类，，看到效果也蛮吸引人的啊！哈哈。。。学习了

function aa(i:Number) {
function brightnessWatcher(prop:String, oldVal:Number, newVal:Number, img_mc:MovieClip):Number {
  var brightness_array:Array = [1, 0, 0, 0, newVal, 0, 1, 0, 0, newVal, 0, 0, 1, 0, newVal, 0, 0, 0, 1, 0];
  colorMF = new ColorMatrixFilter(brightness_array);
  img_mc.filters = [colorMF];
  return newVal;
}
this.createEmptyMovieClip("img_mc", 0);
img_mc.attachMovie("pic"+i, "pic"+i, i);
img_mc._x = (Stage.width-img_mc._width)/2;
img_mc._y = (Stage.height-img_mc._height)-40;
img_mc.watch("brightness", brightnessWatcher, img_mc);
////////////////////////////////////////////////////////////////////////////////////
var t:Object = new Tween(img_mc, "brightness", Elastic.easeOut, 100, 0, 5, true);
//////////////////////////////////////////////////////////////////////////////////////

}
aa(1);
这个是从帮助文档里"偷来"的.
我是觉得那个效果定义为img_mc的一个属性.当属性brightness一发生变化时,又来调用brightnessWatcher这个函数.
用这watch监视着brightness属性是否发生变化.这一点用得好...
同时,这个效果也是用了flash.filters包里面的ColorMatrixFilter
也是用到了这个矩阵

进一步测试滤镜效果：

复制内容到剪贴板

代码:

//场景上放若干个MC,实例名依次为:mc1,mc2,mc3，……mc12.
import flash.filters.*;
onEnterFrame = function () {
mc1.filters = [new BlurFilter(_xmouse/10, _ymouse/10, 2)]; //模糊
mc2.filters = [new DropShadowFilter(10, 0, 0x0000FF, 1, _xmouse/10, _ymouse/10)]; //投影
mc3.filters = [new GlowFilter(0xFF0000, .5, _xmouse/10, _ymouse/10)]; //发光
mc4.filters = [new ColorMatrixFilter([0.386, 0.6094, 0.082, 0, 0,
            0.386, 0.6094, 0.082, 0, 0,
            0.386, 0.6094, 0.082, 0, 0,
            0,     0,      0,     1, 0])]; //变灰度，参数是灰度矩阵
var nRed:Number=0.3086;
var nGreen:Number=0.6094;
var nBlue:Number=0.0820;
var nLevel:Number=_xmouse/400;
mc5.filters = [new ColorMatrixFilter([(1-nLevel)*nRed+nLevel,(1-nLevel)*nGreen,(1-nLevel)*nBlue,0,0,
            (1-nLevel)*nRed,(1-nLevel)*nGreen+nLevel,(1-nLevel)*nBlue,0,0,
            (1-nLevel)*nRed,(1-nLevel)*nGreen,(1-nLevel)*nBlue+nLevel,0,0,
            0,               0,                0,                     1,0])];//色饱和度，这个计算有点复杂
var R:Number,G:Number,B:Number
R=G=B=_xmouse/50;
mc6.filters = [new ColorMatrixFilter([R,0,0,0,0,
            0,G,0,0,0,
            0,0,B,0,0,
            0,0,0,1,0])];//亮度，同时改变矩阵中RGB。如果不同步，就调色调。
var nCon:Number=_xmouse/550;
var nSca:Number=nCon*11;
var nOff:Number=63.5-(nCon*698.5);
mc7.filters = [new ColorMatrixFilter([nSca,0,0,0,nOff,
            0,nSca,0,0,nOff,
            0,0,nSca,0,nOff,
            0,0,0,1,0])];//对比度
mc8.filters = [new ColorMatrixFilter([-1,0,0,0,255,
            0,-1,0,0,255,
            0,0,-1,0,255,
            0,0,0,1,0])];//底片效果，颜色反转
mc9.filters = [new ConvolutionFilter(3,3,[0,1,0,1,-4,1,0,1,0])];//边缘检测
mc10.filters = [new ConvolutionFilter(3,3,[0,-1,0,-1,5,-1,0,-1,0])];//锐化
mc11.filters = [new ConvolutionFilter(3,3,[-2,-1,0,-1,1,1,0,1,2])];//浮雕
};

[ 本帖最后由 ybzjllj 于 2006-11-29 08:16 编辑 ]

12楼不错，强！希望你继续研究。

[ 本帖最后由 sxl001 于 2006-11-29 00:25 编辑 ]

顶上去先。

顶上去

这几天在学习Tween,小结一下让大家分享:
使用Tween类小结
Tween类在mx.transitions包中，所以在构造Tween对象之前通常要导入Tween类。一旦构造了一个新的Tween对象，补间就开始了。
import mx.transitions.Tween;
var twMovieClip:Tween=new Tween(电影实例名,属性值,缓动函数,运动开始位置值,运动结束位置值,持续时间,使用秒);
//电影实例名：即将运动的对象
//属性值：”_x”或 ”_y”或 ”_alpha”等，用字符串表示。
//缓动函数：对一个缓动函数的引用。可以用null来表示不应用。
//运动开始位置值：被补间属性的开始值。
//运动结束位置值：被补间属性的结束值。
//持续时间：要发生补间的帧的数量。可以随意地指定一个以秒为单位的值。如果该值是以秒为单位，就必须将下一个参数指定为true。
//使用秒：默认时补间的持续时间以帧为单位。但是，可以随意指定一个true值来告诉Flash应该以秒为单位而不是以帧为单位来解释持续时间。null、underfined、false会导致Flash以帧为单位来解释持续时间。
实例1效果是场景上一个名为mCirle从左向右边水平缓动。
import mx.transitions.Tween;
var twMovieClip;Tween=new Tween(mCirle,”_x”,null,0,550,10,true);
实例2:
打开一个新的文档,并将其保存为tweensEasing.fla.
创建一个新的名为Circle的影片剪辑元件.
在Circle中画一个25*25像素的\对齐到(0,0)处的圆形.
在库中将Cirlcle链接名为Circle标识符.
在主时间轴第一个关键帧中;
/*将缓动添加到程序式补间中
var twMovieClip:Tween=new Tween(myMovieClip,"_x"(or:"_y"),null,开始位置,结束位置,运动时间,true);
为了将缓动运用于补间,可以在Tween构造函数的第3个参数中引用一个缓动函数.尽管可以自己写一个缓动函数,但是使用
mx.transitions.easing.*包中的各个类的缓动函数就简单多了.在该包中有如下几个类:Back, Bounce, Elastic,
Regular和Strong。这些类都有如下的静态方法：easeIn()、easeOut()、easeInOut()。另外，该包还包含具有静态方法
easeNone()的None类，它等价于在构造Tween对象时将缓动函数指定为null值。可以在构造函数的第3个参数中引用
这些方法中的任何一个。理解缓动方法的最简单的方式就是用下面的练习来测试它们.
*/
import mx.transitions.Tween;
import mx.transitions.easing.*;
//定义一个数组存贮每个缓动的方法;
var aClasses:Array = [Back, Bounce, Elastic, Regular, Strong];
//定义一个新数组存贮每个缓动的方法;
var aEasingMethods:Array = new Array();
for (var i:Number = 0; i&lt;aClasses.length; i++) {
        aEasingMethods.push(aClasses&lt;i&gt;.easeIn);
        aEasingMethods.push(aClasses&lt;i&gt;.easeOut);
        aEasingMethods.push(aClasses&lt;i&gt;.easeInOut);
}
var mClip:MovieClip;
var nDepth:Number;
var nX:Number = 20;
var oClips:Object = new Object();
//对于每个缓动方法，创建一个新的Circle实例。
for (var i:Number = 0; i&lt;aEasingMethods.length; i++) {
        nDepth = this.getNextHighestDepth();
        mClip = this.attachMovie("Circle", "mClip"+nDepth, nDepth, {_x:nX, _y:50});
        nX += mClip._width+5;
        //通过将圆形影片剪辑的实例名作为关键字，并将缓动方法作为值，将一个新成员添加到Circle对象。
        oClips[mClip._name] = aEasingMethod
        //当用户单击圆形时就开始新的_y属性的补间。针对被除数单击的影片剪辑。
        mClip.onPress = function():Void  {
                var twMove:Tween = new Tween(this, "_y", oClips[this._name], 50, 350, 2, true);
        };
}
实例3;
/*将缓动添加到程序式补间中
var twMovieClip:Tween=new Tween(myMovieClip,"_x"(or:"_y"),null,开始位置,结束位置,运动时间,true);
为了将缓动运用于补间,可以在Tween构造函数的第3个参数中引用一个缓动函数.尽管可以自己写一个缓动函数,但是使用
mx.transitions.easing.*包中的各个类的缓动函数就简单多了.在该包中有如下几个类:Back, Bounce, Elastic,
Regular和Strong。这些类都有如下的静态方法：easeIn()、easeOut()、easeInOut()。另外，该包还包含具有静态方法
easeNone()的None类，它等价于在构造Tween对象时将缓动函数指定为null值。可以在构造函数的第3个参数中引用
这些方法中的任何一个。理解缓动方法的最简单的方式就是用下面的练习来测试它们。*/
import mx.transitions.Tween;
import mx.transitions.easing.*;
var twMovieClip:Tween=new Tween(myMovieClip,"_x"(or:"_y"),null,开始位置,结束位置,运动时间,true);

[ 本帖最后由 sxl001 于 2006-12-6 02:00 编辑 ]

好贴.找来.顶上去.

強,頂上去!

支持楼主

学习中

顶上去..

太厉害了!!