ActionScript 3
Prestaties optimaliseren

Vectorafbeeldingen

Op vectoren gebaseerde afbeeldingen worden weergegeven door een overvloed aan gegevens die moeten worden berekend door de CPU (vectorpunten, bogen, kleuren, enz.). Alles anders dan eenvoudige vormen met minimale punten en rechte lijnen zal enorme hoeveelheden CPU-bronnen verbruiken.

Er is een vlag "Cache as Bitmap" die kan worden ingeschakeld. Deze vlag slaat het resultaat op van het tekenen van het vectorgebaseerde DisplayObject voor veel snellere hertekeningen. De valkuil hiervan is dat als er transformaties op het object worden toegepast, het hele ding opnieuw moet worden getekend en opnieuw in de cache moet worden geplaatst. Dit kan langzamer zijn dan helemaal niet inschakelen als er frame-voor-frame transformaties worden toegepast (rotatie, schaling, enz.).

Over het algemeen presteert het weergeven van afbeeldingen met bitmaps veel beter dan het gebruik van vectorafbeeldingen. Bibliotheken zoals flixel profiteren hiervan om sprites op een "canvas" te renderen zonder framerate te verminderen.

Tekst

Het renderen van tekst kost veel CPU. Lettertypen worden op dezelfde manier weergegeven als vectorafbeeldingen en bevatten veel vectorpunten voor elk teken. Tekst per beeld wijzigen zal de prestaties verslechteren. De vlag "Cache as bitmap" is uiterst nuttig indien correct gebruikt, wat betekent dat u moet vermijden:

• De tekst regelmatig wijzigen.
• Het tekstveld transformeren (roteren, schalen).

Eenvoudige technieken zoals het inpakken van tekstupdates in een if statement zullen een groot verschil maken:

if (currentScore !== oldScore) {
    field.text = currentScore;
}

Tekst kan worden weergegeven met de anti-alias renderer die is ingebouwd in Flash of met "apparaatlettertypen". Door "apparaatlettertypen" te gebruiken, wordt tekst veel sneller weergegeven, hoewel tekst er rafelig uitziet (alias). Voor apparaatlettertypen moet het lettertype vooraf zijn geïnstalleerd door uw eindgebruiker, of de tekst kan "verdwijnen" op de pc van de gebruiker, hoewel het prima lijkt op die van u.

field.embedFonts = false; // uses "device fonts"

Vector en voor elke vs arrays en voor

Vector.<T> type Vector.<T> en de for each lus is beter dan een conventionele array en for lus:

Mooi zo:

var list:Vector.<Sprite> = new <Sprite>[];

for each(var sprite:Sprite in list) {
    sprite.x += 1;
}

Slecht:

var list:Array = [];

for (var i:int = 0; i < list.length; i++) {
    var sprite:Sprite = list[i];

    sprite.x += 1;
}

Snelle verwijdering van array-items

Als u niet wilt dat een array in een bepaalde volgorde staat, levert een kleine truc met pop() u enorme prestatiewinst op in vergelijking met splice() .

Wanneer u een array splice() , moet de index van de volgende elementen in die array met 1 worden verminderd. Dit proces kan een groot deel van de tijd vergen als de array groot is en het object dat u verwijdert zich dichter bij het begin van die array bevindt .

Als u niet geïnteresseerd bent in de volgorde van de elementen in de array, kunt u in plaats daarvan het item dat u wilt verwijderen vervangen door een item dat u uit de array pop() . Op deze manier blijven de indexen van alle andere items in de array hetzelfde en neemt het proces niet af naarmate de lengte van uw array toeneemt.

Voorbeeld:

function slowRemove(list:Array, item:*):void {
    var index:int = list.indexOf(item);
    
    if (index >= 0) list.splice(index, 1);
}

function fastRemove(list:Array, item:*):void {
    var index:int = list.indexOf(item);

    if (index >= 0) {
        if (index === list.length - 1) list.pop();

        else {
            // Replace item to delete with last item.
            list[index] = list.pop();
        }
    }
}

Vectoren in plaats van arrays

Flash Player 10 introduceerde het generieke lijsttype Vector. <*> Dat sneller was dan de array. Dit is echter niet helemaal waar. Alleen de volgende vectortypen zijn sneller dan de tegenhangers van de array vanwege de manier waarop ze in Flash Player zijn geïmplementeerd.

• Vector.<int> - Vector van 32-bits gehele getallen
• Vector.<uint> - Vector van 32-bits gehele getallen zonder teken
• Vector.<Double> - Vector van 64-bit floats

In alle andere gevallen zal het gebruik van een array beter presteren dan het gebruik van vectoren, voor alle bewerkingen (maken, manipuleren, enz.). Als u uw code echter "sterk wilt typen", kunt u vectoren gebruiken ondanks de vertraging. FlashDevelop heeft een syntaxis waarmee vervolgkeuzelijsten voor code-voltooiing kunnen werken, zelfs voor arrays, met behulp van /*ObjectType*/Array .

var wheels:Vector.<Wheel> // strongly typed, but slow

var wheels:/*Wheel*/Array // weakly typed, but faster

Afbeeldingen opnieuw gebruiken en poolen

Het maken en configureren van Sprite en TextField objecten tijdens runtime kan kostbaar zijn als u honderdduizenden hiervan op één frame maakt. Daarom is een veel voorkomende truc het "poolen" van deze objecten voor later hergebruik. Vergeet niet dat we niet alleen proberen de aanmaaktijd te optimaliseren ( new Sprite() ) maar ook de configuratie (instelling van standaardeigenschappen).

Laten we zeggen dat we een lijstcomponent bouwden met behulp van honderden TextField-objecten. Wanneer u een nieuw object moet maken, controleert u of een bestaand object opnieuw kan worden gebruikt.

var pool:Array = [];

if (pool.length > 0){

    // reuse an existing TextField
    var label = pool.pop();

}else{
    // create a new TextField
    label = new TextField();
    
    // initialize your TextField over here
    label.setDefaultTextFormat(...);
    label.multiline = false;
    label.selectable = false;
}

// add the TextField into the holder so it appears on-screen
// you will need to layout it and set its "text" and other stuff seperately
holder.addChild(label);

Wanneer u later uw component vernietigt (of van het scherm verwijdert), vergeet dan niet om ongebruikte labels weer in de pool toe te voegen.

foreach (var label in allLabels){
    label.parent.removeChild(label); // remove from parent Sprite
    pool.push(label); // add to pool
}

In de meeste gevallen is het het beste om een pool per gebruik te maken in plaats van een globale pool. Nadelen van het maken van een globale pool is dat u het object telkens opnieuw moet initialiseren om het uit de pool te halen, om de instellingen van andere functies te negeren. Dit is even duur en ontkracht vrijwel de prestatieverbetering van het gebruik van pooling in de eerste plaats.