Subversion Repositories AndroidProjects

package com.gebauz.bauzoid.graphics.sprite;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.Texture;
import com.gebauz.bauzoid.graphics.Graphics;
import com.gebauz.bauzoid.graphics.GraphicsObject;
import com.gebauz.bauzoid.graphics.model.SimpleGeometry;
import com.gebauz.bauzoid.graphics.model.Geometry.PrimitiveType;
import com.gebauz.bauzoid.graphics.renderstates.RenderStates;
import com.gebauz.bauzoid.graphics.sprite.SpriteRegion;
import com.gebauz.bauzoid.graphics.sprite.SpriteShader;
import com.gebauz.bauzoid.math.Vector4;

/** Sprite class that loads a texture and allows definition of regions (for atlasing, or multi-framing). */
public class Sprite extends GraphicsObject
{

        // Constants========================================================================================
       
        public static int NUM_INDICES_PER_REGION = 6;
        public static int NUM_ATTRIBUTES_PER_REGION = 4;

        // Embedded Types===================================================================================

        // Fields===========================================================================================
       
        /** The texture this sprite is based on. */
        protected Texture mTexture = null;
       
        /** Stores the separate regions of the sprite that were defined. */
        private SpriteRegion[] mRegions = null;
       
        /** Stores all Geometry of all SpriteRegions. */
        private SimpleGeometry mMesh = null;
       
        /** Store the texture filename so it can be loaded asynchronously later. */
        protected String mTextureFilename = null;
       
        /** Store the atlas region definition filename so it can be loaded asynchronously later. */
        protected String mRegionDefFilename = null;
       
        /** Flag to check if asynchronous or synchronous loading was requested. */
        protected boolean mIsAsync = false;
       
        // Methods==========================================================================================
       
        public Sprite(Graphics graphics, String textureFile)
        {
                super(graphics);
                mTextureFilename = textureFile;
        }
       
        public Sprite(Graphics graphics, String textureFile, String atlasFile)
        {
                this(graphics, textureFile);
                mRegionDefFilename = atlasFile;
        }
       
        /** Called during asynchronous loading to initiate AssetManager's loading mechanism. */
        public void initAsync()
        {
                if (mTextureFilename == null)
                        return; // maybe ASSERT?
               
                mIsAsync = true;
                getAssetManager().load(mTextureFilename, Texture.class);
               
                if (mRegionDefFilename != null)
                {
                        getAssetManager().load(mRegionDefFilename, SpriteRegionDefinition.class);
                }
        }
       
        /** Called synchronously (or after initAsync() for asynchronous loading). */
        public void init()
        {
                if (mTextureFilename == null)
                        return;
               
                if (!mIsAsync)
                {
                        // load texture synchronously
                        mTexture = new Texture(Gdx.files.internal(mTextureFilename));
                }
                else
                {
                        // grab texture that should be loaded asynchronously already
                        mTexture = getAssetManager().get(mTextureFilename, Texture.class);
                }

                if (mRegionDefFilename != null)
                {
                        SpriteRegionDefinition atlas = null;
                       
                        if (!mIsAsync)
                        {
                                // load synchronously
                                atlas = SpriteUtil.readSpriteRegionInfo(Gdx.files.internal(mRegionDefFilename));
                        }
                        else
                        {
                                atlas = getAssetManager().get(mRegionDefFilename, SpriteRegionDefinition.class);
                        }
                        SpriteRegion regions[] = new SpriteRegion[atlas.frames.size()];
                        for (int i = 0; i < atlas.frames.size(); i++)
                        {
                                SpriteRegionDefinition.FrameInfo info = atlas.frames.get(i);
                                regions[i] = new SpriteRegion(this, i, info.x, info.y, info.w, info.h, true);
                        }

                        setRegions(regions);
                }
                else
                {
                        // create default geometry for entire sprite (make 1 region)
                        SpriteRegion regions[] = new SpriteRegion[1];
                        regions[0] = new SpriteRegion(this, 0, 0, 0, getTextureWidth(), getTextureHeight(), true);
                       
                        setRegions(regions);
                }
        }
       
        /** Destroy sprite. */
        public void dispose()
        {
                if (mRegions != null)
                        mRegions = null;
               
                if (mTexture != null)
                {
                        if (mIsAsync)
                        {
                                getAssetManager().unload(mTextureFilename);
                        }
                        else
                        {
                                mTexture.dispose();
                        }
                        mTexture = null;
                }
               
                if (mRegionDefFilename != null)
                {
                        if (mIsAsync)
                        {
                                getAssetManager().unload(mRegionDefFilename);
                        }
                }
        }
       
        public void setRegions(SpriteRegion[] regions)
        {
                if (mMesh != null)
                {
                        mMesh.dispose();
                        mMesh = null;
                }
               
                mRegions = regions;
                mMesh = createGeometry();      
        }
       
