sigonasr2
/
jmonkeyengine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

jME3 tools: delete triangle stripper

Browse Source
experimental
shadowislord 10 years ago
parent 9759e24961
commit 8b300f5109
13 changed files with 0 additions and 2808 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 183
      jme3-core/src/tools/java/jme3tools/converters/model/ModelConverter.java
  2. 53
      jme3-core/src/tools/java/jme3tools/converters/model/strip/EdgeInfo.java
  3. 50
      jme3-core/src/tools/java/jme3tools/converters/model/strip/EdgeInfoVec.java
  4. 59
      jme3-core/src/tools/java/jme3tools/converters/model/strip/FaceInfo.java
  5. 54
      jme3-core/src/tools/java/jme3tools/converters/model/strip/FaceInfoVec.java
  6. 71
      jme3-core/src/tools/java/jme3tools/converters/model/strip/IntVec.java
  7. 107
      jme3-core/src/tools/java/jme3tools/converters/model/strip/PrimitiveGroup.java
  8. 355
      jme3-core/src/tools/java/jme3tools/converters/model/strip/StripInfo.java
  9. 51
      jme3-core/src/tools/java/jme3tools/converters/model/strip/StripInfoVec.java
  10. 49
      jme3-core/src/tools/java/jme3tools/converters/model/strip/StripStartInfo.java
  11. 1365
      jme3-core/src/tools/java/jme3tools/converters/model/strip/Stripifier.java
  12. 311
      jme3-core/src/tools/java/jme3tools/converters/model/strip/TriStrip.java
  13. 100
      jme3-core/src/tools/java/jme3tools/converters/model/strip/VertexCache.java

183
jme3-core/src/tools/java/jme3tools/converters/model/ModelConverter.java
Unescape View File

