Subversion Repositories AndroidProjects

package com.gebauz.bauzoid.graphics.model;

import java.nio.ByteBuffer;

import java.nio.FloatBuffer;

import java.nio.IntBuffer;

import java.util.ArrayList;

import java.util.List;

import com.badlogic.gdx.Gdx;

import com.badlogic.gdx.graphics.GL20;

import com.badlogic.gdx.utils.BufferUtils;

import com.gebauz.bauzoid.app.Consts;

import com.gebauz.bauzoid.graphics.Graphics;

import com.gebauz.bauzoid.graphics.GraphicsObject;

/** Vertex Stream that supports individual or interleaved vertex attributes. */

public class VertexStream extends GraphicsObject

{

        /** Type of stream - single attribute or multi-attribute interleaved. */

        public enum StreamType

        {

                INDIVIDUAL,

                INTERLEAVED

        };

        private static List<VertexStream> mManagedStreams = new ArrayList<VertexStream>();

        private StreamType mStreamType;

        private String mName;

        private FloatBuffer mData = null;

        private ByteBuffer mByteBuffer = null;

        private boolean mIsDynamic = false;

        private int mVertexCount = 0;

        private int mCoordsPerElement = 0;

        private int mBytesPerElement = 0;

        private int mBufferID = 0;

        //private static int[] BUFFERID = new int[1];

        private static final IntBuffer BUFFERID = BufferUtils.newIntBuffer(1);

        private VertexAttribute[] mAttribs;

        /** Constructor. */

        public VertexStream(Graphics graphics, StreamType streamType, String name, VertexAttribute[] attribs, boolean isDynamic)

        {

                super(graphics);

                mStreamType = streamType;

                mName = name;

                mAttribs = attribs;

                mIsDynamic = isDynamic;

                mManagedStreams.add(this);

        }

        /** Destroy all internal data. */

        public void dispose()

        {

                mManagedStreams.remove(this);

                unload();

                mAttribs = null;

                mVertexCount = 0;

                mCoordsPerElement = 0;

                mBytesPerElement = 0;

                if (mByteBuffer != null)

                {

                        BufferUtils.disposeUnsafeByteBuffer(mByteBuffer);

                        mByteBuffer = null;

                }

                mData = null;

        }

        /** Reload all managed vertex streams. */

        public static void reloadManagedStreams()

        {

                for (int i = 0; i < mManagedStreams.size(); i++)

                {

                        VertexStream stream = mManagedStreams.get(i);

                        stream.upload();

                        Gdx.app.log(Consts.LOG_TAG, "VertexStream '" + stream.getName() + "' reloaded!");

                }

        }      

        /** Set the buffer data. */

        public void setData(byte[] data, int coordsPerElement, int bytesPerElement)

        {

                if (data == null)

                {

                        dispose();

                        return;

                }

                int newVertexCount = data.length / bytesPerElement;

                if ((mVertexCount != newVertexCount) || (mByteBuffer == null))

                {

                        // reallocate

                        allocateBuffer(data.length);

                }              

                mVertexCount = newVertexCount;

                mCoordsPerElement = coordsPerElement;

                mBytesPerElement = bytesPerElement;

                /*ByteBuffer byteBuffer = ByteBuffer.allocateDirect(data.length);

                byteBuffer.order(ByteOrder.nativeOrder());

                byteBuffer.put(data);

                byteBuffer.position(0);

                mData = byteBuffer.asFloatBuffer();*/

                BufferUtils.copy(data, 0, mData, data.length);

                mData.position(0);

                mData.limit(data.length);

        }

        /** Set the buffer data. */

        public void setData(float[] data, int coordsPerElement, int bytesPerElement)

        {

                if (data == null)

                {

                        dispose();

                        return;

                }

                int newVertexCount = data.length / coordsPerElement;

                if ((mVertexCount != newVertexCount) || (mByteBuffer == null))

                {

                        // reallocate

                        allocateBuffer(data.length * Consts.SIZEOF_FLOAT);

                }              

                mVertexCount = data.length / coordsPerElement;

                mCoordsPerElement = coordsPerElement;

                mBytesPerElement = bytesPerElement;

                BufferUtils.copy(data, mByteBuffer, data.length, 0);

                mData.position(0);

                mData.limit(data.length);

        }

