SHARE
TWEET

Untitled

a guest Mar 6th, 2013 181 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package com.kpulv {
  2.         import flash.display.Bitmap;
  3.         import flash.display.BitmapData;
  4.         import flash.geom.Point;
  5.         import flash.geom.Rectangle;
  6.         import net.flashpunk.FP;
  7.         import net.flashpunk.graphics.Image;
  8.         import net.flashpunk.utils.Draw;
  9.         /**
  10.          * ...
  11.          * @author kpulv
  12.          */
  13.         public class NineSlice {
  14.                
  15.                 private var _width:uint;
  16.                 private var _height:uint;
  17.                
  18.                 public var gridX:uint;
  19.                 public var gridY:uint;
  20.                
  21.                 public var snapWidth:Boolean = false;
  22.                 public var snapHeight:Boolean = false;
  23.                
  24.                 public var stretchLeft:Boolean = false;
  25.                 public var stretchTop:Boolean = false;
  26.                 public var stretchRight:Boolean = false;
  27.                 public var stretchBottom:Boolean = false;
  28.                 public var stretchCenter:Boolean = false;
  29.                
  30.                 private var _x:Number;
  31.                 private var _y:Number;
  32.                
  33.                 public var scrollX:Number = 1;
  34.                 public var scrollY:Number = 1;
  35.                
  36.                 private var _source:BitmapData;
  37.                
  38.                 public var buffer:BitmapData;
  39.                
  40.                 public var image:Image;
  41.                
  42.                 public var slices:Vector.<BitmapData> = new Vector.<BitmapData>(9);
  43.                
  44.                 private var needsRefresh:Boolean = false;
  45.                
  46.                 public function NineSlice(source:*, gridX:uint, gridY:uint, width:uint = 1, height:uint = 1) {
  47.                         if (source is Class) {
  48.                                 this.source = FP.getBitmap(source);
  49.                         }
  50.                         else {
  51.                                 this.source = source
  52.                         }
  53.                        
  54.                         this.gridX = gridX;
  55.                         this.gridY = gridY;
  56.                         _width = width;
  57.                         _height = height;
  58.                        
  59.                         updateBuffer();
  60.                 }
  61.                
  62.                 public function updateBuffer():void {
  63.                         var i:uint = 0;
  64.                         var j:uint = 0;
  65.                         for (i = 0; i < 9; i++) {
  66.                                 slices[i] = new BitmapData(gridX, gridY);
  67.                                 var xx:uint = convert2dX(i, 3) * gridX;
  68.                                 var yy:uint = convert2dY(i, 3) * gridY;
  69.                                 slices[i].copyPixels(_source, new Rectangle(xx, yy, gridX, gridY), FP.zero);
  70.                         }
  71.                        
  72.                         buffer = new BitmapData(_width, _height);
  73.                         buffer.fillRect(buffer.rect, 0);
  74.                        
  75.                         var bd:BitmapData;
  76.                        
  77.                         /** Draw the center */
  78.                         if (stretchCenter) {
  79.                                 if (_width > gridX + gridX) {
  80.                                         if (_height > gridY + gridY) {
  81.                                                 bd = scaleBitmapData(slices[4], (_width - gridX - gridX) / gridX, (_height - gridY - gridY) / gridY);
  82.                                                 buffer.copyPixels(bd, bd.rect, new Point(gridX, gridY));
  83.                                                 bd.dispose();
  84.                                         }
  85.                                 }
  86.                         }
  87.                         else {
  88.                                 for (i = gridX; i < _width - gridX; i += gridX) {
  89.                                         for (j = gridY; j < _height - gridY; j += gridY) {
  90.                                                 buffer.copyPixels(slices[4], slices[4].rect, new Point(i, j));
  91.                                         }
  92.                                 }
  93.                         }
  94.                        
  95.                         /** Draw the edges */
  96.                         if (stretchTop) {
  97.                                 if (_width > gridX + gridX) {
  98.                                         bd = scaleBitmapData(slices[1], (_width - gridX - gridX) / gridX, 1);
  99.                                         buffer.copyPixels(bd, bd.rect, new Point(gridX, 0));
  100.                                         bd.dispose();
  101.                                 }
  102.                         }
  103.                         else {
  104.                                 for (i = gridX; i < _width - gridX; i += gridX) {
  105.                                         buffer.copyPixels(slices[1], slices[1].rect, new Point(i, 0));
  106.                                 }
  107.                         }
  108.                        
  109.                         if (stretchBottom) {
  110.                                 if (_width > gridX + gridX) {
  111.                                         bd = scaleBitmapData(slices[7], (_width - gridX - gridX) / gridX, 1);
  112.                                         buffer.copyPixels(bd, bd.rect, new Point(gridX, _height - gridY));
  113.                                         bd.dispose();
  114.                                 }
  115.                         }
  116.                         else {
  117.                                 for (i = gridX; i < _width - gridX; i += gridX) {
  118.                                         buffer.copyPixels(slices[7], slices[7].rect, new Point(i, _height - gridY));   
  119.                                 }
  120.                         }
  121.                        
  122.                         if (stretchLeft) {
  123.                                 if (_height > gridY + gridY) {
  124.                                         bd = scaleBitmapData(slices[3], 1, (_height - gridY - gridY) / gridY);
  125.                                         buffer.copyPixels(bd, bd.rect, new Point(0, gridY));
  126.                                         bd.dispose();
  127.                                 }
  128.                         }
  129.                         else {
  130.                                 for (i = gridY; i < _height - gridY; i += gridY) {
  131.                                         buffer.copyPixels(slices[3], slices[3].rect, new Point(0, i));
  132.                                 }
  133.                         }
  134.                        
  135.                         if (stretchRight) {
  136.                                 if (_height > gridY + gridY) {
  137.                                         bd = KscaleBitmapData(slices[5], 1, (_height - gridY - gridY) / gridY);
  138.                                         buffer.copyPixels(bd, bd.rect, new Point(_width - gridX, gridY));
  139.                                         bd.dispose();
  140.                                 }
  141.                         }
  142.                         else {
  143.                                 for (i = gridY; i < _height - gridY; i += gridY) {
  144.                                         buffer.copyPixels(slices[5], slices[5].rect, new Point(_width - gridX, i));
  145.                                 }
  146.                         }
  147.                        
  148.                         /** draw corners */
  149.                         buffer.copyPixels(slices[0], slices[0].rect, FP.zero);
  150.                         buffer.copyPixels(slices[2], slices[2].rect, new Point(_width - gridX, 0));
  151.                         buffer.copyPixels(slices[6], slices[6].rect, new Point(0, _height - gridY));
  152.                         buffer.copyPixels(slices[8], slices[8].rect, new Point(_width - gridX, _height - gridY));
  153.                        
  154.                         bd = null;
  155.                        
  156.                         image = new Image(buffer);
  157.                         image.scrollX = scrollX;
  158.                         image.scrollY = scrollY;
  159.                         image.x = x;
  160.                         image.y = y;
  161.                 }
  162.                
  163.                 public function render():void {
  164.                         if (needsRefresh) {
  165.                                 needsRefresh = false;
  166.                                 updateBuffer();
  167.                         }
  168.                         Draw.graphic(image);
  169.                 }
  170.                
  171.                 public function get source():BitmapData { return _source; }
  172.                 public function set source(value:*):void {
  173.                         if (value is Class) {
  174.                                 _source = FP.getBitmap(value);
  175.                         }
  176.                         else {
  177.                                 _source = value;
  178.                         }
  179.                         needsRefresh = true;
  180.                 }
  181.                
  182.                 public function get x():Number { return _x; }
  183.                 public function set x(value:Number):void {
  184.                         _x = value;
  185.                         needsRefresh = true;
  186.                 }
  187.                
  188.                 public function get y():Number { return _x; }
  189.                 public function set y(value:Number):void {
  190.                         _y = value;
  191.                         needsRefresh = true;
  192.                 }
  193.                
  194.                 public function get width():uint { return _width; }
  195.                 public function set width(value:uint):void {
  196.                         _width = value;
  197.                         if (snapWidth) {
  198.                                 _width = Math.floor(_width / gridX) * gridX;
  199.                         }
  200.                         needsRefresh = true;
  201.                 }
  202.                
  203.                 public function get height():uint { return _height; }
  204.                 public function set height(value:uint):void {
  205.                         _height = value;
  206.                         if (snapHeight) {
  207.                                 _height = Math.floor(_height / gridY) * gridY;
  208.                         }
  209.                         needsRefresh = true;
  210.                 }
  211.  
  212.                 public static function scaleBitmapData(bitmapData:BitmapData, scaleX:Number, scaleY:Number):BitmapData {
  213.                 scaleX = Math.abs(scaleX);
  214.                 scaleY = Math.abs(scaleY);
  215.                 var width:int = (bitmapData.width * scaleX) || 1;
  216.                 var height:int = (bitmapData.height * scaleY) || 1;
  217.                 var transparent:Boolean = bitmapData.transparent;
  218.                 var result:BitmapData = new BitmapData(width, height, transparent);
  219.                 var matrix:Matrix = new Matrix();
  220.                 matrix.scale(scaleX, scaleY);
  221.                 result.draw(bitmapData, matrix);
  222.                 return result;
  223.                 }
  224.  
  225.                 public static function convert2dX(i:int, width:uint):int {
  226.                         return i % width;
  227.                 }
  228.                 public static function convert2dY(i:int, width:uint, height:uint = 0):int {
  229.                         return Math.floor(i / width);
  230.                 }
  231.                
  232.         }
  233.  
  234. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top