include/IPSA/VertexStorage.h

Go to the documentation of this file.

#ifndef _VERTEX_STORAGE_
#define _VERTEX_STORAGE_
/*
 *  VertexStorage.h
 *
 * Copyright (c) 2007, 2008, 2009, University of Karlsruhe (for members see AUTHORS file)
 *
 * ISC License
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Created by Manfred Kroehnert on 23.11.07.
 *
 */

template<typename T>
class VertexStorage
{
public:
                VertexStorage(int maxVertexCount, int maxIndexCount);
                ~VertexStorage();
                int getVertexCount();
                int getIndexCount();
                bool appendVertex( T vertex );
                bool appendVertexIndices(int idx1, int idx2, int idx3);
                bool appendVertexWithIndices(T vertex, int idx1, int idx2, int idx3);
                const int MAX_VERTEX_COUNT;
                const int MAX_INDEX_COUNT;
                T *vertices;
                int *indices;
private:
                int nextVertex;
                int nextIndex;
};

template <typename T>
VertexStorage<T>::VertexStorage(int maxVertexCount, int maxIndexCount)
: MAX_VERTEX_COUNT(maxVertexCount), MAX_INDEX_COUNT(maxIndexCount),
nextVertex(0), nextIndex(0)
{
                vertices =  new T[maxVertexCount];
                indices = new int[maxIndexCount];
                for (int i = 0; i < maxIndexCount; i++)
                                indices[i] = 0;
}

template <typename T>
VertexStorage<T>::~VertexStorage()
{
                if (vertices)
                {
                                for( int i = 0; i < this->MAX_VERTEX_COUNT; i++ )
                                                delete vertices[i];
                                delete vertices;
                }
                if (indices)
                                delete indices;
}

template <typename T>
bool VertexStorage<T>::appendVertex( T vertex )
{
                if ( MAX_VERTEX_COUNT <= nextVertex )
                                return false;
                vertices[nextVertex][0] = vertex[0];
                vertices[nextVertex][1] = vertex[1];
                vertices[nextVertex][2] = vertex[2];
                nextVertex++;
                return true;
}

template <typename T>
bool VertexStorage<T>::appendVertexIndices(int idx1, int idx2, int idx3)
{
                if ( MAX_INDEX_COUNT <= nextIndex + 2 )
                                return false;
                indices[nextIndex] = idx1;
                indices[nextIndex + 1] = idx2;
                indices[nextIndex + 2] = idx3;
                nextIndex += 3;
                return true;
}

template <typename T>
bool VertexStorage<T>::appendVertexWithIndices(T vertex, int idx1, int idx2, int idx3)
{
                if ( false == this->appendVertex( vertex ) )
                                return false;
                bool result = this->appendVertexIndices( idx1, idx2, idx3 );
                if (false == result)
                {
                                // "delete" an inserted triangle if the
                                // indices can not be inserted
                                if (0 < nextVertex)
                                                nextVertex--;
                }
                return result;
}

#endif // _VERTEX_STORAGE_

---