caching und rendering eines spritesheets funzt nicht

[drpelz]

Hallo Leute;

ich wurde gerne meine spritesheets cachen (in Array schmeissen). Ich will mein System so haben dass meine Objekte auf den Cache (es wird mehrere unterschiedliche Zaches geben) mit den bitmapDatas bloss noch zugreifen muessen. Aber irgendwie funktioniert das nicht, denn es wird absolut nichts gerendert. Und zwar gar nichts. Fehlermeldungen habe ich auch keine gesehen.

Im cache selbst befindet sich durchaus was (ich gehe mal davon aus dass es bitmapDatas sind) und null ist es auch nicht aber irgendwie wird rein gar nichts aus dem cache heraus gerendert.

Es wäre sehr nett, wenn mir da bitte jemand weiterhelfen koennte denn ich komme da einfach nicht mehr weiter. Vielen Dank.

diese Funktion soll die einzelnen Titels aus dem Spritesheet heraus erstellen und in einen Array (cache) schmeissen

private function tileToCache():void {
			var tileBitmapData:BitmapData = new BitmapData(tileWidth, tileHeight, true, 0x00000000);
			var tilePt:Point = new Point(0, 0);
			var tileRect:Rectangle = new Rectangle;
			
			
			tileCache = [];
			
			for (var tileCtr:int = 0; tileCtr < tilesLength; tileCtr++) {
				
				tileBitmapData.lock();
				tileRect.x = int((tileCtr % spritesPerRow)) * tileWidth;
				tileRect.y = int((tileCtr / spritesPerRow)) * tileHeight;
				
				tileBitmapData.copyPixels(tileSheet, tileRect, tilePt);
				tileBitmapData.unlock();

				tileCache.push(tileBitmapData);
				
			}
}

diese Funktion soll die Tiles aus dem Array heraus auf einen Hintergrund rendern mit der copyPixels-Methode

public function renderCachedTile(canvasBitmapData:BitmapData, tileArray:Array):void
		{
			
			tileCache = tileArray;
			
			tileArray = [];
			
			x = nextX;
			y = nextY;
			
			point.x = x;
			point.y = y;
			
			tileRect.x = tileWidth;
			tileRect.y = tileHeight;
			
			if (animationCount >= animationDelay)
			{
				animationCount = 0;
				
				if(reverse)
				{
					currentTile--;
					if (currentTile < 1)
					{
						currentTile = tilesLength - 1;
					}
					
					
				} else {
					
					currentTile++;
					if (currentTile >= tilesLength - 1)
					{
						currentTile = 0;
					}
					
					
				}
				
			} else {
				animationCount++;
			}
				
			canvasBitmapData.lock();	
			
			
			canvasBitmapData.copyPixels(tileCache[currentTile], tileRect, point);
			canvasBitmapData.unlock();
			
			
		}

[thomas_E]

PHP-Code:

private function tileToCache():void 
{
    var tilePt:Point = new Point(0, 0);
    //dein Rectangle brauch auch breite und höhe
    var tileRect:Rectangle = new Rectangle(0,0,tileWidth, tileHeight);
    tileCache = [];
    
    for (var tileCtr:int = 0; tileCtr < tilesLength; tileCtr++)
    {
        //wenn du das so machen willst, musst du schon für jedes tile ein eigenes BitmapData erzeugen
        var tileBitmapData:BitmapData = new BitmapData(tileWidth, tileHeight, true, 0x00000000);
        tileRect.x = int((tileCtr % spritesPerRow)) * tileWidth;
        tileRect.y = int((tileCtr / spritesPerRow)) * tileHeight;
        
        tileBitmapData.copyPixels(tileSheet, tileRect, tilePt);
        tileBitmapData.unlock();

        tileCache.push(tileBitmapData);
    }
    //dir ist schon bewusst, dass du jetzt den doppelten Speicherverbrauch hast, weil tileSheet + cache
}

public function renderCachedTile(canvasBitmapData:BitmapData, tileArray:Array):void
{
//    wieso überschreibst du beim Rendern deinen Cache ???
//    tileCache = tileArray;
//    tileArray = [];
    
    x = nextX;
    y = nextY;
    
    point.x = x;
    point.y = y;
    
    //tileRect existiert doch nur in tileToCache
    //und müsste wenn dann 0,0 als Position haben
//    tileRect.x = 0;
//    tileRect.y = 0;
    
    if (animationCount >= animationDelay)
    {
        animationCount = 0;
        
        if(reverse)
        {
            currentTile--;
            if (currentTile < 0)        //0 ist auch ein gültiger Index
            {
                currentTile = tilesLength - 1;
            }
        } else {
            currentTile++;
            if (currentTile >= tilesLength)    //ebenso wie tilesLength-1
            {
                currentTile = 0;
            }
        }
    } else {
        animationCount++;
    }
        
    //das solltest du genau 1 mal / renderzyklus machen, und zwar zentral
    //weil es sonst sinnlos ist
    //canvasBitmapData.lock();
    
    var tile:BitmapData = tileCache[currentTile];
    canvasBitmapData.copyPixels(tile, tile.rect, point);
    
    //canvasBitmapData.unlock(); 
} 


