AssetManager (Bonzai Engine bonzaiengine.com Copyright © 2007-2019 Jérôme Jouvie)

java.lang.Object
- com.bonzaiengine.model.asset.AssetManager

All Implemented Interfaces:

OnLoadListener<Texture>, IDestroyable
```
public class AssetManager
extends java.lang.Object
implements OnLoadListener<Texture>, IDestroyable
```
Asset manager to store and load assets (model, motion, texture and shader).

Field Summary

Fields
Modifier and Type	Field and Description
`protected static int`	`ANIM_PRIORITY`
`AnimGraphLibrary`	`animGraphs` AnimGraph library
`java.lang.ClassLoader`	`context` `ClassLoader` which may be used by asynchronous loading task to resolve resources
`MaterialLibrary`	`materials` Material library
`protected static int`	`MODEL_PRIORITY`
`ModelLibrary`	`models` Model library
`MotionLibrary`	`motions` Motion library
`ShaderList`	`shaders` Optional: List of shaders
`SplineLibrary`	`splines` Spline library
`protected static int`	`TEXTURE_DIFFUSE_PRIORITY`
`TextureList`	`textures` List of textures

Constructor Summary

Constructors
Constructor and Description

AssetManager()

Constructors
Constructor and Description
`AssetManager()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static AssetManager`	`create()`
`static AssetManager`	`create(boolean concurrent)`
`void`	`destroy(IGLApi glApi)` Destroy AsyncModel/Texture/Shader with a reference count of 0, and all AsyncMotion, MaterialAdvanced
`void`	`destroy(IGLApi glApi, boolean force)` Destroy all assets if `force` set to true, if false equivalent to `destroy(IGLApi)`
`void`	`generateShadersAsync(Model model)` Force asynchronous shader generation to the specified `Model`.
`boolean`	`hasAsyncModelLoaded()`
`boolean`	`hasAsyncMotionLoaded()`
`boolean`	`isWorking()`
`AsyncModel`	`loadModel(ModelReaderSettings settings)` Deprecated. use `ModelLibrary.use(AssetManager, ModelReaderSettings)`, or to bypass `ModelLibrary` use the `AsyncModel` constructor directly.
`Model`	`loadModelSync(ModelReaderSettings settings)` Deprecated. use `loadModel(ModelReaderSettings)`
`AsyncModel`	`loadModelWithCache(ModelReaderSettings settings)` Load model asynchronously using download cache
`AsyncMotion`	`loadMotion(ReaderSettings settings)` Asynchronous `Motion` loading.
`AsyncMotion`	`loadMotionWithCache(ReaderSettings settings)` Load motion asynchronously using download cache
`void`	`onContextLost()` The be called when the OpenGL context has been lost
`void`	`onContextLost(Model model)` Must be called after `onContextLost()`
`protected void`	`onLoad(Model model)`
`protected void`	`onLoad(Motion motion)`
`void`	`onLoad(Texture texture)`
`void`	`onMaterialChanged(Mesh mesh, IMaterial material)` Internal use Notifies a `IMaterial` has a changed in a `Mesh`
`void`	`onMaterialChanged(Model model, MaterialStandard material)` Internal use Notifies a `MaterialStandard` has a shader changed
`void`	`readTexture(Texture texture, TextureParam textureParam)`
`void`	`readTextures(Model model)` Asynchronous read all textures of the specified `Model`
`void`	`setShaderGenerator(ShaderGenerator shaderGenerator)` Automatically queue asynchronous shader generation when a `Texture` has been loaded

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - MODEL_PRIORITY
```
protected static final int MODEL_PRIORITY
```
    See Also:
    
    Constant Field Values
  - ANIM_PRIORITY
```
protected static final int ANIM_PRIORITY
```
    See Also:
    
    Constant Field Values
  - TEXTURE_DIFFUSE_PRIORITY
```
protected static final int TEXTURE_DIFFUSE_PRIORITY
```
    See Also:
    
    Constant Field Values
  - textures
```
public TextureList textures
```
    List of textures
  - shaders
```
public ShaderList shaders
```
    Optional: List of shaders
  - models
```
public ModelLibrary models
```
    Model library
  - motions
```
public MotionLibrary motions
```
    Motion library
  - splines
```
public SplineLibrary splines
```
    Spline library
  - materials
```
public MaterialLibrary materials
```
    Material library
  - animGraphs
```
public AnimGraphLibrary animGraphs
```
    AnimGraph library
  - context
```
public java.lang.ClassLoader context
```
    ClassLoader which may be used by asynchronous loading task to resolve resources
- Constructor Detail
  - AssetManager
```
public AssetManager()
```
- Method Detail
  - create
```
public static AssetManager create()
```
    Returns:
    
    A new AssetManager with a TextureList, ShaderList, MaterialLibrary, ModelLibrary. Asynchronous texture and shader is enabled.
  - create
```
public static AssetManager create(boolean concurrent)
```
    Parameters:
    
    concurrent - true to support concurrent assets modifications
    
    Returns:
    
    A new AssetManager with a TextureList, ShaderList, MaterialLibrary, ModelLibrary. Asynchronous texture and shader is enabled.
  - isWorking
```
public final boolean isWorking()
```
    Returns:
    
    true if async
  - setShaderGenerator
```
public final void setShaderGenerator(ShaderGenerator shaderGenerator)
```
    Automatically queue asynchronous shader generation when a Texture has been loaded
    
    Throws:
    
    java.lang.IllegalStateException - if textures is not set
  - loadModelSync
