Manuell bitmappscaching

Använd klassen BitmapData för att skapa ett eget bitmappscachningbeteende.

I följande exempel återanvänds en rastrerad bitmappsversion av ett visningsobjekt och referenser görs till samma BitmapData-objekt. När varje visningsobjekt skalas kommer det ursprungliga BitmapData-objektet i minnet varken att uppdateras eller att ritas om. Detta arbetssätt sparar processorresurser och gör att programmet körs snabbare. När ett visningsobjekt skalas kommer bitmappen däri att sträckas ut.

Här visas den uppdaterade BitmapApple -klassen:

package org.bytearray.bitmap 
{ 
    import flash.display.Bitmap; 
    import flash.display.BitmapData; 
    import flash.events.Event; 
     
    public class BitmapApple extends Bitmap 
    { 
        private var destinationX:Number; 
        private var destinationY:Number; 
         
        public function BitmapApple(buffer:BitmapData) 
        { 
            super(buffer); 
 
            addEventListener(Event.ADDED_TO_STAGE,activation); 
            addEventListener(Event.REMOVED_FROM_STAGE,deactivation);     
        } 
         
        private function activation(e:Event):void  
        { 
            initPos();     
            addEventListener(Event.ENTER_FRAME,handleMovement); 
        } 
         
        private function deactivation(e:Event):void  
        { 
            removeEventListener(Event.ENTER_FRAME,handleMovement);     
        } 
         
        private function initPos():void 
        { 
            destinationX = Math.random()*(stage.stageWidth - (width>>1)); 
            destinationY = Math.random()*(stage.stageHeight - (height>>1)); 
        } 
         
        private function handleMovement(e:Event):void  
        {             
            alpha = Math.random(); 
             
            x -= (x - destinationX)*.5; 
            y -= (y - destinationY)*.5; 
             
            if ( Math.abs(x - destinationX) < 1 && Math.abs(y - destinationY) < 1) 
                initPos(); 
        } 
    } 
}

Alfavärdet ändras fortfarande för varje bildruta. I följande kod skickas originalkällans buffert till varje BitmapApple-instans:

import org.bytearray.bitmap.BitmapApple; 
 
const MAX_NUM:int = 100; 
var holder:Sprite = new Sprite(); 
 
addChild(holder); 
 
var holderVector:Vector.<BitmapApple> = new Vector.<BitmapApple>(MAX_NUM, true); 
var source:AppleSource = new AppleSource(); 
var bounds:Object = source.getBounds(source); 
     
var mat:Matrix = new Matrix(); 
mat.translate(-bounds.x,-bounds.y); 
 
var buffer:BitmapData = new BitmapData(source.width+1, source.height+1, true, 0); 
buffer.draw(source,mat); 
     
var bitmapApple:BitmapApple; 
     
for (var i:int = 0; i< MAX_NUM; i++) 
{ 
    bitmapApple = new BitmapApple(buffer); 
     
    holderVector[i] = bitmapApple; 
         
    holder.addChild(bitmapApple); 
}

Med den här tekniken används endast en liten del av minnet eftersom endast en cache-lagrad bitmapp används och den delas av alla BitmapApple -instanser. Dessutom kommer originalkällans bitmapp aldrig att uppdateras, trots ändringar som görs i BitmapApple -instanserna, som exempelvis i alfavärdet, rotering och skalning. Använd den här tekniken för att förhindra prestandaförsämringar.

För en mjuk slutlig bitmapp ska du ange att smoothing -egenskapen ska vara true :

public function BitmapApple(buffer:BitmapData) 
{ 
    super (buffer); 
  
    smoothing = true; 
  
    addEventListener(Event.ADDED_TO_STAGE, activation); 
     addEventListener(Event.REMOVED_FROM_STAGE, deactivation);     
}

Du kan även få prestandaförbättringar genom att ändra scenkvaliteten. Ange att scenkvaliteten ska vara HIGH före rastreringen och ändra den sedan till låg LOW :

import org.bytearray.bitmap.BitmapApple; 
  
const MAX_NUM:int = 100; 
var holder:Sprite = new Sprite(); 
  
addChild ( holder ); 
  
var holderVector:Vector.<BitmapApple> = new Vector.<BitmapApple>(MAX_NUM, true); 
var source:AppleSource = new AppleSource(); 
var bounds:Object = source.getBounds ( source ); 
      
var mat:Matrix = new Matrix(); 
mat.translate ( -bounds.x, -bounds.y ); 
  
var buffer:BitmapData = new BitmapData ( source.width+1, source.height+1, true, 0 ); 
  
stage.quality = StageQuality.HIGH; 
  
buffer.draw ( source, mat ); 
  
stage.quality = StageQuality.LOW; 
      
var bitmapApple:BitmapApple; 
      
for (var i:int = 0; i< MAX_NUM; i++ ) 
{ 
    bitmapApple = new BitmapApple( buffer ); 
     
    holderVector[i] = bitmapApple; 
         
    holder.addChild ( bitmapApple ); 
}

Att växla scenkvalitet före och efter det att vektorn för en bitmapp ritats upp, kan vara en användbar teknik för att få kantutjämnat innehåll på skärmen. Den här tekniken kan vara effektiv oberoende av den slutgiltiga scenkvaliteten. Du kan till exempel få en kantutjämnad bitmapp med kantutjämnad text även om scenkvaliteten är inställd på LOW . Denna teknik går inte att använda med egenskapen cacheAsBitmap . I detta fall kommer vektorkvaliteten att uppdateras när du anger att scenkvaliteten ska vara LOW , vilket leder till att bitmappsytan i minnet uppdateras och att den slutgiltiga kvaliteten uppdateras.

Isolera beteenden