@ -1,183 +0,0 @@
/*
* Copyright (c) 2009-2012 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;
import com.jme3.scene.*;
import com.jme3.scene.Mesh.Mode;
import com.jme3.scene.VertexBuffer.Format;
import com.jme3.scene.VertexBuffer.Type;
import com.jme3.scene.mesh.IndexBuffer;
import com.jme3.util.IntMap;
import com.jme3.util.IntMap.Entry;
import java.nio.Buffer;
import java.util.Arrays;
import java.util.Comparator;
import jme3tools.converters.model.strip.PrimitiveGroup;
import jme3tools.converters.model.strip.TriStrip;
public class ModelConverter {
private static final class PrimComparator
implements Comparator<PrimitiveGroup> {
public int compare(PrimitiveGroup g1, PrimitiveGroup g2) {
if (g1.type < g2.type)
return -1;
else if (g1.type > g2.type)
return 1;
else
return 0;
}
}
private static final PrimComparator primComp = new PrimComparator();
public static void generateStrips(Mesh mesh, boolean stitch, boolean listOnly, int cacheSize, int minStripSize){
TriStrip ts = new TriStrip();
ts.setStitchStrips(stitch);
ts.setCacheSize(cacheSize);
ts.setListsOnly(listOnly);
ts.setMinStripSize(minStripSize);
IndexBuffer ib = mesh.getIndicesAsList();
int[] indices = new int[ib.size()];
for (int i = 0; i < indices.length; i++)
indices[i] = ib.get(i);
PrimitiveGroup[] groups = ts.generateStrips(indices);
Arrays.sort(groups, primComp);
int numElements = 0;
for (PrimitiveGroup group : groups)
numElements += group.numIndices;
VertexBuffer original = mesh.getBuffer(Type.Index);
Buffer buf = VertexBuffer.createBuffer(original.getFormat(),
original.getNumComponents(),
numElements);
original.updateData(buf);
ib = mesh.getIndexBuffer();
int curIndex = 0;
int[] modeStart = new int[]{ -1, -1, -1 };
int[] elementLengths = new int[groups.length];
for (int i = 0; i < groups.length; i++){
PrimitiveGroup group = groups[i];
elementLengths[i] = group.numIndices;
if (modeStart[group.type] == -1){
modeStart[group.type] = i;
}
int[] trimmedIndices = group.getTrimmedIndices();
for (int j = 0; j < trimmedIndices.length; j++){
ib.put(curIndex + j, trimmedIndices[j]);
}
curIndex += group.numIndices;
}
if (modeStart[0] == -1 && modeStart[1] == 0 && modeStart[2] == -1 &&
elementLengths.length == 1){
original.compact(elementLengths[0]);
mesh.setMode(Mode.TriangleStrip);
}else{
mesh.setElementLengths(elementLengths);
mesh.setModeStart(modeStart);
mesh.setMode(Mode.Hybrid);
}
mesh.updateCounts();
}
public static void optimize(Mesh mesh, boolean toFixed){
// update any data that need updating
mesh.updateBound();
mesh.updateCounts();
// set all buffers into STATIC_DRAW mode
mesh.setStatic();
if (mesh.getBuffer(Type.Index) != null){
// compress index buffer from UShort to UByte (if possible)
FloatToFixed.compressIndexBuffer(mesh);
// generate triangle strips stitched with degenerate tris
generateStrips(mesh, false, false, 16, 0);
}
IntMap<VertexBuffer> bufs = mesh.getBuffers();
for (Entry<VertexBuffer> entry : bufs){
VertexBuffer vb = entry.getValue();
if (vb == null || vb.getBufferType() == Type.Index)
continue;
if (vb.getFormat() == Format.Float){
if (vb.getBufferType() == Type.Color){
// convert the color buffer to UByte
vb = FloatToFixed.convertToUByte(vb);
vb.setNormalized(true);
}else if (toFixed){
// convert normals, positions, and texcoords
// to fixed-point (16.16)
vb = FloatToFixed.convertToFixed(vb);
// vb = FloatToFixed.convertToFloat(vb);
}
mesh.clearBuffer(vb.getBufferType());
mesh.setBuffer(vb);
}
}
//mesh.setInterleaved();
}
private static void optimizeScene(Spatial source, boolean toFixed){
if (source instanceof Geometry){
Geometry geom = (Geometry) source;
Mesh mesh = geom.getMesh();
optimize(mesh, toFixed);
}else if (source instanceof Node){
Node node = (Node) source;
for (int i = node.getQuantity() - 1; i >= 0; i--){
Spatial child = node.getChild(i);
optimizeScene(child, toFixed);
}
}
}
public static void optimize(Spatial source, boolean toFixed){
optimizeScene(source, toFixed);
source.updateLogicalState(0);
source.updateGeometricState();
}
}

53
jme3-core/src/tools/java/jme3tools/converters/model/strip/EdgeInfo.java
Unescape View File

@ -1,53 +0,0 @@
/*
* Copyright (c) 2009-2012 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 EdgeInfo {
FaceInfo m_face0, m_face1;
int m_v0, m_v1;
EdgeInfo m_nextV0, m_nextV1;
public EdgeInfo(int v0, int v1) {
m_v0 = v0;
m_v1 = v1;
m_face0 = null;
m_face1 = null;
m_nextV0 = null;
m_nextV1 = null;
}
}

50
jme3-core/src/tools/java/jme3tools/converters/model/strip/EdgeInfoVec.java
Unescape View File

@ -1,50 +0,0 @@
/*
* Copyright (c) 2009-2012 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;
import java.util.ArrayList;
class EdgeInfoVec extends ArrayList<EdgeInfo> {
private static final long serialVersionUID = 1L;
public EdgeInfoVec() {
super();
}
public EdgeInfo at(int index) {
return get(index);
}
}

59
jme3-core/src/tools/java/jme3tools/converters/model/strip/FaceInfo.java
Unescape View File

@ -1,59 +0,0 @@
/*
* Copyright (c) 2009-2012 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 FaceInfo {
int m_v0, m_v1, m_v2;
int m_stripId; // real strip Id
int m_testStripId; // strip Id in an experiment
int m_experimentId; // in what experiment was it given an experiment Id?
public FaceInfo(int v0, int v1, int v2){
m_v0 = v0; m_v1 = v1; m_v2 = v2;
m_stripId = -1;
m_testStripId = -1;
m_experimentId = -1;
}
public void set(FaceInfo o) {
m_v0 = o.m_v0;
m_v1 = o.m_v1;
m_v2 = o.m_v2;
m_stripId = o.m_stripId;
m_testStripId = o.m_testStripId;
m_experimentId = o.m_experimentId;
}
}

54
jme3-core/src/tools/java/jme3tools/converters/model/strip/FaceInfoVec.java
Unescape View File

@ -1,54 +0,0 @@
/*
* Copyright (c) 2009-2012 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;
import java.util.ArrayList;
class FaceInfoVec extends ArrayList<FaceInfo> {
private static final long serialVersionUID = 1L;
public FaceInfoVec() {
super();
}
public FaceInfo at(int index) {
return get(index);
}
public void reserve(int i) {
super.ensureCapacity(i);
}
}

71
jme3-core/src/tools/java/jme3tools/converters/model/strip/IntVec.java
Unescape View File

@ -1,71 +0,0 @@
/*
* Copyright (c) 2009-2012 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;
public class IntVec {
private int[] data;
private int count = 0;
public IntVec() {
data = new int[16];
}
public IntVec(int startSize) {
data = new int[startSize];
}
public int size() {
return count;
}
public int get(int i) {
return data[i];
}
public void add(int val) {
if ( count == data.length ) {
int[] ndata = new int[count*2];
System.arraycopy(data,0,ndata,0,count);
data = ndata;
}
data[count] = val;
count++;
}
public void clear() {
count = 0;
}
}

107
jme3-core/src/tools/java/jme3tools/converters/model/strip/PrimitiveGroup.java
Unescape View File

@ -1,107 +0,0 @@
/*
* Copyright (c) 2009-2012 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;
/**
*
*/
public class PrimitiveGroup {
public static final int PT_LIST = 0;
public static final int PT_STRIP = 1;
public static final int PT_FAN = 2;
public int type;
public int[] indices;
public int numIndices;
public PrimitiveGroup() {
type = PT_STRIP;
}
public String getTypeString() {
switch(type) {
case PT_LIST : return "list";
case PT_STRIP: return "strip";
case PT_FAN: return "fan";
default: return "????";
}
}
public String toString() {
return getTypeString() + " : " + numIndices;
}
public String getFullInfo() {
if ( type != PT_STRIP )
return toString();
int[] stripLengths = new int[numIndices];
int prev = -1;
int length = -1;
for ( int i =0; i < numIndices; i++) {
if (indices[i] == prev) {
stripLengths[length]++;
length = -1;
prev = -1;
} else {
prev = indices[i];
length++;
}
}
stripLengths[length]++;
StringBuffer sb = new StringBuffer();
sb.append("Strip:").append(numIndices).append("\n");
for ( int i =0; i < stripLengths.length; i++) {
if ( stripLengths[i] > 0) {
sb.append(i).append("->").append(stripLengths[i]).append("\n");
}
}
return sb.toString();
}
/**
* @return
*/
public int[] getTrimmedIndices() {
if ( indices.length == numIndices )
return indices;
int[] nind = new int[numIndices];
System.arraycopy(indices,0,nind,0,numIndices);
return nind;
}
}

