Subversion Repositories AndroidProjects

package com.gebauz.Bauzoid.graphics.sprite;

import com.gebauz.Bauzoid.graphics.renderstates.RenderStates;
import com.gebauz.Bauzoid.math.Matrix4;
import com.gebauz.Bauzoid.math.Vector4;

public class AtlasSpriteInstance
{
        public float x = 0.0f;
        public float y = 0.0f;
        public float w = 0.0f;
        public float h = 0.0f;
        public float angle = 0.0f;
        public float alpha = 1.0f;
        public Vector4 color = new Vector4(1.0f, 1.0f, 1.0f, 1.0f);
       
        public boolean mirrorX = false;
        public boolean mirrorY = false;
       
        /** Rotation and scaling pivot point in absolute coordinates. */
        public float pivotX = 0.0f;
        public float pivotY = 0.0f;

        private AtlasSprite mSprite = null;
        private int mRegionIndex = -1;
       
        private Matrix4 mScale = new Matrix4();
        private Matrix4 mMirror = new Matrix4();
        private Matrix4 mPivotTranslate = new Matrix4();
        private Matrix4 mRotateZ = new Matrix4();
        private Matrix4 mTranslate = new Matrix4();
       
        private Matrix4 mModelMatrix = new Matrix4();
       
        public AtlasSpriteInstance(AtlasSprite sprite, int regionIndex)
        {
                mSprite = sprite;
                mRegionIndex = regionIndex;
               
                w = mSprite.getRegionWidth(mRegionIndex);
                h = mSprite.getRegionHeight(mRegionIndex);
                pivotX = w/2;
                pivotY = h/2;
        }

        public void render()
        {
                render(x, y, w, h);
        }
       
        public void render(float _x, float _y, float _w, float _h)
        {
/*              mSprite.x = x;
                mSprite.y = y;
                mSprite.w = w;
                mSprite.h = h;
                mSprite.angle = angle;
                mSprite.alpha = alpha;
                mSprite.pivotX = pivotX;
                mSprite.pivotY = pivotY;
                mSprite.mirrorX = mirrorX;
                mSprite.mirrorY = mirrorY;
                mSprite.color = color;
                mSprite.render(mRegionIndex);*/
               
                //SpriteShader shader = mSprite.getGraphics().getSpriteShader();
                RenderStates rs = mSprite.getRenderStates();
               
                mScale.setScale(_w, _h, 1.0f);
                mPivotTranslate.setTranslation(-pivotX, -pivotY, 0);
                mMirror.setScale((mirrorX ? -1 : 1), (mirrorY ? -1 : 1), 1);
                mRotateZ.setRotationZ(angle);
                mTranslate.setTranslation(_x, _y, 0);

                //Matrix4 modelMatrix = new Matrix4();
                mModelMatrix.identity();
               
                //Matrix4.multiply(mScale, mPivotTranslate);
                Matrix4.multiply(mModelMatrix, mScale, mPivotTranslate);
               
                //modelMatrix = Matrix4.multiply(modelMatrix, mMirror);
                Matrix4.multiply(mModelMatrix, mModelMatrix, mMirror);

                //modelMatrix = Matrix4.multiply(modelMatrix, mRotateZ);
                Matrix4.multiply(mModelMatrix, mModelMatrix, mRotateZ);

                //modelMatrix = Matrix4.multiply(modelMatrix, mTranslate);
                Matrix4.multiply(mModelMatrix, mModelMatrix, mTranslate);
               
/*              Matrix4 modelMatrix = Matrix4.multiply(Matrix4.createScale(_w, _h, 1.0f), Matrix4.createTranslation(-pivotX, -pivotY, 0));
               
                modelMatrix = Matrix4.multiply(modelMatrix, Matrix4.createScale((mirrorX ? -1 : 1), (mirrorY ? -1 : 1), 1));

                modelMatrix = Matrix4.multiply(modelMatrix, Matrix4.createRotationZ(angle));

                modelMatrix = Matrix4.multiply(modelMatrix, Matrix4.createTranslation(_x, _y, 0));*/
               
                rs.pushModelMatrix();
                {
                        rs.model = mModelMatrix;
                       
                        mSprite.performRender(mRegionIndex, alpha, color);
                       
                        // draw sprite
/*                      shader.activate(mSprite.getTexture(), alpha, color);
                        {
                                rs.blending.setEnabled(true);
                                rs.culling.setEnabled(false);
                                rs.activate();
                                {
                                        mSprite.getMesh().render(mSprite.getMeshStartIndex(mRegionIndex), AtlasSprite.NUM_INDICES_PER_REGION);
                                }
                                rs.deactivate();
                        }
                        shader.deactivate();*/
                }
                rs.popModelMatrix();
        }
       
        public final int getRegionIndex()
        {
                return mRegionIndex;           
        }

}