        public void allocateBuffer(int newSize)

        {

                if (mByteBuffer != null)

                        BufferUtils.disposeUnsafeByteBuffer(mByteBuffer);

                mByteBuffer = BufferUtils.newUnsafeByteBuffer(newSize);

                mData = mByteBuffer.asFloatBuffer();

                mData.flip();

                mByteBuffer.flip();

        }

        /** Create GL handle and upload vertex data to hardware. */

        public final void upload()

        {

                if (mData == null)

                        return;

                Gdx.gl20.glGenBuffers(1, BUFFERID);

                mBufferID = BUFFERID.get(0);

                Gdx.gl20.glBindBuffer(GL20.GL_ARRAY_BUFFER, mBufferID);

                int usage = GL20.GL_STATIC_DRAW;

                if (isDynamic())

                        usage = GL20.GL_DYNAMIC_DRAW;

                //Gdx.gl20.glBufferData(GL20.GL_ARRAY_BUFFER, mData.capacity() * Consts.SIZEOF_FLOAT, mData, usage);

                Gdx.gl20.glBufferData(GL20.GL_ARRAY_BUFFER, mByteBuffer.limit(), mByteBuffer, usage);

                Gdx.gl20.glBindBuffer(GL20.GL_ARRAY_BUFFER, 0);

        }

        /** Reupload data to hardware. */

        public final void reupload()

        {

                if (mBufferID == 0)

                {

                        // perform initial upload

                        upload();

                        return;

                }

                if (mData == null)

                        return;

                Gdx.gl20.glBindBuffer(GL20.GL_ARRAY_BUFFER, mBufferID);

                Gdx.gl20.glBufferSubData(GL20.GL_ARRAY_BUFFER, 0, mData.capacity() * Consts.SIZEOF_FLOAT, mData);

                Gdx.gl20.glBindBuffer(GL20.GL_ARRAY_BUFFER, 0);

        }

        /** Unload vertex data from hardware. */

        public final void unload()

        {

                deactivate();

                BUFFERID.put(0, mBufferID);

                Gdx.gl20.glDeleteBuffers(1, BUFFERID);

                mBufferID = 0;

        }

        //static int mCurrentBufferId = 0;

        /** Activate stream for rendering. */

        public final void activate()

        {

                // TODO: buffer state tracking

                //if (mCurrentBufferId != mBufferID)

                {

                        Gdx.gl20.glBindBuffer(GL20.GL_ARRAY_BUFFER, mBufferID);

                        //mCurrentBufferId = mBufferID;

                }

                for (int i = 0; i < mAttribs.length; i++)

                {

                        VertexAttribute attrib = mAttribs[i];

                        // TODO: attrib to handle adapter

                        Gdx.gl20.glVertexAttribPointer(attrib.getAttribType(), attrib.getCoordsPerElement(), GL20.GL_FLOAT, false, getBytesPerElement(), attrib.getByteOffset());

                        Gdx.gl20.glEnableVertexAttribArray(attrib.getAttribType());

                }              

        }

        public final void deactivate()

        {

                for (int i = 0; i < mAttribs.length; i++)

                {

                        VertexAttribute attrib = mAttribs[i];

                        // TODO: attrib to handle adapter

                        Gdx.gl20.glDisableVertexAttribArray(attrib.getAttribType());

                }              

                // TODO: buffer state tracking

                //Gdx.gl20.glBindBuffer(GL20.GL_ARRAY_BUFFER, 0);

        }

        /** Get Coords per element. */

        public final int getCoordsPerElement()

        {

                return mCoordsPerElement;

        }

        /** Get number of bytes per complete element (equals vertex stride). */

        public final int getBytesPerElement()

        {

                return mBytesPerElement;

        }

        /** Get number of elements. */

        public final int getVertexCount()

        {

                return mVertexCount;

        }

        /** Get name of vertex stream. */

        public final String getName()

        {

                return mName;

        }

        /** Get stream type. */

        public final StreamType getStreamType()

        {

                return mStreamType;

        }

        /** Check if the stream is dynamic or static. */

        public final boolean isDynamic()

        {

                return mIsDynamic;

        }

}