355
jme3-core/src/tools/java/jme3tools/converters/model/strip/StripInfo.java
Unescape View File

@ -1,355 +0,0 @@
/*
* Copyright (c) 2009-2012 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;
}
}

51
jme3-core/src/tools/java/jme3tools/converters/model/strip/StripInfoVec.java
Unescape View File

@ -1,51 +0,0 @@
/*
* Copyright (c) 2009-2012 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;
import java.util.ArrayList;
class StripInfoVec extends ArrayList<StripInfo> {
private static final long serialVersionUID = 1L;
public StripInfoVec() {
super();
}
public StripInfo at(int index) {
return get(index);
}
}

49
jme3-core/src/tools/java/jme3tools/converters/model/strip/StripStartInfo.java
Unescape View File

@ -1,49 +0,0 @@
/*
* Copyright (c) 2009-2012 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 StripStartInfo {
FaceInfo m_startFace;
EdgeInfo m_startEdge;
boolean m_toV1;
public StripStartInfo(FaceInfo startFace, EdgeInfo startEdge, boolean toV1){
m_startFace = startFace;
m_startEdge = startEdge;
m_toV1 = toV1;
}
}

1365
jme3-core/src/tools/java/jme3tools/converters/model/strip/Stripifier.java
View File

File diff suppressed because it is too large Load Diff

311
jme3-core/src/tools/java/jme3tools/converters/model/strip/TriStrip.java
Unescape View File

@ -1,311 +0,0 @@
/*
* Copyright (c) 2009-2012 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;
import java.util.Arrays;
/**
* To use, call generateStrips method, passing your triangle index list and
* then construct geometry/render resulting PrimitiveGroup objects.
* Features:
* <ul>
* <li>generates strips from arbitrary geometry.
* <li>flexibly optimizes for post TnL vertex caches (16 on GeForce1/2, 24 on GeForce3).
* <li>can stitch together strips using degenerate triangles, or not.
* <li>can output lists instead of strips.
* <li>can optionally throw excessively small strips into a list instead.
* <li>can remap indices to improve spatial locality in your vertex buffers.
* </ul>
* On cache sizes: Note that it's better to UNDERESTIMATE the cache size
* instead of OVERESTIMATING. So, if you're targetting GeForce1, 2, and 3, be
* conservative and use the GeForce1_2 cache size, NOT the GeForce3 cache size.
* This will make sure you don't "blow" the cache of the GeForce1 and 2. Also
* note that the cache size you specify is the "actual" cache size, not the
* "effective" cache size you may have heard about. This is 16 for GeForce1 and 2,
* and 24 for GeForce3.
*
* Credit goes to Curtis Beeson and Joe Demers for the basis for this
* stripifier and to Jason Regier and Jon Stone at Blizzard for providing a
* much cleaner version of CreateStrips().
*
* Ported to java by Artur Biesiadowski <abies@pg.gda.pl>
*/
public class TriStrip {
public static final int CACHESIZE_GEFORCE1_2 = 16;
public static final int CACHESIZE_GEFORCE3 = 24;
int cacheSize = CACHESIZE_GEFORCE1_2;
boolean bStitchStrips = true;
int minStripSize = 0;
boolean bListsOnly = false;
/**
*
*/
public TriStrip() {
super();
}
/**
* If set to true, will return an optimized list, with no strips at all.
* Default value: false
*/
public void setListsOnly(boolean _bListsOnly) {
bListsOnly = _bListsOnly;
}
/**
* Sets the cache size which the stripfier uses to optimize the data.
* Controls the length of the generated individual strips. This is the
* "actual" cache size, so 24 for GeForce3 and 16 for GeForce1/2 You may
* want to play around with this number to tweak performance. Default
* value: 16
*/
public void setCacheSize(int _cacheSize) {
cacheSize = _cacheSize;
}
/**
* bool to indicate whether to stitch together strips into one huge strip
* or not. If set to true, you'll get back one huge strip stitched together
* using degenerate triangles. If set to false, you'll get back a large
* number of separate strips. Default value: true
*/
public void setStitchStrips(boolean _bStitchStrips) {
bStitchStrips = _bStitchStrips;
}
/**
* Sets the minimum acceptable size for a strip, in triangles. All strips
* generated which are shorter than this will be thrown into one big,
* separate list. Default value: 0
*/
public void setMinStripSize(int _minStripSize) {
minStripSize = _minStripSize;
}
/**
* @param in_indices
* input index list, the indices you would use to render
* @return array of optimized/stripified PrimitiveGroups
*/
public PrimitiveGroup[] generateStrips(int[] in_indices) {
int numGroups = 0;
PrimitiveGroup[] primGroups;
//put data in format that the stripifier likes
IntVec tempIndices = new IntVec();
int maxIndex = 0;
for (int i = 0; i < in_indices.length; i++) {
tempIndices.add(in_indices[i]);
if (in_indices[i] > maxIndex)
maxIndex = in_indices[i];
}
StripInfoVec tempStrips = new StripInfoVec();
FaceInfoVec tempFaces = new FaceInfoVec();
Stripifier stripifier = new Stripifier();
//do actual stripification
stripifier.stripify(tempIndices, cacheSize, minStripSize, maxIndex, tempStrips, tempFaces);
//stitch strips together
IntVec stripIndices = new IntVec();
int numSeparateStrips = 0;
if (bListsOnly) {
//if we're outputting only lists, we're done
numGroups = 1;
primGroups = new PrimitiveGroup[numGroups];
primGroups[0] = new PrimitiveGroup();
PrimitiveGroup[] primGroupArray = primGroups;
//count the total number of indices
int numIndices = 0;
for (int i = 0; i < tempStrips.size(); i++) {
numIndices += tempStrips.at(i).m_faces.size() * 3;
}
//add in the list
numIndices += tempFaces.size() * 3;
primGroupArray[0].type = PrimitiveGroup.PT_LIST;
primGroupArray[0].indices = new int[numIndices];
primGroupArray[0].numIndices = numIndices;
//do strips
int indexCtr = 0;
for (int i = 0; i < tempStrips.size(); i++) {
for (int j = 0; j < tempStrips.at(i).m_faces.size(); j++) {
//degenerates are of no use with lists
if (!Stripifier.isDegenerate(tempStrips.at(i).m_faces.at(j))) {
primGroupArray[0].indices[indexCtr++] = tempStrips.at(i).m_faces.at(j).m_v0;
primGroupArray[0].indices[indexCtr++] = tempStrips.at(i).m_faces.at(j).m_v1;
primGroupArray[0].indices[indexCtr++] = tempStrips.at(i).m_faces.at(j).m_v2;
} else {
//we've removed a tri, reduce the number of indices
primGroupArray[0].numIndices -= 3;
}
}
}
//do lists
for (int i = 0; i < tempFaces.size(); i++) {
primGroupArray[0].indices[indexCtr++] = tempFaces.at(i).m_v0;
primGroupArray[0].indices[indexCtr++] = tempFaces.at(i).m_v1;
primGroupArray[0].indices[indexCtr++] = tempFaces.at(i).m_v2;
}
} else {
numSeparateStrips = stripifier.createStrips(tempStrips, stripIndices, bStitchStrips);
//if we're stitching strips together, we better get back only one
// strip from CreateStrips()
//convert to output format
numGroups = numSeparateStrips; //for the strips
if (tempFaces.size() != 0)
numGroups++; //we've got a list as well, increment
primGroups = new PrimitiveGroup[numGroups];
for (int i = 0; i < primGroups.length; i++) {
primGroups[i] = new PrimitiveGroup();
}
PrimitiveGroup[] primGroupArray = primGroups;
//first, the strips
int startingLoc = 0;
for (int stripCtr = 0; stripCtr < numSeparateStrips; stripCtr++) {
int stripLength = 0;
if (!bStitchStrips) {
int i;
//if we've got multiple strips, we need to figure out the
// correct length
for (i = startingLoc; i < stripIndices.size(); i++) {
if (stripIndices.get(i) == -1)
break;
}
stripLength = i - startingLoc;
} else
stripLength = stripIndices.size();
primGroupArray[stripCtr].type = PrimitiveGroup.PT_STRIP;
primGroupArray[stripCtr].indices = new int[stripLength];
primGroupArray[stripCtr].numIndices = stripLength;
int indexCtr = 0;
for (int i = startingLoc; i < stripLength + startingLoc; i++)
primGroupArray[stripCtr].indices[indexCtr++] = stripIndices.get(i);
//we add 1 to account for the -1 separating strips
//this doesn't break the stitched case since we'll exit the
// loop
startingLoc += stripLength + 1;
}
//next, the list
if (tempFaces.size() != 0) {
int faceGroupLoc = numGroups - 1; //the face group is the last
// one
primGroupArray[faceGroupLoc].type = PrimitiveGroup.PT_LIST;
primGroupArray[faceGroupLoc].indices = new int[tempFaces.size() * 3];
primGroupArray[faceGroupLoc].numIndices = tempFaces.size() * 3;
int indexCtr = 0;
for (int i = 0; i < tempFaces.size(); i++) {
primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces.at(i).m_v0;
primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces.at(i).m_v1;
primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces.at(i).m_v2;
}
}
}
return primGroups;
}
/**
* Function to remap your indices to improve spatial locality in your
* vertex buffer.
*
* in_primGroups: array of PrimitiveGroups you want remapped numGroups:
* number of entries in in_primGroups numVerts: number of vertices in your
* vertex buffer, also can be thought of as the range of acceptable values
* for indices in your primitive groups. remappedGroups: array of remapped
* PrimitiveGroups
*
* Note that, according to the remapping handed back to you, you must
* reorder your vertex buffer.
*
*/
public static int[] remapIndices(int[] indices, int numVerts) {
int[] indexCache = new int[numVerts];
Arrays.fill(indexCache, -1);
int numIndices = indices.length;
int[] remappedIndices = new int[numIndices];
int indexCtr = 0;
for (int j = 0; j < numIndices; j++) {
int cachedIndex = indexCache[indices[j]];
if (cachedIndex == -1) //we haven't seen this index before
{
//point to "last" vertex in VB
remappedIndices[j] = indexCtr;
//add to index cache, increment
indexCache[indices[j]] = indexCtr++;
} else {
//we've seen this index before
remappedIndices[j] = cachedIndex;
}
}
return remappedIndices;
}
public static void remapArrays(float[] vertexBuffer, int vertexSize, int[] indices) {
int[] remapped = remapIndices(indices, vertexBuffer.length / vertexSize);
float[] bufferCopy = vertexBuffer.clone();
for (int i = 0; i < remapped.length; i++) {
int from = indices[i] * vertexSize;
int to = remapped[i] * vertexSize;
for (int j = 0; j < vertexSize; j++) {
vertexBuffer[to + j] = bufferCopy[from + j];
}
}
System.arraycopy(remapped, 0, indices, 0, indices.length);
}
}

100
jme3-core/src/tools/java/jme3tools/converters/model/strip/VertexCache.java
Unescape View File

@ -1,100 +0,0 @@
/*
* Copyright (c) 2009-2012 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;
import java.util.Arrays;
class VertexCache {
int[] entries;
int numEntries;
public VertexCache() {
this(16);
}
public VertexCache(int size) {
numEntries = size;
entries = new int[numEntries];
clear();
}
public boolean inCache(int entry) {
for(int i = 0; i < numEntries; i++)
{
if(entries[i] == entry)
{
return true;
}
}
return false;
}
public int addEntry(int entry) {
int removed;
removed = entries[numEntries - 1];
//push everything right one
for(int i = numEntries - 2; i >= 0; i--)
{
entries[i + 1] = entries[i];
}
entries[0] = entry;
return removed;
}
public void clear() {
Arrays.fill(entries,-1);
}
public int at(int index) {
return entries[index];
}
public void set(int index, int value) {
entries[index] = value;
}
public void copy(VertexCache inVcache)
{
for(int i = 0; i < numEntries; i++)
{
inVcache.set(i, entries[i]);
}
}
}
Write Preview
Loading…
Cancel
Save