How can I optimise drawing from large SKTextureAtlas files with preloading? - sprite-kit

Question

I have a game with 4 Texture Atlases. Each atlas is 4096 x 4096 and contains roughly 300 sprites, all ~ 15kb - 50kb. Unoptimised in Texture Packer, they're around 2 - 4MB each, and about half that when optimised.
They contain assets to draw characters, but I'm finding it's very slow to draw a single character (around 24 nodes) ~ 0.5 seconds. This is because of multiple calls to [atlas textureNamed:textureName]
To speed things up, I want to preload the atlases. Ideally I would keep them in memory as I always need them. So my first question is, is this possible with atlases of this size? I've tried calling [SKTextureAtlas preloadTextureAtlases:#[MaleFeatureAtlas] withCompletionHandler...] but I get a crash with no stack trace, just a lost connection to device.
Currently, I have an AtlasManager class, that has static variables that initialise to each texture atlas:
static SKTextureAtlas *MaleFeatureAtlas;
static SKTextureAtlas *MaleItemAtlas;
static SKTextureAtlas *FemaleFeatureAtlas;
static SKTextureAtlas *FemaleItemAtlas;
#implementation AtlasManager
{
}
#pragma mark - Initialisation Methods
+ (void)initialize
{
MaleFeatureAtlas = [SKTextureAtlas atlasNamed:MaleFeatures];
MaleItemAtlas = [SKTextureAtlas atlasNamed:MaleItems];
FemaleFeatureAtlas = [SKTextureAtlas atlasNamed:FemaleFeatures];
FemaleItemAtlas = [SKTextureAtlas atlasNamed:FemaleItems];
}
Each character sprite has an instance of an AtlasManager, but since the SKTextureAtlases are static variables, I figured they would be fast to draw. But the constant calls to [atlas textureNamed:textureName] really slow the drawing down. I am storing an NSDictionary of nodes once drawn, so redrawing is very quick, but the initial draw takes far too long. Rendering 8 characters, with just over 100 nodes in total, takes about 5 seconds.
So, is a singleton approach better than using static variables? And is it wise to preload atlases of this size?

Answer 1

There's a lot of room for differing opinions regarding your questions. Keeping that in mind, I suggest the following:
When creating a texture atlas you should always plan ahead to what is really needed. For example, you have 5 different kinds of enemies but your game's first level only presents enemy #1 and #2. In this case you should create a texture atlas which only contains the required assets for your first level (enemy #1 & #2).
Singleton Pros:
Centralizing all your code into one class.
You only need to have 1 instance of the class.
Prevents having to double load some assets.
Singleton Cons:
Amount of code can get overwhelming if there are a lot of assets to manage.
Subclassing Pros:
Having all your code & assets handled in one class specific to the sprite's needs.
Subclassing Cons:
In certain instances you might have the same animation or image loaded multiple times by different classes. For example, a certain kind of explosion might get utilized by one or more subclass.
I prefer using the singleton approach because I like to centralize my code. Below is a simplified example on how I do this. I also use TexturePacker and use the header file option when creating a texture atlas. My singleton class is called Animations.
In the Animations header file I have this:
-(void)loadPlayer0Atlas;
#property (strong) SKTexture *player0_startLeft;
#property (strong) SKAction *player0_idleLeft;
#property (strong) SKAction *player0_idleRight;
#property (strong) SKAction *player0_walkLeft;
#property (strong) SKAction *player0_walkRight;
In the Animations implementation file:
-(void)loadPlayer0Atlas {
if(self.player0Atlas == nil) {
self.player0Atlas = [SKTextureAtlas atlasNamed:PLAYER0ATLAS_ATLAS_NAME];
[SKTextureAtlas preloadTextureAtlases:[NSArray arrayWithObject:self.player0Atlas] withCompletionHandler:^{
[self loadPlayer0Assets];
}];
} else {
[[NSNotificationCenter defaultCenter]postNotificationName:#"player0AtlasLoaded" object:self];
}
}
-(void)loadPlayer0Assets {
self.player0_startLeft = PLAYER0ATLAS_TEX_PLAYERIDLEL__000;
self.player0_idleLeft = [SKAction repeatActionForever:[SKAction animateWithTextures:PLAYER0ATLAS_ANIM_PLAYERIDLEL timePerFrame:0.2]];
self.player0_idleRight = [SKAction repeatActionForever:[SKAction animateWithTextures:PLAYER0ATLAS_ANIM_PLAYERIDLE timePerFrame:0.2]];
self.player0_walkLeft = [SKAction repeatActionForever:[SKAction animateWithTextures:PLAYER0ATLAS_ANIM_PLAYERWALKL timePerFrame:0.1]];
self.player0_walkRight = [SKAction repeatActionForever:[SKAction animateWithTextures:PLAYER0ATLAS_ANIM_PLAYERWALK timePerFrame:0.1]];
[[NSNotificationCenter defaultCenter]postNotificationName:#"player0AtlasLoaded" object:self];
}
The above code allows me to load up the player's assets by calling the method loadPlayer0Atlas. This method checks if the atlas has already been created. If yes, it posts a NSNotification indicating this. If no, it loads up the atlas, assigns the assets to class properties and then posts the NSNotification.
Back in the class which called loadPlayer0Atlas, you need to register for the NSNotification in either the init or didMoveToView methods.
[[NSNotificationCenter defaultCenter] addObserver:self
selector:#selector(myMethod)
name:#"player0AtlasLoaded"
object:nil];
Once the notification has been received, the myMethod can proceed with code knowing the player atlas is now loaded.
For good housekeeping remember to remove the calling class from NSNotifications like this:
-(void)willMoveFromView:(SKView *)view {
[[NSNotificationCenter defaultCenter] removeObserver:self];
}
To answer your last question on preloading an atlas. Yes it is always wise to preload your atlas because it makes for smoother game play. Having to load assets mid game will potentially cause lags. Just remember to only load the assets you require for the scene you are currently in. Good planning will yield you good results.