Libgdx之AssetManager 资源管理器及进度条的实现

概述

在前面我们用到的游戏资源，是直接加载的，由于只是一个demo，资源比较少，因此看不出时间用到的长短。实际上我们在游戏开发过程中用到的图片，声音等资源比较多，这时加载游戏过程中会出现黑屏现象，其实就是后台在加载资源了，这时我们需要AssetManager来异步加载资源，同时实现进度条给用户友好的体验。
简单介绍AssetManager中常用的方法
* void clear() 清空和销毁已加载和预加载的资源
* void dispose() AssetManager是很耗内存的，不用事要销毁
* void finishLoading() 阻塞线程，直到所有资源加载完毕
* boolean update() 异步加载资源，如资源加载完毕，返回true
* void load(AssetDescriptor desc)
void load(java.lang.String fileName, java.lang.Class type)
上面2个方法都是加载资源时需要使用的方法，只是将资源enqueue，并没有装进内存，只有调用update方法时资源才会被真正加载到内存中
* void unload(java.lang.String fileName) 将不再使用的资源移除
* T get(java.lang.String fileName)
T get(java.lang.String fileName, java.lang.Class type)
根据load的文件名来加载资源，一般推荐使用第二个方法，这样可以节约搜寻的时间
* float getProgress() 获取资源加载的进度
* setLoader(java.lang.Class type, AssetLoader loader) 大多数资源在初始化函数中已经指定了，但有一些没有定义的资源比如：TiledMap需要自己设置资源加载器，此时需要用到此方法

使用方法

AssetManager初始化比较简单：AssetManager am = new AssetManager()
这个方法最终调用另外一个初始化函数，指定了默认的Loader

public AssetManager (FileHandleResolver resolver, boolean defaultLoaders) {
        this.resolver = resolver;
        if (defaultLoaders) {
            setLoader(BitmapFont.class, new BitmapFontLoader(resolver));
            setLoader(Music.class, new MusicLoader(resolver));
            setLoader(Pixmap.class, new PixmapLoader(resolver));
            setLoader(Sound.class, new SoundLoader(resolver));
            setLoader(TextureAtlas.class, new TextureAtlasLoader(resolver));
            setLoader(Texture.class, new TextureLoader(resolver));
            setLoader(Skin.class, new SkinLoader(resolver));
            setLoader(ParticleEffect.class, new ParticleEffectLoader(resolver));
            setLoader(com.badlogic.gdx.graphics.g3d.particles.ParticleEffect.class,
                new com.badlogic.gdx.graphics.g3d.particles.ParticleEffectLoader(resolver));
            setLoader(PolygonRegion.class, new PolygonRegionLoader(resolver));
            setLoader(I18NBundle.class, new I18NBundleLoader(resolver));
            setLoader(Model.class, ".g3dj", new G3dModelLoader(new JsonReader(), resolver));
            setLoader(Model.class, ".g3db", new G3dModelLoader(new UBJsonReader(), resolver));
            setLoader(Model.class, ".obj", new ObjLoader(resolver));
        }
        executor = new AsyncExecutor(1);
    }

注意： 最好不要讲 am 声明为static变量，因为在Android开发环境中有时候AssetManager的生命周期和应用程序的周期并不同步，可能会造成异常
一些Loader在加载资源的时候允许我们传递一些参数，比如下面代码：

TextureParameter param = new TextureParameter();
param.minFilter = TextureFilter.Linear;
param.genMipMaps = true;
manager.load("data/mytexture.png", Texture.class, param);

为了使用资源我们可以通过get()方法获取

Texture tex = am.get("data/mytexture.png", Texture.class);
BitmapFont font = am.get("data/myfont.fnt", BitmapFont.class);

但有时候为了保证资源确实被加载，我们可以使用下面方法

if(am.isLoaded("data/mytexture.png")) {
   // texture is available, let's fetch it and do something interesting
   Texture tex = am.get("data/mytexture.png", Texture.class);
}

销毁资源，我们可以单个销毁资源

am.unload("data/myfont.fnt");

同时我们也可以一次销毁所有资源

am.clear()   或者  am.dispose()   //dispose不仅销毁所有加载的资源同时也销毁am本身

在Android应用程序中，调用paused()和resume()方法时，一些OpenGL的资源像Texuture需要被重新加载，如果想再次调用loading screen可以在初始化am设置如下内容: Texture.setAssetManager(am);

在GitHub上找了一个开源的代码 libgdx-loading-screen，下面是代码简单的展示：
首先定义了LoadingBar.java 主要作用是将加载的进度条做成一个动画，这样更有动感

public class LoadingBar extends Actor {

    Animation animation;
    TextureRegion reg;
    float stateTime;

    public LoadingBar(Animation animation) {
        this.animation = animation;
        reg = animation.getKeyFrame(0);
    }