hier noch ne andere Variante, ohne das tileSheet zu splicen

PHP-Code:

private var tiles:Array = [];        //eigentlich nur die rects, die er ausm tileSheet kopieren soll
private function tileToCache():void 
{
    tiles = [];
    for(var i:int, i<tilesLength; ++i){
        tiles[i] = new Rectangle(
            int((tileCtr % spritesPerRow)) * tileWidth,
            int((tileCtr / spritesPerRow)) * tileHeight,
            tileWidth,
            tileHeight
        );
    }
}

public function renderCachedTile(canvasBitmapData:BitmapData, tileArray:Array):void
{
    if (++animationCount >= animationDelay)
    {
        animationCount = 0;
        if(reverse)
        {
            if (--currentTile < 0)
                currentTile = tilesLength - 1;
        } else {
            if (++currentTile == tilesLength)
                currentTile = 0;
        }
    }
    point.x = x = nextX;
    point.y = y = nextY;
    canvasBitmapData.copyPixels(tileSheet, tiles[currentTile], point);
} 


[drpelz]

Wow! Vielen Dank! Eine FRage haette ich allerding noch: Du sagst ich habe doppelten Speicherverbrach. Wenn ich mein urspruengliches tileSheet aus dem Speicher loesche sollte doch wieder alles in Ordnung sein, oder?

Sollte man ein tileSheet waehrend des Spielprozesses auslesen (z.Bsp. mit copyPixels) oder alles aus einem Array? Was ist schneller? Momentan wird alles aus dem tileSheet in Echtzeit ausgelesen und irgendwie kommt mir mein Spiel seitdem etwas langsamer vor.

[thomas_E]

müsste ich mal testen. sollte eigentlich keinen Unterschied machen, da die selbe Anzahl an Pixeln kopiert und verarbeitet werden muss.

Wenn ich mein urspruengliches tileSheet aus dem Speicher loesche sollte doch wieder alles in Ordnung sein, oder?

ja, dann hast du ja nur noch die einzelnen Kacheln.
(BitmapData.dispose())

Momentan wird alles aus dem tileSheet in Echtzeit ausgelesen und irgendwie kommt mir mein Spiel seitdem etwas langsamer vor.

wie machst du das momentan mit dem canvasBitmapData.lock()?
das sollte so aussehen:

PHP-Code:

//pseudocode
function onEnterFrame(e:Event):void
{
    canvasBitmapData.lock();
    for each(var item:Type in items)
        item.renderCachedTile(canvasBitmapData);
    canvasBitmapData.unlock()
} 


[drpelz]

Rendering funktioniert wieder wirft aber bei mir Fehlermeldungen aus ("Error #2007: Parameter sourceBitmapData must be non-null.
at flash.display::BitmapData/copyPixels()
at com.framework_mod.src::BasicBlitArrayObject/renderCachedTile()").

Ich vermute der Fehler liegt bei currentTile (bin mir aber nicht 100% sicher).

Ich hab 'ne Frage: ich brache ja dieses eine Kachel nur fuer eine pixel-genaue Kollisionsabfrage. Gibt's da irgendwie 'ne Moeglichkeit das TileSheet zu kacheln ohne dass es doppelt so viel Speicher frisst?? Selbst wenn ich tileSheet.dispose mache verbraucht mein Spiel deutlich mehr Speicher als vorher (momentan: 111000 kb, vorher: 89000 kb).

Du hattest ja geschrieben , dass man einen Array nur mit den Rects machen kann. Kann man mit diesem Ansatz irgendwie da was machen?

Das mit dem Cache hatte ich uebrgiens aus diesem Tutorial hier: http://www.8bitrocket.com/2008/3/25/...eroids-Part-4/

Update:

Fehler ist weg. Lag an falschem Wert bei tiles.length. Momentan habe ich 5 verschiedene Caches angelegt, damit jedes unterschiedliche Objekt auf seinen entsprechenden Cache zugreifen kann. Es funktioniert. Die pixel-genaue Abfrage funzt auch wie geschmiert.

Bitte nicht hauen - ist das sinnvoll oder voelliger Bloedsinn (funktioniert aber):

for each (tempAsteroid in asteroidManager.asteroids) {
				
				
				//tempAsteroid.renderCachedTile(canvasBitmapData);
				
				switch (tempAsteroid._size) {
					
					case 1: 
							tempAsteroid.renderCachedTile(canvasBitmapData, asteroidManager.tileCache1);
							
							break;
							
					case 2: 
							tempAsteroid.renderCachedTile(canvasBitmapData, asteroidManager.tileCache2);
							
							break;
							
					case 3: 
							tempAsteroid.renderCachedTile(canvasBitmapData, asteroidManager.tileCache3);
							
							break;
							
					case 4: 
							tempAsteroid.renderCachedTile(canvasBitmapData, asteroidManager.tileCache4);
							
							break;
							
					case 5: 
							tempAsteroid.renderCachedTile(canvasBitmapData, asteroidManager.tileCache5);
							
							break;
					
				}
				
				
			}

Frisst so was viel Performance oder geht das auch eleganter?