java.lang.Object
- com.badlogic.gdx.graphics.g3d.ModelCache

All Implemented Interfaces:

RenderableProvider, Disposable
```
public class ModelCache
extends java.lang.Object
implements Disposable, RenderableProvider
```
ModelCache tries to combine multiple render calls into a single render call by merging them where possible. Can be used for multiple type of models (e.g. varying vertex attributes or materials), the ModelCache will combine where possible. Can be used dynamically (e.g. every frame) or statically (e.g. to combine part of scenery). Be aware that any combined vertices are directly transformed, therefore the resulting Renderable.worldTransform might not be suitable for sorting anymore (such as the default sorter of ModelBatch does).

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static interface`	`ModelCache.MeshPool`	Allows to reuse one or more meshes while avoiding creating new objects.
`static class`	`ModelCache.SimpleMeshPool`	A basic `ModelCache.MeshPool` implementation that avoids creating new meshes at the cost of memory usage.
`static class`	`ModelCache.Sorter`	A `RenderableSorter` that sorts by vertex attributes, material attributes and primitive types (in that order), so that meshes can be easily merged.
`static class`	`ModelCache.TightMeshPool`	A tight `ModelCache.MeshPool` implementation, which is typically used for static meshes (create once, use many).

Constructor Summary

Constructors
Constructor	Description
`ModelCache()`	Create a ModelCache using the default `ModelCache.Sorter` and the `ModelCache.SimpleMeshPool` implementation.
`ModelCache(RenderableSorter sorter, ModelCache.MeshPool meshPool)`	Create a ModelCache using the specified `RenderableSorter` and `ModelCache.MeshPool` implementation.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`add(Renderable renderable)`	Adds the specified `Renderable` to the cache.
`void`	`add(RenderableProvider renderableProvider)`	Adds the specified `RenderableProvider` to the cache, see `add(Renderable)`.
`<T extends RenderableProvider> void`	`add(java.lang.Iterable<T> renderableProviders)`	Adds the specified `RenderableProvider`s to the cache, see `add(Renderable)`.
`void`	`begin()`	Begin creating the cache, must be followed by a call to `end()`, in between these calls one or more calls to one of the add(...) methods can be made.
`void`	`begin(Camera camera)`	Begin creating the cache, must be followed by a call to `end()`, in between these calls one or more calls to one of the add(...) methods can be made.
`void`	`dispose()`	Releases all resources of this object.
`void`	`end()`	Finishes creating the cache, must be called after a call to `begin()`, only after this call the cache will be valid (until the next call to `begin()`).
`void`	`getRenderables(Array<Renderable> renderables, Pool<Renderable> pool)`	Returns `Renderable` instances.

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

- Constructor Detail
  - ModelCache
```
public ModelCache()
```
    Create a ModelCache using the default ModelCache.Sorter and the ModelCache.SimpleMeshPool implementation. This might not be the most optimal implementation for you use-case, but should be good to start with.
  - ModelCache
```
public ModelCache(RenderableSorter sorter,
                  ModelCache.MeshPool meshPool)
```
    Create a ModelCache using the specified RenderableSorter and ModelCache.MeshPool implementation. The RenderableSorter implementation will be called with the camera specified in begin(Camera). By default this will be null. The sorter is important for optimizing the cache. For the best result, make sure that renderables that can be merged are next to each other.
- Method Detail
  - begin
```
public void begin()
```
    Begin creating the cache, must be followed by a call to end(), in between these calls one or more calls to one of the add(...) methods can be made. Calling this method will clear the cache and prepare it for creating a new cache. The cache is not valid until the call to end() is made. Use one of the add methods (e.g. add(Renderable) or add(RenderableProvider)) to add renderables to the cache.
  - begin
```
public void begin(Camera camera)
```
    Begin creating the cache, must be followed by a call to end(), in between these calls one or more calls to one of the add(...) methods can be made. Calling this method will clear the cache and prepare it for creating a new cache. The cache is not valid until the call to end() is made. Use one of the add methods (e.g. add(Renderable) or add(RenderableProvider)) to add renderables to the cache.
    
    Parameters:
    
    camera - The Camera that will passed to the RenderableSorter
  - end
```
public void end()
```
    Finishes creating the cache, must be called after a call to begin(), only after this call the cache will be valid (until the next call to begin()). Calling this method will process all renderables added using one of the add(...) methods and will combine them if possible.
  - add
```
public void add(Renderable renderable)
```
    Adds the specified Renderable to the cache. Must be called in between a call to begin() and end(). All member objects might (depending on possibilities) be used by reference and should not change while the cache is used. If the Renderable.bones member is not null then skinning is assumed and the renderable will be added as-is, by reference. Otherwise the renderable will be merged with other renderables as much as possible, depending on the Mesh.getVertexAttributes(), Renderable.material and primitiveType (in that order). The Renderable.environment, Renderable.shader and Renderable.userData values (if any) are removed.
    
    Parameters:
    
    renderable - The Renderable to add, should not change while the cache is needed.
  - add
```
public void add(RenderableProvider renderableProvider)
```
    Adds the specified RenderableProvider to the cache, see add(Renderable).
  - add
```
public <T extends RenderableProvider> void add(java.lang.Iterable<T> renderableProviders)
```
    Adds the specified RenderableProviders to the cache, see add(Renderable).
  - getRenderables
```
public void getRenderables(Array<Renderable> renderables,
                           Pool<Renderable> pool)
```
    Description copied from interface: RenderableProvider
    
    Returns Renderable instances. Renderables are obtained from the provided Pool and added to the provided array. The Renderables obtained using Pool.obtain() will later be put back into the pool, do not store them internally. The resulting array can be rendered via a ModelBatch.
    
    Specified by:
    
    getRenderables in interface RenderableProvider
    
    Parameters:
    
    renderables - the output array
    
    pool - the pool to obtain Renderables from
  - dispose
```
public void dispose()
```
    Description copied from interface: Disposable
    
    Releases all resources of this object.
    
    Specified by:
    
    dispose in interface Disposable

Class ModelCache

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ModelCache

ModelCache

Method Detail

begin

begin

end

add

add

add

getRenderables

dispose