mirror of
https://github.com/burrow-dev/burrow-server.git
synced 2026-11-19 09:37:50 -05:00
Brought up to date with the private repository (feea4c7)
This commit is contained in:
1 parent
1aa738d692
commit
1b1df1ae48
7925 files changed
+2617237
-20
No files matched your search
@@ -0,0 +1,463 @@
|
||||
package com.sbi.graphics
|
||||
{
|
||||
import flash.display.BitmapData;
|
||||
import flash.geom.Rectangle;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class BitmapByteArray
|
||||
{
|
||||
|
||||
private static const PALETTE_ALPHA_OFFSET:int = 25;
|
||||
|
||||
private static const SHADOW_GRADIENT_SCALE:int = 3;
|
||||
|
||||
private const TRANS:int = 0;
|
||||
|
||||
private var _palette:Array;
|
||||
|
||||
private var _h:int;
|
||||
|
||||
private var _w:int;
|
||||
|
||||
private var _offX:int;
|
||||
|
||||
private var _offY:int;
|
||||
|
||||
private var _ba:Vector.<int>;
|
||||
|
||||
public function BitmapByteArray()
|
||||
{
|
||||
super();
|
||||
_palette = PaletteHelper.getAnimalPalette();
|
||||
}
|
||||
|
||||
public static function scaleAndPackImage(param1:BitmapData) : Object
|
||||
{
|
||||
var _loc2_:BitmapByteArray = new BitmapByteArray();
|
||||
_loc2_.loadBitmap(param1);
|
||||
_loc2_.halfImage();
|
||||
_loc2_.crop();
|
||||
return _loc2_.processPackImage();
|
||||
}
|
||||
|
||||
public static function scaleAndPackShadow(param1:BitmapData, param2:int, param3:int, param4:int, param5:int) : Object
|
||||
{
|
||||
var _loc6_:BitmapByteArray = new BitmapByteArray();
|
||||
return _loc6_.scaleShadow(param1,param2,param3,param4,param5);
|
||||
}
|
||||
|
||||
private function loadBitmap(param1:BitmapData) : void
|
||||
{
|
||||
var _loc4_:* = 0;
|
||||
var _loc3_:* = 0;
|
||||
var _loc2_:* = 0;
|
||||
_w = param1.width;
|
||||
_h = param1.height;
|
||||
_ba = new Vector.<int>(_w * _h,true);
|
||||
var _loc7_:uint = 0;
|
||||
var _loc6_:int = -1;
|
||||
var _loc5_:int = 0;
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < _h)
|
||||
{
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < _w)
|
||||
{
|
||||
_loc2_ = param1.getPixel32(_loc3_,_loc4_);
|
||||
if(_loc7_ != _loc2_ || _loc6_ < 0)
|
||||
{
|
||||
_loc7_ = _loc2_;
|
||||
_loc6_ = int(findPaletteColor(_loc2_));
|
||||
}
|
||||
_ba[_loc5_++] = _loc6_;
|
||||
_loc3_++;
|
||||
}
|
||||
_loc4_++;
|
||||
}
|
||||
}
|
||||
|
||||
private function scaleShadow(param1:BitmapData, param2:int, param3:int, param4:int, param5:int) : Object
|
||||
{
|
||||
var _loc10_:* = 0;
|
||||
var _loc11_:* = 0;
|
||||
var _loc13_:* = 0;
|
||||
var _loc9_:* = 0;
|
||||
var _loc17_:int = 0;
|
||||
var _loc16_:int = 0;
|
||||
var _loc15_:int = 0;
|
||||
_w = param1.width;
|
||||
_h = param1.height;
|
||||
var _loc14_:Vector.<uint> = param1.getVector(new Rectangle(0,0,_w,_h));
|
||||
var _loc7_:Vector.<int> = new Vector.<int>(_w * _h * 0.25,true);
|
||||
var _loc12_:int = 0;
|
||||
var _loc8_:int = 0;
|
||||
_loc17_ = 0;
|
||||
while(_loc17_ < _h)
|
||||
{
|
||||
_loc16_ = 0;
|
||||
while(_loc16_ < _w)
|
||||
{
|
||||
_loc12_ = _loc16_ + _loc17_ * _w;
|
||||
_loc9_ = _loc14_[_loc12_];
|
||||
_loc10_ = _loc14_[_loc12_ + 1];
|
||||
_loc12_ += _w;
|
||||
_loc11_ = _loc14_[_loc12_];
|
||||
_loc13_ = _loc14_[_loc12_ + 1];
|
||||
_loc7_[_loc8_++] = blendShadowColors(_loc9_,_loc10_,_loc11_,_loc13_);
|
||||
_loc16_ += 2;
|
||||
}
|
||||
_loc17_ += 2;
|
||||
}
|
||||
_ba = _loc7_;
|
||||
_h /= 2;
|
||||
_w /= 2;
|
||||
if(param4 != _w || param5 != _h)
|
||||
{
|
||||
_loc8_ = 0;
|
||||
_loc7_ = new Vector.<int>(param4 * param5,true);
|
||||
_loc17_ = param3;
|
||||
while(_loc17_ < param3 + param5)
|
||||
{
|
||||
_loc15_ = _loc17_ * _w + param2;
|
||||
_loc16_ = 0;
|
||||
while(_loc16_ < param4)
|
||||
{
|
||||
_loc7_[_loc8_++] = _ba[_loc15_++];
|
||||
_loc16_++;
|
||||
}
|
||||
_loc17_++;
|
||||
}
|
||||
_w = param4;
|
||||
_h = param5;
|
||||
_offX = param2;
|
||||
_offY = param3;
|
||||
_ba = _loc7_;
|
||||
}
|
||||
var _loc6_:Object = processPackImage();
|
||||
_loc6_.sm = 3;
|
||||
return _loc6_;
|
||||
}
|
||||
|
||||
private function halfImage() : void
|
||||
{
|
||||
var _loc9_:int = 0;
|
||||
var _loc1_:int = 0;
|
||||
var _loc3_:int = 0;
|
||||
var _loc8_:int = 0;
|
||||
var _loc7_:int = 0;
|
||||
var _loc5_:int = 0;
|
||||
var _loc4_:Vector.<int> = new Vector.<int>(_w * _h * 0.25,true);
|
||||
var _loc2_:int = 0;
|
||||
var _loc6_:int = 0;
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < _h)
|
||||
{
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < _w)
|
||||
{
|
||||
_loc2_ = _loc5_ + _loc7_ * _w;
|
||||
_loc8_ = _ba[_loc2_];
|
||||
_loc9_ = _ba[_loc2_ + 1];
|
||||
_loc2_ += _w;
|
||||
_loc1_ = _ba[_loc2_];
|
||||
_loc3_ = _ba[_loc2_ + 1];
|
||||
_loc4_[_loc6_++] = blendColors(_loc8_,_loc9_,_loc1_,_loc3_);
|
||||
_loc5_ += 2;
|
||||
}
|
||||
_loc7_ += 2;
|
||||
}
|
||||
_ba = _loc4_;
|
||||
_h /= 2;
|
||||
_w /= 2;
|
||||
}
|
||||
|
||||
private function crop() : void
|
||||
{
|
||||
var _loc10_:int = 0;
|
||||
var _loc8_:int = 0;
|
||||
var _loc3_:* = undefined;
|
||||
var _loc6_:int = 0;
|
||||
var _loc2_:int = _w;
|
||||
var _loc5_:int = 0;
|
||||
var _loc1_:int = _h;
|
||||
var _loc4_:int = 0;
|
||||
var _loc11_:int = 0;
|
||||
_loc10_ = 0;
|
||||
while(_loc10_ < _h)
|
||||
{
|
||||
_loc8_ = 0;
|
||||
while(_loc8_ < _w)
|
||||
{
|
||||
if(_ba[_loc11_++] > 0)
|
||||
{
|
||||
if(_loc8_ < _loc2_)
|
||||
{
|
||||
_loc2_ = _loc8_;
|
||||
}
|
||||
if(_loc8_ > _loc5_)
|
||||
{
|
||||
_loc5_ = _loc8_;
|
||||
}
|
||||
if(_loc10_ < _loc1_)
|
||||
{
|
||||
_loc1_ = _loc10_;
|
||||
}
|
||||
if(_loc10_ > _loc4_)
|
||||
{
|
||||
_loc4_ = _loc10_;
|
||||
}
|
||||
}
|
||||
_loc8_++;
|
||||
}
|
||||
_loc10_++;
|
||||
}
|
||||
_offX = _loc2_;
|
||||
_offY = _loc1_;
|
||||
var _loc7_:uint = _loc5_ - _loc2_ + 1;
|
||||
var _loc9_:uint = _loc4_ - _loc1_ + 1;
|
||||
if(_loc2_ == _w && _loc1_ == _h)
|
||||
{
|
||||
_w = 0;
|
||||
_h = 0;
|
||||
_ba = null;
|
||||
return;
|
||||
}
|
||||
_loc11_ = 0;
|
||||
if(_loc7_ != _w || _loc9_ != _h)
|
||||
{
|
||||
_loc3_ = new Vector.<int>(_loc7_ * _loc9_,true);
|
||||
_loc10_ = _loc1_;
|
||||
while(_loc10_ < _loc1_ + _loc9_)
|
||||
{
|
||||
_loc6_ = _loc10_ * _w + _offX;
|
||||
_loc8_ = 0;
|
||||
while(_loc8_ < _loc7_)
|
||||
{
|
||||
_loc3_[_loc11_++] = _ba[_loc6_++];
|
||||
_loc8_++;
|
||||
}
|
||||
_loc10_++;
|
||||
}
|
||||
_w = _loc7_;
|
||||
_h = _loc9_;
|
||||
_ba = _loc3_;
|
||||
}
|
||||
}
|
||||
|
||||
private function processPackImage() : Object
|
||||
{
|
||||
var _loc6_:int = 0;
|
||||
var _loc5_:int = 0;
|
||||
var _loc4_:* = null;
|
||||
var _loc2_:* = 0;
|
||||
if(_ba == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
var _loc10_:Object = {
|
||||
"x":_offX,
|
||||
"y":_offY,
|
||||
"w":_w,
|
||||
"h":_h
|
||||
};
|
||||
var _loc7_:ByteArray = new ByteArray();
|
||||
_loc10_.b = _loc7_;
|
||||
var _loc3_:int = int(_ba.length);
|
||||
var _loc9_:uint = 256;
|
||||
var _loc8_:uint = 0;
|
||||
var _loc1_:int = 0;
|
||||
while(_loc1_ < _loc3_)
|
||||
{
|
||||
_loc2_ = uint(_ba[_loc1_++]);
|
||||
if(_loc9_ == 256)
|
||||
{
|
||||
_loc9_ = _loc2_;
|
||||
}
|
||||
else if(_loc2_ != _loc9_)
|
||||
{
|
||||
if(_loc8_)
|
||||
{
|
||||
_loc9_ |= 128;
|
||||
while(_loc8_ > 255)
|
||||
{
|
||||
_loc7_.writeByte(_loc9_);
|
||||
_loc7_.writeByte(255);
|
||||
_loc8_ -= 256;
|
||||
}
|
||||
if(_loc8_ > 0)
|
||||
{
|
||||
_loc7_.writeByte(_loc9_);
|
||||
_loc7_.writeByte(_loc8_);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc7_.writeByte(uint(_loc9_ & 0x7F));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc7_.writeByte(_loc9_);
|
||||
}
|
||||
_loc9_ = _loc2_;
|
||||
_loc8_ = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc8_++;
|
||||
}
|
||||
}
|
||||
if(_loc8_ || _loc3_ == 1)
|
||||
{
|
||||
_loc9_ |= 128;
|
||||
while(_loc8_ > 255)
|
||||
{
|
||||
_loc7_.writeByte(_loc9_);
|
||||
_loc7_.writeByte(255);
|
||||
_loc8_ -= 256;
|
||||
}
|
||||
if(_loc8_ > 0)
|
||||
{
|
||||
_loc7_.writeByte(_loc9_);
|
||||
_loc7_.writeByte(_loc8_);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc7_.writeByte(uint(_loc9_ & 0x7F));
|
||||
}
|
||||
}
|
||||
return _loc10_;
|
||||
}
|
||||
|
||||
private function findPaletteColor(param1:uint) : uint
|
||||
{
|
||||
var _loc4_:* = 0;
|
||||
var _loc3_:uint = uint((param1 & 0xFF000000) >> 24);
|
||||
if(_loc3_ < 160)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
param1 |= 4278190080;
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < 25)
|
||||
{
|
||||
if(_palette[_loc4_] == param1)
|
||||
{
|
||||
return _loc4_;
|
||||
}
|
||||
_loc4_++;
|
||||
}
|
||||
var _loc5_:int = param1 >> 16 & 0xFF;
|
||||
var _loc2_:int = param1 >> 8 & 0xFF;
|
||||
var _loc6_:int = param1 & 0xFF;
|
||||
return findClosetPaletteIndex(_loc5_,_loc2_,_loc6_);
|
||||
}
|
||||
|
||||
private function findClosetPaletteIndex(param1:int, param2:int, param3:int) : int
|
||||
{
|
||||
var _loc4_:int = 0;
|
||||
var _loc5_:int = 0;
|
||||
var _loc10_:int = 0;
|
||||
var _loc6_:int = 0;
|
||||
var _loc8_:int = 0;
|
||||
var _loc11_:* = 0;
|
||||
var _loc7_:* = 0;
|
||||
var _loc9_:int = 10000000;
|
||||
var _loc12_:int = 0;
|
||||
_loc11_ = 0;
|
||||
while(_loc11_ < 25)
|
||||
{
|
||||
_loc7_ = uint(_palette[_loc11_]);
|
||||
_loc5_ = (_loc7_ >> 16 & 0xFF) - param1;
|
||||
_loc10_ = (_loc7_ >> 8 & 0xFF) - param2;
|
||||
_loc6_ = (_loc7_ & 0xFF) - param3;
|
||||
_loc8_ = _loc5_ * _loc5_ + _loc10_ * _loc10_ + _loc6_ * _loc6_;
|
||||
if(_loc8_ < _loc9_)
|
||||
{
|
||||
_loc9_ = _loc8_;
|
||||
_loc12_ = _loc11_;
|
||||
}
|
||||
_loc11_++;
|
||||
}
|
||||
return _loc12_;
|
||||
}
|
||||
|
||||
private function blendColors(param1:uint, param2:uint, param3:uint, param4:uint) : uint
|
||||
{
|
||||
var _loc9_:* = 0;
|
||||
var _loc8_:int = 0;
|
||||
var _loc5_:Array = null;
|
||||
var _loc6_:int = 0;
|
||||
var _loc11_:int = 0;
|
||||
var _loc7_:int = 0;
|
||||
var _loc12_:int = 0;
|
||||
var _loc10_:int = 0;
|
||||
if(param1 == 0)
|
||||
{
|
||||
_loc8_++;
|
||||
}
|
||||
if(param2 == 0)
|
||||
{
|
||||
_loc8_++;
|
||||
}
|
||||
if(param3 == 0)
|
||||
{
|
||||
_loc8_++;
|
||||
}
|
||||
if(param4 == 0)
|
||||
{
|
||||
_loc8_++;
|
||||
}
|
||||
if(_loc8_ == 4)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
if(param1 == param2 && param1 == param3 && param1 == param4)
|
||||
{
|
||||
_loc9_ = param1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc5_ = [param1,param2,param3,param4];
|
||||
while(_loc10_ < 4)
|
||||
{
|
||||
if(_loc5_[_loc10_] != 0)
|
||||
{
|
||||
param1 = uint(_palette[_loc5_[_loc10_]]);
|
||||
_loc11_ += param1 >> 16 & 0xFF;
|
||||
_loc7_ += param1 >> 8 & 0xFF;
|
||||
_loc12_ += param1 & 0xFF;
|
||||
_loc6_++;
|
||||
}
|
||||
_loc10_++;
|
||||
}
|
||||
_loc11_ /= _loc6_;
|
||||
_loc7_ /= _loc6_;
|
||||
_loc12_ /= _loc6_;
|
||||
_loc9_ = uint(findClosetPaletteIndex(_loc11_,_loc7_,_loc12_));
|
||||
}
|
||||
return uint(_loc9_ + _loc8_ * 25);
|
||||
}
|
||||
|
||||
private function blendShadowColors(param1:uint, param2:uint, param3:uint, param4:uint) : int
|
||||
{
|
||||
var _loc6_:* = 0;
|
||||
var _loc5_:uint = ((param1 >> 24 & 0xFF) + (param2 >> 24 & 0xFF) + (param3 >> 24 & 0xFF) + (param4 >> 24 & 0xFF)) / 4;
|
||||
if(_loc5_)
|
||||
{
|
||||
_loc6_ = uint(((param1 & 0xFF & 0xFF) + (param2 & 0xFF & 0xFF) + (param3 & 0xFF & 0xFF) + (param4 & 0xFF & 0xFF)) / 4);
|
||||
_loc6_ = uint(_loc6_ + (255 - _loc6_) * ((255 - _loc5_) / 255));
|
||||
_loc6_ = uint(_loc6_ >> 3);
|
||||
if(_loc6_ == 0)
|
||||
{
|
||||
_loc6_ = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc6_ = 0;
|
||||
}
|
||||
return _loc6_;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,100 @@
|
||||
package com.sbi.graphics
|
||||
{
|
||||
import flash.display.BitmapData;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class ImageArray
|
||||
{
|
||||
|
||||
public static const VERSION:uint = 117967104;
|
||||
|
||||
private var _frames:Array;
|
||||
|
||||
public function ImageArray()
|
||||
{
|
||||
super();
|
||||
_frames = [];
|
||||
}
|
||||
|
||||
public function get length() : int
|
||||
{
|
||||
return _frames.length;
|
||||
}
|
||||
|
||||
public function release() : void
|
||||
{
|
||||
_frames.splice(0,_frames.length);
|
||||
}
|
||||
|
||||
public function addBitmap(param1:BitmapData) : void
|
||||
{
|
||||
var _loc2_:Object = BitmapByteArray.scaleAndPackImage(param1);
|
||||
_frames.push(_loc2_);
|
||||
}
|
||||
|
||||
public function attachShadow(param1:BitmapData) : void
|
||||
{
|
||||
var _loc2_:Object = null;
|
||||
var _loc3_:Object = null;
|
||||
if(_frames.length)
|
||||
{
|
||||
_loc2_ = _frames[_frames.length - 1];
|
||||
_loc3_ = BitmapByteArray.scaleAndPackShadow(param1,_loc2_.x,_loc2_.y,_loc2_.w,_loc2_.h);
|
||||
_loc2_.s = _loc3_.b;
|
||||
_loc2_.sm = _loc3_.sm;
|
||||
}
|
||||
}
|
||||
|
||||
public function addFrame(param1:Object) : void
|
||||
{
|
||||
_frames.push(param1);
|
||||
}
|
||||
|
||||
public function loadPackage(param1:ByteArray) : void
|
||||
{
|
||||
release();
|
||||
param1.position = 0;
|
||||
try
|
||||
{
|
||||
param1.uncompress();
|
||||
}
|
||||
catch(err:Error)
|
||||
{
|
||||
}
|
||||
var _loc2_:Object = param1.readObject();
|
||||
if(_loc2_.v != 117967104)
|
||||
{
|
||||
return;
|
||||
}
|
||||
_frames = _loc2_.f;
|
||||
}
|
||||
|
||||
public function getFrame(param1:int) : Object
|
||||
{
|
||||
return _frames[param1];
|
||||
}
|
||||
|
||||
public function getPackage(param1:Boolean = true) : ByteArray
|
||||
{
|
||||
var _loc3_:int = 0;
|
||||
var _loc4_:ByteArray = null;
|
||||
var _loc2_:Object = null;
|
||||
if(_frames.length)
|
||||
{
|
||||
_loc2_ = {
|
||||
"v":117967104,
|
||||
"f":_frames
|
||||
};
|
||||
_loc4_ = new ByteArray();
|
||||
_loc4_.writeObject(_loc2_);
|
||||
_loc4_.position = 0;
|
||||
if(param1)
|
||||
{
|
||||
_loc4_.compress();
|
||||
}
|
||||
}
|
||||
return _loc4_;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
package com.sbi.graphics
|
||||
{
|
||||
public class ImageArrayHelper
|
||||
{
|
||||
|
||||
public function ImageArrayHelper()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public static function packId(param1:int, param2:int, param3:int) : uint
|
||||
{
|
||||
return param1 << 24 | param2 << 16 | param3;
|
||||
}
|
||||
|
||||
public static function avatarId(param1:uint) : int
|
||||
{
|
||||
return param1 >> 24 & 0xFF;
|
||||
}
|
||||
|
||||
public static function categoryId(param1:uint) : int
|
||||
{
|
||||
return param1 >> 16 & 0xFF;
|
||||
}
|
||||
|
||||
public static function layerId(param1:uint) : int
|
||||
{
|
||||
return param1 & 0xFFFF;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
package com.sbi.graphics
|
||||
{
|
||||
import flash.events.Event;
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class JPEGAsyncCompleteEvent extends Event
|
||||
{
|
||||
|
||||
public static const JPEGASYNC_COMPLETE:String = "JPEGAsyncComplete";
|
||||
|
||||
public var ImageData:ByteArray;
|
||||
|
||||
public function JPEGAsyncCompleteEvent(param1:ByteArray)
|
||||
{
|
||||
ImageData = param1;
|
||||
super("JPEGAsyncComplete");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,761 @@
|
||||
package com.sbi.graphics
|
||||
{
|
||||
import flash.display.BitmapData;
|
||||
import flash.events.EventDispatcher;
|
||||
import flash.events.ProgressEvent;
|
||||
import flash.utils.ByteArray;
|
||||
import flash.utils.setTimeout;
|
||||
|
||||
public class JpegAsynchEncoder extends EventDispatcher
|
||||
{
|
||||
|
||||
public static const CONTENT_TYPE:String = "image/jpeg";
|
||||
|
||||
private var ZigZag:Array = [0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18,24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63];
|
||||
|
||||
private var std_dc_luminance_nrcodes:Array = [0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0];
|
||||
|
||||
private var std_dc_luminance_values:Array = [0,1,2,3,4,5,6,7,8,9,10,11];
|
||||
|
||||
private var std_ac_luminance_nrcodes:Array = [0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,125];
|
||||
|
||||
private var std_ac_luminance_values:Array = [1,2,3,0,4,17,5,18,33,49,65,6,19,81,97,7,34,113,20,50,129,145,161,8,35,66,177,193,21,82,209,240,36,51,98,114,130,9,10,22,23,24,25,26,37,38,39,40,41,42,52,53,54,55,56,57,58,67,68,69,70,71,72,73,74,83,84,85,86,87,88,89,90,99,100,101,102,103,104,105,106,115,116,117,118,119,120,121,122,131,132,133,134,135,136,137,138,146,147,148,149,150,151,152,153,154,162,163,164,165,166,167,168,169,170,178,179,180,181,182,183,184,185,186,194,195,196,197,198,199,200,201,202,210,211,212,213,214,215,216,217,218,225,226,227,228,229,230,231,232,233,234,241,242,243,244,245,246,247,248,249,250];
|
||||
|
||||
private var std_dc_chrominance_nrcodes:Array = [0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0];
|
||||
|
||||
private var std_dc_chrominance_values:Array = [0,1,2,3,4,5,6,7,8,9,10,11];
|
||||
|
||||
private var std_ac_chrominance_nrcodes:Array = [0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,119];
|
||||
|
||||
private var std_ac_chrominance_values:Array = [0,1,2,3,17,4,5,33,49,6,18,65,81,7,97,113,19,34,50,129,8,20,66,145,161,177,193,9,35,51,82,240,21,98,114,209,10,22,36,52,225,37,241,23,24,25,26,38,39,40,41,42,53,54,55,56,57,58,67,68,69,70,71,72,73,74,83,84,85,86,87,88,89,90,99,100,101,102,103,104,105,106,115,116,117,118,119,120,121,122,130,131,132,133,134,135,136,137,138,146,147,148,149,150,151,152,153,154,162,163,164,165,166,167,168,169,170,178,179,180,181,182,183,184,185,186,194,195,196,197,198,199,200,201,202,210,211,212,213,214,215,216,217,218,226,227,228,229,230,231,232,233,234,242,243,244,245,246,247,248,249,250];
|
||||
|
||||
private var YTable:Array = new Array(64);
|
||||
|
||||
private var UVTable:Array = new Array(64);
|
||||
|
||||
private var fdtbl_Y:Array = new Array(64);
|
||||
|
||||
private var fdtbl_UV:Array = new Array(64);
|
||||
|
||||
private var YDC_HT:Array;
|
||||
|
||||
private var UVDC_HT:Array;
|
||||
|
||||
private var YAC_HT:Array;
|
||||
|
||||
private var UVAC_HT:Array;
|
||||
|
||||
private var YDU:Array = new Array(64);
|
||||
|
||||
private var UDU:Array = new Array(64);
|
||||
|
||||
private var VDU:Array = new Array(64);
|
||||
|
||||
private var DU:Array = new Array(64);
|
||||
|
||||
private var bitcode:Array = new Array(65535);
|
||||
|
||||
private var category:Array = new Array(65535);
|
||||
|
||||
private var byteout:ByteArray;
|
||||
|
||||
private var bytenew:int = 0;
|
||||
|
||||
private var bytepos:int = 7;
|
||||
|
||||
private var DCY:Number = 0;
|
||||
|
||||
private var DCU:Number = 0;
|
||||
|
||||
private var DCV:Number = 0;
|
||||
|
||||
private var SrcWidth:int = 0;
|
||||
|
||||
private var SrcHeight:int = 0;
|
||||
|
||||
private var Source:Object = null;
|
||||
|
||||
private var TotalSize:int = 0;
|
||||
|
||||
private var PixelsPerIter:int = 128;
|
||||
|
||||
private var PercentageInc:int = 0;
|
||||
|
||||
private var NextProgressAt:int = 0;
|
||||
|
||||
private var CurrentTotalPos:int = 0;
|
||||
|
||||
private var Working:Boolean = false;
|
||||
|
||||
public function JpegAsynchEncoder()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function JPEGAsyncEncoder(param1:Number = 50) : void
|
||||
{
|
||||
if(param1 <= 0)
|
||||
{
|
||||
param1 = 1;
|
||||
}
|
||||
if(param1 > 100)
|
||||
{
|
||||
param1 = 100;
|
||||
}
|
||||
var _loc2_:int = 0;
|
||||
if(param1 < 50)
|
||||
{
|
||||
_loc2_ = 5000 / param1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc2_ = 200 - param1 * 2;
|
||||
}
|
||||
initHuffmanTbl();
|
||||
initCategoryNumber();
|
||||
initQuantTables(_loc2_);
|
||||
}
|
||||
|
||||
public function get contentType() : String
|
||||
{
|
||||
return "image/jpeg";
|
||||
}
|
||||
|
||||
public function get PixelsPerIteration() : int
|
||||
{
|
||||
return PixelsPerIter;
|
||||
}
|
||||
|
||||
public function set PixelsPerIteration(param1:int) : void
|
||||
{
|
||||
PixelsPerIter = param1;
|
||||
}
|
||||
|
||||
public function get ImageData() : ByteArray
|
||||
{
|
||||
return byteout;
|
||||
}
|
||||
|
||||
public function encodeByteArray(param1:ByteArray, param2:int, param3:int) : Boolean
|
||||
{
|
||||
return internalEncode(param1,param2,param3);
|
||||
}
|
||||
|
||||
public function encode(param1:BitmapData) : Boolean
|
||||
{
|
||||
return internalEncode(param1,param1.width,param1.height);
|
||||
}
|
||||
|
||||
private function internalEncode(param1:Object, param2:int, param3:int) : Boolean
|
||||
{
|
||||
if(Working)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
Working = true;
|
||||
Source = param1;
|
||||
SrcWidth = param2;
|
||||
SrcHeight = param3;
|
||||
TotalSize = param2 * param3;
|
||||
PercentageInc = TotalSize / 100;
|
||||
NextProgressAt = PercentageInc;
|
||||
CurrentTotalPos = 0;
|
||||
setTimeout(StartEncode,10);
|
||||
return true;
|
||||
}
|
||||
|
||||
private function StartEncode() : void
|
||||
{
|
||||
byteout = new ByteArray();
|
||||
bytenew = 0;
|
||||
bytepos = 7;
|
||||
writeWord(65496);
|
||||
writeAPP0();
|
||||
writeDQT();
|
||||
writeSOF0(SrcWidth,SrcHeight);
|
||||
writeDHT();
|
||||
writeSOS();
|
||||
DCY = 0;
|
||||
DCV = 0;
|
||||
DCU = 0;
|
||||
bytenew = 0;
|
||||
bytepos = 7;
|
||||
this.dispatchEvent(new ProgressEvent("progress",false,false,0,TotalSize));
|
||||
setTimeout(AsyncLoop,10,0,0);
|
||||
}
|
||||
|
||||
private function AsyncLoop(param1:int, param2:int) : void
|
||||
{
|
||||
var _loc3_:int = 0;
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < PixelsPerIter)
|
||||
{
|
||||
RGB2YUV(Source,param1,param2,SrcWidth,SrcHeight);
|
||||
DCY = processDU(YDU,fdtbl_Y,DCY,YDC_HT,YAC_HT);
|
||||
DCU = processDU(UDU,fdtbl_UV,DCU,UVDC_HT,UVAC_HT);
|
||||
DCV = processDU(VDU,fdtbl_UV,DCV,UVDC_HT,UVAC_HT);
|
||||
param1 += 8;
|
||||
if(param1 >= SrcWidth)
|
||||
{
|
||||
param1 = 0;
|
||||
param2 += 8;
|
||||
}
|
||||
if(param2 >= SrcHeight)
|
||||
{
|
||||
setTimeout(FinishEncode,10);
|
||||
return;
|
||||
}
|
||||
CurrentTotalPos += 64;
|
||||
if(CurrentTotalPos >= NextProgressAt)
|
||||
{
|
||||
this.dispatchEvent(new ProgressEvent("progress",false,false,CurrentTotalPos,TotalSize));
|
||||
NextProgressAt += PercentageInc;
|
||||
}
|
||||
_loc3_++;
|
||||
}
|
||||
setTimeout(AsyncLoop,10,param1,param2);
|
||||
}
|
||||
|
||||
private function FinishEncode() : void
|
||||
{
|
||||
var _loc1_:BitString = null;
|
||||
if(bytepos >= 0)
|
||||
{
|
||||
_loc1_ = new BitString();
|
||||
_loc1_.len = bytepos + 1;
|
||||
_loc1_.val = (1 << bytepos + 1) - 1;
|
||||
writeBits(_loc1_);
|
||||
}
|
||||
writeWord(65497);
|
||||
this.dispatchEvent(new ProgressEvent("progress",false,false,TotalSize,TotalSize));
|
||||
this.dispatchEvent(new JPEGAsyncCompleteEvent(byteout));
|
||||
Working = false;
|
||||
}
|
||||
|
||||
private function initQuantTables(param1:int) : void
|
||||
{
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc6_:int = 0;
|
||||
var _loc2_:int = 0;
|
||||
var _loc5_:int = 0;
|
||||
var _loc7_:Array = [16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22,37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99];
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < 64)
|
||||
{
|
||||
_loc4_ = Math.floor((_loc7_[_loc5_] * param1 + 50) / 100);
|
||||
if(_loc4_ < 1)
|
||||
{
|
||||
_loc4_ = 1;
|
||||
}
|
||||
else if(_loc4_ > 255)
|
||||
{
|
||||
_loc4_ = 255;
|
||||
}
|
||||
YTable[ZigZag[_loc5_]] = _loc4_;
|
||||
_loc5_++;
|
||||
}
|
||||
var _loc3_:Array = [17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99];
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < 64)
|
||||
{
|
||||
_loc4_ = Math.floor((_loc3_[_loc5_] * param1 + 50) / 100);
|
||||
if(_loc4_ < 1)
|
||||
{
|
||||
_loc4_ = 1;
|
||||
}
|
||||
else if(_loc4_ > 255)
|
||||
{
|
||||
_loc4_ = 255;
|
||||
}
|
||||
UVTable[ZigZag[_loc5_]] = _loc4_;
|
||||
_loc5_++;
|
||||
}
|
||||
var _loc8_:Array = [1,1.387039845,1.306562965,1.175875602,1,0.785694958,0.5411961,0.275899379];
|
||||
_loc5_ = 0;
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < 8)
|
||||
{
|
||||
_loc2_ = 0;
|
||||
while(_loc2_ < 8)
|
||||
{
|
||||
fdtbl_Y[_loc5_] = 1 / (YTable[ZigZag[_loc5_]] * _loc8_[_loc6_] * _loc8_[_loc2_] * 8);
|
||||
fdtbl_UV[_loc5_] = 1 / (UVTable[ZigZag[_loc5_]] * _loc8_[_loc6_] * _loc8_[_loc2_] * 8);
|
||||
_loc5_++;
|
||||
_loc2_++;
|
||||
}
|
||||
_loc6_++;
|
||||
}
|
||||
}
|
||||
|
||||
private function computeHuffmanTbl(param1:Array, param2:Array) : Array
|
||||
{
|
||||
var _loc6_:int = 0;
|
||||
var _loc5_:int = 0;
|
||||
var _loc4_:int = 0;
|
||||
var _loc3_:int = 0;
|
||||
var _loc7_:Array = [];
|
||||
_loc6_ = 1;
|
||||
while(_loc6_ <= 16)
|
||||
{
|
||||
_loc5_ = 1;
|
||||
while(_loc5_ <= param1[_loc6_])
|
||||
{
|
||||
_loc7_[param2[_loc3_]] = new BitString();
|
||||
_loc7_[param2[_loc3_]].val = _loc4_;
|
||||
_loc7_[param2[_loc3_]].len = _loc6_;
|
||||
_loc3_++;
|
||||
_loc4_++;
|
||||
_loc5_++;
|
||||
}
|
||||
_loc4_ *= 2;
|
||||
_loc6_++;
|
||||
}
|
||||
return _loc7_;
|
||||
}
|
||||
|
||||
private function initHuffmanTbl() : void
|
||||
{
|
||||
YDC_HT = computeHuffmanTbl(std_dc_luminance_nrcodes,std_dc_luminance_values);
|
||||
UVDC_HT = computeHuffmanTbl(std_dc_chrominance_nrcodes,std_dc_chrominance_values);
|
||||
YAC_HT = computeHuffmanTbl(std_ac_luminance_nrcodes,std_ac_luminance_values);
|
||||
UVAC_HT = computeHuffmanTbl(std_ac_chrominance_nrcodes,std_ac_chrominance_values);
|
||||
}
|
||||
|
||||
private function initCategoryNumber() : void
|
||||
{
|
||||
var _loc2_:int = 0;
|
||||
var _loc4_:int = 0;
|
||||
var _loc1_:int = 1;
|
||||
var _loc3_:int = 2;
|
||||
_loc4_ = 1;
|
||||
while(_loc4_ <= 15)
|
||||
{
|
||||
_loc2_ = _loc1_;
|
||||
while(_loc2_ < _loc3_)
|
||||
{
|
||||
category[32767 + _loc2_] = _loc4_;
|
||||
bitcode[32767 + _loc2_] = new BitString();
|
||||
bitcode[32767 + _loc2_].len = _loc4_;
|
||||
bitcode[32767 + _loc2_].val = _loc2_;
|
||||
_loc2_++;
|
||||
}
|
||||
_loc2_ = -(_loc3_ - 1);
|
||||
while(_loc2_ <= -_loc1_)
|
||||
{
|
||||
category[32767 + _loc2_] = _loc4_;
|
||||
bitcode[32767 + _loc2_] = new BitString();
|
||||
bitcode[32767 + _loc2_].len = _loc4_;
|
||||
bitcode[32767 + _loc2_].val = _loc3_ - 1 + _loc2_;
|
||||
_loc2_++;
|
||||
}
|
||||
_loc1_ <<= 1;
|
||||
_loc3_ <<= 1;
|
||||
_loc4_++;
|
||||
}
|
||||
}
|
||||
|
||||
private function writeBits(param1:BitString) : void
|
||||
{
|
||||
var _loc3_:int = param1.val;
|
||||
var _loc2_:int = param1.len - 1;
|
||||
while(_loc2_ >= 0)
|
||||
{
|
||||
if(_loc3_ & uint(1 << _loc2_))
|
||||
{
|
||||
bytenew |= uint(1 << bytepos);
|
||||
}
|
||||
_loc2_--;
|
||||
bytepos = bytepos - 1;
|
||||
if(bytepos < 0)
|
||||
{
|
||||
if(bytenew == 255)
|
||||
{
|
||||
writeByte(255);
|
||||
writeByte(0);
|
||||
}
|
||||
else
|
||||
{
|
||||
writeByte(bytenew);
|
||||
}
|
||||
bytepos = 7;
|
||||
bytenew = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private function writeByte(param1:int) : void
|
||||
{
|
||||
byteout.writeByte(param1);
|
||||
}
|
||||
|
||||
private function writeWord(param1:int) : void
|
||||
{
|
||||
writeByte(param1 >> 8 & 0xFF);
|
||||
writeByte(param1 & 0xFF);
|
||||
}
|
||||
|
||||
private function fDCTQuant(param1:Array, param2:Array) : Array
|
||||
{
|
||||
var _loc7_:int = 0;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc16_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc17_:Number = NaN;
|
||||
var _loc21_:Number = NaN;
|
||||
var _loc18_:Number = NaN;
|
||||
var _loc20_:Number = NaN;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc22_:Number = NaN;
|
||||
var _loc23_:Number = NaN;
|
||||
var _loc3_:int = 0;
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < 8)
|
||||
{
|
||||
_loc15_ = param1[_loc3_ + 0] + param1[_loc3_ + 7];
|
||||
_loc16_ = param1[_loc3_ + 0] - param1[_loc3_ + 7];
|
||||
_loc11_ = param1[_loc3_ + 1] + param1[_loc3_ + 6];
|
||||
_loc8_ = param1[_loc3_ + 1] - param1[_loc3_ + 6];
|
||||
_loc13_ = param1[_loc3_ + 2] + param1[_loc3_ + 5];
|
||||
_loc6_ = param1[_loc3_ + 2] - param1[_loc3_ + 5];
|
||||
_loc9_ = param1[_loc3_ + 3] + param1[_loc3_ + 4];
|
||||
_loc10_ = param1[_loc3_ + 3] - param1[_loc3_ + 4];
|
||||
_loc5_ = _loc15_ + _loc9_;
|
||||
_loc12_ = _loc15_ - _loc9_;
|
||||
_loc4_ = _loc11_ + _loc13_;
|
||||
_loc14_ = _loc11_ - _loc13_;
|
||||
param1[_loc3_ + 0] = _loc5_ + _loc4_;
|
||||
param1[_loc3_ + 4] = _loc5_ - _loc4_;
|
||||
_loc17_ = (_loc14_ + _loc12_) * 0.707106781;
|
||||
param1[_loc3_ + 2] = _loc12_ + _loc17_;
|
||||
param1[_loc3_ + 6] = _loc12_ - _loc17_;
|
||||
_loc5_ = _loc10_ + _loc6_;
|
||||
_loc4_ = _loc6_ + _loc8_;
|
||||
_loc14_ = _loc8_ + _loc16_;
|
||||
_loc21_ = (_loc5_ - _loc14_) * 0.382683433;
|
||||
_loc18_ = 0.5411961 * _loc5_ + _loc21_;
|
||||
_loc20_ = 1.306562965 * _loc14_ + _loc21_;
|
||||
_loc19_ = _loc4_ * 0.707106781;
|
||||
_loc22_ = _loc16_ + _loc19_;
|
||||
_loc23_ = _loc16_ - _loc19_;
|
||||
param1[_loc3_ + 5] = _loc23_ + _loc18_;
|
||||
param1[_loc3_ + 3] = _loc23_ - _loc18_;
|
||||
param1[_loc3_ + 1] = _loc22_ + _loc20_;
|
||||
param1[_loc3_ + 7] = _loc22_ - _loc20_;
|
||||
_loc3_ += 8;
|
||||
_loc7_++;
|
||||
}
|
||||
_loc3_ = 0;
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < 8)
|
||||
{
|
||||
_loc15_ = param1[_loc3_ + 0] + param1[_loc3_ + 56];
|
||||
_loc16_ = param1[_loc3_ + 0] - param1[_loc3_ + 56];
|
||||
_loc11_ = param1[_loc3_ + 8] + param1[_loc3_ + 48];
|
||||
_loc8_ = param1[_loc3_ + 8] - param1[_loc3_ + 48];
|
||||
_loc13_ = param1[_loc3_ + 16] + param1[_loc3_ + 40];
|
||||
_loc6_ = param1[_loc3_ + 16] - param1[_loc3_ + 40];
|
||||
_loc9_ = param1[_loc3_ + 24] + param1[_loc3_ + 32];
|
||||
_loc10_ = param1[_loc3_ + 24] - param1[_loc3_ + 32];
|
||||
_loc5_ = _loc15_ + _loc9_;
|
||||
_loc12_ = _loc15_ - _loc9_;
|
||||
_loc4_ = _loc11_ + _loc13_;
|
||||
_loc14_ = _loc11_ - _loc13_;
|
||||
param1[_loc3_ + 0] = _loc5_ + _loc4_;
|
||||
param1[_loc3_ + 32] = _loc5_ - _loc4_;
|
||||
_loc17_ = (_loc14_ + _loc12_) * 0.707106781;
|
||||
param1[_loc3_ + 16] = _loc12_ + _loc17_;
|
||||
param1[_loc3_ + 48] = _loc12_ - _loc17_;
|
||||
_loc5_ = _loc10_ + _loc6_;
|
||||
_loc4_ = _loc6_ + _loc8_;
|
||||
_loc14_ = _loc8_ + _loc16_;
|
||||
_loc21_ = (_loc5_ - _loc14_) * 0.382683433;
|
||||
_loc18_ = 0.5411961 * _loc5_ + _loc21_;
|
||||
_loc20_ = 1.306562965 * _loc14_ + _loc21_;
|
||||
_loc19_ = _loc4_ * 0.707106781;
|
||||
_loc22_ = _loc16_ + _loc19_;
|
||||
_loc23_ = _loc16_ - _loc19_;
|
||||
param1[_loc3_ + 40] = _loc23_ + _loc18_;
|
||||
param1[_loc3_ + 24] = _loc23_ - _loc18_;
|
||||
param1[_loc3_ + 8] = _loc22_ + _loc20_;
|
||||
param1[_loc3_ + 56] = _loc22_ - _loc20_;
|
||||
_loc3_++;
|
||||
_loc7_++;
|
||||
}
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < 64)
|
||||
{
|
||||
param1[_loc7_] = Math.round(param1[_loc7_] * param2[_loc7_]);
|
||||
_loc7_++;
|
||||
}
|
||||
return param1;
|
||||
}
|
||||
|
||||
private function writeAPP0() : void
|
||||
{
|
||||
writeWord(65504);
|
||||
writeWord(16);
|
||||
writeByte(74);
|
||||
writeByte(70);
|
||||
writeByte(73);
|
||||
writeByte(70);
|
||||
writeByte(0);
|
||||
writeByte(1);
|
||||
writeByte(1);
|
||||
writeByte(0);
|
||||
writeWord(1);
|
||||
writeWord(1);
|
||||
writeByte(0);
|
||||
writeByte(0);
|
||||
}
|
||||
|
||||
private function writeSOF0(param1:int, param2:int) : void
|
||||
{
|
||||
writeWord(65472);
|
||||
writeWord(17);
|
||||
writeByte(8);
|
||||
writeWord(param2);
|
||||
writeWord(param1);
|
||||
writeByte(3);
|
||||
writeByte(1);
|
||||
writeByte(17);
|
||||
writeByte(0);
|
||||
writeByte(2);
|
||||
writeByte(17);
|
||||
writeByte(1);
|
||||
writeByte(3);
|
||||
writeByte(17);
|
||||
writeByte(1);
|
||||
}
|
||||
|
||||
private function writeDQT() : void
|
||||
{
|
||||
var _loc1_:int = 0;
|
||||
writeWord(65499);
|
||||
writeWord(132);
|
||||
writeByte(0);
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 64)
|
||||
{
|
||||
writeByte(YTable[_loc1_]);
|
||||
_loc1_++;
|
||||
}
|
||||
writeByte(1);
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 64)
|
||||
{
|
||||
writeByte(UVTable[_loc1_]);
|
||||
_loc1_++;
|
||||
}
|
||||
}
|
||||
|
||||
private function writeDHT() : void
|
||||
{
|
||||
var _loc1_:int = 0;
|
||||
writeWord(65476);
|
||||
writeWord(418);
|
||||
writeByte(0);
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 16)
|
||||
{
|
||||
writeByte(std_dc_luminance_nrcodes[_loc1_ + 1]);
|
||||
_loc1_++;
|
||||
}
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ <= 11)
|
||||
{
|
||||
writeByte(std_dc_luminance_values[_loc1_]);
|
||||
_loc1_++;
|
||||
}
|
||||
writeByte(16);
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 16)
|
||||
{
|
||||
writeByte(std_ac_luminance_nrcodes[_loc1_ + 1]);
|
||||
_loc1_++;
|
||||
}
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ <= 161)
|
||||
{
|
||||
writeByte(std_ac_luminance_values[_loc1_]);
|
||||
_loc1_++;
|
||||
}
|
||||
writeByte(1);
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 16)
|
||||
{
|
||||
writeByte(std_dc_chrominance_nrcodes[_loc1_ + 1]);
|
||||
_loc1_++;
|
||||
}
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ <= 11)
|
||||
{
|
||||
writeByte(std_dc_chrominance_values[_loc1_]);
|
||||
_loc1_++;
|
||||
}
|
||||
writeByte(17);
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 16)
|
||||
{
|
||||
writeByte(std_ac_chrominance_nrcodes[_loc1_ + 1]);
|
||||
_loc1_++;
|
||||
}
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ <= 161)
|
||||
{
|
||||
writeByte(std_ac_chrominance_values[_loc1_]);
|
||||
_loc1_++;
|
||||
}
|
||||
}
|
||||
|
||||
private function writeSOS() : void
|
||||
{
|
||||
writeWord(65498);
|
||||
writeWord(12);
|
||||
writeByte(3);
|
||||
writeByte(1);
|
||||
writeByte(0);
|
||||
writeByte(2);
|
||||
writeByte(17);
|
||||
writeByte(3);
|
||||
writeByte(17);
|
||||
writeByte(0);
|
||||
writeByte(63);
|
||||
writeByte(0);
|
||||
}
|
||||
|
||||
private function processDU(param1:Array, param2:Array, param3:Number, param4:Array, param5:Array) : Number
|
||||
{
|
||||
var _loc9_:int = 0;
|
||||
var _loc11_:int = 0;
|
||||
var _loc6_:int = 0;
|
||||
var _loc10_:int = 0;
|
||||
var _loc12_:BitString = param5[0];
|
||||
var _loc13_:BitString = param5[240];
|
||||
var _loc7_:Array = fDCTQuant(param1,param2);
|
||||
_loc9_ = 0;
|
||||
while(_loc9_ < 64)
|
||||
{
|
||||
DU[ZigZag[_loc9_]] = _loc7_[_loc9_];
|
||||
_loc9_++;
|
||||
}
|
||||
var _loc8_:int = DU[0] - param3;
|
||||
param3 = Number(DU[0]);
|
||||
if(_loc8_ == 0)
|
||||
{
|
||||
writeBits(param4[0]);
|
||||
}
|
||||
else
|
||||
{
|
||||
writeBits(param4[category[32767 + _loc8_]]);
|
||||
writeBits(bitcode[32767 + _loc8_]);
|
||||
}
|
||||
var _loc14_:int = 63;
|
||||
while(_loc14_ > 0 && DU[_loc14_] == 0)
|
||||
{
|
||||
_loc14_--;
|
||||
}
|
||||
if(_loc14_ == 0)
|
||||
{
|
||||
writeBits(_loc12_);
|
||||
return param3;
|
||||
}
|
||||
_loc9_ = 1;
|
||||
while(_loc9_ <= _loc14_)
|
||||
{
|
||||
_loc11_ = _loc9_;
|
||||
while(DU[_loc9_] == 0 && _loc9_ <= _loc14_)
|
||||
{
|
||||
_loc9_++;
|
||||
}
|
||||
_loc6_ = _loc9_ - _loc11_;
|
||||
if(_loc6_ >= 16)
|
||||
{
|
||||
_loc10_ = 1;
|
||||
while(_loc10_ <= _loc6_ / 16)
|
||||
{
|
||||
writeBits(_loc13_);
|
||||
_loc10_++;
|
||||
}
|
||||
_loc6_ &= 15;
|
||||
}
|
||||
writeBits(param5[_loc6_ * 16 + category[32767 + DU[_loc9_]]]);
|
||||
writeBits(bitcode[32767 + DU[_loc9_]]);
|
||||
_loc9_++;
|
||||
}
|
||||
if(_loc14_ != 63)
|
||||
{
|
||||
writeBits(_loc12_);
|
||||
}
|
||||
return param3;
|
||||
}
|
||||
|
||||
private function RGB2YUV(param1:Object, param2:int, param3:int, param4:int = 0, param5:int = 0) : void
|
||||
{
|
||||
var _loc12_:int = 0;
|
||||
var _loc11_:int = 0;
|
||||
var _loc6_:* = 0;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc9_:int = 0;
|
||||
_loc12_ = 0;
|
||||
while(_loc12_ < 8)
|
||||
{
|
||||
_loc11_ = 0;
|
||||
while(_loc11_ < 8)
|
||||
{
|
||||
_loc6_ = getPixel32(param1,param2 + _loc11_,param3 + _loc12_,param4,param5);
|
||||
_loc7_ = _loc6_ >> 16 & 0xFF;
|
||||
_loc10_ = _loc6_ >> 8 & 0xFF;
|
||||
_loc8_ = _loc6_ & 0xFF;
|
||||
YDU[_loc9_] = 0.299 * _loc7_ + 0.587 * _loc10_ + 0.114 * _loc8_ - 128;
|
||||
UDU[_loc9_] = -0.16874 * _loc7_ + -0.33126 * _loc10_ + 0.5 * _loc8_;
|
||||
VDU[_loc9_] = 0.5 * _loc7_ + -0.41869 * _loc10_ + -0.08131 * _loc8_;
|
||||
_loc9_++;
|
||||
_loc11_++;
|
||||
}
|
||||
_loc12_++;
|
||||
}
|
||||
}
|
||||
|
||||
private function getPixel32(param1:Object, param2:int, param3:int, param4:int = 0, param5:int = 0) : uint
|
||||
{
|
||||
var _loc6_:BitmapData = null;
|
||||
var _loc7_:ByteArray = null;
|
||||
if(param1 is BitmapData)
|
||||
{
|
||||
_loc6_ = param1 as BitmapData;
|
||||
return _loc6_.getPixel32(param2,param3);
|
||||
}
|
||||
if(param1 is ByteArray)
|
||||
{
|
||||
_loc7_ = param1 as ByteArray;
|
||||
_loc7_.position = param3 * param4 * 4 + param2 * 4;
|
||||
return _loc7_.readUnsignedInt();
|
||||
}
|
||||
throw new ArgumentError("The source argument must be an instance of flash.display.BitmapData or flash.utils.ByteArray.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class BitString
|
||||
{
|
||||
|
||||
public var len:int = 0;
|
||||
|
||||
public var val:int = 0;
|
||||
|
||||
public function BitString()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,804 @@
|
||||
package com.sbi.graphics
|
||||
{
|
||||
import com.sbi.corelib.Set;
|
||||
import com.sbi.corelib.audio.SBAudio;
|
||||
import com.sbi.loader.ImageServerEvent;
|
||||
import com.sbi.loader.ImageServerURL;
|
||||
import flash.geom.Matrix;
|
||||
import flash.geom.Point;
|
||||
|
||||
public class LayerAnim
|
||||
{
|
||||
|
||||
public static const PLAY_LOOP:int = 0;
|
||||
|
||||
public static const PLAY_ONE_SHOT:int = 1;
|
||||
|
||||
public static const PLAY_LOOP__KEEP_CURRENT_FRAME:int = 2;
|
||||
|
||||
public static const PLAY_FRAME:int = 3;
|
||||
|
||||
public static const AN_SIT_NNE:int = 1;
|
||||
|
||||
public static const AN_SIT_NE:int = 2;
|
||||
|
||||
public static const AN_SIT_E:int = 3;
|
||||
|
||||
public static const AN_SIT_SE:int = 4;
|
||||
|
||||
public static const AN_SIT_SSE:int = 5;
|
||||
|
||||
public static const AN_MOVE_NNE:int = 7;
|
||||
|
||||
public static const AN_MOVE_NE:int = 8;
|
||||
|
||||
public static const AN_MOVE_E:int = 9;
|
||||
|
||||
public static const AN_MOVE_SE:int = 10;
|
||||
|
||||
public static const AN_MOVE_SSE:int = 11;
|
||||
|
||||
public static const AN_BBCARD:int = 13;
|
||||
|
||||
public static const AN_IDLE_SE:int = 14;
|
||||
|
||||
public static const AN_HUD_AVT:int = 15;
|
||||
|
||||
public static const AN_IDLE_NE:int = 16;
|
||||
|
||||
public static const AN_HOP:int = 17;
|
||||
|
||||
public static const AN_SLEEP:int = 22;
|
||||
|
||||
public static const AN_DANCE:int = 23;
|
||||
|
||||
public static const AN_PLAY:int = 6;
|
||||
|
||||
public static const AN_LEAP:int = 35;
|
||||
|
||||
public static const AN_JUMP_EAST:int = 34;
|
||||
|
||||
public static const AN_SWIM_N:int = 36;
|
||||
|
||||
public static const AN_SWIM_NE:int = 34;
|
||||
|
||||
public static const AN_SWIM_E:int = 29;
|
||||
|
||||
public static const AN_SWIM_SE:int = 35;
|
||||
|
||||
public static const AN_SWIM_S:int = 37;
|
||||
|
||||
public static const AN_FLOAT:int = 32;
|
||||
|
||||
public static const AN_WATER_DIVE:int = 41;
|
||||
|
||||
public static const AN_WATER_PLAY:int = 39;
|
||||
|
||||
public static const AN_WATER_SPIN:int = 33;
|
||||
|
||||
public static const AN_WATER_JIG:int = 38;
|
||||
|
||||
public static const AN_WATER_POSE:int = 40;
|
||||
|
||||
public static const AN_PHOTO:int = 42;
|
||||
|
||||
public static const AN_PARACHUTE_IDLE:int = 19;
|
||||
|
||||
public static const AN_PARACHUTE_JUMP:int = 24;
|
||||
|
||||
public static const AN_PARACHUTE_DISTRESS:int = 20;
|
||||
|
||||
public static const AN_PARACHUTE_LAND:int = 21;
|
||||
|
||||
public static const AN_WINDRIDER_JUMP:int = 28;
|
||||
|
||||
public static const AN_WINDRIDER_IDLE:int = 29;
|
||||
|
||||
public static const AN_WINDRIDER_FALL:int = 30;
|
||||
|
||||
public static const AN_WINDRIDER_START:int = 31;
|
||||
|
||||
public static const AN_WINDRIDER_DISTRESS:int = 20;
|
||||
|
||||
public static const AVATAR_BITMAP_OFFSET_X:int = 375;
|
||||
|
||||
public static const AVATAR_BITMAP_OFFSET_Y:int = 365;
|
||||
|
||||
private static var _activePool:Vector.<LayerAnim>;
|
||||
|
||||
private static var _avOffsets:Array;
|
||||
|
||||
private static var _throttle:int = 8;
|
||||
|
||||
private static var _lastEntry:int;
|
||||
|
||||
private static var _useMaxThrottle:Function;
|
||||
|
||||
private static function _isOnscreen(param1:LayerAnim):Boolean
|
||||
{
|
||||
return true;
|
||||
}
|
||||
private static function _hasSequence(param1:int):Boolean
|
||||
{
|
||||
return true;
|
||||
}
|
||||
private var _bitmap:LayerBitmap;
|
||||
|
||||
private var _avDefId:int;
|
||||
|
||||
private var _animId:int;
|
||||
|
||||
private var _frame:int;
|
||||
|
||||
private var _hFlip:Boolean;
|
||||
|
||||
private var _totalFrames:int;
|
||||
|
||||
private var _lastAnchorPoint:Point;
|
||||
|
||||
private var _x:int;
|
||||
|
||||
private var _y:int;
|
||||
|
||||
private var _rotation:int;
|
||||
|
||||
private var _xOff:int;
|
||||
|
||||
private var _yOff:int;
|
||||
|
||||
private var _bReposition:Boolean;
|
||||
|
||||
private var _bPause:Boolean;
|
||||
|
||||
private var _layers:Array;
|
||||
|
||||
private var _colors:Array;
|
||||
|
||||
private var _callback:Function;
|
||||
|
||||
private var _mode:int;
|
||||
|
||||
private var _tStep:int;
|
||||
|
||||
private var _bReload:Boolean;
|
||||
|
||||
private var _avatarEnabled:Boolean = true;
|
||||
|
||||
private var _requestAnimId:int;
|
||||
|
||||
private var _receivedData:Array;
|
||||
|
||||
private var _requestedIds:Set;
|
||||
|
||||
private var _requestedCacheKey:String;
|
||||
|
||||
private var _requestCallback:Function;
|
||||
|
||||
private var _requestMode:int;
|
||||
|
||||
private var _preloadRequestedIds:Set;
|
||||
|
||||
private var _preloadCallback:Function;
|
||||
|
||||
private var _bounceEnabled:Boolean;
|
||||
|
||||
private var _bounceOverride:Boolean;
|
||||
|
||||
private var _bounceOffSet:int;
|
||||
|
||||
private var _local:Boolean;
|
||||
|
||||
private var _skipWorldCheck:Boolean;
|
||||
|
||||
public function LayerAnim(param1:Class)
|
||||
{
|
||||
super();
|
||||
if(param1 != SingletonLock)
|
||||
{
|
||||
throw new Error("Invalid access. Use LayerAnim.getNew");
|
||||
}
|
||||
}
|
||||
|
||||
public static function set avOffsets(param1:Array) : void
|
||||
{
|
||||
_avOffsets = param1;
|
||||
}
|
||||
|
||||
public static function getAvOffset(param1:int) : Point
|
||||
{
|
||||
if(_avOffsets[param1])
|
||||
{
|
||||
return _avOffsets[param1];
|
||||
}
|
||||
return new Point(-100,-100);
|
||||
}
|
||||
|
||||
public static function set throttle(param1:int) : void
|
||||
{
|
||||
_throttle = param1;
|
||||
}
|
||||
|
||||
public static function getNew(param1:Boolean = false) : LayerAnim
|
||||
{
|
||||
if(!_activePool)
|
||||
{
|
||||
_activePool = new Vector.<LayerAnim>();
|
||||
}
|
||||
var _loc2_:LayerAnim = new LayerAnim(SingletonLock);
|
||||
_activePool.push(_loc2_);
|
||||
_loc2_.init(param1);
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
public static function destroy(param1:LayerAnim) : void
|
||||
{
|
||||
var _loc2_:int = _activePool.indexOf(param1);
|
||||
if(_loc2_ >= 0)
|
||||
{
|
||||
_activePool.splice(_loc2_,1);
|
||||
if(_loc2_ > 0 && _lastEntry >= _loc2_)
|
||||
{
|
||||
_lastEntry = _lastEntry - 1;
|
||||
}
|
||||
param1.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
public static function heartbeat() : void
|
||||
{
|
||||
var _loc2_:int = 0;
|
||||
var _loc4_:int = 0;
|
||||
var _loc1_:int = 0;
|
||||
var _loc5_:int = 0;
|
||||
if(_activePool && _activePool.length)
|
||||
{
|
||||
_loc2_ = int(_activePool.length);
|
||||
_loc4_ = _loc2_;
|
||||
_loc1_ = _loc2_ * 0.5;
|
||||
if(_loc1_ < 1 || _useMaxThrottle && _useMaxThrottle())
|
||||
{
|
||||
_loc1_ = 1;
|
||||
}
|
||||
if(_loc1_ > _throttle)
|
||||
{
|
||||
_loc1_ = _throttle;
|
||||
}
|
||||
_loc5_ = _lastEntry;
|
||||
for each(var _loc3_:LayerAnim in _activePool)
|
||||
{
|
||||
_loc3_._tStep++;
|
||||
}
|
||||
while(_loc1_ > 0 && _loc4_ > 0)
|
||||
{
|
||||
if(_loc5_ >= _loc2_)
|
||||
{
|
||||
_loc5_ = 0;
|
||||
}
|
||||
_loc3_ = _activePool[_loc5_++];
|
||||
if(_loc3_._tStep >= 2)
|
||||
{
|
||||
_loc3_._tStep = 0;
|
||||
if((_loc3_._requestMode == 1 || _isOnscreen(_loc3_) || _loc3_._skipWorldCheck) && _loc3_.heartbeat())
|
||||
{
|
||||
_loc1_--;
|
||||
}
|
||||
}
|
||||
_loc4_--;
|
||||
}
|
||||
_lastEntry = _loc5_;
|
||||
}
|
||||
}
|
||||
|
||||
public static function set useMaxThrottle(param1:Function) : void
|
||||
{
|
||||
_useMaxThrottle = param1;
|
||||
}
|
||||
|
||||
public static function set isOnscreen(param1:Function) : void
|
||||
{
|
||||
if(param1 != null)
|
||||
{
|
||||
_isOnscreen = param1;
|
||||
}
|
||||
}
|
||||
|
||||
public static function set hasSequence(param1:Function) : void
|
||||
{
|
||||
if(param1 != null)
|
||||
{
|
||||
_hasSequence = param1;
|
||||
}
|
||||
}
|
||||
|
||||
public static function trimAnims() : Set
|
||||
{
|
||||
var _loc2_:Set = new Set();
|
||||
if(_activePool && _activePool.length)
|
||||
{
|
||||
for each(var _loc1_:LayerAnim in _activePool)
|
||||
{
|
||||
_loc2_.addAll(_loc1_.bitmap.trimLayerGroups());
|
||||
}
|
||||
}
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
public function get bounceOffSet() : int
|
||||
{
|
||||
return _bounceOffSet;
|
||||
}
|
||||
|
||||
public function get bounceEnabled() : Boolean
|
||||
{
|
||||
return _bounceEnabled;
|
||||
}
|
||||
|
||||
public function set bounceEnabled(param1:Boolean) : void
|
||||
{
|
||||
_bounceEnabled = param1;
|
||||
}
|
||||
|
||||
public function set local(param1:Boolean) : void
|
||||
{
|
||||
_local = param1;
|
||||
}
|
||||
|
||||
private function init(param1:Boolean = false) : void
|
||||
{
|
||||
_bitmap = new LayerBitmap();
|
||||
_bitmap.pixelSnapping = "always";
|
||||
_layers = null;
|
||||
_requestAnimId = -1;
|
||||
_avDefId = -1;
|
||||
_animId = -1;
|
||||
_totalFrames = 0;
|
||||
_lastAnchorPoint = new Point(0,0);
|
||||
_bReposition = true;
|
||||
_bReload = true;
|
||||
_tStep = 1;
|
||||
_bounceEnabled = false;
|
||||
_avatarEnabled = true;
|
||||
_skipWorldCheck = param1;
|
||||
_preloadRequestedIds = new Set();
|
||||
_requestedIds = new Set();
|
||||
}
|
||||
|
||||
private function destroy() : void
|
||||
{
|
||||
if(_bitmap)
|
||||
{
|
||||
_bitmap.destroy();
|
||||
_bitmap = null;
|
||||
}
|
||||
ImageServerURL.instance.removeEventListener("OnNewData",onReceiveData);
|
||||
_layers = null;
|
||||
_callback = null;
|
||||
_preloadRequestedIds.clear();
|
||||
_requestedIds.clear();
|
||||
}
|
||||
|
||||
public function set avDefId(param1:int) : void
|
||||
{
|
||||
if(param1 != _avDefId)
|
||||
{
|
||||
_avDefId = param1;
|
||||
_xOff = -getAvOffset(_avDefId).x - 375;
|
||||
_yOff = -getAvOffset(_avDefId).y - 365;
|
||||
_bReposition = true;
|
||||
_bReload = true;
|
||||
}
|
||||
}
|
||||
|
||||
public function get layers() : Array
|
||||
{
|
||||
return _layers;
|
||||
}
|
||||
|
||||
public function get avDefId() : int
|
||||
{
|
||||
return _avDefId;
|
||||
}
|
||||
|
||||
public function get animId() : int
|
||||
{
|
||||
return _animId;
|
||||
}
|
||||
|
||||
public function get hFlip() : Boolean
|
||||
{
|
||||
return _hFlip;
|
||||
}
|
||||
|
||||
public function get frame() : int
|
||||
{
|
||||
return _frame;
|
||||
}
|
||||
|
||||
public function set frame(param1:int) : void
|
||||
{
|
||||
_frame = param1;
|
||||
}
|
||||
|
||||
public function set avatarEnabled(param1:Boolean) : void
|
||||
{
|
||||
_avatarEnabled = param1;
|
||||
}
|
||||
|
||||
public function set layers(param1:Array) : void
|
||||
{
|
||||
var _loc2_:Boolean = true;
|
||||
var _loc3_:Boolean = false;
|
||||
if(_layers && _layers.length == param1.length)
|
||||
{
|
||||
_loc2_ = false;
|
||||
for(var _loc4_ in param1)
|
||||
{
|
||||
if(!_layers[_loc4_] || _layers[_loc4_].l != param1[_loc4_].l)
|
||||
{
|
||||
_loc2_ = true;
|
||||
break;
|
||||
}
|
||||
if(_layers[_loc4_].c != param1[_loc4_].c)
|
||||
{
|
||||
_loc3_ = true;
|
||||
}
|
||||
}
|
||||
if(!_loc2_ && !_loc3_)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
if(param1.length > 0)
|
||||
{
|
||||
_layers = param1;
|
||||
if(_loc2_)
|
||||
{
|
||||
_bReload = true;
|
||||
}
|
||||
else if(_loc3_)
|
||||
{
|
||||
for each(var _loc5_:Object in param1)
|
||||
{
|
||||
_bitmap.setLayerColor(ImageServerURL.instance.getLayerIndex(_loc5_.l),_loc5_.c);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function get x() : int
|
||||
{
|
||||
return _x;
|
||||
}
|
||||
|
||||
public function get y() : int
|
||||
{
|
||||
return _y;
|
||||
}
|
||||
|
||||
public function set x(param1:int) : void
|
||||
{
|
||||
if(_x != param1)
|
||||
{
|
||||
_x = param1;
|
||||
_bReposition = true;
|
||||
}
|
||||
}
|
||||
|
||||
public function set y(param1:int) : void
|
||||
{
|
||||
if(_y != param1)
|
||||
{
|
||||
_y = param1;
|
||||
_bReposition = true;
|
||||
}
|
||||
}
|
||||
|
||||
public function set alpha(param1:Number) : void
|
||||
{
|
||||
_bitmap.alpha = param1;
|
||||
}
|
||||
|
||||
public function set rotation(param1:Number) : void
|
||||
{
|
||||
if(_rotation != param1)
|
||||
{
|
||||
_rotation = param1;
|
||||
_bReposition = true;
|
||||
}
|
||||
}
|
||||
|
||||
public function set hFlip(param1:Boolean) : void
|
||||
{
|
||||
if(param1 != _hFlip)
|
||||
{
|
||||
_hFlip = param1;
|
||||
}
|
||||
}
|
||||
|
||||
public function set visible(param1:Boolean) : void
|
||||
{
|
||||
_bitmap.visible = param1;
|
||||
}
|
||||
|
||||
public function get visible() : Boolean
|
||||
{
|
||||
return _bitmap.visible;
|
||||
}
|
||||
|
||||
public function set pause(param1:Boolean) : void
|
||||
{
|
||||
_bPause = param1;
|
||||
}
|
||||
|
||||
public function get bitmap() : LayerBitmap
|
||||
{
|
||||
return _bitmap;
|
||||
}
|
||||
|
||||
public function playAnim(param1:int, param2:int = 0, param3:Function = null, param4:int = 0) : void
|
||||
{
|
||||
if(_requestAnimId == -1 && param1 != _animId || _requestAnimId != param1 || param2 == 3)
|
||||
{
|
||||
_requestCallback = param3;
|
||||
_requestMode = param2;
|
||||
_requestAnimId = param1;
|
||||
_bReload = true;
|
||||
_bounceOverride = param1 != 17;
|
||||
}
|
||||
}
|
||||
|
||||
public function preload(param1:Array, param2:Function) : void
|
||||
{
|
||||
var _loc4_:int = 0;
|
||||
_preloadCallback = param2;
|
||||
var _loc3_:Array = [];
|
||||
while(_loc4_ < param1.length)
|
||||
{
|
||||
buildRequestArray(param1[_loc4_],_loc3_,null);
|
||||
_loc4_++;
|
||||
}
|
||||
_preloadRequestedIds.addAll(_loc3_);
|
||||
requestImages(_loc3_);
|
||||
}
|
||||
|
||||
private function heartbeat() : Boolean
|
||||
{
|
||||
var _loc1_:Boolean = false;
|
||||
if(_bReload)
|
||||
{
|
||||
loadAnim();
|
||||
}
|
||||
if(_totalFrames == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if(_mode == 3 && _callback != null)
|
||||
{
|
||||
_callback(_totalFrames);
|
||||
_callback = null;
|
||||
}
|
||||
if(_frame >= _totalFrames)
|
||||
{
|
||||
if(_mode == 1)
|
||||
{
|
||||
_frame = _totalFrames > 0 ? _totalFrames - 1 : 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
_frame = 0;
|
||||
}
|
||||
if(_callback != null)
|
||||
{
|
||||
_callback(this,_animId);
|
||||
_callback = null;
|
||||
}
|
||||
}
|
||||
if(_avatarEnabled)
|
||||
{
|
||||
_lastAnchorPoint.copyFrom(_bitmap.anchorPoint);
|
||||
_loc1_ = _bitmap.paint(_frame,_hFlip);
|
||||
if(!_lastAnchorPoint.equals(_bitmap.anchorPoint))
|
||||
{
|
||||
_bReposition = true;
|
||||
}
|
||||
}
|
||||
calcBounceOffset();
|
||||
if(_bReposition)
|
||||
{
|
||||
updateBitmapPos();
|
||||
}
|
||||
if(!_bPause && _mode != 3)
|
||||
{
|
||||
_frame = _frame + 1;
|
||||
}
|
||||
return _loc1_;
|
||||
}
|
||||
|
||||
private function calcBounceOffset() : void
|
||||
{
|
||||
var _loc3_:int = 0;
|
||||
var _loc1_:int = 0;
|
||||
var _loc2_:Number = NaN;
|
||||
if(_bounceEnabled && !_bounceOverride)
|
||||
{
|
||||
_loc3_ = _bounceOffSet;
|
||||
_loc1_ = 75;
|
||||
_loc2_ = (_frame + 1) / _totalFrames;
|
||||
_bounceOffSet = (1 - (2 * _loc2_ - 1) * (2 * _loc2_ - 1)) * _loc1_;
|
||||
if(_bounceOffSet != _loc3_)
|
||||
{
|
||||
if(_local && _frame == 0)
|
||||
{
|
||||
SBAudio.playCachedSound("BOUNCE");
|
||||
}
|
||||
_bReposition = true;
|
||||
}
|
||||
}
|
||||
else if(_bounceOffSet != 0)
|
||||
{
|
||||
_bounceOffSet = 0;
|
||||
_bReposition = true;
|
||||
}
|
||||
}
|
||||
|
||||
private function updateBitmapPos() : void
|
||||
{
|
||||
var _loc3_:Matrix = null;
|
||||
var _loc4_:Point = _bitmap.anchorPoint;
|
||||
var _loc1_:int = _x + _loc4_.x + _xOff;
|
||||
var _loc2_:int = _y + _loc4_.y + _yOff - _bounceOffSet;
|
||||
if(_rotation)
|
||||
{
|
||||
_loc3_ = _bitmap.transform.matrix;
|
||||
_loc3_.identity();
|
||||
_loc3_.translate(_loc4_.x + _xOff,_loc4_.y + _yOff);
|
||||
_loc3_.rotate(_rotation * (3.141592653589793 / 180));
|
||||
_loc3_.translate(_loc1_,_loc2_);
|
||||
_bitmap.transform.matrix = _loc3_;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(_bitmap.rotation != _rotation)
|
||||
{
|
||||
_bitmap.rotation = _rotation;
|
||||
}
|
||||
_bitmap.x = _loc1_;
|
||||
_bitmap.y = _loc2_;
|
||||
}
|
||||
_bReposition = false;
|
||||
}
|
||||
|
||||
private function loadAnim() : void
|
||||
{
|
||||
var _loc1_:int = 0;
|
||||
if(_layers != null && _layers.length > 0)
|
||||
{
|
||||
_loc1_ = _requestAnimId != -1 ? _requestAnimId : _animId;
|
||||
if(_loc1_ >= 0)
|
||||
{
|
||||
_requestAnimId = _loc1_;
|
||||
requestAnim(_loc1_);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private function requestAnim(param1:int) : void
|
||||
{
|
||||
_bReload = false;
|
||||
var _loc4_:Array = [];
|
||||
var _loc2_:Array = [];
|
||||
buildRequestArray(param1,_loc2_,_loc4_);
|
||||
_loc2_.sort();
|
||||
var _loc3_:String = _loc2_.join();
|
||||
_colors = _loc4_;
|
||||
_requestedCacheKey = _loc3_;
|
||||
_receivedData = [];
|
||||
_requestedIds = new Set();
|
||||
_requestedIds.addAll(_loc2_);
|
||||
requestImages(_loc2_);
|
||||
}
|
||||
|
||||
private function buildRequestArray(param1:int, param2:Array, param3:Array) : void
|
||||
{
|
||||
var _loc4_:uint = ImageArrayHelper.packId(_avDefId,param1,0);
|
||||
if(_hasSequence(_loc4_))
|
||||
{
|
||||
param2.push(_loc4_);
|
||||
}
|
||||
for each(var _loc5_:Object in _layers)
|
||||
{
|
||||
_loc4_ = ImageArrayHelper.packId(_avDefId,param1,_loc5_.l);
|
||||
param2.push(_loc4_);
|
||||
if(param3)
|
||||
{
|
||||
param3[_loc4_] = _loc5_.c;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private function requestImages(param1:Array) : void
|
||||
{
|
||||
ImageServerURL.instance.addEventListener("OnNewData",onReceiveData,false,0,true);
|
||||
for each(var _loc2_:uint in param1)
|
||||
{
|
||||
ImageServerURL.instance.requestImage(_loc2_);
|
||||
}
|
||||
}
|
||||
|
||||
private function onReceiveData(param1:ImageServerEvent) : void
|
||||
{
|
||||
var _loc2_:* = 0;
|
||||
var _loc3_:int = 0;
|
||||
if(_preloadRequestedIds.remove(param1.id))
|
||||
{
|
||||
if(_preloadRequestedIds.isEmpty())
|
||||
{
|
||||
if(_requestedIds.isEmpty())
|
||||
{
|
||||
ImageServerURL.instance.removeEventListener("OnNewData",onReceiveData);
|
||||
}
|
||||
if(_preloadCallback != null)
|
||||
{
|
||||
_preloadCallback(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(_requestedIds.remove(param1.id))
|
||||
{
|
||||
_loc3_ = param1.layer;
|
||||
if(_loc3_ > 0)
|
||||
{
|
||||
_loc2_ = uint(_colors[param1.id]);
|
||||
}
|
||||
if(param1.success)
|
||||
{
|
||||
_receivedData.push({
|
||||
"l":_loc3_,
|
||||
"d":param1.imageData,
|
||||
"c":_loc2_
|
||||
});
|
||||
}
|
||||
if(_requestedIds.isEmpty())
|
||||
{
|
||||
if(_preloadRequestedIds.isEmpty())
|
||||
{
|
||||
ImageServerURL.instance.removeEventListener("OnNewData",onReceiveData);
|
||||
}
|
||||
for each(var _loc4_:Object in _receivedData)
|
||||
{
|
||||
_bitmap.setLayer(_loc4_.l,_loc4_.d,_loc4_.c,_requestedCacheKey);
|
||||
}
|
||||
finishAnimRequest();
|
||||
_receivedData = null;
|
||||
_requestedCacheKey = null;
|
||||
_colors = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private function finishAnimRequest() : void
|
||||
{
|
||||
if(_mode != 2 && _mode != 3)
|
||||
{
|
||||
_frame = 0;
|
||||
}
|
||||
_mode = _requestMode;
|
||||
if(_requestAnimId >= 0)
|
||||
{
|
||||
_animId = _requestAnimId;
|
||||
}
|
||||
_requestAnimId = -1;
|
||||
_callback = _requestCallback;
|
||||
_totalFrames = _bitmap.length;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class SingletonLock
|
||||
{
|
||||
|
||||
public function SingletonLock()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,799 @@
|
||||
package com.sbi.graphics
|
||||
{
|
||||
import com.sbi.corelib.Set;
|
||||
import com.sbi.loader.ImageServerURL;
|
||||
import flash.display.Bitmap;
|
||||
import flash.display.BitmapData;
|
||||
import flash.geom.Point;
|
||||
import flash.utils.ByteArray;
|
||||
import flash.utils.Dictionary;
|
||||
|
||||
public class LayerBitmap extends Bitmap
|
||||
{
|
||||
|
||||
public static const BACKGROUND_COLOR:uint = 0;
|
||||
|
||||
private var _anchorPoint:Point;
|
||||
|
||||
private var _activeLayerGroup:LayerGroup;
|
||||
|
||||
private var _bmin:Point;
|
||||
|
||||
private var _bmax:Point;
|
||||
|
||||
private var _lastFrame:int;
|
||||
|
||||
private var _lastHFlip:Boolean;
|
||||
|
||||
private var _blendColor:uint;
|
||||
|
||||
private var _cachedLayerGroups:Dictionary;
|
||||
|
||||
private var _currCacheKey:String;
|
||||
|
||||
public function LayerBitmap()
|
||||
{
|
||||
super();
|
||||
_activeLayerGroup = new LayerGroup();
|
||||
_anchorPoint = new Point();
|
||||
_bmin = new Point();
|
||||
_bmax = new Point();
|
||||
_cachedLayerGroups = new Dictionary();
|
||||
}
|
||||
|
||||
public function destroy() : void
|
||||
{
|
||||
if(_currCacheKey == null)
|
||||
{
|
||||
_activeLayerGroup.destroy();
|
||||
}
|
||||
for each(var _loc1_:LayerGroup in _cachedLayerGroups)
|
||||
{
|
||||
_loc1_.destroy();
|
||||
}
|
||||
_cachedLayerGroups = null;
|
||||
if(this.bitmapData)
|
||||
{
|
||||
this.bitmapData.dispose();
|
||||
this.bitmapData = null;
|
||||
}
|
||||
}
|
||||
|
||||
public function get length() : int
|
||||
{
|
||||
return _activeLayerGroup.length;
|
||||
}
|
||||
|
||||
public function release() : void
|
||||
{
|
||||
for each(var _loc1_:LayerGroup in _cachedLayerGroups)
|
||||
{
|
||||
_loc1_.destroy();
|
||||
}
|
||||
_cachedLayerGroups = new Dictionary();
|
||||
if(_currCacheKey == null)
|
||||
{
|
||||
_activeLayerGroup.destroy();
|
||||
}
|
||||
else
|
||||
{
|
||||
_currCacheKey = null;
|
||||
}
|
||||
_activeLayerGroup = new LayerGroup();
|
||||
invalidate();
|
||||
_lastHFlip = false;
|
||||
}
|
||||
|
||||
public function invalidate() : void
|
||||
{
|
||||
_lastFrame = -1;
|
||||
}
|
||||
|
||||
public function trimLayerGroups() : Set
|
||||
{
|
||||
var _loc3_:LayerGroup = null;
|
||||
var _loc2_:Set = new Set();
|
||||
for(var _loc4_:Object in _cachedLayerGroups)
|
||||
{
|
||||
if(_loc4_ != _currCacheKey)
|
||||
{
|
||||
_loc3_ = _cachedLayerGroups[_loc4_];
|
||||
if(_loc3_.decrementTtl() < 1)
|
||||
{
|
||||
delete _cachedLayerGroups[_loc4_];
|
||||
_loc3_.destroy();
|
||||
continue;
|
||||
}
|
||||
}
|
||||
for each(var _loc1_:int in String(_loc4_).split(","))
|
||||
{
|
||||
_loc2_.add(_loc1_);
|
||||
}
|
||||
}
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
public function setLayer(param1:int, param2:Object, param3:uint, param4:String = null) : void
|
||||
{
|
||||
if(param1 < 0 || param1 > 10)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if(param4 != null)
|
||||
{
|
||||
if(param4 != _currCacheKey)
|
||||
{
|
||||
if(_currCacheKey == null)
|
||||
{
|
||||
_cachedLayerGroups[param4] = _activeLayerGroup;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(!_cachedLayerGroups[param4])
|
||||
{
|
||||
_cachedLayerGroups[param4] = new LayerGroup();
|
||||
}
|
||||
_activeLayerGroup = _cachedLayerGroups[param4];
|
||||
}
|
||||
_currCacheKey = param4;
|
||||
}
|
||||
}
|
||||
if(param2)
|
||||
{
|
||||
if(_activeLayerGroup.layers[param1] == null)
|
||||
{
|
||||
_activeLayerGroup.layers[param1] = {
|
||||
"c":param3,
|
||||
"lastColor":-1,
|
||||
"blendColor":-1
|
||||
};
|
||||
_activeLayerGroup.checkColors = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
setLayerColor(param1,param3);
|
||||
}
|
||||
_activeLayerGroup.layers[param1].o = param2;
|
||||
}
|
||||
else
|
||||
{
|
||||
delete _activeLayerGroup.layers[param1];
|
||||
_activeLayerGroup.checkColors = true;
|
||||
}
|
||||
invalidate();
|
||||
}
|
||||
|
||||
public function setLayerColor(param1:int, param2:uint) : void
|
||||
{
|
||||
var _loc3_:Object = _activeLayerGroup.layers[param1];
|
||||
if(_loc3_ && param2 != _loc3_.c)
|
||||
{
|
||||
_loc3_.c = param2;
|
||||
_activeLayerGroup.checkColors = true;
|
||||
}
|
||||
}
|
||||
|
||||
public function setBlendColor(param1:uint) : void
|
||||
{
|
||||
if(_blendColor != param1)
|
||||
{
|
||||
_blendColor = param1;
|
||||
for each(var _loc2_:LayerGroup in _cachedLayerGroups)
|
||||
{
|
||||
_loc2_.checkColors = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function switchLayerGroup(param1:Array, param2:String = null) : Boolean
|
||||
{
|
||||
var _loc6_:int = 0;
|
||||
var _loc4_:LayerGroup = param2 == null ? _activeLayerGroup : _cachedLayerGroups[param2];
|
||||
if(_loc4_ == null || param1 == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
var _loc3_:ImageServerURL = ImageServerURL.instance;
|
||||
for each(var _loc5_:Object in param1)
|
||||
{
|
||||
_loc6_ = _loc3_.getLayerIndex(_loc5_.l);
|
||||
if(!_loc4_.layers[_loc6_])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if(_loc4_.layers[_loc6_].c != _loc5_.c)
|
||||
{
|
||||
_loc4_.layers[_loc6_].c = _loc5_.c;
|
||||
_loc4_.checkColors = true;
|
||||
}
|
||||
}
|
||||
if(param2 != null && param2 != _currCacheKey)
|
||||
{
|
||||
_activeLayerGroup = _cachedLayerGroups[param2];
|
||||
_currCacheKey = param2;
|
||||
}
|
||||
invalidate();
|
||||
return true;
|
||||
}
|
||||
|
||||
public function get anchorPoint() : Point
|
||||
{
|
||||
return _anchorPoint;
|
||||
}
|
||||
|
||||
private function refreshLayerPalette(param1:int) : Boolean
|
||||
{
|
||||
var _loc7_:Boolean = false;
|
||||
var _loc5_:* = 0;
|
||||
var _loc6_:Array = null;
|
||||
var _loc8_:int = 0;
|
||||
var _loc10_:int = 0;
|
||||
var _loc2_:int = 0;
|
||||
var _loc3_:int = 0;
|
||||
var _loc4_:int = 0;
|
||||
var _loc9_:Object = _activeLayerGroup.layers[param1];
|
||||
if(_loc9_)
|
||||
{
|
||||
_loc7_ = param1 == 3;
|
||||
if(_loc9_.lastColor != _loc9_.c || !_loc7_ && _loc9_.blendColor != _blendColor)
|
||||
{
|
||||
_loc5_ = uint(_loc9_.c);
|
||||
_loc6_ = PaletteHelper.gamePalette;
|
||||
_loc8_ = _loc5_ >> 24 & 0xFF;
|
||||
_loc10_ = _loc5_ >> 16 & 0xFF;
|
||||
_loc2_ = _loc5_ >> 8 & 0xFF;
|
||||
_loc3_ = _loc5_ & 0xFF;
|
||||
if(!_loc9_.pal)
|
||||
{
|
||||
_loc9_.pal = [];
|
||||
}
|
||||
PaletteHelper.BuildAnimalPalette(_loc9_.pal,_loc6_[_loc8_],_loc6_[_loc10_],_loc6_[_loc2_],_loc6_[_loc3_]);
|
||||
if(!_loc7_)
|
||||
{
|
||||
_loc4_ = _blendColor >> 24 & 0xFF;
|
||||
if(_loc4_ > 0)
|
||||
{
|
||||
PaletteHelper.adjustPaletteColor(_loc9_.pal,_blendColor);
|
||||
}
|
||||
_loc9_.blendColor = _blendColor;
|
||||
}
|
||||
_loc9_.lastColor = _loc5_;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private function refreshAllPalettes() : Boolean
|
||||
{
|
||||
var _loc2_:Boolean = false;
|
||||
for(var _loc1_ in _activeLayerGroup.layers)
|
||||
{
|
||||
if(_loc1_ > 0)
|
||||
{
|
||||
if(refreshLayerPalette(_loc1_))
|
||||
{
|
||||
_loc2_ = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(_loc2_)
|
||||
{
|
||||
_activeLayerGroup.invalidate();
|
||||
}
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
private function calcBounds(param1:int) : void
|
||||
{
|
||||
var _loc4_:Object = null;
|
||||
var _loc10_:Object = null;
|
||||
var _loc3_:int = 0;
|
||||
var _loc8_:Object = null;
|
||||
var _loc2_:int = 0;
|
||||
var _loc9_:int = 0;
|
||||
var _loc5_:int = 0;
|
||||
var _loc6_:int = 0;
|
||||
_bmin.setTo(1000,1000);
|
||||
_bmax.setTo(0,0);
|
||||
for(var _loc7_ in _activeLayerGroup.layers)
|
||||
{
|
||||
if(_loc7_ != 0)
|
||||
{
|
||||
_loc4_ = _activeLayerGroup.layers[_loc7_];
|
||||
_loc10_ = _loc4_.o;
|
||||
if(_loc10_.v != 117967104)
|
||||
{
|
||||
return;
|
||||
}
|
||||
_loc3_ = int(_loc10_.f.length);
|
||||
if(param1 < _loc3_)
|
||||
{
|
||||
_loc8_ = _loc10_.f[param1];
|
||||
if(_loc8_)
|
||||
{
|
||||
_loc2_ = int(_loc8_.x);
|
||||
_loc9_ = int(_loc8_.y);
|
||||
_loc5_ = int(_loc8_.w);
|
||||
_loc6_ = int(_loc8_.h);
|
||||
if(_loc2_ < _bmin.x)
|
||||
{
|
||||
_bmin.x = _loc2_;
|
||||
}
|
||||
if(_loc9_ < _bmin.y)
|
||||
{
|
||||
_bmin.y = _loc9_;
|
||||
}
|
||||
if(_loc2_ + _loc5_ > _bmax.x)
|
||||
{
|
||||
_bmax.x = _loc2_ + _loc5_;
|
||||
}
|
||||
if(_loc9_ + _loc6_ > _bmax.y)
|
||||
{
|
||||
_bmax.y = _loc9_ + _loc6_;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(_bmin.x == 1000 || _bmin.y == 1000)
|
||||
{
|
||||
trace("WARNING: detected frame with unexpected bounds - currCacheKey:" + _currCacheKey + " index:" + param1 + " bmin.x:" + _bmin.x + " bmin.y:" + _bmin.y + " bmax.x:" + _bmax.x + " bmax.y:" + _bmax.y);
|
||||
_bmin.copyFrom(_bmax);
|
||||
}
|
||||
}
|
||||
|
||||
private function switchFrame() : Boolean
|
||||
{
|
||||
var _loc1_:Boolean = false;
|
||||
var _loc2_:Array = _activeLayerGroup.paintedFrames;
|
||||
if(!_loc2_[_lastFrame])
|
||||
{
|
||||
_loc2_[_lastFrame] = [];
|
||||
createFrame(_loc2_[_lastFrame]);
|
||||
}
|
||||
else if(_loc2_[_lastFrame][_lastHFlip] != null && _loc2_[_lastFrame][_lastHFlip].isValid)
|
||||
{
|
||||
_loc2_[_lastFrame][_lastHFlip].copyBoundsTo(_bmin,_bmax);
|
||||
_loc1_ = true;
|
||||
}
|
||||
else if(_loc2_[_lastFrame][!_lastHFlip] != null && _loc2_[_lastFrame][!_lastHFlip].isValid)
|
||||
{
|
||||
_loc2_[_lastFrame][_lastHFlip] = _loc2_[_lastFrame][!_lastHFlip].flip();
|
||||
_loc2_[_lastFrame][_lastHFlip].copyBoundsTo(_bmin,_bmax);
|
||||
_loc1_ = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
createFrame(_loc2_[_lastFrame]);
|
||||
}
|
||||
this.bitmapData = _loc2_[_lastFrame][_lastHFlip].frameData;
|
||||
_loc2_[_lastFrame][_lastHFlip].updateAnchorPoint(_anchorPoint,_lastHFlip);
|
||||
return _loc1_;
|
||||
}
|
||||
|
||||
private function createFrame(param1:Array) : void
|
||||
{
|
||||
calcBounds(_lastFrame);
|
||||
if(param1[_lastHFlip] == null)
|
||||
{
|
||||
param1[_lastHFlip] = new PaintedFrame(_bmin,_bmax);
|
||||
}
|
||||
else if(!param1[_lastHFlip].validateBounds(_bmin,_bmax))
|
||||
{
|
||||
param1[_lastHFlip].destroy();
|
||||
param1[_lastHFlip] = new PaintedFrame(_bmin,_bmax);
|
||||
}
|
||||
else
|
||||
{
|
||||
param1[_lastHFlip].isValid = true;
|
||||
}
|
||||
}
|
||||
|
||||
public function paint(param1:int, param2:Boolean = false, param3:Boolean = true) : Boolean
|
||||
{
|
||||
var _loc6_:Object = null;
|
||||
var _loc4_:Boolean = false;
|
||||
var _loc7_:Boolean = false;
|
||||
var _loc5_:int = 0;
|
||||
_activeLayerGroup.resetTtl();
|
||||
if(param3 && _activeLayerGroup.layers[0] != null)
|
||||
{
|
||||
_loc6_ = _activeLayerGroup.layers[0];
|
||||
param1 = int(_loc6_.o.f[param1]);
|
||||
}
|
||||
if(_activeLayerGroup.checkColors)
|
||||
{
|
||||
_loc7_ = refreshAllPalettes();
|
||||
_activeLayerGroup.checkColors = false;
|
||||
}
|
||||
if(param1 != _lastFrame || param2 != _lastHFlip || _loc7_)
|
||||
{
|
||||
_lastFrame = param1;
|
||||
_lastHFlip = param2;
|
||||
if(!switchFrame())
|
||||
{
|
||||
_loc5_ = 1;
|
||||
while(_loc5_ < _activeLayerGroup.layers.length)
|
||||
{
|
||||
_loc6_ = _activeLayerGroup.layers[_loc5_];
|
||||
if(_loc6_ != null && _loc6_.o != null && _loc6_.pal != null)
|
||||
{
|
||||
if(paintFrame(_loc6_.o,param1,_loc6_.pal,param2))
|
||||
{
|
||||
_loc4_ = true;
|
||||
}
|
||||
}
|
||||
_loc5_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
return _loc4_;
|
||||
}
|
||||
|
||||
private function paintFrame(param1:Object, param2:int, param3:Array, param4:Boolean) : Boolean
|
||||
{
|
||||
var _loc25_:int = 0;
|
||||
var _loc18_:int = 0;
|
||||
var _loc13_:* = 0;
|
||||
var _loc15_:* = 0;
|
||||
var _loc31_:int = 0;
|
||||
var _loc20_:int = 0;
|
||||
var _loc8_:int = 0;
|
||||
var _loc26_:int = 0;
|
||||
var _loc5_:int = 0;
|
||||
var _loc21_:int = 0;
|
||||
var _loc10_:int = 0;
|
||||
var _loc27_:int = 0;
|
||||
var _loc9_:int = 0;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc23_:* = 0;
|
||||
var _loc12_:int = 0;
|
||||
if(param1 == null || !param1.hasOwnProperty("f"))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if(param2 >= param1.f.length)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
var _loc24_:Object = param1.f[param2];
|
||||
if(!_loc24_)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
var _loc6_:BitmapData = this.bitmapData;
|
||||
if(_loc6_ == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_loc6_.lock();
|
||||
var _loc22_:ByteArray = _loc24_.b;
|
||||
var _loc11_:int = int(_loc24_.x);
|
||||
var _loc7_:int = int(_loc24_.y);
|
||||
var _loc28_:int = int(_loc24_.w);
|
||||
var _loc17_:int = int(_loc24_.h);
|
||||
_loc11_ -= _bmin.x;
|
||||
_loc7_ -= _bmin.y;
|
||||
_loc28_ += _loc11_;
|
||||
_loc22_.position = 0;
|
||||
var _loc16_:int = int(_loc22_.length);
|
||||
var _loc29_:int = _loc11_;
|
||||
var _loc30_:int = _loc7_;
|
||||
var _loc19_:int = _loc28_ - _loc11_;
|
||||
if(!param4)
|
||||
{
|
||||
while(_loc22_.position < _loc16_)
|
||||
{
|
||||
_loc25_ = int(_loc22_.readUnsignedByte());
|
||||
_loc18_ = 1;
|
||||
if((_loc25_ & 0x80) == 128)
|
||||
{
|
||||
_loc25_ &= 127;
|
||||
_loc18_ = _loc22_.readUnsignedByte() + 1;
|
||||
}
|
||||
if(_loc25_ == 0)
|
||||
{
|
||||
_loc29_ += _loc18_;
|
||||
if(_loc29_ >= _loc28_)
|
||||
{
|
||||
_loc18_ = _loc29_ - _loc28_;
|
||||
_loc29_ = _loc11_ + _loc18_ % _loc19_;
|
||||
_loc30_ += _loc18_ / _loc19_ + 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc13_ = uint(param3[_loc25_]);
|
||||
if(_loc13_ >= 4278190080)
|
||||
{
|
||||
if(_loc29_ + _loc18_ < _loc28_)
|
||||
{
|
||||
while(--_loc18_ > -1)
|
||||
{
|
||||
_loc6_.setPixel32(_loc29_++,_loc30_,_loc13_);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while(--_loc18_ > -1)
|
||||
{
|
||||
_loc6_.setPixel32(_loc29_++,_loc30_,_loc13_);
|
||||
if(_loc29_ == _loc28_)
|
||||
{
|
||||
_loc29_ = _loc11_;
|
||||
_loc30_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while(--_loc18_ > -1)
|
||||
{
|
||||
_loc15_ = _loc6_.getPixel32(_loc29_,_loc30_);
|
||||
if(_loc15_ != 0)
|
||||
{
|
||||
_loc26_ = _loc13_ >> 24 & 0xFF;
|
||||
_loc31_ = _loc13_ >> 16 & 0xFF;
|
||||
_loc20_ = _loc13_ >> 8 & 0xFF;
|
||||
_loc8_ = _loc13_ & 0xFF;
|
||||
_loc27_ = _loc15_ >> 24 & 0xFF;
|
||||
_loc5_ = _loc15_ >> 16 & 0xFF;
|
||||
_loc21_ = _loc15_ >> 8 & 0xFF;
|
||||
_loc10_ = _loc15_ & 0xFF;
|
||||
if(_loc26_ == 192)
|
||||
{
|
||||
_loc31_ = (_loc31_ + _loc31_ + _loc31_ + _loc5_) * 0.25;
|
||||
_loc20_ = (_loc20_ + _loc20_ + _loc20_ + _loc21_) * 0.25;
|
||||
_loc8_ = (_loc8_ + _loc8_ + _loc8_ + _loc10_) * 0.25;
|
||||
}
|
||||
else if(_loc26_ == 128)
|
||||
{
|
||||
_loc31_ = (_loc31_ + _loc5_) * 0.5;
|
||||
_loc20_ = (_loc20_ + _loc21_) * 0.5;
|
||||
_loc8_ = (_loc8_ + _loc10_) * 0.5;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc31_ = (_loc31_ + _loc5_ + _loc5_ + _loc5_) * 0.25;
|
||||
_loc20_ = (_loc20_ + _loc21_ + _loc21_ + _loc21_) * 0.25;
|
||||
_loc8_ = (_loc8_ + _loc10_ + _loc10_ + _loc10_) * 0.25;
|
||||
}
|
||||
if(_loc27_ > _loc26_)
|
||||
{
|
||||
_loc26_ = _loc27_;
|
||||
}
|
||||
_loc13_ = uint(_loc26_ << 24 | _loc31_ << 16 | _loc20_ << 8 | _loc8_);
|
||||
}
|
||||
_loc6_.setPixel32(_loc29_++,_loc30_,_loc13_);
|
||||
if(_loc29_ == _loc28_)
|
||||
{
|
||||
_loc29_ = _loc11_;
|
||||
_loc30_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc9_ = _bmax.x - _bmin.x;
|
||||
while(_loc22_.position < _loc16_)
|
||||
{
|
||||
_loc25_ = int(_loc22_.readUnsignedByte());
|
||||
_loc18_ = 1;
|
||||
if((_loc25_ & 0x80) == 128)
|
||||
{
|
||||
_loc25_ &= 127;
|
||||
_loc18_ = _loc22_.readUnsignedByte() + 1;
|
||||
}
|
||||
if(_loc25_ == 0)
|
||||
{
|
||||
_loc29_ += _loc18_;
|
||||
if(_loc29_ >= _loc28_)
|
||||
{
|
||||
_loc18_ = _loc29_ - _loc28_;
|
||||
_loc29_ = _loc11_ + _loc18_ % _loc19_;
|
||||
_loc30_ += _loc18_ / _loc19_ + 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc13_ = uint(param3[_loc25_]);
|
||||
if(_loc13_ >= 4278190080)
|
||||
{
|
||||
if(_loc29_ + _loc18_ < _loc28_)
|
||||
{
|
||||
while(--_loc18_ > -1)
|
||||
{
|
||||
_loc6_.setPixel32(_loc9_ - _loc29_++,_loc30_,_loc13_);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while(--_loc18_ > -1)
|
||||
{
|
||||
_loc6_.setPixel32(_loc9_ - _loc29_++,_loc30_,_loc13_);
|
||||
if(_loc29_ == _loc28_)
|
||||
{
|
||||
_loc29_ = _loc11_;
|
||||
_loc30_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while(--_loc18_ > -1)
|
||||
{
|
||||
_loc15_ = _loc6_.getPixel32(_loc9_ - _loc29_,_loc30_);
|
||||
if(_loc15_ != 0)
|
||||
{
|
||||
_loc26_ = _loc13_ >> 24 & 0xFF;
|
||||
_loc31_ = _loc13_ >> 16 & 0xFF;
|
||||
_loc20_ = _loc13_ >> 8 & 0xFF;
|
||||
_loc8_ = _loc13_ & 0xFF;
|
||||
_loc27_ = _loc15_ >> 24 & 0xFF;
|
||||
_loc5_ = _loc15_ >> 16 & 0xFF;
|
||||
_loc21_ = _loc15_ >> 8 & 0xFF;
|
||||
_loc10_ = _loc15_ & 0xFF;
|
||||
switch(_loc26_)
|
||||
{
|
||||
case 192:
|
||||
_loc31_ = (_loc31_ + _loc31_ + _loc31_ + _loc5_) * 0.25;
|
||||
_loc20_ = (_loc20_ + _loc20_ + _loc20_ + _loc21_) * 0.25;
|
||||
_loc8_ = (_loc8_ + _loc8_ + _loc8_ + _loc10_) * 0.25;
|
||||
break;
|
||||
case 128:
|
||||
_loc31_ = (_loc31_ + _loc5_) * 0.5;
|
||||
_loc20_ = (_loc20_ + _loc21_) * 0.5;
|
||||
_loc8_ = (_loc8_ + _loc10_) * 0.5;
|
||||
break;
|
||||
case 64:
|
||||
_loc31_ = (_loc31_ + _loc5_ + _loc5_ + _loc5_) * 0.25;
|
||||
_loc20_ = (_loc20_ + _loc21_ + _loc21_ + _loc21_) * 0.25;
|
||||
_loc8_ = (_loc8_ + _loc10_ + _loc10_ + _loc10_) * 0.25;
|
||||
}
|
||||
if(_loc27_ > _loc26_)
|
||||
{
|
||||
_loc26_ = _loc27_;
|
||||
}
|
||||
_loc13_ = uint(_loc26_ << 24 | _loc31_ << 16 | _loc20_ << 8 | _loc8_);
|
||||
}
|
||||
_loc6_.setPixel32(_loc9_ - _loc29_++,_loc30_,_loc13_);
|
||||
if(_loc29_ == _loc28_)
|
||||
{
|
||||
_loc29_ = _loc11_;
|
||||
_loc30_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(_loc24_.hasOwnProperty("s"))
|
||||
{
|
||||
_loc12_ = int(_loc24_.sm);
|
||||
_loc22_ = _loc24_.s;
|
||||
_loc16_ = int(_loc22_.length);
|
||||
_loc22_.position = 0;
|
||||
_loc29_ = _loc11_;
|
||||
_loc30_ = _loc7_;
|
||||
if(!param4)
|
||||
{
|
||||
while(_loc22_.position < _loc16_)
|
||||
{
|
||||
_loc25_ = int(_loc22_.readUnsignedByte());
|
||||
_loc18_ = 1;
|
||||
if((_loc25_ & 0x80) == 128)
|
||||
{
|
||||
_loc25_ &= 127;
|
||||
_loc18_ = _loc22_.readUnsignedByte() + 1;
|
||||
}
|
||||
if(_loc25_ == 0)
|
||||
{
|
||||
_loc29_ += _loc18_;
|
||||
if(_loc29_ >= _loc28_)
|
||||
{
|
||||
_loc18_ = _loc29_ - _loc28_;
|
||||
_loc29_ = _loc11_ + _loc18_ % _loc19_;
|
||||
_loc30_ += _loc18_ / _loc19_ + 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc13_ = uint(_loc25_ << _loc12_);
|
||||
_loc13_ = uint(_loc13_ + 24);
|
||||
if(_loc13_ > 255)
|
||||
{
|
||||
_loc14_ = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc14_ = _loc13_ / 255;
|
||||
}
|
||||
while(--_loc18_ > -1)
|
||||
{
|
||||
_loc15_ = _loc6_.getPixel32(_loc29_,_loc30_);
|
||||
if(_loc15_ != 0)
|
||||
{
|
||||
_loc26_ = _loc15_ >> 24 & 0xFF;
|
||||
_loc31_ = (_loc15_ >> 16 & 0xFF) * _loc14_;
|
||||
_loc20_ = (_loc15_ >> 8 & 0xFF) * _loc14_;
|
||||
_loc8_ = (_loc15_ & 0xFF) * _loc14_;
|
||||
_loc23_ = uint(_loc26_ << 24 | _loc31_ << 16 | _loc20_ << 8 | _loc8_);
|
||||
_loc6_.setPixel32(_loc29_,_loc30_,_loc23_);
|
||||
}
|
||||
if(++_loc29_ == _loc28_)
|
||||
{
|
||||
_loc29_ = _loc11_;
|
||||
_loc30_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc9_ = _bmax.x - _bmin.x;
|
||||
while(_loc22_.position < _loc16_)
|
||||
{
|
||||
_loc25_ = int(_loc22_.readUnsignedByte());
|
||||
_loc18_ = 1;
|
||||
if((_loc25_ & 0x80) == 128)
|
||||
{
|
||||
_loc25_ &= 127;
|
||||
_loc18_ = _loc22_.readUnsignedByte() + 1;
|
||||
}
|
||||
if(_loc25_ == 0)
|
||||
{
|
||||
_loc29_ += _loc18_;
|
||||
if(_loc29_ >= _loc28_)
|
||||
{
|
||||
_loc18_ = _loc29_ - _loc28_;
|
||||
_loc29_ = _loc11_ + _loc18_ % _loc19_;
|
||||
_loc30_ += _loc18_ / _loc19_ + 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc13_ = uint(_loc25_ << _loc12_);
|
||||
_loc13_ = uint(_loc13_ + 24);
|
||||
if(_loc13_ > 255)
|
||||
{
|
||||
_loc14_ = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc14_ = _loc13_ / 255;
|
||||
}
|
||||
while(--_loc18_ > -1)
|
||||
{
|
||||
_loc15_ = _loc6_.getPixel32(_loc9_ - _loc29_,_loc30_);
|
||||
if(_loc15_ != 0)
|
||||
{
|
||||
_loc26_ = _loc15_ >> 24 & 0xFF;
|
||||
_loc31_ = (_loc15_ >> 16 & 0xFF) * _loc14_;
|
||||
_loc20_ = (_loc15_ >> 8 & 0xFF) * _loc14_;
|
||||
_loc8_ = (_loc15_ & 0xFF) * _loc14_;
|
||||
_loc23_ = uint(_loc26_ << 24 | _loc31_ << 16 | _loc20_ << 8 | _loc8_);
|
||||
_loc6_.setPixel32(_loc9_ - _loc29_,_loc30_,_loc23_);
|
||||
}
|
||||
if(++_loc29_ == _loc28_)
|
||||
{
|
||||
_loc29_ = _loc11_;
|
||||
_loc30_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
_loc6_.unlock();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
package com.sbi.graphics
|
||||
{
|
||||
public class LayerGroup
|
||||
{
|
||||
|
||||
private var _layers:Array;
|
||||
|
||||
private var _paintedFrames:Array;
|
||||
|
||||
private var _ttl:int;
|
||||
|
||||
private var _checkColors:Boolean;
|
||||
|
||||
public function LayerGroup()
|
||||
{
|
||||
super();
|
||||
_layers = [];
|
||||
_paintedFrames = [];
|
||||
_checkColors = true;
|
||||
}
|
||||
|
||||
public function destroy() : void
|
||||
{
|
||||
for each(var _loc1_:Object in _paintedFrames)
|
||||
{
|
||||
if(_loc2_)
|
||||
{
|
||||
for each(var _loc2_:PaintedFrame in _loc1_)
|
||||
{
|
||||
if(_loc2_)
|
||||
{
|
||||
_loc2_.destroy();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
_layers = null;
|
||||
_paintedFrames = null;
|
||||
}
|
||||
|
||||
public function invalidate() : void
|
||||
{
|
||||
for each(var _loc1_:Array in _paintedFrames)
|
||||
{
|
||||
for each(var _loc2_:PaintedFrame in _loc1_)
|
||||
{
|
||||
_loc2_.isValid = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function get length() : int
|
||||
{
|
||||
var _loc1_:Object = _layers[0];
|
||||
if(!_loc1_)
|
||||
{
|
||||
_loc1_ = _layers[1];
|
||||
}
|
||||
return !_loc1_ ? 0 : _loc1_.o.f.length;
|
||||
}
|
||||
|
||||
public function get layers() : Array
|
||||
{
|
||||
return _layers;
|
||||
}
|
||||
|
||||
public function get paintedFrames() : Array
|
||||
{
|
||||
return _paintedFrames;
|
||||
}
|
||||
|
||||
public function resetTtl() : void
|
||||
{
|
||||
_ttl = 30;
|
||||
}
|
||||
|
||||
public function decrementTtl() : int
|
||||
{
|
||||
return _ttl--;
|
||||
}
|
||||
|
||||
public function get checkColors() : Boolean
|
||||
{
|
||||
return _checkColors;
|
||||
}
|
||||
|
||||
public function set checkColors(param1:Boolean) : void
|
||||
{
|
||||
_checkColors = param1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,87 @@
|
||||
package com.sbi.graphics
|
||||
{
|
||||
import flash.display.BitmapData;
|
||||
import flash.geom.Matrix;
|
||||
import flash.geom.Point;
|
||||
|
||||
public class PaintedFrame
|
||||
{
|
||||
|
||||
private var _isValid:Boolean;
|
||||
|
||||
private var _min:Point;
|
||||
|
||||
private var _max:Point;
|
||||
|
||||
private var _frameData:BitmapData;
|
||||
|
||||
public function PaintedFrame(param1:Point, param2:Point)
|
||||
{
|
||||
super();
|
||||
_isValid = true;
|
||||
_min = param1.clone();
|
||||
_max = param2.clone();
|
||||
_frameData = new BitmapData(calcWidth(),calcHeight(),true,0);
|
||||
}
|
||||
|
||||
public function destroy() : void
|
||||
{
|
||||
_isValid = false;
|
||||
_frameData.dispose();
|
||||
}
|
||||
|
||||
public function flip() : PaintedFrame
|
||||
{
|
||||
var _loc1_:PaintedFrame = new PaintedFrame(_min,_max);
|
||||
var _loc2_:Matrix = new Matrix(-1,0,0,1,_frameData.width,0);
|
||||
_loc1_.frameData.draw(_frameData,_loc2_);
|
||||
return _loc1_;
|
||||
}
|
||||
|
||||
public function get isValid() : Boolean
|
||||
{
|
||||
return _isValid;
|
||||
}
|
||||
|
||||
public function set isValid(param1:Boolean) : void
|
||||
{
|
||||
_isValid = param1;
|
||||
}
|
||||
|
||||
public function get frameData() : BitmapData
|
||||
{
|
||||
return _frameData;
|
||||
}
|
||||
|
||||
public function copyBoundsTo(param1:Point, param2:Point) : void
|
||||
{
|
||||
param1.copyFrom(_min);
|
||||
param2.copyFrom(_max);
|
||||
}
|
||||
|
||||
public function updateAnchorPoint(param1:Point, param2:Boolean) : void
|
||||
{
|
||||
param1.copyFrom(_min);
|
||||
if(param2)
|
||||
{
|
||||
param1.x = 500 - _max.x;
|
||||
}
|
||||
}
|
||||
|
||||
public function validateBounds(param1:Point, param2:Point) : Boolean
|
||||
{
|
||||
return _min.equals(param1) && _max.equals(param2);
|
||||
}
|
||||
|
||||
private function calcWidth() : int
|
||||
{
|
||||
return 1 + _max.x - _min.x;
|
||||
}
|
||||
|
||||
private function calcHeight() : int
|
||||
{
|
||||
return 1 + _max.y - _min.y;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,257 @@
|
||||
package com.sbi.graphics
|
||||
{
|
||||
import flash.utils.ByteArray;
|
||||
|
||||
public class PaletteHelper
|
||||
{
|
||||
|
||||
public static var gamePalette:Array;
|
||||
|
||||
public static var avatarPalette1:Array;
|
||||
|
||||
public static var avatarPalette2:Array;
|
||||
|
||||
private static const PALETTE_ALPHA_OFFSET:int = 25;
|
||||
|
||||
public function PaletteHelper()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public static function setGamePalette(param1:ByteArray, param2:ByteArray = null, param3:ByteArray = null) : void
|
||||
{
|
||||
var _loc4_:int = param1.length / 4;
|
||||
gamePalette = new Array(_loc4_);
|
||||
var _loc5_:int = 0;
|
||||
while(_loc5_ < _loc4_)
|
||||
{
|
||||
gamePalette[_loc5_++] = param1.readUnsignedInt();
|
||||
}
|
||||
if(param2)
|
||||
{
|
||||
_loc4_ = int(param2.length);
|
||||
avatarPalette1 = new Array(_loc4_);
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < _loc4_)
|
||||
{
|
||||
avatarPalette1[_loc5_++] = param2.readUnsignedByte();
|
||||
}
|
||||
}
|
||||
if(param3)
|
||||
{
|
||||
param3.position = 0;
|
||||
_loc4_ = int(param3.length);
|
||||
avatarPalette2 = new Array(_loc4_);
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < _loc4_)
|
||||
{
|
||||
avatarPalette2[_loc5_++] = param3.readUnsignedByte();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static function mixColors(param1:uint, param2:uint) : uint
|
||||
{
|
||||
var _loc7_:uint = uint(param1 >> 16 & 0xFF);
|
||||
var _loc5_:uint = uint(param1 >> 8 & 0xFF);
|
||||
var _loc8_:uint = uint(param1 & 0xFF);
|
||||
var _loc3_:uint = uint(param2 >> 16 & 0xFF);
|
||||
var _loc6_:uint = uint(param2 >> 8 & 0xFF);
|
||||
var _loc4_:uint = uint(param2 & 0xFF);
|
||||
_loc7_ = (_loc7_ + _loc3_) / 2;
|
||||
_loc5_ = (_loc5_ + _loc6_) / 2;
|
||||
_loc8_ = (_loc8_ + _loc4_) / 2;
|
||||
return _loc7_ << 16 | _loc5_ << 8 | _loc8_;
|
||||
}
|
||||
|
||||
public static function setColorGradient(param1:Array, param2:uint, param3:uint, param4:uint) : void
|
||||
{
|
||||
var _loc9_:* = 0;
|
||||
var _loc6_:* = 0;
|
||||
var _loc12_:uint = uint(param2 >> 16 & 0xFF);
|
||||
var _loc7_:uint = uint(param2 >> 8 & 0xFF);
|
||||
var _loc5_:uint = uint(param2 & 0xFF);
|
||||
var _loc13_:uint = _loc12_ / (param4 + 2);
|
||||
var _loc10_:uint = _loc7_ / (param4 + 2);
|
||||
var _loc11_:uint = _loc5_ / (param4 + 2);
|
||||
var _loc8_:int = param3 + param4 - 1;
|
||||
_loc9_ = 0;
|
||||
while(_loc9_ < param4)
|
||||
{
|
||||
_loc6_ = uint(_loc12_ << 16 | _loc7_ << 8 | _loc5_);
|
||||
param1[_loc8_] = _loc6_ | -16777216;
|
||||
param1[_loc8_ + 25] = _loc6_ | -1073741824;
|
||||
param1[_loc8_ + 25 * 2] = _loc6_ | -2147483648;
|
||||
param1[_loc8_ + 25 * 3] = _loc6_ | 0x40000000;
|
||||
_loc12_ -= _loc13_;
|
||||
_loc7_ -= _loc10_;
|
||||
_loc5_ -= _loc11_;
|
||||
_loc8_--;
|
||||
_loc9_++;
|
||||
}
|
||||
}
|
||||
|
||||
public static function AddRGB(param1:uint, param2:int, param3:int, param4:int) : uint
|
||||
{
|
||||
var _loc7_:int = param1 >> 24 & 0xFF;
|
||||
var _loc5_:int = param1 >> 16 & 0xFF;
|
||||
var _loc8_:int = param1 >> 8 & 0xFF;
|
||||
var _loc6_:int = param1 & 0xFF;
|
||||
_loc5_ += param2;
|
||||
if(_loc5_ < 0)
|
||||
{
|
||||
_loc5_ = 0;
|
||||
}
|
||||
else if(_loc5_ > 255)
|
||||
{
|
||||
_loc5_ = 255;
|
||||
}
|
||||
_loc8_ += param3;
|
||||
if(_loc8_ < 0)
|
||||
{
|
||||
_loc8_ = 0;
|
||||
}
|
||||
else if(_loc8_ > 255)
|
||||
{
|
||||
_loc8_ = 255;
|
||||
}
|
||||
_loc6_ += param4;
|
||||
if(_loc6_ < 0)
|
||||
{
|
||||
_loc6_ = 0;
|
||||
}
|
||||
else if(_loc6_ > 255)
|
||||
{
|
||||
_loc6_ = 255;
|
||||
}
|
||||
return uint(_loc7_ << 24 | _loc5_ << 16 | _loc8_ << 8 | _loc6_);
|
||||
}
|
||||
|
||||
public static function getAnimalPalette() : Array
|
||||
{
|
||||
var _loc5_:int = 0;
|
||||
var _loc6_:int = 0;
|
||||
var _loc3_:* = 0;
|
||||
var _loc4_:* = 0;
|
||||
var _loc1_:Array = new Array(4278255615,4286513152,4290707456,4294901760,4278222592,4278238976,4278255360,4278190207,4278190271,4278190335,4286545791,4290756543,4294967295,4282400768,4286611456,4278206528,4278222976,4282384448,4286578816,4286595136,4294934656,4282417216,4286644096,4282400896,4286611711,4278190080);
|
||||
var _loc2_:* = 4294967295;
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < 3)
|
||||
{
|
||||
_loc6_ = 1;
|
||||
while(_loc6_ <= 25)
|
||||
{
|
||||
_loc3_ = uint(_loc1_[_loc6_] & 0xFFFFFF);
|
||||
_loc4_ = uint(_loc3_ | _loc2_);
|
||||
_loc1_.push(_loc4_);
|
||||
_loc6_++;
|
||||
}
|
||||
_loc2_ -= 1073741824;
|
||||
_loc5_++;
|
||||
}
|
||||
return _loc1_;
|
||||
}
|
||||
|
||||
public static function BuildAnimalPalette(param1:Array, param2:uint, param3:uint, param4:uint, param5:uint) : void
|
||||
{
|
||||
setColorGradient(param1,param2,1,3);
|
||||
setColorGradient(param1,param3,4,3);
|
||||
setColorGradient(param1,param4,7,3);
|
||||
setColorGradient(param1,param5,10,3);
|
||||
setColorGradient(param1,PaletteHelper.mixColors(param2,param3),13,2);
|
||||
setColorGradient(param1,PaletteHelper.mixColors(param3,param4),15,2);
|
||||
setColorGradient(param1,PaletteHelper.mixColors(param2,param4),17,2);
|
||||
setColorGradient(param1,PaletteHelper.mixColors(param2,param5),19,2);
|
||||
setColorGradient(param1,PaletteHelper.mixColors(param3,param5),21,2);
|
||||
setColorGradient(param1,PaletteHelper.mixColors(param4,param5),23,2);
|
||||
}
|
||||
|
||||
public static function adjustPaletteColor(param1:Array, param2:uint) : void
|
||||
{
|
||||
var _loc7_:int = 0;
|
||||
var _loc6_:* = 0;
|
||||
var _loc5_:int = 0;
|
||||
var _loc10_:int = 0;
|
||||
var _loc12_:int = 0;
|
||||
var _loc3_:int = 0;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc8_:Number = (param2 >> 24 & 0xFF) / 255;
|
||||
var _loc9_:int = param2 >> 16 & 0xFF;
|
||||
var _loc11_:int = param2 >> 8 & 0xFF;
|
||||
var _loc13_:int = param2 & 0xFF;
|
||||
while(_loc7_ < param1.length)
|
||||
{
|
||||
_loc6_ = uint(param1[_loc7_]);
|
||||
_loc5_ = _loc6_ >> 24 & 0xFF;
|
||||
_loc10_ = _loc6_ >> 16 & 0xFF;
|
||||
_loc12_ = _loc6_ >> 8 & 0xFF;
|
||||
_loc3_ = _loc6_ & 0xFF;
|
||||
_loc4_ = _loc9_ - _loc10_;
|
||||
_loc4_ = _loc4_ * _loc8_;
|
||||
_loc10_ += _loc4_;
|
||||
if(_loc10_ < 0)
|
||||
{
|
||||
_loc10_ = 0;
|
||||
}
|
||||
else if(_loc10_ > 255)
|
||||
{
|
||||
_loc10_ = 255;
|
||||
}
|
||||
_loc4_ = _loc11_ - _loc12_;
|
||||
_loc4_ = _loc4_ * _loc8_;
|
||||
_loc12_ += _loc4_;
|
||||
if(_loc12_ < 0)
|
||||
{
|
||||
_loc12_ = 0;
|
||||
}
|
||||
else if(_loc12_ > 255)
|
||||
{
|
||||
_loc12_ = 255;
|
||||
}
|
||||
_loc4_ = _loc13_ - _loc3_;
|
||||
_loc4_ = _loc4_ * _loc8_;
|
||||
_loc3_ += _loc4_;
|
||||
if(_loc3_ < 0)
|
||||
{
|
||||
_loc3_ = 0;
|
||||
}
|
||||
else if(_loc3_ > 255)
|
||||
{
|
||||
_loc3_ = 255;
|
||||
}
|
||||
param1[_loc7_] = uint(_loc5_ << 24 | _loc10_ << 16 | _loc12_ << 8 | _loc3_);
|
||||
_loc7_++;
|
||||
}
|
||||
}
|
||||
|
||||
public static function getHexColorsFromPalette(param1:uint) : Array
|
||||
{
|
||||
var _loc2_:Array = [];
|
||||
_loc2_[0] = gamePalette[param1 >> 24 & 0xFF];
|
||||
_loc2_[1] = gamePalette[param1 >> 16 & 0xFF];
|
||||
_loc2_[2] = gamePalette[param1 >> 8 & 0xFF];
|
||||
_loc2_[3] = gamePalette[param1 & 0xFF];
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
public static function getRGBColors(param1:uint) : Array
|
||||
{
|
||||
var _loc2_:Array = [];
|
||||
_loc2_[0] = decToRGBObj(gamePalette[param1 >> 24 & 0xFF]);
|
||||
_loc2_[1] = decToRGBObj(gamePalette[param1 >> 16 & 0xFF]);
|
||||
_loc2_[2] = decToRGBObj(gamePalette[param1 >> 8 & 0xFF]);
|
||||
_loc2_[3] = decToRGBObj(gamePalette[param1 & 0xFF]);
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
private static function decToRGBObj(param1:uint) : Object
|
||||
{
|
||||
return {
|
||||
"r":param1 >> 16 & 0xFF,
|
||||
"g":param1 >> 8 & 0xFF,
|
||||
"b":param1 & 0xFF
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,204 @@
|
||||
package com.sbi.graphics
|
||||
{
|
||||
import flash.display.DisplayObject;
|
||||
import flash.display.Sprite;
|
||||
import flash.geom.Rectangle;
|
||||
import flash.utils.Dictionary;
|
||||
|
||||
public class SortLayer extends Sprite
|
||||
{
|
||||
|
||||
private var _bottoms:Dictionary;
|
||||
|
||||
private var _nudge:Number = 0;
|
||||
|
||||
private var _throttle:int;
|
||||
|
||||
public function SortLayer()
|
||||
{
|
||||
super();
|
||||
_bottoms = new Dictionary(true);
|
||||
}
|
||||
|
||||
override public function addChild(param1:DisplayObject) : DisplayObject
|
||||
{
|
||||
var _loc2_:int = int(param1.name);
|
||||
param1.name = (getNudge() + _loc2_).toString();
|
||||
return super.addChild(param1);
|
||||
}
|
||||
|
||||
override public function addChildAt(param1:DisplayObject, param2:int) : DisplayObject
|
||||
{
|
||||
var _loc3_:int = int(param1.name);
|
||||
param1.name = (getNudge() + _loc3_).toString();
|
||||
return super.addChildAt(param1,param2);
|
||||
}
|
||||
|
||||
public function release() : void
|
||||
{
|
||||
_nudge = 0;
|
||||
_bottoms = new Dictionary(true);
|
||||
}
|
||||
|
||||
public function depthSort(param1:DisplayObject, param2:DisplayObject) : int
|
||||
{
|
||||
return _bottoms[param1] - _bottoms[param2];
|
||||
}
|
||||
|
||||
public function heartbeat() : void
|
||||
{
|
||||
var _loc6_:int = 0;
|
||||
var _loc2_:int = 0;
|
||||
var _loc1_:Rectangle = null;
|
||||
var _loc9_:Boolean = false;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc7_:Array = null;
|
||||
var _loc3_:DisplayObject = null;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
_throttle = _throttle + 1;
|
||||
if(_throttle > 20)
|
||||
{
|
||||
_throttle = 0;
|
||||
_loc2_ = this.numChildren;
|
||||
_loc5_ = -999999999;
|
||||
if(_loc2_ < 2)
|
||||
{
|
||||
return;
|
||||
}
|
||||
_loc7_ = [_loc2_];
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < _loc2_)
|
||||
{
|
||||
_loc3_ = this.getChildAt(_loc6_);
|
||||
_loc7_[_loc6_] = _loc3_;
|
||||
_loc1_ = _loc3_.getBounds(this);
|
||||
_loc8_ = _loc1_.bottom;
|
||||
_loc4_ = Number(_loc3_.name);
|
||||
if(!_loc4_)
|
||||
{
|
||||
_loc4_ = getNudge();
|
||||
_loc3_.name = _loc4_.toString();
|
||||
}
|
||||
_loc8_ -= _loc4_;
|
||||
_bottoms[_loc3_] = _loc8_;
|
||||
if(!_loc9_)
|
||||
{
|
||||
if(_loc8_ < _loc5_)
|
||||
{
|
||||
_loc9_ = true;
|
||||
}
|
||||
_loc5_ = _loc8_;
|
||||
}
|
||||
_loc6_++;
|
||||
}
|
||||
if(_loc9_)
|
||||
{
|
||||
_loc7_.sort(depthSort);
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < _loc2_)
|
||||
{
|
||||
this.setChildIndex(_loc7_[_loc6_],_loc6_);
|
||||
_loc6_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private function getNudge() : Number
|
||||
{
|
||||
_nudge += 0.001;
|
||||
if(_nudge > 0.9)
|
||||
{
|
||||
_nudge = 0;
|
||||
}
|
||||
return _nudge;
|
||||
}
|
||||
|
||||
private function sort(param1:Vector.<Number>) : void
|
||||
{
|
||||
quickSort(param1,0,param1.length - 1);
|
||||
InsertionSort(param1,0,param1.length - 1);
|
||||
}
|
||||
|
||||
private function quickSort(param1:Vector.<Number>, param2:int, param3:int) : void
|
||||
{
|
||||
var _loc5_:int = 0;
|
||||
var _loc6_:int = 0;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc7_:int = 4;
|
||||
if(param3 - param2 > _loc7_)
|
||||
{
|
||||
_loc5_ = (param3 + param2) / 2;
|
||||
if(param1[param2] > param1[_loc5_])
|
||||
{
|
||||
swap(param1,param2,_loc5_);
|
||||
}
|
||||
if(param1[param2] > param1[param3])
|
||||
{
|
||||
swap(param1,param2,param3);
|
||||
}
|
||||
if(param1[_loc5_] > param1[param3])
|
||||
{
|
||||
swap(param1,_loc5_,param3);
|
||||
}
|
||||
_loc6_ = param3 - 1;
|
||||
swap(param1,_loc5_,_loc6_);
|
||||
_loc5_ = param2;
|
||||
_loc4_ = param1[_loc6_];
|
||||
while(true)
|
||||
{
|
||||
while(param1[++_loc5_] < _loc4_)
|
||||
{
|
||||
}
|
||||
while(param1[--_loc6_] > _loc4_)
|
||||
{
|
||||
}
|
||||
if(_loc6_ < _loc5_)
|
||||
{
|
||||
break;
|
||||
}
|
||||
swap(param1,_loc5_,_loc6_);
|
||||
}
|
||||
swap(param1,_loc5_,param3 - 1);
|
||||
quickSort(param1,param2,_loc6_);
|
||||
quickSort(param1,_loc5_ + 1,param3);
|
||||
}
|
||||
}
|
||||
|
||||
private function swap(param1:Vector.<Number>, param2:int, param3:int) : void
|
||||
{
|
||||
var _loc4_:Number = NaN;
|
||||
_loc4_ = param1[param2];
|
||||
param1[param2] = param1[param3];
|
||||
param1[param3] = _loc4_;
|
||||
swapChildrenAt(param2,param3);
|
||||
}
|
||||
|
||||
private function move(param1:Vector.<Number>, param2:int, param3:int) : void
|
||||
{
|
||||
param1[param3] = param1[param2];
|
||||
addChildAt(getChildAt(param2),param3);
|
||||
}
|
||||
|
||||
private function InsertionSort(param1:Vector.<Number>, param2:int, param3:int) : void
|
||||
{
|
||||
var _loc5_:int = 0;
|
||||
var _loc6_:int = 0;
|
||||
var _loc4_:Number = NaN;
|
||||
_loc5_ = param2 + 1;
|
||||
while(_loc5_ <= param3)
|
||||
{
|
||||
_loc4_ = param1[_loc5_];
|
||||
_loc6_ = _loc5_;
|
||||
while(_loc6_ > param2 && param1[_loc6_ - 1] > _loc4_)
|
||||
{
|
||||
move(param1,_loc6_ - 1,_loc6_);
|
||||
_loc6_--;
|
||||
}
|
||||
_loc5_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,174 @@
|
||||
package com.sbi.graphics
|
||||
{
|
||||
import flash.display.Bitmap;
|
||||
import flash.display.BitmapData;
|
||||
import flash.display.Sprite;
|
||||
import flash.events.Event;
|
||||
import flash.events.MouseEvent;
|
||||
import flash.geom.Rectangle;
|
||||
import flash.system.System;
|
||||
import flash.text.StyleSheet;
|
||||
import flash.text.TextField;
|
||||
import flash.utils.getTimer;
|
||||
|
||||
public class Stats extends Sprite
|
||||
{
|
||||
|
||||
protected const WIDTH:uint = 70;
|
||||
|
||||
protected const HEIGHT:uint = 100;
|
||||
|
||||
protected var xml:XML;
|
||||
|
||||
protected var text:TextField;
|
||||
|
||||
protected var style:StyleSheet;
|
||||
|
||||
protected var timer:uint;
|
||||
|
||||
protected var fps:uint;
|
||||
|
||||
protected var ms:uint;
|
||||
|
||||
protected var ms_prev:uint;
|
||||
|
||||
protected var mem:Number;
|
||||
|
||||
protected var mem_max:Number;
|
||||
|
||||
protected var graph:Bitmap;
|
||||
|
||||
protected var rectangle:Rectangle;
|
||||
|
||||
protected var fps_graph:uint;
|
||||
|
||||
protected var mem_graph:uint;
|
||||
|
||||
protected var mem_max_graph:uint;
|
||||
|
||||
protected var theme:Object = {
|
||||
"bg":51,
|
||||
"fps":16776960,
|
||||
"ms":65280,
|
||||
"mem":65535,
|
||||
"memmax":16711792
|
||||
};
|
||||
|
||||
public function Stats(param1:Object = null)
|
||||
{
|
||||
super();
|
||||
if(param1)
|
||||
{
|
||||
if(param1.bg != null)
|
||||
{
|
||||
theme.bg = param1.bg;
|
||||
}
|
||||
if(param1.fps != null)
|
||||
{
|
||||
theme.fps = param1.fps;
|
||||
}
|
||||
if(param1.ms != null)
|
||||
{
|
||||
theme.ms = param1.ms;
|
||||
}
|
||||
if(param1.mem != null)
|
||||
{
|
||||
theme.mem = param1.mem;
|
||||
}
|
||||
if(param1.memmax != null)
|
||||
{
|
||||
theme.memmax = param1.memmax;
|
||||
}
|
||||
}
|
||||
mem_max = 0;
|
||||
xml = <xml><fps>FPS:</fps><ms>MS:</ms><mem>MEM:</mem><memMax>MAX:</memMax></xml>;
|
||||
style = new StyleSheet();
|
||||
style.setStyle("xml",{
|
||||
"fontSize":"9px",
|
||||
"fontFamily":"_sans",
|
||||
"leading":"-2px"
|
||||
});
|
||||
style.setStyle("fps",{"color":hex2css(theme.fps)});
|
||||
style.setStyle("ms",{"color":hex2css(theme.ms)});
|
||||
style.setStyle("mem",{"color":hex2css(theme.mem)});
|
||||
style.setStyle("memMax",{"color":hex2css(theme.memmax)});
|
||||
text = new TextField();
|
||||
text.width = 70;
|
||||
text.height = 50;
|
||||
text.styleSheet = style;
|
||||
text.condenseWhite = true;
|
||||
text.selectable = false;
|
||||
text.mouseEnabled = false;
|
||||
graph = new Bitmap();
|
||||
graph.y = 50;
|
||||
rectangle = new Rectangle(70 - 1,0,1,100 - 50);
|
||||
addEventListener("addedToStage",init,false,0,true);
|
||||
addEventListener("removedFromStage",destroy,false,0,true);
|
||||
}
|
||||
|
||||
private function init(param1:Event) : void
|
||||
{
|
||||
graphics.beginFill(theme.bg);
|
||||
graphics.drawRect(0,0,70,100);
|
||||
graphics.endFill();
|
||||
addChild(text);
|
||||
graph.bitmapData = new BitmapData(70,100 - 50,false,theme.bg);
|
||||
addChild(graph);
|
||||
addEventListener("click",onClick);
|
||||
addEventListener("enterFrame",update);
|
||||
}
|
||||
|
||||
private function destroy(param1:Event) : void
|
||||
{
|
||||
graphics.clear();
|
||||
while(numChildren > 0)
|
||||
{
|
||||
removeChildAt(0);
|
||||
}
|
||||
graph.bitmapData.dispose();
|
||||
removeEventListener("click",onClick);
|
||||
removeEventListener("enterFrame",update);
|
||||
}
|
||||
|
||||
private function update(param1:Event) : void
|
||||
{
|
||||
timer = getTimer();
|
||||
if(timer - 1000 > ms_prev)
|
||||
{
|
||||
ms_prev = timer;
|
||||
mem = Number((System.totalMemory * 9.54e-7).toFixed(3));
|
||||
mem_max = mem_max > mem ? mem_max : mem;
|
||||
fps_graph = Math.min(graph.height,fps / stage.frameRate * graph.height);
|
||||
mem_graph = Math.min(graph.height,Math.sqrt(Math.sqrt(mem * 5000))) - 2;
|
||||
mem_max_graph = Math.min(graph.height,Math.sqrt(Math.sqrt(mem_max * 5000))) - 2;
|
||||
graph.bitmapData.scroll(-1,0);
|
||||
graph.bitmapData.fillRect(rectangle,theme.bg);
|
||||
graph.bitmapData.setPixel(graph.width - 1,graph.height - fps_graph,theme.fps);
|
||||
graph.bitmapData.setPixel(graph.width - 1,graph.height - (timer - ms >> 1),theme.ms);
|
||||
graph.bitmapData.setPixel(graph.width - 1,graph.height - mem_graph,theme.mem);
|
||||
graph.bitmapData.setPixel(graph.width - 1,graph.height - mem_max_graph,theme.memmax);
|
||||
xml.fps = "FPS: " + fps + " / " + stage.frameRate;
|
||||
xml.mem = "MEM: " + mem;
|
||||
xml.memMax = "MAX: " + mem_max;
|
||||
fps = 0;
|
||||
}
|
||||
fps = fps + 1;
|
||||
xml.ms = "MS: " + (timer - ms);
|
||||
ms = timer;
|
||||
text.htmlText = xml;
|
||||
}
|
||||
|
||||
private function onClick(param1:MouseEvent) : void
|
||||
{
|
||||
mouseY / height > 0.5 ? stage.frameRate-- : Number(stage.frameRate++);
|
||||
xml.fps = "FPS: " + fps + " / " + stage.frameRate;
|
||||
text.htmlText = xml;
|
||||
}
|
||||
|
||||
private function hex2css(param1:int) : String
|
||||
{
|
||||
return "#" + param1.toString(16);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user