```
@Deprecated
public final Model loadModelSync(ModelReaderSettings settings)
                                      throws java.io.IOException
```
    Deprecated. use loadModel(ModelReaderSettings)
    Equivalent to:
```
   AsyncModel asyncModel = assets.loadModelAsync(settings);
   Model model = asyncModel.getSync();
   asyncModel.release();
   return model;
```
    Parameters:
    
    settings -
    
    Returns:
    
    loadModelAsync(settings).getSync()
    
    Throws:
    
    java.io.IOException - if an exception occurs while loading
    
    See Also:
    
    loadModel(ModelReaderSettings)
  - loadModel
```
public final AsyncModel loadModel(ModelReaderSettings settings)
```
    Deprecated. use ModelLibrary.use(AssetManager, ModelReaderSettings), or to bypass ModelLibrary use the AsyncModel constructor directly.
    
    Asynchronous Model loading.
    AsyncModel.release() must be called on the result returned.
    
    Parameters:
    
    settings - ModelReaderSettings of the model to load
    
    Returns:
    
    AsyncModel with reference counter increased by one.
  - loadModelWithCache
```
public final AsyncModel loadModelWithCache(ModelReaderSettings settings)
                                    throws java.lang.IllegalStateException
```
    Load model asynchronously using download cache
    
    Parameters:
    
    settings - ModelReaderSettings to load
    
    Returns:
    
    AsyncModel
    
    Throws:
    
    java.lang.IllegalStateException - if models is not set
    
    See Also:
    
    Cache
  - onLoad
```
protected final void onLoad(Model model)
```
  - hasAsyncModelLoaded
```
public final boolean hasAsyncModelLoaded()
```
    Returns:
    
    true if at least an AsyncModel has been loaded since last call of this method
  - loadMotion
```
public final AsyncMotion loadMotion(ReaderSettings settings)
```
    Asynchronous Motion loading.
    
    Parameters:
    
    settings - ReaderSettings describing the motion to load
    
    Returns:
    
    AsyncMotion which will load asynchronously the Motion, use AsyncAsset.get()
  - loadMotionWithCache
```
public final AsyncMotion loadMotionWithCache(ReaderSettings settings)
                                      throws java.lang.IllegalStateException
```
    Load motion asynchronously using download cache
    
    Parameters:
    
    settings - ReaderSettings to load
    
    Returns:
    
    AsyncMotion
    
    Throws:
    
    java.lang.IllegalStateException - if motions is not set
    
    See Also:
    
    Cache
  - onLoad
```
protected final void onLoad(Motion motion)
```
  - hasAsyncMotionLoaded
```
public final boolean hasAsyncMotionLoaded()
```
    Returns:
    
    true if at least an AsyncMotion has been loaded since last call of this method
  - readTextures
```
public final void readTextures(Model model)
```
    Asynchronous read all textures of the specified Model
  - readTexture
```
public final void readTexture(Texture texture,
                              TextureParam textureParam)
```
  - onLoad
```
public final void onLoad(Texture texture)
```
    Specified by:
    
    onLoad in interface OnLoadListener<Texture>
  - destroy
```
public final void destroy(IGLApi glApi)
```
    Destroy AsyncModel/Texture/Shader with a reference count of 0, and all AsyncMotion, MaterialAdvanced
    
    Specified by:
    
    destroy in interface IDestroyable
    
    See Also:
    
    destroy(IGLApi, boolean)
  - destroy
```
public final void destroy(IGLApi glApi,
                          boolean force)
```
    Destroy all assets if force set to true, if false equivalent to destroy(IGLApi)
    
    See Also:
    
    destroy(IGLApi)
  - onContextLost
```
public final void onContextLost()
```
    The be called when the OpenGL context has been lost
  - onContextLost
```
public final void onContextLost(Model model)
```
    Must be called after onContextLost()
    
    Parameters:
    
    model - discard renderer data. Also, if automatic asynchronous loading is used, according assets (texture and/or shader) will be reloaded
    
    See Also:
    
    onContextLost(), #setReadTextureAsync(boolean), setShaderGenerator(ShaderGenerator)
  - generateShadersAsync
```
public final void generateShadersAsync(Model model)
                                throws java.lang.IllegalStateException
```
    Force asynchronous shader generation to the specified Model.
    Requires setShaderGenerator(ShaderGenerator) to be set.
    
    Parameters:
    
    model - Model to generate shader to
    
    Throws:
    
    java.lang.IllegalStateException
    
    See Also:
    
    setShaderGenerator(ShaderGenerator)
  - onMaterialChanged
```
public final void onMaterialChanged(Model model,
                                    MaterialStandard material)
```
    Internal use
    Notifies a MaterialStandard has a shader changed
  - onMaterialChanged
```
public final void onMaterialChanged(Mesh mesh,
                                    IMaterial material)
```
    Internal use
    Notifies a IMaterial has a changed in a Mesh

Class AssetManager

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MODEL_PRIORITY

ANIM_PRIORITY

TEXTURE_DIFFUSE_PRIORITY

textures

shaders

models

motions

splines

materials

animGraphs

context

Constructor Detail

AssetManager

Method Detail

create

create

isWorking

setShaderGenerator

loadModelSync

loadModel

loadModelWithCache

onLoad

hasAsyncModelLoaded

loadMotion

loadMotionWithCache

onLoad

hasAsyncMotionLoaded

readTextures

readTexture

onLoad

destroy

destroy

onContextLost

onContextLost

generateShadersAsync

onMaterialChanged

onMaterialChanged