SoundLoader Class Reference

#include <CUSoundLoader.h>

Inheritance diagram for SoundLoader:

Classes
class	Coordinator

Public Member Functions
void	start () override
void	stop () override
size_t	waitCount () const override
Sound *	load (std::string key, std::string source) override
void	loadAsync (std::string key, std::string source) override
void	unload (std::string key) override
void	unloadAll () override
Public Member Functions inherited from Loader< Sound >
virtual bool	contains (std::string key) const
virtual Sound *	get (std::string key) const
Sound *	operator[] (std::string key) const
virtual size_t	loadCount () const override
Public Member Functions inherited from BaseLoader
bool	isActive () const
bool	isComplete () const
float	progress () const
CC_CONSTRUCTOR_ACCESS	_active (false)
virtual	~BaseLoader ()

Static Public Member Functions
static SoundLoader *	create ()

Public Attributes
CC_CONSTRUCTOR_ACCESS	__pad0__: SoundLoader() : Loader<Sound>() {} virtual ~SoundLoader() { if (_active) { stop()
Public Attributes inherited from BaseLoader
CC_CONSTRUCTOR_ACCESS	__pad0__: BaseLoader() : Ref()

Protected Member Functions
void	allocate (std::string key, Sound *sound)

Protected Attributes
std::unordered_set< std::string >	_squeue
Protected Attributes inherited from Loader< Sound >
std::unordered_map< std::string, Sound * >	_assets
Protected Attributes inherited from BaseLoader
bool	_active

Static Protected Attributes
static Coordinator *	_gCoordinator = nullptr

Detailed Description

Class is a implementation of Loader<Sound>

This asset loader allows us to allocate sound objects from the associated sound files. Even though Android does not allow preloading of sounds, this loader gives a platform-indepedent way of managing sound assets.

As with all of our loaders, this loader is designed to be attached to a scene. This is the natural was to do things, as Cocos2d is scene based. However, its asset loading is typically done through the director, which is global. This makes is hard to determine when it is safe to unload an asset. Even though the current scene many not need it, it may be used by another active scene. Unloading the asset would corrupt that scene.

This loader solves this problem by have a static coordinator behind the scenes. This coordinate is shared across all loader instances. It decides When an asset is truly ready to be unloaded. We assume that all instances are run only in the Director thread.

Sound objects are uniquely identified by their source file. Attempt to load a sound file a second time, even under a new key, will return a reference to the same sound object.

Member Function Documentation

void SoundLoader::allocate ( std::string  key, Sound *  sound  )

protected

A function to create a new sound from a filename.

This method should be part of a C++11 closure so that it can be used by the thread pool for asynchronous loading. When done, it will safely update the data structures of this loader.

Parameters

key	the key for the sound information
sound	the sound to associate with the key

SoundLoader * SoundLoader::create ( )

static

Creates a new SoundLoader.

This constructor does not start the sound loader. It simply creates an object for the sound loader so that it can be attached to the asset manager. Call start() when you are ready to start using it.

Returns

an autoreleased SoundLoader object

Sound * SoundLoader::load ( std::string  key, std::string  source  )

overridevirtual

Loads a sound and assigns it to the given key.

The sound will be loaded synchronously. It will be available immediately. This method should be limited to those times in which a sound is really necessary immediately, such as for a loading screen.

Parameters

key	The key to access the sound after loading
source	The pathname to the sound file

the sound upon loading

Returns

the loaded sound

Reimplemented from Loader< Sound >.

void SoundLoader::loadAsync ( std::string  key, std::string  source  )

overridevirtual

Adds a new sound to the loading queue.

The sound will be loaded asynchronously. When it is finished loading, it will be added to this loader, and accessible under the given key. This method will mark the loading process as not complete, even if it was completed previously. It is not safe to access the loaded sound until it is complete again.

Parameters

key	The key to access the sound after loading
source	The pathname to the sound file

the sound upon loading

Reimplemented from BaseLoader.

void SoundLoader::start ( )

overridevirtual

Starts this resource loader.

This method bootstraps the loader with any initial resources that it needs to load assets. Attempts to load an asset before this method is called will fail.

By separating this call from the constructor, this allows us to construct loaders and attach them to the AssetManager before we are ready to load assets.

Reimplemented from BaseLoader.

void SoundLoader::stop ( )

overridevirtual

Stops this resource loader removing all assets.

Any assets loaded by this loader will be immediately released by the loader. However, an asset may still be available if it is attached to another loader. The asset manager is backed by a central coordinator that allows the sharing of assets.

Once the loader is stopped, any attempts to load a new asset will fail. You must call start() to begin loading assets again.

Reimplemented from BaseLoader.

void SoundLoader::unload ( std::string  key )

overridevirtual

Unloads the sound for the given key.

This method simply unloads the sound for the scene associated with this loader. The sound will not be deleted or removed from memory until it is removed from all instances of SoundLoader.

Parameters

key	the key referencing the sound

the sound for the given key

Reimplemented from BaseLoader.

void SoundLoader::unloadAll ( )

overridevirtual

Unloads all assets present in this loader.

This method simply unloads the sounds for the scene associated with this loader. The sounds will not be deleted or removed from memory until they are removed from all instances of SoundLoader.

all loaded sounds

Reimplemented from BaseLoader.

size_t SoundLoader::waitCount ( ) const

inlineoverridevirtual

Returns the number of sounds waiting to load.

This is a rough way to determine how many sounds are still pending. A sound is pending if it has been loaded asychronously, and the loading process has not yet finished. This method counts each sound equally regardless of the memory requirements of the format.

Returns

the number of sounds waiting to load.

Reimplemented from BaseLoader.

Member Data Documentation

NS_CC_BEGIN SoundLoader::Coordinator * SoundLoader::_gCoordinator = nullptr

staticprotected

The static coordinator singleton

std::unordered_set<std::string> SoundLoader::_squeue

protected

The sounds we are expecting that are not yet loaded

---

The documentation for this class was generated from the following files:

• /Users/wmwhite/Developer/cocos2d-cornell/cocos/cornell/CUSoundLoader.h
• /Users/wmwhite/Developer/cocos2d-cornell/cocos/cornell/CUSoundLoader.cpp