        public SimpleGeometry createGeometry()
        {
                float[] vertices = new float[NUM_ATTRIBUTES_PER_REGION * SimpleGeometry.POSITION_COORD_PER_ELEMENT * mRegions.length];
                float[] texCoords = new float[NUM_ATTRIBUTES_PER_REGION * SimpleGeometry.TEXCOORD_COORD_PER_ELEMENT * mRegions.length];
                float[] colors = new float[NUM_ATTRIBUTES_PER_REGION * SimpleGeometry.COLOR_COORD_PER_ELEMENT * mRegions.length];
               
                // two triangles per region
                short[] indices = new short[NUM_INDICES_PER_REGION * mRegions.length];
               
                for (int i = 0; i < mRegions.length; i++)
                {
                        SpriteRegion r = getRegion(i);
                       
                        float[] v =
                        {
                                -1.0f, -1.0f, 0.0f,
                                 1.0f, -1.0f, 0.0f,
                                 1.0f,  1.0f, 0.0f,
                                -1.0f,  1.0f, 0.0f
                        };
                       
                        float[] t =
                        {
                                r.left, r.top,
                                r.right, r.top,
                                r.right, r.bottom,
                                r.left, r.bottom
                        };
                       
                        float[] c =
                        {
                                1, 1, 1, 1,
                                1, 1, 1, 1,
                                1, 1, 1, 1,
                                1, 1, 1, 1
                        };
                       
                        System.arraycopy(v, 0, vertices, NUM_ATTRIBUTES_PER_REGION * SimpleGeometry.POSITION_COORD_PER_ELEMENT * i, v.length);
                        System.arraycopy(t, 0, texCoords, NUM_ATTRIBUTES_PER_REGION * SimpleGeometry.TEXCOORD_COORD_PER_ELEMENT * i, t.length);
                        System.arraycopy(c, 0, colors, NUM_ATTRIBUTES_PER_REGION * SimpleGeometry.COLOR_COORD_PER_ELEMENT * i, c.length);
                       
                        int n = i*NUM_INDICES_PER_REGION;                      
                        short base = (short)(i * NUM_ATTRIBUTES_PER_REGION);
                        indices[n++] = base; indices[n++] = (short)(base+1); indices[n++] = (short)(base+2);
                        indices[n++] = base; indices[n++] = (short)(base+2); indices[n++] = (short)(base+3);
                }
               
               
                SimpleGeometry mesh = new SimpleGeometry(getGraphics(), PrimitiveType.TRIANGLES);
                mesh.setPositions(vertices);
                mesh.setTexCoords(texCoords);
                mesh.setColors(colors);
                mesh.setIndices(indices);
               
                return mesh;
        }
       
        /** Create a single SpriteInstance for a single region. */
        public final SpriteInstance createSpriteInstance(int regionIndex)
        {
                return new SpriteInstance(getRegion(regionIndex));
        }
       
        /** Create a multiple SpriteInstances, each for a single region. */
        public void createSpriteInstances(SpriteInstance[] instances)
        {
                if (instances.length < mRegions.length)
                        return;
               
                for (int i = 0; i < instances.length; i++)
                {
                        instances[i] = createSpriteInstance(i);
                }
        }
       
        /** Create a multiple SpriteInstances, each for a single region. */
        public SpriteInstance[] createSpriteInstances()
        {
                SpriteInstance frames[] = new SpriteInstance[mRegions.length];
                createSpriteInstances(frames);
                return frames;
        }
       
        /** Create a single SpriteInstance for all regions. */
        public SpriteInstance createSpriteInstanceForAll()
        {
                SpriteInstance instance = new SpriteInstance(mRegions);
                return instance;
        }
       
        /** Peforms the actual render without any model matrix handling. */
        public void performRender(int region, float alpha, Vector4 color)
        {
                RenderStates rs = getRenderStates();
                SpriteShader shader = getGraphics().getSpriteShader();

                // draw sprite
                shader.activate(getTexture(), alpha, color);
                {
                        rs.blending.setEnabled(true);                  
                        rs.culling.setEnabled(false);
                        rs.activate();
                        rs.blending.activate(true);
                        {
                                mMesh.render(getMeshStartIndex(region), NUM_INDICES_PER_REGION);
                        }
                        rs.deactivate();
                }
                shader.deactivate();
        }

        // Getters/Setters==================================================================================

        /** Get a reference to the texture. */
        public final Texture getTexture()
        {
                return mTexture;
        }
       
        /** Get the sprite texture's total width. */
        public final int getTextureWidth()
        {
                if (mTexture == null)
                        return 0;
                return mTexture.getWidth();
        }
       
        /** Get the sprite texture's total height. */
        public final int getTextureHeight()
        {
                if (mTexture == null)
                        return 0;
                return mTexture.getHeight();
        }
       
        /** Get number of defined regions. */
        public final int getRegionCount()
        {
                if (mRegions == null)
                        return 0;
               
                return mRegions.length;
        }
       
        /** Get region. */
        public final SpriteRegion getRegion(int i)
        {
                if (mRegions == null)
                        return null;
               
                return mRegions[i];
        }
       
        /** Get regions array.*/
        public final SpriteRegion[] getRegions()
        {
                return mRegions;
        }
       
        /** Get starting index for region mesh rendering. */
        private final int getMeshStartIndex(int regionIndex)
        {
                return (regionIndex * NUM_INDICES_PER_REGION);
        }
       
       
       
}