    @Override
    public void act(float delta) {
        stateTime += delta;
        reg = animation.getKeyFrame(stateTime);
    }

    @Override
    public void draw(SpriteBatch batch, float parentAlpha) {
        batch.draw(reg, getX(), getY());
    }
}

其次定义了LoadingScreen.java

public class LoadingScreen extends AbstractScreen {

    private Stage stage;

    private Image logo;
    private Image loadingFrame;
    private Image loadingBarHidden;
    private Image screenBg;
    private Image loadingBg;

    private float startX, endX;
    private float percent;

    private Actor loadingBar;

    public LoadingScreen(SomeCoolGame game) {
        super(game);
    }

    @Override
    public void show() {
        // Tell the manager to load assets for the loading screen
        game.manager.load("data/loading.pack", TextureAtlas.class);
        // Wait until they are finished loading
        game.manager.finishLoading();

        // Initialize the stage where we will place everything
        stage = new Stage();

        // Get our textureatlas from the manager
        TextureAtlas atlas = game.manager.get("data/loading.pack", TextureAtlas.class);

        // Grab the regions from the atlas and create some images
        logo = new Image(atlas.findRegion("libgdx-logo"));
        loadingFrame = new Image(atlas.findRegion("loading-frame"));
        loadingBarHidden = new Image(atlas.findRegion("loading-bar-hidden"));
        screenBg = new Image(atlas.findRegion("screen-bg"));
        loadingBg = new Image(atlas.findRegion("loading-frame-bg"));

        // Add the loading bar animation
        Animation anim = new Animation(0.05f, atlas.findRegions("loading-bar-anim") );
        anim.setPlayMode(Animation.LOOP_REVERSED);
        loadingBar = new LoadingBar(anim);

        // Or if you only need a static bar, you can do
        // loadingBar = new Image(atlas.findRegion("loading-bar1"));

        // Add all the actors to the stage
        stage.addActor(screenBg);
        stage.addActor(loadingBar);
        stage.addActor(loadingBg);
        stage.addActor(loadingBarHidden);
        stage.addActor(loadingFrame);
        stage.addActor(logo);

        // Add everything to be loaded, for instance:
        // game.manager.load("data/assets1.pack", TextureAtlas.class);
        // game.manager.load("data/assets2.pack", TextureAtlas.class);
        // game.manager.load("data/assets3.pack", TextureAtlas.class);
    }

    @Override
    public void resize(int width, int height) {
        // Set our screen to always be XXX x 480 in size
        width = 480 * width / height;
        height = 480;
        stage.setViewport(width , height, false);

        // Make the background fill the screen
        screenBg.setSize(width, height);

        // Place the logo in the middle of the screen and 100 px up
        logo.setX((width - logo.getWidth()) / 2);
        logo.setY((height - logo.getHeight()) / 2 + 100);

        // Place the loading frame in the middle of the screen
        loadingFrame.setX((stage.getWidth() - loadingFrame.getWidth()) / 2);
        loadingFrame.setY((stage.getHeight() - loadingFrame.getHeight()) / 2);

        // Place the loading bar at the same spot as the frame, adjusted a few px
        loadingBar.setX(loadingFrame.getX() + 15);
        loadingBar.setY(loadingFrame.getY() + 5);

        // Place the image that will hide the bar on top of the bar, adjusted a few px
        loadingBarHidden.setX(loadingBar.getX() + 35);
        loadingBarHidden.setY(loadingBar.getY() - 3);
        // The start position and how far to move the hidden loading bar
        startX = loadingBarHidden.getX();
        endX = 440;

        // The rest of the hidden bar
        loadingBg.setSize(450, 50);
        loadingBg.setX(loadingBarHidden.getX() + 30);
        loadingBg.setY(loadingBarHidden.getY() + 3);
    }

    @Override
    public void render(float delta) {
        // Clear the screen
        Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

        if (game.manager.update()) { // Load some, will return true if done loading
            if (Gdx.input.isTouched()) { // If the screen is touched after the game is done loading, go to the main menu screen
                game.setScreen(new MainMenuScreen(game));
            }
        }

        // Interpolate the percentage to make it more smooth
        percent = Interpolation.linear.apply(percent, game.manager.getProgress(), 0.1f);

        // Update positions (and size) to match the percentage
        loadingBarHidden.setX(startX + endX * percent);
        loadingBg.setX(loadingBarHidden.getX() + 30);
        loadingBg.setWidth(450 - 450 * percent);
        loadingBg.invalidate();

        // Show the loading screen
        stage.act();
        stage.draw();
    }

    @Override
    public void hide() {
        // Dispose the loading assets as we no longer need them
        game.manager.unload("data/loading.pack");
    }
}

具体效果: