720 lines
27 KiB
C++
720 lines
27 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_LIST_ENCODER_INL
|
|
#define O3DGC_TRIANGLE_LIST_ENCODER_INL
|
|
|
|
namespace o3dgc
|
|
{
|
|
// extract opposite edge
|
|
template <class T>
|
|
inline void CompueOppositeEdge(const long focusVertex,
|
|
const T * triangle,
|
|
long & a, long & b)
|
|
{
|
|
if ((long) triangle[0] == focusVertex)
|
|
{
|
|
a = triangle[1];
|
|
b = triangle[2];
|
|
}
|
|
else if ((long) triangle[1] == focusVertex)
|
|
{
|
|
a = triangle[2];
|
|
b = triangle[0];
|
|
}
|
|
else
|
|
{
|
|
a = triangle[0];
|
|
b = triangle[1];
|
|
}
|
|
}
|
|
inline bool IsCase0(long degree, long numIndices, const long * const ops, const long * const indices)
|
|
{
|
|
// ops: 1000001 vertices: -1 -2
|
|
if ((numIndices != 2) || (degree < 2)) {
|
|
return false;
|
|
}
|
|
if ((indices[0] != -1) ||(indices[1] != -2) ||
|
|
(ops[0] != 1) ||(ops[degree-1] != 1) ) return false;
|
|
for (long u = 1; u < degree-1; u++) {
|
|
if (ops[u] != 0) return false;
|
|
}
|
|
return true;
|
|
}
|
|
inline bool IsCase1(long degree, long numIndices, const long * const ops, const long * const indices)
|
|
{
|
|
// ops: 1xxxxxx1 indices: -1 x x x x x -2
|
|
if ((degree < 2) || (numIndices < 1))
|
|
{
|
|
return false;
|
|
}
|
|
if ((indices[0] != -1) ||(indices[numIndices-1] != -2) ||
|
|
(ops[0] != 1) ||(ops[degree-1] != 1) ) return false;
|
|
return true;
|
|
}
|
|
inline bool IsCase2(long degree, long numIndices, const long * const ops, const long * const indices)
|
|
{
|
|
// ops: 00000001 indices: -1
|
|
if ((degree < 2) || (numIndices!= 1))
|
|
{
|
|
return false;
|
|
}
|
|
if ((indices[0] != -1) || (ops[degree-1] != 1) ) return false;
|
|
for (long u = 0; u < degree-1; u++) {
|
|
if (ops[u] != 0) return false;
|
|
}
|
|
return true;
|
|
}
|
|
inline bool IsCase3(long degree, long numIndices, const long * const ops, const long * const indices)
|
|
{
|
|
// ops: 00000001 indices: -2
|
|
if ((degree < 2) || (numIndices!= 1))
|
|
{
|
|
return false;
|
|
}
|
|
if ((indices[0] != -2) || (ops[degree-1] != 1) ) return false;
|
|
for (long u = 0; u < degree-1; u++) {
|
|
if (ops[u] != 0) return false;
|
|
}
|
|
return true;
|
|
}
|
|
inline bool IsCase4(long degree, long numIndices, const long * const ops, const long * const indices)
|
|
{
|
|
// ops: 10000000 indices: -1
|
|
if ((degree < 2) || (numIndices!= 1))
|
|
{
|
|
return false;
|
|
}
|
|
if ((indices[0] != -1) || (ops[0] != 1) ) return false;
|
|
for (long u = 1; u < degree; u++)
|
|
{
|
|
if (ops[u] != 0) return false;
|
|
}
|
|
return true;
|
|
}
|
|
inline bool IsCase5(long degree, long numIndices, const long * const ops, const long * const indices)
|
|
{
|
|
// ops: 10000000 indices: -2
|
|
if ((degree < 2) || (numIndices!= 1))
|
|
{
|
|
return false;
|
|
}
|
|
if ((indices[0] != -2) || (ops[0] != 1) ) return false;
|
|
for (long u = 1; u < degree; u++) {
|
|
if (ops[u] != 0) return false;
|
|
}
|
|
return true;
|
|
}
|
|
inline bool IsCase6(long degree, long numIndices, const long * const ops, const long * const /*indices*/)
|
|
{
|
|
// ops: 0000000 indices:
|
|
if (numIndices!= 0)
|
|
{
|
|
return false;
|
|
}
|
|
for (long u = 0; u < degree; u++)
|
|
{
|
|
if (ops[u] != 0) return false;
|
|
}
|
|
return true;
|
|
}
|
|
inline bool IsCase7(long degree, long numIndices, const long * const ops, const long * const indices)
|
|
{
|
|
// ops: 1000001 indices: -2 -1
|
|
if ((numIndices!= 2) || (degree < 2))
|
|
{
|
|
return false;
|
|
}
|
|
if ((indices[0] != -2) ||(indices[1] != -1) ||
|
|
(ops[0] != 1) ||(ops[degree-1] != 1) ) return false;
|
|
for (long u = 1; u < degree-1; u++)
|
|
{
|
|
if (ops[u] != 0) return false;
|
|
}
|
|
return true;
|
|
}
|
|
inline bool IsCase8(long degree, long numIndices, const long * const ops, const long * const indices)
|
|
{
|
|
// ops: 1xxxxxx1 indices: -1 x x x x x -2
|
|
if ((degree < 2) || (numIndices < 1))
|
|
{
|
|
return false;
|
|
}
|
|
if ((indices[0] != -2) ||(indices[numIndices-1] != -1) ||
|
|
(ops[0] != 1) ||(ops[degree-1] != 1) ) return false;
|
|
return true;
|
|
}
|
|
template <class T>
|
|
TriangleListEncoder<T>::TriangleListEncoder(void)
|
|
{
|
|
m_vtags = 0;
|
|
m_ttags = 0;
|
|
m_tmap = 0;
|
|
m_vmap = 0;
|
|
m_count = 0;
|
|
m_invVMap = 0;
|
|
m_invTMap = 0;
|
|
m_nonConqueredTriangles = 0;
|
|
m_nonConqueredEdges = 0;
|
|
m_visitedVertices = 0;
|
|
m_visitedVerticesValence = 0;
|
|
m_vertexCount = 0;
|
|
m_triangleCount = 0;
|
|
m_maxNumVertices = 0;
|
|
m_maxNumTriangles = 0;
|
|
m_numTriangles = 0;
|
|
m_numVertices = 0;
|
|
m_triangles = 0;
|
|
m_maxSizeVertexToTriangle = 0;
|
|
m_streamType = O3DGC_STREAM_TYPE_UNKOWN;
|
|
}
|
|
template <class T>
|
|
TriangleListEncoder<T>::~TriangleListEncoder()
|
|
{
|
|
delete [] m_vtags;
|
|
delete [] m_vmap;
|
|
delete [] m_invVMap;
|
|
delete [] m_invTMap;
|
|
delete [] m_visitedVerticesValence;
|
|
delete [] m_visitedVertices;
|
|
delete [] m_ttags;
|
|
delete [] m_tmap;
|
|
delete [] m_count;
|
|
delete [] m_nonConqueredTriangles;
|
|
delete [] m_nonConqueredEdges;
|
|
}
|
|
template <class T>
|
|
O3DGCErrorCode TriangleListEncoder<T>::Init(const T * const triangles,
|
|
long numTriangles,
|
|
long numVertices)
|
|
{
|
|
assert(numVertices > 0);
|
|
assert(numTriangles > 0);
|
|
|
|
m_numTriangles = numTriangles;
|
|
m_numVertices = numVertices;
|
|
m_triangles = triangles;
|
|
m_vertexCount = 0;
|
|
m_triangleCount = 0;
|
|
|
|
if (m_numVertices > m_maxNumVertices)
|
|
{
|
|
delete [] m_vtags;
|
|
delete [] m_vmap;
|
|
delete [] m_invVMap;
|
|
delete [] m_visitedVerticesValence;
|
|
delete [] m_visitedVertices;
|
|
m_maxNumVertices = m_numVertices;
|
|
m_vtags = new long [m_numVertices];
|
|
m_vmap = new long [m_numVertices];
|
|
m_invVMap = new long [m_numVertices];
|
|
m_visitedVerticesValence = new long [m_numVertices];
|
|
m_visitedVertices = new long [m_numVertices];
|
|
}
|
|
|
|
if (m_numTriangles > m_maxNumTriangles)
|
|
{
|
|
delete [] m_ttags;
|
|
delete [] m_tmap;
|
|
delete [] m_invTMap;
|
|
delete [] m_nonConqueredTriangles;
|
|
delete [] m_nonConqueredEdges;
|
|
delete [] m_count;
|
|
m_maxNumTriangles = m_numTriangles;
|
|
m_ttags = new long [m_numTriangles];
|
|
m_tmap = new long [m_numTriangles];
|
|
m_invTMap = new long [m_numTriangles];
|
|
m_count = new long [m_numTriangles+1];
|
|
m_nonConqueredTriangles = new long [m_numTriangles];
|
|
m_nonConqueredEdges = new long [2*m_numTriangles];
|
|
}
|
|
|
|
memset(m_vtags , 0x00, sizeof(long) * m_numVertices );
|
|
memset(m_vmap , 0xFF, sizeof(long) * m_numVertices );
|
|
memset(m_invVMap, 0xFF, sizeof(long) * m_numVertices );
|
|
memset(m_ttags , 0x00, sizeof(long) * m_numTriangles);
|
|
memset(m_tmap , 0xFF, sizeof(long) * m_numTriangles);
|
|
memset(m_invTMap, 0xFF, sizeof(long) * m_numTriangles);
|
|
memset(m_count , 0x00, sizeof(long) * (m_numTriangles+1));
|
|
|
|
m_vfifo.Allocate(m_numVertices);
|
|
m_ctfans.SetStreamType(m_streamType);
|
|
m_ctfans.Allocate(m_numVertices, m_numTriangles);
|
|
|
|
// compute vertex-to-triangle adjacency information
|
|
m_vertexToTriangle.AllocateNumNeighborsArray(numVertices);
|
|
m_vertexToTriangle.ClearNumNeighborsArray();
|
|
long * numNeighbors = m_vertexToTriangle.GetNumNeighborsBuffer();
|
|
for(long i = 0, t = 0; i < m_numTriangles; ++i, t+=3)
|
|
{
|
|
++numNeighbors[ triangles[t ] ];
|
|
++numNeighbors[ triangles[t+1] ];
|
|
++numNeighbors[ triangles[t+2] ];
|
|
}
|
|
m_maxSizeVertexToTriangle = 0;
|
|
for(long i = 0; i < numVertices; ++i)
|
|
{
|
|
if (m_maxSizeVertexToTriangle < numNeighbors[i])
|
|
{
|
|
m_maxSizeVertexToTriangle = numNeighbors[i];
|
|
}
|
|
}
|
|
m_vertexToTriangle.AllocateNeighborsArray();
|
|
m_vertexToTriangle.ClearNeighborsArray();
|
|
for(long i = 0, t = 0; i < m_numTriangles; ++i, t+=3)
|
|
{
|
|
m_vertexToTriangle.AddNeighbor(triangles[t ], i);
|
|
m_vertexToTriangle.AddNeighbor(triangles[t+1], i);
|
|
m_vertexToTriangle.AddNeighbor(triangles[t+2], i);
|
|
}
|
|
return O3DGC_OK;
|
|
}
|
|
template <class T>
|
|
O3DGCErrorCode TriangleListEncoder<T>::Encode(const T * const triangles,
|
|
const unsigned long * const indexBufferIDs,
|
|
const long numTriangles,
|
|
const long numVertices,
|
|
BinaryStream & bstream)
|
|
{
|
|
assert(numVertices > 0);
|
|
assert(numTriangles > 0);
|
|
|
|
Init(triangles, numTriangles, numVertices);
|
|
unsigned char mask = 0;
|
|
bool encodeTrianglesOrder = (indexBufferIDs != 0);
|
|
|
|
|
|
if (encodeTrianglesOrder)
|
|
{
|
|
long numBufferIDs = 0;
|
|
for (long t = 0; t < numTriangles; t++)
|
|
{
|
|
if (numBufferIDs <= (long) indexBufferIDs[t])
|
|
{
|
|
++numBufferIDs;
|
|
assert(numBufferIDs <= numTriangles);
|
|
}
|
|
++m_count[indexBufferIDs[t]+1];
|
|
}
|
|
for (long i = 2; i <= numBufferIDs; i++)
|
|
{
|
|
m_count[i] += m_count[i-1];
|
|
}
|
|
mask += 2; // preserved triangles order
|
|
}
|
|
bstream.WriteUChar(mask, m_streamType);
|
|
bstream.WriteUInt32(m_maxSizeVertexToTriangle, m_streamType);
|
|
|
|
long v0;
|
|
for (long v = 0; v < m_numVertices; v++)
|
|
{
|
|
if (!m_vtags[v])
|
|
{
|
|
m_vfifo.PushBack(v);
|
|
m_vtags[v] = 1;
|
|
m_vmap[v] = m_vertexCount++;
|
|
m_invVMap[m_vmap[v]] = v;
|
|
while (m_vfifo.GetSize() > 0 )
|
|
{
|
|
v0 = m_vfifo.PopFirst();
|
|
ProcessVertex(v0);
|
|
}
|
|
}
|
|
}
|
|
if (encodeTrianglesOrder)
|
|
{
|
|
long t, prev = 0;
|
|
long pred;
|
|
for (long i = 0; i < numTriangles; ++i)
|
|
{
|
|
t = m_invTMap[i];
|
|
m_tmap[t] = m_count[ indexBufferIDs[t] ]++;
|
|
pred = m_tmap[t] - prev;
|
|
m_ctfans.PushTriangleIndex(pred);
|
|
prev = m_tmap[t] + 1;
|
|
}
|
|
for (long tt = 0; tt < numTriangles; ++tt)
|
|
{
|
|
m_invTMap[m_tmap[tt]] = tt;
|
|
}
|
|
}
|
|
m_ctfans.Save(bstream, encodeTrianglesOrder, m_streamType);
|
|
return O3DGC_OK;
|
|
}
|
|
template <class T>
|
|
O3DGCErrorCode TriangleListEncoder<T>::CompueLocalConnectivityInfo(const long focusVertex)
|
|
{
|
|
long t, v, p;
|
|
m_numNonConqueredTriangles = 0;
|
|
m_numConqueredTriangles = 0;
|
|
m_numVisitedVertices = 0;
|
|
for(long i = m_vertexToTriangle.Begin(focusVertex); i < m_vertexToTriangle.End(focusVertex); ++i)
|
|
{
|
|
t = m_vertexToTriangle.GetNeighbor(i);
|
|
|
|
if ( m_ttags[t] == 0) // non-processed triangle
|
|
{
|
|
m_nonConqueredTriangles[m_numNonConqueredTriangles] = t;
|
|
CompueOppositeEdge( focusVertex,
|
|
m_triangles + (3*t),
|
|
m_nonConqueredEdges[m_numNonConqueredTriangles*2],
|
|
m_nonConqueredEdges[m_numNonConqueredTriangles*2+1]);
|
|
++m_numNonConqueredTriangles;
|
|
}
|
|
else // triangle already processed
|
|
{
|
|
m_numConqueredTriangles++;
|
|
p = 3*t;
|
|
// extract visited vertices
|
|
for(long k = 0; k < 3; ++k)
|
|
{
|
|
v = m_triangles[p+k];
|
|
if (m_vmap[v] > m_vmap[focusVertex]) // vertices are insertices by increasing traversal order
|
|
{
|
|
bool foundOrInserted = false;
|
|
for (long j = 0; j < m_numVisitedVertices; ++j)
|
|
{
|
|
|
|
if (m_vmap[v] == m_visitedVertices[j])
|
|
{
|
|
m_visitedVerticesValence[j]++;
|
|
foundOrInserted = true;
|
|
break;
|
|
}
|
|
else if (m_vmap[v] < m_visitedVertices[j])
|
|
{
|
|
++m_numVisitedVertices;
|
|
for (long h = m_numVisitedVertices-1; h > j; --h)
|
|
{
|
|
m_visitedVertices[h] = m_visitedVertices[h-1];
|
|
m_visitedVerticesValence[h] = m_visitedVerticesValence[h-1];
|
|
}
|
|
m_visitedVertices[j] = m_vmap[v];
|
|
m_visitedVerticesValence[j] = 1;
|
|
foundOrInserted = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!foundOrInserted)
|
|
{
|
|
m_visitedVertices[m_numVisitedVertices] = m_vmap[v];
|
|
m_visitedVerticesValence[m_numVisitedVertices] = 1;
|
|
m_numVisitedVertices++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// re-order visited vertices by taking into account their valence (i.e., # of conquered triangles incident to each vertex)
|
|
// in order to avoid config. 9
|
|
if (m_numVisitedVertices > 2)
|
|
{
|
|
long y;
|
|
for(long x = 1; x < m_numVisitedVertices; ++x)
|
|
{
|
|
|
|
if (m_visitedVerticesValence[x] == 1)
|
|
{
|
|
y = x;
|
|
while( (y > 0) && (m_visitedVerticesValence[y] < m_visitedVerticesValence[y-1]) )
|
|
{
|
|
swap(m_visitedVerticesValence[y], m_visitedVerticesValence[y-1]);
|
|
swap(m_visitedVertices[y], m_visitedVertices[y-1]);
|
|
--y;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (m_numNonConqueredTriangles > 0)
|
|
{
|
|
// compute triangle-to-triangle adjacency information
|
|
m_triangleToTriangle.AllocateNumNeighborsArray(m_numNonConqueredTriangles);
|
|
m_triangleToTriangle.ClearNumNeighborsArray();
|
|
m_triangleToTriangleInv.AllocateNumNeighborsArray(m_numNonConqueredTriangles);
|
|
m_triangleToTriangleInv.ClearNumNeighborsArray();
|
|
long * const numNeighbors = m_triangleToTriangle.GetNumNeighborsBuffer();
|
|
long * const invNumNeighbors = m_triangleToTriangleInv.GetNumNeighborsBuffer();
|
|
for(long i = 0; i < m_numNonConqueredTriangles; ++i)
|
|
{
|
|
for(long j = i+1; j < m_numNonConqueredTriangles; ++j)
|
|
{
|
|
if (m_nonConqueredEdges[2*i+1] == m_nonConqueredEdges[2*j]) // edge i is connected to edge j
|
|
{
|
|
++numNeighbors[i];
|
|
++invNumNeighbors[j];
|
|
}
|
|
if (m_nonConqueredEdges[2*i] == m_nonConqueredEdges[2*j+1]) // edge i is connected to edge j
|
|
{
|
|
++numNeighbors[j];
|
|
++invNumNeighbors[i];
|
|
}
|
|
}
|
|
}
|
|
m_triangleToTriangle.AllocateNeighborsArray();
|
|
m_triangleToTriangle.ClearNeighborsArray();
|
|
m_triangleToTriangleInv.AllocateNeighborsArray();
|
|
m_triangleToTriangleInv.ClearNeighborsArray();
|
|
for(long i = 0; i < m_numNonConqueredTriangles; ++i)
|
|
{
|
|
for(long j = 1; j < m_numNonConqueredTriangles; ++j)
|
|
{
|
|
if (m_nonConqueredEdges[2*i+1] == m_nonConqueredEdges[2*j]) // edge i is connected to edge j
|
|
{
|
|
m_triangleToTriangle.AddNeighbor(i, j);
|
|
m_triangleToTriangleInv.AddNeighbor(j, i);
|
|
}
|
|
if (m_nonConqueredEdges[2*i] == m_nonConqueredEdges[2*j+1]) // edge i is connected to edge j
|
|
{
|
|
m_triangleToTriangle.AddNeighbor(j, i);
|
|
m_triangleToTriangleInv.AddNeighbor(i, j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return O3DGC_OK;
|
|
}
|
|
template <class T>
|
|
O3DGCErrorCode TriangleListEncoder<T>::ComputeTFANDecomposition(const long focusVertex)
|
|
{
|
|
long processedTriangles = 0;
|
|
long minNumInputEdges;
|
|
long numInputEdges;
|
|
long indexSeedTriangle;
|
|
long seedTriangle;
|
|
long currentIndex;
|
|
long currentTriangle;
|
|
long i0, i1, index;
|
|
|
|
m_tfans.Clear();
|
|
while (processedTriangles != m_numNonConqueredTriangles)
|
|
{
|
|
// find non processed triangle with lowest number of inputs
|
|
minNumInputEdges = m_numTriangles;
|
|
indexSeedTriangle = -1;
|
|
for(long i = 0; i < m_numNonConqueredTriangles; ++i)
|
|
{
|
|
numInputEdges = m_triangleToTriangleInv.GetNumNeighbors(i);
|
|
if ( !m_ttags[m_nonConqueredTriangles[i]] &&
|
|
numInputEdges < minNumInputEdges )
|
|
{
|
|
minNumInputEdges = numInputEdges;
|
|
indexSeedTriangle = i;
|
|
if (minNumInputEdges == 0) // found boundary triangle
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
assert(indexSeedTriangle >= 0);
|
|
seedTriangle = m_nonConqueredTriangles[indexSeedTriangle];
|
|
m_tfans.AddTFAN();
|
|
m_tfans.AddVertex( focusVertex );
|
|
m_tfans.AddVertex( m_nonConqueredEdges[indexSeedTriangle*2] );
|
|
m_tfans.AddVertex( m_nonConqueredEdges[indexSeedTriangle*2 + 1] );
|
|
m_ttags[ seedTriangle ] = 1; // mark triangle as processed
|
|
m_tmap[seedTriangle] = m_triangleCount++;
|
|
m_invTMap[m_tmap[seedTriangle]] = seedTriangle;
|
|
++processedTriangles;
|
|
currentIndex = indexSeedTriangle;
|
|
currentTriangle = seedTriangle;
|
|
do
|
|
{
|
|
// find next triangle
|
|
i0 = m_triangleToTriangle.Begin(currentIndex);
|
|
i1 = m_triangleToTriangle.End(currentIndex);
|
|
currentIndex = -1;
|
|
for(long i = i0; i < i1; ++i)
|
|
{
|
|
index = m_triangleToTriangle.GetNeighbor(i);
|
|
currentTriangle = m_nonConqueredTriangles[index];
|
|
if ( !m_ttags[currentTriangle] )
|
|
{
|
|
currentIndex = index;
|
|
m_tfans.AddVertex( m_nonConqueredEdges[currentIndex*2+1] );
|
|
m_ttags[currentTriangle] = 1; // mark triangle as processed
|
|
m_tmap [currentTriangle] = m_triangleCount++;
|
|
m_invTMap[m_tmap [currentTriangle]] = currentTriangle;
|
|
++processedTriangles;
|
|
break;
|
|
}
|
|
}
|
|
} while (currentIndex != -1);
|
|
}
|
|
|
|
return O3DGC_OK;
|
|
}
|
|
template <class T>
|
|
O3DGCErrorCode TriangleListEncoder<T>::CompressTFAN(const long focusVertex)
|
|
{
|
|
m_ctfans.PushNumTFans(m_tfans.GetNumTFANs());
|
|
|
|
const long ntfans = m_tfans.GetNumTFANs();
|
|
long degree;
|
|
long k0, k1;
|
|
long v0;
|
|
long ops[O3DGC_MAX_TFAN_SIZE];
|
|
long indices[O3DGC_MAX_TFAN_SIZE];
|
|
|
|
long numOps;
|
|
long numIndices;
|
|
long pos;
|
|
long found;
|
|
|
|
if (m_tfans.GetNumTFANs() > 0)
|
|
{
|
|
for(long f = 0; f != ntfans; f++)
|
|
{
|
|
degree = m_tfans.GetTFANSize(f) - 1;
|
|
m_ctfans.PushDegree(degree-2+ m_numConqueredTriangles);
|
|
numOps = 0;
|
|
numIndices = 0;
|
|
k0 = 1 + m_tfans.Begin(f);
|
|
k1 = m_tfans.End(f);
|
|
for(long k = k0; k < k1; k++)
|
|
{
|
|
v0 = m_tfans.GetVertex(k);
|
|
if (m_vtags[v0] == 0)
|
|
{
|
|
ops[numOps++] = 0;
|
|
m_vtags[v0] = 1;
|
|
m_vmap[v0] = m_vertexCount++;
|
|
m_invVMap[m_vmap[v0]] = v0;
|
|
m_vfifo.PushBack(v0);
|
|
m_visitedVertices[m_numVisitedVertices++] = m_vmap[v0];
|
|
}
|
|
else
|
|
{
|
|
ops[numOps++] = 1;
|
|
pos = 0;
|
|
found = 0;
|
|
for(long u=0; u < m_numVisitedVertices; ++u)
|
|
{
|
|
pos++;
|
|
if (m_visitedVertices[u] == m_vmap[v0])
|
|
{
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (found == 1)
|
|
{
|
|
indices[numIndices++] = -pos;
|
|
}
|
|
else
|
|
{
|
|
indices[numIndices++] = m_vmap[v0] - m_vmap[focusVertex];
|
|
}
|
|
}
|
|
}
|
|
//-----------------------------------------------
|
|
if (IsCase0(degree, numIndices, ops, indices))
|
|
{
|
|
// ops: 1000001 vertices: -1 -2
|
|
m_ctfans.PushConfig(0);
|
|
}
|
|
else if (IsCase1(degree, numIndices, ops, indices))
|
|
{
|
|
// ops: 1xxxxxx1 vertices: -1 x x x x x -2
|
|
long u = 1;
|
|
for(u = 1; u < degree-1; u++)
|
|
{
|
|
m_ctfans.PushOperation(ops[u]);
|
|
}
|
|
for(u =1; u < numIndices-1; u++)
|
|
{
|
|
m_ctfans.PushIndex(indices[u]);
|
|
}
|
|
m_ctfans.PushConfig(1);
|
|
}
|
|
else if (IsCase2(degree, numIndices, ops, indices))
|
|
{
|
|
// ops: 00000001 vertices: -1
|
|
m_ctfans.PushConfig(2);
|
|
}
|
|
else if (IsCase3(degree, numIndices, ops, indices))
|
|
{
|
|
// ops: 00000001 vertices: -2
|
|
m_ctfans.PushConfig(3);
|
|
}
|
|
else if (IsCase4(degree, numIndices, ops, indices))
|
|
{
|
|
// ops: 10000000 vertices: -1
|
|
m_ctfans.PushConfig(4);
|
|
}
|
|
else if (IsCase5(degree, numIndices, ops, indices))
|
|
{
|
|
// ops: 10000000 vertices: -2
|
|
m_ctfans.PushConfig(5);
|
|
}
|
|
else if (IsCase6(degree, numIndices, ops, indices))
|
|
{
|
|
// ops: 00000000 vertices:
|
|
m_ctfans.PushConfig(6);
|
|
}
|
|
else if (IsCase7(degree, numIndices, ops, indices))
|
|
{
|
|
// ops: 1000001 vertices: -1 -2
|
|
m_ctfans.PushConfig(7);
|
|
}
|
|
else if (IsCase8(degree, numIndices, ops, indices))
|
|
{
|
|
// ops: 1xxxxxx1 vertices: -2 x x x x x -1
|
|
long u = 1;
|
|
for(u =1; u < degree-1; u++)
|
|
{
|
|
m_ctfans.PushOperation(ops[u]);
|
|
}
|
|
for(u =1; u < numIndices-1; u++)
|
|
{
|
|
m_ctfans.PushIndex(indices[u]);
|
|
}
|
|
m_ctfans.PushConfig(8);
|
|
}
|
|
else
|
|
{
|
|
long u = 0;
|
|
for(u =0; u < degree; u++)
|
|
{
|
|
m_ctfans.PushOperation(ops[u]);
|
|
}
|
|
for(u =0; u < numIndices; u++)
|
|
{
|
|
m_ctfans.PushIndex(indices[u]);
|
|
}
|
|
m_ctfans.PushConfig(9);
|
|
}
|
|
}
|
|
}
|
|
return O3DGC_OK;
|
|
}
|
|
template <class T>
|
|
O3DGCErrorCode TriangleListEncoder<T>::ProcessVertex(const long focusVertex)
|
|
{
|
|
CompueLocalConnectivityInfo(focusVertex);
|
|
ComputeTFANDecomposition(focusVertex);
|
|
CompressTFAN(focusVertex);
|
|
return O3DGC_OK;
|
|
}
|
|
}
|
|
#endif //O3DGC_TRIANGLE_LIST_ENCODER_INL
|