292 lines
15 KiB
C++
292 lines
15 KiB
C++
/*
|
|
Copyright (c) 2013 Khaled Mammou - Advanced Micro Devices, Inc.
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
*/
|
|
|
|
|
|
#pragma once
|
|
#ifndef O3DGC_TRIANGLE_FANS_H
|
|
#define O3DGC_TRIANGLE_FANS_H
|
|
|
|
#include "o3dgcCommon.h"
|
|
#include "o3dgcVector.h"
|
|
#include "o3dgcBinaryStream.h"
|
|
|
|
|
|
namespace o3dgc
|
|
{
|
|
const long O3DGC_TFANS_MIN_SIZE_ALLOCATED_VERTICES_BUFFER = 128;
|
|
const long O3DGC_TFANS_MIN_SIZE_TFAN_SIZE_BUFFER = 8;
|
|
|
|
class CompressedTriangleFans
|
|
{
|
|
public:
|
|
//! Constructor.
|
|
CompressedTriangleFans(void)
|
|
{
|
|
m_streamType = O3DGC_STREAM_TYPE_UNKOWN;
|
|
m_bufferAC = 0;
|
|
m_sizeBufferAC = 0;
|
|
};
|
|
//! Destructor.
|
|
~CompressedTriangleFans(void)
|
|
{
|
|
delete [] m_bufferAC;
|
|
};
|
|
O3DGCStreamType GetStreamType() const { return m_streamType; }
|
|
void SetStreamType(O3DGCStreamType streamType) { m_streamType = streamType; }
|
|
|
|
O3DGCErrorCode Allocate(long numVertices, long numTriangles)
|
|
{
|
|
assert(numVertices > 0);
|
|
m_numTFANs.Allocate(numVertices);
|
|
m_degrees.Allocate(2*numVertices);
|
|
m_configs.Allocate(2*numVertices);
|
|
m_operations.Allocate(2*numVertices);
|
|
m_indices.Allocate(2*numVertices);
|
|
m_trianglesOrder.Allocate(numTriangles);
|
|
Clear();
|
|
return O3DGC_OK;
|
|
}
|
|
O3DGCErrorCode PushNumTFans(long numTFans)
|
|
{
|
|
m_numTFANs.PushBack(numTFans);
|
|
return O3DGC_OK;
|
|
}
|
|
long ReadNumTFans(unsigned long & iterator) const
|
|
{
|
|
assert(iterator < m_numTFANs.GetSize());
|
|
return m_numTFANs[iterator++];
|
|
}
|
|
O3DGCErrorCode PushDegree(long degree)
|
|
{
|
|
m_degrees.PushBack(degree);
|
|
return O3DGC_OK;
|
|
}
|
|
long ReadDegree(unsigned long & iterator) const
|
|
{
|
|
assert(iterator < m_degrees.GetSize());
|
|
return m_degrees[iterator++];
|
|
}
|
|
O3DGCErrorCode PushConfig(long config)
|
|
{
|
|
m_configs.PushBack(config);
|
|
return O3DGC_OK;
|
|
}
|
|
long ReadConfig(unsigned long & iterator) const
|
|
{
|
|
assert(iterator < m_configs.GetSize());
|
|
return m_configs[iterator++];
|
|
}
|
|
O3DGCErrorCode PushOperation(long op)
|
|
{
|
|
m_operations.PushBack(op);
|
|
return O3DGC_OK;
|
|
}
|
|
long ReadOperation(unsigned long & iterator) const
|
|
{
|
|
assert(iterator < m_operations.GetSize());
|
|
return m_operations[iterator++];
|
|
}
|
|
O3DGCErrorCode PushIndex(long index)
|
|
{
|
|
m_indices.PushBack(index);
|
|
return O3DGC_OK;
|
|
}
|
|
long ReadIndex(unsigned long & iterator) const
|
|
{
|
|
assert(iterator < m_indices.GetSize());
|
|
return m_indices[iterator++];
|
|
}
|
|
O3DGCErrorCode PushTriangleIndex(long index)
|
|
{
|
|
m_trianglesOrder.PushBack(IntToUInt(index));
|
|
return O3DGC_OK;
|
|
}
|
|
long ReadTriangleIndex(unsigned long & iterator) const
|
|
{
|
|
assert(iterator < m_trianglesOrder.GetSize());
|
|
return UIntToInt(m_trianglesOrder[iterator++]);
|
|
}
|
|
O3DGCErrorCode Clear()
|
|
{
|
|
m_numTFANs.Clear();
|
|
m_degrees.Clear();
|
|
m_configs.Clear();
|
|
m_operations.Clear();
|
|
m_indices.Clear();
|
|
return O3DGC_OK;
|
|
}
|
|
O3DGCErrorCode Save(BinaryStream & bstream,
|
|
bool encodeTrianglesOrder,
|
|
O3DGCStreamType streamType);
|
|
O3DGCErrorCode Load(const BinaryStream & bstream,
|
|
unsigned long & iterator,
|
|
bool decodeTrianglesOrder,
|
|
O3DGCStreamType streamType);
|
|
|
|
private:
|
|
O3DGCErrorCode SaveBinAC(const Vector<long> & data,
|
|
BinaryStream & bstream);
|
|
O3DGCErrorCode SaveUIntAC(const Vector<long> & data,
|
|
const unsigned long M,
|
|
BinaryStream & bstream);
|
|
O3DGCErrorCode SaveIntACEGC(const Vector<long> & data,
|
|
const unsigned long M,
|
|
BinaryStream & bstream);
|
|
|
|
Vector<long> m_numTFANs;
|
|
Vector<long> m_degrees;
|
|
Vector<long> m_configs;
|
|
Vector<long> m_operations;
|
|
Vector<long> m_indices;
|
|
Vector<long> m_trianglesOrder;
|
|
unsigned char * m_bufferAC;
|
|
unsigned long m_sizeBufferAC;
|
|
O3DGCStreamType m_streamType;
|
|
};
|
|
|
|
//!
|
|
class TriangleFans
|
|
{
|
|
public:
|
|
//! Constructor.
|
|
TriangleFans(long sizeTFAN = O3DGC_TFANS_MIN_SIZE_TFAN_SIZE_BUFFER,
|
|
long verticesSize = O3DGC_TFANS_MIN_SIZE_ALLOCATED_VERTICES_BUFFER)
|
|
{
|
|
assert(sizeTFAN > 0);
|
|
assert(verticesSize > 0);
|
|
m_numTFANs = 0;
|
|
m_numVertices = 0;
|
|
m_verticesAllocatedSize = verticesSize;
|
|
m_sizeTFANAllocatedSize = sizeTFAN;
|
|
m_sizeTFAN = new long [m_sizeTFANAllocatedSize];
|
|
m_vertices = new long [m_verticesAllocatedSize];
|
|
};
|
|
//! Destructor.
|
|
~TriangleFans(void)
|
|
{
|
|
delete [] m_vertices;
|
|
delete [] m_sizeTFAN;
|
|
};
|
|
|
|
O3DGCErrorCode Allocate(long sizeTFAN, long verticesSize)
|
|
{
|
|
assert(sizeTFAN > 0);
|
|
assert(verticesSize > 0);
|
|
m_numTFANs = 0;
|
|
m_numVertices = 0;
|
|
if (m_verticesAllocatedSize < verticesSize)
|
|
{
|
|
delete [] m_vertices;
|
|
m_verticesAllocatedSize = verticesSize;
|
|
m_vertices = new long [m_verticesAllocatedSize];
|
|
}
|
|
if (m_sizeTFANAllocatedSize < sizeTFAN)
|
|
{
|
|
delete [] m_sizeTFAN;
|
|
m_sizeTFANAllocatedSize = sizeTFAN;
|
|
m_sizeTFAN = new long [m_sizeTFANAllocatedSize];
|
|
}
|
|
return O3DGC_OK;
|
|
};
|
|
O3DGCErrorCode Clear()
|
|
{
|
|
m_numTFANs = 0;
|
|
m_numVertices = 0;
|
|
return O3DGC_OK;
|
|
}
|
|
O3DGCErrorCode AddVertex(long vertex)
|
|
{
|
|
assert(m_numTFANs >= 0);
|
|
assert(m_numTFANs < m_sizeTFANAllocatedSize);
|
|
assert(m_numVertices >= 0);
|
|
++m_numVertices;
|
|
if (m_numVertices == m_verticesAllocatedSize)
|
|
{
|
|
m_verticesAllocatedSize *= 2;
|
|
long * tmp = m_vertices;
|
|
m_vertices = new long [m_verticesAllocatedSize];
|
|
memcpy(m_vertices, tmp, sizeof(long) * m_numVertices);
|
|
delete [] tmp;
|
|
}
|
|
m_vertices[m_numVertices-1] = vertex;
|
|
++m_sizeTFAN[m_numTFANs-1];
|
|
return O3DGC_OK;
|
|
}
|
|
O3DGCErrorCode AddTFAN()
|
|
{
|
|
assert(m_numTFANs >= 0);
|
|
++m_numTFANs;
|
|
if (m_numTFANs == m_sizeTFANAllocatedSize)
|
|
{
|
|
m_sizeTFANAllocatedSize *= 2;
|
|
long * tmp = m_sizeTFAN;
|
|
m_sizeTFAN = new long [m_sizeTFANAllocatedSize];
|
|
memcpy(m_sizeTFAN, tmp, sizeof(long) * m_numTFANs);
|
|
delete [] tmp;
|
|
}
|
|
m_sizeTFAN[m_numTFANs-1] = (m_numTFANs > 1) ? m_sizeTFAN[m_numTFANs-2] : 0;
|
|
return O3DGC_OK;
|
|
}
|
|
long Begin(long tfan) const
|
|
{
|
|
assert(tfan < m_numTFANs);
|
|
assert(tfan >= 0);
|
|
return (tfan>0)?m_sizeTFAN[tfan-1]:0;
|
|
}
|
|
long End(long tfan) const
|
|
{
|
|
assert(tfan < m_numTFANs);
|
|
assert(tfan >= 0);
|
|
return m_sizeTFAN[tfan];
|
|
}
|
|
long GetVertex(long vertex) const
|
|
{
|
|
assert(vertex < m_numVertices);
|
|
assert(vertex >= 0);
|
|
return m_vertices[vertex];
|
|
}
|
|
long GetTFANSize(long tfan) const
|
|
{
|
|
return End(tfan) - Begin(tfan);
|
|
}
|
|
long GetNumTFANs() const
|
|
{
|
|
return m_numTFANs;
|
|
}
|
|
long GetNumVertices() const
|
|
{
|
|
return m_numVertices;
|
|
}
|
|
|
|
private:
|
|
long m_verticesAllocatedSize;
|
|
long m_sizeTFANAllocatedSize;
|
|
long m_numTFANs;
|
|
long m_numVertices;
|
|
long * m_vertices;
|
|
long * m_sizeTFAN;
|
|
|
|
};
|
|
}
|
|
#endif // O3DGC_TRIANGLE_FANS_H
|
|
|