private void LoadScn(string fileName, SpriteArray spriteArray, DynamicSpriteArray dynamicSpriteArray,
SpriteGridArray spriteGridArray, AttachableList<SpriteFrame> spriteFrames, SpriteLayer spriteLayer)
{
// the first step is to create the SpriteEditorScene and load (deserialize it)
SpriteEditorScene spriteEditorScene = new SpriteEditorScene();
spriteEditorScene.LoadScene(fileName);
// Remember, Sprites in the Scene can have attachments. These attachments should
// obviously be reestablished when the .scn loads. To do this, we have to have a
// SpriteArray storing all elements which can be attached to. Two things to remember:
// 1. The SpriteArray will have Sprites and DynamicSprites as they can be attached
// to eachother.
// 2. Sprites can (and should) be added one-way since the list will only
// be used in this method. Not only is this slightly faster, but there's no
// need to explicitly clear the SpriteArra at the end of the method if it's one way.
SpriteArray oneWaySpriteArray = new SpriteArray();
// great, everything's loaded into ram. Next step is to take the individual components
// of the SpriteEditorScene and create actual FRB objects out of them.
// first, we'll deal with the regular Sprites. All Sprite information is stored
// in the SpriteSaveArray field called ssa. It is possible to manually set each
// individual Sprite property from its corresponding SpriteSave reference, but
// not only is that a lot of code, but it also requires your code to update whenever
// the .scn format changes. It's much easier to simply call the Sprite's SetFromSave
// method.
// I'll loop through the ssa SpriteSaveArray and create the Sprite from the SpriteSave
foreach(SpriteSave spriteSave in spriteEditorScene.ssa) {
Sprite newSprite = new Sprite();
newSprite.SetFromSave(spriteSave);
// since the SetFromSave is a public method, any objects which inherit from the
// Sprite class will also be able to call this method. That means that regardless
// of the type, this method will work. Just replace the Sprite type with your
// object type.
// add the Sprite to the SpriteManager and perhaps to other SpriteArrays
if(spriteLayer != null)
sprMan.AddSprite(newSprite, spriteLayer);
else
sprMan.AddSprite(newSprite);
spriteArray.Add(newSprite); // this is two way
oneWaySpriteArray.AddOneWay(newSprite); // this is one way
// the Sprite is almost ready to go. One thing that remains is to validate the
// ordered/unordered property of the Sprite. That is, the Sprite knows if it
// should be ordered or unordered, so calling ValidateOrdered will make sure that
// it is categorized correctly in the SpriteManager.
// Setting the texture and attachments will be done outside of the
// loops once we have all of our Sprites and Dynamic Sprites created.
sprMan.ValidateOrdered(newSprite);
}
// yeah, it's redundant, but do it all again for DynamicSprites
foreach(DynamicSpriteSave dynamicSpriteSave in spriteEditorScene.dynamicSpriteSaveList) {
DynamicSprite newDynamicSprite = new DynamicSprite();
newDynamicSprite.SetFromSave(dynamicSpriteSave);
// add the DynamicSprite to the SpriteManager and perhaps to other SpriteArrays
if(spriteLayer != null)
sprMan.AddDynamicSprite(newDynamicSprite, spriteLayer);
else
sprMan.AddDynamicSprite(newDynamicSprite);
dynamicSpriteArray.Add(newDynamicSprite); // this is two way
oneWaySpriteArray.AddOneWay(newDynamicSprite); // this is one way
// no need to validate ordered
}
// validate the textures
// this call is what usually takes the most time when loading a scene. .scn files
// are usually very small (a few kbytes), whereas all textures can total a few
// mbytes.
sprMan.ValidateSpriteTextureAndAnimations(oneWaySpriteArray);
// may consider checking the static SpriteManager.texturesNotFound field if you plan
// on handling textures that weren't found when validating. If checking this,
// you may also want to check it after creating the MSGs like SpriteGrids and SpriteFrames
// now that all Sprites are loaded, we can validate Dependencies (attachments)
sprMan.ValidateDependencies(spriteEditorScene.ssa, oneWaySpriteArray, oneWaySpriteArray);
sprMan.ValidateDependencies(spriteEditorScene.dynamicSpriteSaveList, oneWaySpriteArray, oneWaySpriteArray);
// our Sprites are good to go. Next, SpriteGrids
// the spriteGridSaveArray could be null, so check against that
if(spriteEditorScene.spriteGridSaveArray != null) {
spriteGridArray.SetFromSave(spriteEditorScene.spriteGridSaveArray, sprMan, camera, random);
// just like Sprites, SpriteGrids must have their textures validated.
// Also, they must be populated and the paint must be refreshed.
foreach(SpriteGrid spriteGrid in spriteGridArray) {
// If using a version of FRB earlier than August 2007, the
// following call is needed. Otherwise, it is done automatically in the
// SetFromSave call above.
spriteGrid.ValidateTexturesAndAnimations();
// We'll just say the population should occur at the center of the screen
spriteGrid.PopulateGrid(camera.x, camera.y, camera.z);
spriteGrid.RefreshPaint();
}
}
// ahh, now that part was easy. Finally, we create the SpriteFrames. Like the SpriteGrids,
// they're pretty easy to deal with.
// first, make sure the spriteFrameSaveList is not null
if(spriteEditorScene.spriteFrameSaveList != null) {
// let's create the SpriteFrames
foreach(SpriteFrameSave spriteFrameSave in spriteEditorScene.spriteFrameSaveList) {
SpriteFrame newSpriteFrame;
if(spriteLayer != null)
newSpriteFrame = new SpriteFrame(sprMan, spriteFrameSave, spriteLayer);
else
newSpriteFrame = new SpriteFrame(sprMan, spriteFrameSave);
// SpriteFrames automatically validate their textures when loading from
// a SpriteFrameSave - how nice of them!
spriteFrames.Add(newSpriteFrame); // two way
}
}
}