/*
* Copyright (c) 2009-2010 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package jme3tools.converters.model.strip;
/**
*
*/
class StripInfo {
StripStartInfo m_startInfo;
FaceInfoVec m_faces = new FaceInfoVec();
int m_stripId;
int m_experimentId;
boolean visited;
int m_numDegenerates;
public StripInfo(StripStartInfo startInfo,int stripId, int experimentId) {
m_startInfo = startInfo;
m_stripId = stripId;
m_experimentId = experimentId;
visited = false;
m_numDegenerates = 0;
}
boolean isExperiment() {
return m_experimentId >= 0;
}
boolean isInStrip(FaceInfo faceInfo) {
if(faceInfo == null)
return false;
return (m_experimentId >= 0 ? faceInfo.m_testStripId == m_stripId : faceInfo.m_stripId == m_stripId);
}
///////////////////////////////////////////////////////////////////////////////////////////
// IsMarked()
//
// If either the faceInfo has a real strip index because it is
// already assign to a committed strip OR it is assigned in an
// experiment and the experiment index is the one we are building
// for, then it is marked and unavailable
boolean isMarked(FaceInfo faceInfo){
return (faceInfo.m_stripId >= 0) || (isExperiment() && faceInfo.m_experimentId == m_experimentId);
}
///////////////////////////////////////////////////////////////////////////////////////////
// MarkTriangle()
//
// Marks the face with the current strip ID
//
void markTriangle(FaceInfo faceInfo){
if (isExperiment()){
faceInfo.m_experimentId = m_experimentId;
faceInfo.m_testStripId = m_stripId;
}
else{
faceInfo.m_experimentId = -1;
faceInfo.m_stripId = m_stripId;
}
}
boolean unique(FaceInfoVec faceVec, FaceInfo face)
{
boolean bv0, bv1, bv2; //bools to indicate whether a vertex is in the faceVec or not
bv0 = bv1 = bv2 = false;
for(int i = 0; i < faceVec.size(); i++)
{
if(!bv0)
{
if( (faceVec.at(i).m_v0 == face.m_v0) ||
(faceVec.at(i).m_v1 == face.m_v0) ||
(faceVec.at(i).m_v2 == face.m_v0) )
bv0 = true;
}
if(!bv1)
{
if( (faceVec.at(i).m_v0 == face.m_v1) ||
(faceVec.at(i).m_v1 == face.m_v1) ||
(faceVec.at(i).m_v2 == face.m_v1) )
bv1 = true;
}
if(!bv2)
{
if( (faceVec.at(i).m_v0 == face.m_v2) ||
(faceVec.at(i).m_v1 == face.m_v2) ||
(faceVec.at(i).m_v2 == face.m_v2) )
bv2 = true;
}
//the face is not unique, all it's vertices exist in the face vector
if(bv0 && bv1 && bv2)
return false;
}
//if we get out here, it's unique
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Build()
//
// Builds a strip forward as far as we can go, then builds backwards, and joins the two lists
//
void build(EdgeInfoVec edgeInfos, FaceInfoVec faceInfos)
{
// used in building the strips forward and backward
IntVec scratchIndices = new IntVec();
// build forward... start with the initial face
FaceInfoVec forwardFaces = new FaceInfoVec();
FaceInfoVec backwardFaces = new FaceInfoVec();
forwardFaces.add(m_startInfo.m_startFace);
markTriangle(m_startInfo.m_startFace);
int v0 = (m_startInfo.m_toV1 ? m_startInfo.m_startEdge.m_v0 : m_startInfo.m_startEdge.m_v1);
int v1 = (m_startInfo.m_toV1 ? m_startInfo.m_startEdge.m_v1 : m_startInfo.m_startEdge.m_v0);
// easiest way to get v2 is to use this function which requires the
// other indices to already be in the list.
scratchIndices.add(v0);
scratchIndices.add(v1);
int v2 = Stripifier.getNextIndex(scratchIndices, m_startInfo.m_startFace);
scratchIndices.add(v2);
//
// build the forward list
//
int nv0 = v1;
int nv1 = v2;
FaceInfo nextFace = Stripifier.findOtherFace(edgeInfos, nv0, nv1, m_startInfo.m_startFace);
while (nextFace != null && !isMarked(nextFace))
{
//check to see if this next face is going to cause us to die soon
int testnv0 = nv1;
int testnv1 = Stripifier.getNextIndex(scratchIndices, nextFace);
FaceInfo nextNextFace = Stripifier.findOtherFace(edgeInfos, testnv0, testnv1, nextFace);
if( (nextNextFace == null) || (isMarked(nextNextFace)) )
{
//uh, oh, we're following a dead end, try swapping
FaceInfo testNextFace = Stripifier.findOtherFace(edgeInfos, nv0, testnv1, nextFace);
if( ((testNextFace != null) && !isMarked(testNextFace)) )
{
//we only swap if it buys us something
//add a "fake" degenerate face
FaceInfo tempFace = new FaceInfo(nv0, nv1, nv0);
forwardFaces.add(tempFace);
markTriangle(tempFace);
scratchIndices.add(nv0);
testnv0 = nv0;
++m_numDegenerates;
}
}
// add this to the strip
forwardFaces.add(nextFace);
markTriangle(nextFace);
// add the index
//nv0 = nv1;
//nv1 = NvStripifier::GetNextIndex(scratchIndices, nextFace);
scratchIndices.add(testnv1);
// and get the next face
nv0 = testnv0;
nv1 = testnv1;
nextFace = Stripifier.findOtherFace(edgeInfos, nv0, nv1, nextFace);
}
// tempAllFaces is going to be forwardFaces + backwardFaces
// it's used for Unique()
FaceInfoVec tempAllFaces = new FaceInfoVec();
for(int i = 0; i < forwardFaces.size(); i++)
tempAllFaces.add(forwardFaces.at(i));
//
// reset the indices for building the strip backwards and do so
//
scratchIndices.clear();
scratchIndices.add(v2);
scratchIndices.add(v1);
scratchIndices.add(v0);
nv0 = v1;
nv1 = v0;
nextFace = Stripifier.findOtherFace(edgeInfos, nv0, nv1, m_startInfo.m_startFace);
while (nextFace != null && !isMarked(nextFace))
{
//this tests to see if a face is "unique", meaning that its vertices aren't already in the list
// so, strips which "wrap-around" are not allowed
if(!unique(tempAllFaces, nextFace))
break;
//check to see if this next face is going to cause us to die soon
int testnv0 = nv1;
int testnv1 = Stripifier.getNextIndex(scratchIndices, nextFace);
FaceInfo nextNextFace = Stripifier.findOtherFace(edgeInfos, testnv0, testnv1, nextFace);
if( (nextNextFace == null) || (isMarked(nextNextFace)) )
{
//uh, oh, we're following a dead end, try swapping
FaceInfo testNextFace = Stripifier.findOtherFace(edgeInfos, nv0, testnv1, nextFace);
if( ((testNextFace != null) && !isMarked(testNextFace)) )
{
//we only swap if it buys us something
//add a "fake" degenerate face
FaceInfo tempFace = new FaceInfo(nv0, nv1, nv0);
backwardFaces.add(tempFace);
markTriangle(tempFace);
scratchIndices.add(nv0);
testnv0 = nv0;
++m_numDegenerates;
}
}
// add this to the strip
backwardFaces.add(nextFace);
//this is just so Unique() will work
tempAllFaces.add(nextFace);
markTriangle(nextFace);
// add the index
//nv0 = nv1;
//nv1 = NvStripifier::GetNextIndex(scratchIndices, nextFace);
scratchIndices.add(testnv1);
// and get the next face
nv0 = testnv0;
nv1 = testnv1;
nextFace = Stripifier.findOtherFace(edgeInfos, nv0, nv1, nextFace);
}
// Combine the forward and backwards stripification lists and put into our own face vector
combine(forwardFaces, backwardFaces);
}
///////////////////////////////////////////////////////////////////////////////////////////
// Combine()
//
// Combines the two input face vectors and puts the result into m_faces
//
void combine(FaceInfoVec forward, FaceInfoVec backward){
// add backward faces
int numFaces = backward.size();
for (int i = numFaces - 1; i >= 0; i--)
m_faces.add(backward.at(i));
// add forward faces
numFaces = forward.size();
for (int i = 0; i < numFaces; i++)
m_faces.add(forward.at(i));
}
///////////////////////////////////////////////////////////////////////////////////////////
// SharesEdge()
//
// Returns true if the input face and the current strip share an edge
//
boolean sharesEdge(FaceInfo faceInfo, EdgeInfoVec edgeInfos)
{
//check v0.v1 edge
EdgeInfo currEdge = Stripifier.findEdgeInfo(edgeInfos, faceInfo.m_v0, faceInfo.m_v1);
if(isInStrip(currEdge.m_face0) || isInStrip(currEdge.m_face1))
return true;
//check v1.v2 edge
currEdge = Stripifier.findEdgeInfo(edgeInfos, faceInfo.m_v1, faceInfo.m_v2);
if(isInStrip(currEdge.m_face0) || isInStrip(currEdge.m_face1))
return true;
//check v2.v0 edge
currEdge = Stripifier.findEdgeInfo(edgeInfos, faceInfo.m_v2, faceInfo.m_v0);
if(isInStrip(currEdge.m_face0) || isInStrip(currEdge.m_face1))
return true;
return false;
}
}