Subversion Repositories AndroidProjects

package com.gebauz.pingK.game;

import java.util.Vector;

import javax.microedition.khronos.opengles.GL10;

import android.util.Log;

import com.gebauz.framework.util.GLUtil;
import com.gebauz.framework.util.MathUtil;
import com.gebauz.framework.util.Mesh;
import com.gebauz.framework.util.Texture;
import com.gebauz.framework.util.Vector2;
import com.gebauz.framework.util.renderstates.BlendingStates.BlendingMode;
import com.gebauz.framework.util.renderstates.RenderStates;
import com.gebauz.pingK.R;

public class BallTrail
{
        private class TrailElement
        {
                private Vector2 mPosition;
                private Vector2 mNormal;
                private Vector2 mDirection;
                private Vector2 mPoint1;
                private Vector2 mPoint2;
                private float mLifeTime = 0.0f;
               
                public TrailElement(Vector2 pos, Vector2 prevPos, float angleNormal)
                {
                        mPosition = new Vector2(pos.x, pos.y);
                        mDirection = new Vector2(pos.x - prevPos.x, pos.y - prevPos.y);
                       
                        if (angleNormal < 0.0f)
                        {
                                mNormal = new Vector2(mDirection.y, -mDirection.x);
                        }
                        else
                        {
                                // 0
                                mNormal = new Vector2((float)Math.cos(MathUtil.degToRad(angleNormal)), (float)Math.sin(MathUtil.degToRad(angleNormal)));
                        }
                        mNormal.setLength(GameConsts.BALL_TRAIL_WIDTH);
                       
                        mPoint1 = new Vector2(mPosition.x + mNormal.x, mPosition.y + mNormal.y);
                        mPoint2 = new Vector2(mPosition.x - mNormal.x, mPosition.y - mNormal.y);
                       
                        mLifeTime = 0.0f;
                }
               
                public Vector2 getPosition()
                {
                        return mPosition;
                }
               
                public Vector2 getDirection()
                {
                        return mDirection;
                }
               
                public Vector2 getNormal()
                {
                        return mNormal;
                }
               
                public Vector2 getPoint1()
                {
                        return mPoint1;
                }
               
                public Vector2 getPoint2()
                {
                        return mPoint2;
                }
               
                public void update(float deltaTime)
                {
                        mLifeTime += deltaTime;
                }
               
                public float getAlpha()
                {
                        return (1.0f-MathUtil.clamp(mLifeTime / GameConsts.BALL_TRAIL_ELEMENT_LIFETIME, 0.0f, 1.0f));
                }
        }
       
        private Ball mBall;
        private Mesh mTrailMesh = new Mesh();
        private Texture mTexture = new Texture();
        //private Vector<Vector2> mTrailPoints = new Vector<Vector2>();
        private Vector<TrailElement> mElements = new Vector<TrailElement>();
        private int mNumPrimitives = 0;
        private float mTrailTimer = 0.0f;
        //private float mTrailFadeTimer = 0.0f;
       
        public BallTrail(Ball ball)
        {
                mBall = ball;
                mTexture.loadTexture(R.drawable.trail);
        }
       
        public void reset()
        {
                //mTrailPoints.clear();
                mElements.clear();
                mTrailMesh.setVertices(null);
                mNumPrimitives = 0;
        }
       
        /**
         * Add new trail point
         * @param x X-axis coordinate
         * @param y Y-axis coordinate
         * @param angleNormal if >= 0.0f, specifies the angle of the normal to be used
         */
        public void addTrailPoint(float x, float y, float angleNormal)
        {
                mTrailTimer -= GameConsts.BALL_TRAIL_INTERVAL;
                Vector2 lastPos = new Vector2(x, y);
               
                if (mElements.size() > 0)
                {
                        lastPos = mElements.get(mElements.size()-1).getPosition();
                       
                        // do not add point if positions are the same
                        if (Vector2.distance(lastPos, new Vector2(x, y)) < MathUtil.EPSILON)
                        {
                                return;                                                        
                        }
                }
               
                mElements.add(new TrailElement(new Vector2(x, y), lastPos, angleNormal));

                // trim if larger than wanted
                while (mElements.size() > GameConsts.BALL_TRAIL_LENGTH)
                {
                        mElements.remove(0);
                }
               
                //mTrailFadeTimer = 0.0f;
                buildGeometry();
        }
       
        public void buildGeometry()
        {              
                // prepare geometry
                if (mElements.size() >= 2)
                {
                        //float life = 1.0f - MathUtil.clamp(mTrailFadeTimer / 2.0f, 0.0f, 1.0f);
                       
                        // two vertices per trail element
                        //float vertices[] = new float[mElements.size() * Mesh.COORD_ELEMENTS_COUNT * 6];
                        Mesh.AttributeArray vertices = new Mesh.AttributeArray(mElements.size() * Mesh.COORD_ELEMENTS_COUNT * 2 * 2);
                        Mesh.AttributeArray texCoords = new Mesh.AttributeArray(mElements.size() * Mesh.TEX_COORD_ELEMENTS_COUNT * 2 * 2);
                        Mesh.AttributeArray colors = new Mesh.AttributeArray(mElements.size() * Mesh.COLOR_ELEMENTS_COUNT * 2 * 2);
                       
                        for (int i = mElements.size() - 1; i >= 0; i--)
                        {
                                TrailElement element1 = mElements.get(i);
                               
                                vertices.fill(element1.getPoint1().x, element1.getPoint1().y, 0.0f);
                                vertices.fill(element1.getPoint2().x, element1.getPoint2().y, 0.0f);
                               
                                texCoords.fill(0.0f, 1.0f);
                                texCoords.fill(0.0f, 0.0f);
                               
/*                              float alpha = (float)i / (float)(mElements.size()-1);
                                alpha *= GameConsts.BALL_TRAIL_MAX_ALPHA;
                                alpha *= life;*/
                               
                                float lifeTime = element1.getAlpha();
                               
                                if (i == 0)
                                        lifeTime = 0.0f;
                               
                                colors.fill(1.0f, 1.0f, 1.0f, lifeTime);
                                colors.fill(1.0f, 1.0f, 1.0f, lifeTime);
                               
                                if (i > 0)
                                {
                                       
                                        TrailElement element2 = mElements.get(i-1);
                                        if (Vector2.dotProduct(element1.getNormal(), element2.getNormal()) < 0.0f)
                                        {
                                                // facing away -> twist
                                                vertices.fill(element1.getPoint2().x, element1.getPoint2().y, 0.0f);
                                                vertices.fill(element1.getPoint1().x, element1.getPoint1().y, 0.0f);
                                               
                                                texCoords.fill(0.0f, 1.0f);
                                                texCoords.fill(0.0f, 0.0f);
                                               
                                                colors.fill(1.0f, 1.0f, 1.0f, lifeTime);
                                                colors.fill(1.0f, 1.0f, 1.0f, lifeTime);                                               
                                        }
                                }
                        }
                       
                        mNumPrimitives = vertices.getUsedCount() / Mesh.COORD_ELEMENTS_COUNT;                  
                        mTrailMesh.setPrimitiveType(GL10.GL_TRIANGLE_STRIP);
                        mTrailMesh.setVertices(vertices.getAttributeArray());
                        mTrailMesh.setTexCoords(texCoords.getAttributeArray());
                        mTrailMesh.setColors(colors.getAttributeArray());
                }
        }
       
        public void update(float deltaTime)
        {
                mTrailTimer += deltaTime;
                //mTrailFadeTimer += deltaTime;
                if (mTrailTimer > GameConsts.BALL_TRAIL_INTERVAL)
                {
                        addTrailPoint(mBall.getX(), mBall.getY(), -1.0f);
                }
               
                for (int i = 0; i < mElements.size(); i++)
                {
                        mElements.get(i).update(deltaTime);
                }
        }
       
        public void updateFade(float deltaTime)
        {
                //mTrailFadeTimer += deltaTime;
               
                for (int i = 0; i < mElements.size(); i++)
                {
                        mElements.get(i).update(deltaTime);
                }
               
                // rebuild geometry for color fading...
                buildGeometry();               
        }
       
        public void render()
        {
                GL10 gl = GLUtil.getGL();
               
                // transform
                gl.glMatrixMode(GL10.GL_MODELVIEW);
                gl.glPushMatrix();
                {
                        gl.glLoadIdentity();
                        RenderStates renderStates = GLUtil.getRenderStates();
                        renderStates.depthTest.setEnabled(false);
                        renderStates.culling.setEnabled(false);
                        renderStates.blending.setEnabled(true);
                        renderStates.blending.setBlendingMode(BlendingMode.ALPHABLEND);
                        renderStates.getTextureStage(0).bindTexture(mTexture);
                        renderStates.activate();
                        mTrailMesh.render(mNumPrimitives);
                        //mTrailMesh.render();
                        renderStates.deactivate();
                        renderStates.getTextureStage(0).bindTexture(null);
                }
                gl.glPopMatrix();
        }
}