jmekaelthas
10 years ago
parent
73b7061b0b
commit
f364d66640
@ -0,0 +1,530 @@ |
||||
package com.jme3.scene.plugins.blender.modifiers; |
||||
|
||||
import java.util.ArrayList; |
||||
import java.util.Arrays; |
||||
import java.util.HashMap; |
||||
import java.util.HashSet; |
||||
import java.util.List; |
||||
import java.util.Map; |
||||
import java.util.Map.Entry; |
||||
import java.util.Set; |
||||
import java.util.logging.Level; |
||||
import java.util.logging.Logger; |
||||
|
||||
import com.jme3.math.Vector2f; |
||||
import com.jme3.math.Vector3f; |
||||
import com.jme3.scene.Node; |
||||
import com.jme3.scene.plugins.blender.BlenderContext; |
||||
import com.jme3.scene.plugins.blender.file.BlenderFileException; |
||||
import com.jme3.scene.plugins.blender.file.Structure; |
||||
import com.jme3.scene.plugins.blender.meshes.Edge; |
||||
import com.jme3.scene.plugins.blender.meshes.Face; |
||||
import com.jme3.scene.plugins.blender.meshes.TemporalMesh; |
||||
import com.jme3.scene.plugins.blender.textures.TexturePixel; |
||||
|
||||
/** |
||||
* A modifier that subdivides the mesh using either simple or catmull-clark subdivision. |
||||
* |
||||
* @author Marcin Roguski (Kaelthas) |
||||
*/ |
||||
public class SubdivisionSurfaceModifier extends Modifier { |
||||
private static final Logger LOGGER = Logger.getLogger(SubdivisionSurfaceModifier.class.getName()); |
||||
|
||||
private static final int TYPE_CATMULLCLARK = 0; |
||||
private static final int TYPE_SIMPLE = 1; |
||||
|
||||
private static final int FLAG_SUBDIVIDE_UVS = 0x8; |
||||
|
||||
/** The subdivision type. */ |
||||
private int subdivType; |
||||
/** The amount of subdivision levels. */ |
||||
private int levels; |
||||
/** Indicates if the UV's should also be subdivided. */ |
||||
private boolean subdivideUVS; |
||||
|
||||
/** |
||||
* Constructor loads all neccessary modifier data. |
||||
* @param modifierStructure |
||||
* the modifier structure |
||||
* @param blenderContext |
||||
* the blender context |
||||
*/ |
||||
public SubdivisionSurfaceModifier(Structure modifierStructure, BlenderContext blenderContext) { |
||||
if (this.validate(modifierStructure, blenderContext)) { |
||||
subdivType = ((Number) modifierStructure.getFieldValue("subdivType")).intValue(); |
||||
levels = ((Number) modifierStructure.getFieldValue("levels")).intValue(); |
||||
int flag = ((Number) modifierStructure.getFieldValue("flags")).intValue(); |
||||
subdivideUVS = (flag & FLAG_SUBDIVIDE_UVS) != 0 && subdivType == TYPE_CATMULLCLARK; |
||||
|
||||
if (subdivType != TYPE_CATMULLCLARK && subdivType != TYPE_SIMPLE) { |
||||
LOGGER.log(Level.SEVERE, "Unknown subdivision type: {0}.", subdivType); |
||||
invalid = true; |
||||
} |
||||
if (levels < 0) { |
||||
LOGGER.severe("The amount of subdivision levels cannot be negative."); |
||||
invalid = true; |
||||
} |
||||
} |
||||
} |
||||
|
||||
@Override |
||||
public void apply(Node node, BlenderContext blenderContext) { |
||||
if (invalid) { |
||||
LOGGER.log(Level.WARNING, "Subdivision surface modifier is invalid! Cannot be applied to: {0}", node.getName()); |
||||
} else if (levels > 0) {// no need to do anything if the levels is set to zero
|
||||
TemporalMesh temporalMesh = this.getTemporalMesh(node); |
||||
if (temporalMesh != null) { |
||||
LOGGER.log(Level.FINE, "Applying subdivision surface modifier to: {0}", temporalMesh); |
||||
if (subdivType == TYPE_CATMULLCLARK) { |
||||
for (int i = 0; i < levels; ++i) { |
||||
this.subdivideSimple(temporalMesh);// first do simple subdivision ...
|
||||
this.subdivideCatmullClark(temporalMesh);// ... and then apply Catmull-Clark algorithm
|
||||
if (subdivideUVS) {// UV's can be subdivided only for Catmull-Clark subdivision algorithm
|
||||
this.subdivideUVs(temporalMesh); |
||||
} |
||||
} |
||||
} else { |
||||
for (int i = 0; i < levels; ++i) { |
||||
this.subdivideSimple(temporalMesh); |
||||
} |
||||
} |
||||
} else { |
||||
LOGGER.log(Level.WARNING, "Cannot find temporal mesh for node: {0}. The modifier will NOT be applied!", node); |
||||
} |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Catmull-Clark subdivision. It assumes that the mesh was already simple-subdivided. |
||||
* @param temporalMesh |
||||
* the mesh whose vertices will be transformed to form Catmull-Clark subdivision |
||||
*/ |
||||
private void subdivideCatmullClark(TemporalMesh temporalMesh) { |
||||
Set<Integer> boundaryVertices = new HashSet<Integer>(); |
||||
for (Face face : temporalMesh.getFaces()) { |
||||
for (Integer index : face.getIndexes()) { |
||||
if (temporalMesh.isBoundary(index)) { |
||||
boundaryVertices.add(index); |
||||
} |
||||
} |
||||
} |
||||
|
||||
Vector3f[] averageVert = new Vector3f[temporalMesh.getVertices().size()]; |
||||
int[] averageCount = new int[temporalMesh.getVertices().size()]; |
||||
|
||||
for (Face face : temporalMesh.getFaces()) { |
||||
Vector3f centroid = face.computeCentroid(); |
||||
|
||||
for (Integer index : face.getIndexes()) { |
||||
if (boundaryVertices.contains(index)) { |
||||
Edge edge = this.findEdge(temporalMesh, index, face.getIndexes().getNextIndex(index)); |
||||
if (temporalMesh.isBoundary(edge)) { |
||||
averageVert[index] = averageVert[index] == null ? edge.computeCentroid() : averageVert[index].addLocal(edge.computeCentroid()); |
||||
averageCount[index] += 1; |
||||
} |
||||
edge = this.findEdge(temporalMesh, face.getIndexes().getPreviousIndex(index), index); |
||||
if (temporalMesh.isBoundary(edge)) { |
||||
averageVert[index] = averageVert[index] == null ? edge.computeCentroid() : averageVert[index].addLocal(edge.computeCentroid()); |
||||
averageCount[index] += 1; |
||||
} |
||||
} else { |
||||
averageVert[index] = averageVert[index] == null ? centroid.clone() : averageVert[index].addLocal(centroid); |
||||
averageCount[index] += 1; |
||||
} |
||||
} |
||||
} |
||||
for (Edge edge : temporalMesh.getEdges()) { |
||||
if (!edge.isInFace()) { |
||||
Vector3f centroid = temporalMesh.getVertices().get(edge.getFirstIndex()).add(temporalMesh.getVertices().get(edge.getSecondIndex())).divideLocal(2); |
||||
|
||||
averageVert[edge.getFirstIndex()] = averageVert[edge.getFirstIndex()] == null ? centroid.clone() : averageVert[edge.getFirstIndex()].addLocal(centroid); |
||||
averageVert[edge.getSecondIndex()] = averageVert[edge.getSecondIndex()] == null ? centroid.clone() : averageVert[edge.getSecondIndex()].addLocal(centroid); |
||||
averageCount[edge.getSecondIndex()] += 2; |
||||
} |
||||
} |
||||
|
||||
for (int i = 0; i < averageVert.length; ++i) { |
||||
averageVert[i].divideLocal(averageCount[i]); |
||||
if (!boundaryVertices.contains(i)) { |
||||
temporalMesh.getVertices().get(i).addLocal(averageVert[i].subtract(temporalMesh.getVertices().get(i)).multLocal(4 / (float) averageCount[i])); |
||||
} else { |
||||
temporalMesh.getVertices().get(i).set(averageVert[i]); |
||||
} |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* The method performs a simple subdivision of the mesh. |
||||
* |
||||
* @param temporalMesh |
||||
* the mesh to be subdivided |
||||
*/ |
||||
@SuppressWarnings("unchecked") |
||||
private void subdivideSimple(TemporalMesh temporalMesh) { |
||||
Map<Edge, Integer> edgePoints = new HashMap<Edge, Integer>(); |
||||
Map<Face, Integer> facePoints = new HashMap<Face, Integer>(); |
||||
List<Face> newFaces = new ArrayList<Face>(); |
||||
|
||||
int originalFacesCount = temporalMesh.getFaces().size(); |
||||
|
||||
List<Map<String, Float>> vertexGroups = temporalMesh.getVertexGroups(); |
||||
// the result vertex array will have verts in the following order [[original_verts], [face_verts], [edge_verts]]
|
||||
List<Vector3f> vertices = temporalMesh.getVertices(); |
||||
List<Vector3f> edgeVertices = new ArrayList<Vector3f>(); |
||||
List<Vector3f> faceVertices = new ArrayList<Vector3f>(); |
||||
// the same goes for normals
|
||||
List<Vector3f> normals = temporalMesh.getNormals(); |
||||
List<Vector3f> edgeNormals = new ArrayList<Vector3f>(); |
||||
List<Vector3f> faceNormals = new ArrayList<Vector3f>(); |
||||
|
||||
List<Face> faces = temporalMesh.getFaces(); |
||||
for (Face face : faces) { |
||||
Map<String, List<Vector2f>> uvSets = face.getUvSets(); |
||||
|
||||
Vector3f facePoint = face.computeCentroid(); |
||||
Integer facePointIndex = vertices.size() + faceVertices.size(); |
||||
facePoints.put(face, facePointIndex); |
||||
faceVertices.add(facePoint); |
||||
faceNormals.add(this.computeFaceNormal(face)); |
||||
Map<String, Vector2f> faceUV = this.computeFaceUVs(face); |
||||
byte[] faceVertexColor = this.computeFaceVertexColor(face); |
||||
Map<String, Float> faceVertexGroups = this.computeFaceVertexGroups(face); |
||||
if (vertexGroups.size() > 0) { |
||||
vertexGroups.add(faceVertexGroups); |
||||
} |
||||
|
||||
for (int i = 0; i < face.getIndexes().size(); ++i) { |
||||
int vIndex = face.getIndexes().get(i); |
||||
int vPrevIndex = i == 0 ? face.getIndexes().get(face.getIndexes().size() - 1) : face.getIndexes().get(i - 1); |
||||
int vNextIndex = i == face.getIndexes().size() - 1 ? face.getIndexes().get(0) : face.getIndexes().get(i + 1); |
||||
|
||||
Edge prevEdge = this.findEdge(temporalMesh, vPrevIndex, vIndex);// new Edge(vPrevIndex, vIndex, 0, true, temporalMesh.getVertices());
|
||||
Edge nextEdge = this.findEdge(temporalMesh, vIndex, vNextIndex);// new Edge(vIndex, vNextIndex, 0, true, temporalMesh.getVertices());
|
||||
int vPrevEdgeVertIndex = edgePoints.containsKey(prevEdge) ? edgePoints.get(prevEdge) : -1; |
||||
int vNextEdgeVertIndex = edgePoints.containsKey(nextEdge) ? edgePoints.get(nextEdge) : -1; |
||||
|
||||
Vector3f v = temporalMesh.getVertices().get(vIndex); |
||||
if (vPrevEdgeVertIndex < 0) { |
||||
vPrevEdgeVertIndex = vertices.size() + originalFacesCount + edgeVertices.size(); |
||||
edgeVertices.add(vertices.get(vPrevIndex).add(v).divideLocal(2)); |
||||
edgeNormals.add(normals.get(vPrevIndex).add(normals.get(vIndex)).normalizeLocal()); |
||||
edgePoints.put(prevEdge, vPrevEdgeVertIndex); |
||||
if (vertexGroups.size() > 0) { |
||||
vertexGroups.add(this.interpolateVertexGroups(Arrays.asList(vertexGroups.get(vPrevIndex), vertexGroups.get(vIndex)))); |
||||
} |
||||
} |
||||
if (vNextEdgeVertIndex < 0) { |
||||
vNextEdgeVertIndex = vertices.size() + originalFacesCount + edgeVertices.size(); |
||||
edgeVertices.add(vertices.get(vNextIndex).add(v).divideLocal(2)); |
||||
edgeNormals.add(normals.get(vNextIndex).add(normals.get(vIndex)).normalizeLocal()); |
||||
edgePoints.put(nextEdge, vNextEdgeVertIndex); |
||||
if (vertexGroups.size() > 0) { |
||||
vertexGroups.add(this.interpolateVertexGroups(Arrays.asList(vertexGroups.get(vNextIndex), vertexGroups.get(vIndex)))); |
||||
} |
||||
} |
||||
|
||||
Integer[] indexes = new Integer[] { vIndex, vNextEdgeVertIndex, facePointIndex, vPrevEdgeVertIndex }; |
||||
|
||||
Map<String, List<Vector2f>> newUVSets = null; |
||||
if (uvSets != null) { |
||||
newUVSets = new HashMap<String, List<Vector2f>>(uvSets.size()); |
||||
for (Entry<String, List<Vector2f>> uvset : uvSets.entrySet()) { |
||||
int indexOfvIndex = i; |
||||
int indexOfvPrevIndex = face.getIndexes().indexOf(vPrevIndex); |
||||
int indexOfvNextIndex = face.getIndexes().indexOf(vNextIndex); |
||||
|
||||
Vector2f uv1 = uvset.getValue().get(indexOfvIndex); |
||||
Vector2f uv2 = uvset.getValue().get(indexOfvNextIndex).add(uv1).divideLocal(2); |
||||
Vector2f uv3 = faceUV.get(uvset.getKey()); |
||||
Vector2f uv4 = uvset.getValue().get(indexOfvPrevIndex).add(uv1).divideLocal(2); |
||||
List<Vector2f> uvList = Arrays.asList(uv1, uv2, uv3, uv4); |
||||
newUVSets.put(uvset.getKey(), new ArrayList<Vector2f>(uvList)); |
||||
} |
||||
} |
||||
|
||||
List<byte[]> vertexColors = null; |
||||
if (face.getVertexColors() != null) { |
||||
|
||||
int indexOfvIndex = i; |
||||
int indexOfvPrevIndex = face.getIndexes().indexOf(vPrevIndex); |
||||
int indexOfvNextIndex = face.getIndexes().indexOf(vNextIndex); |
||||
|
||||
byte[] vCol1 = face.getVertexColors().get(indexOfvIndex); |
||||
byte[] vCol2 = this.interpolateVertexColors(face.getVertexColors().get(indexOfvNextIndex), vCol1); |
||||
byte[] vCol3 = faceVertexColor; |
||||
byte[] vCol4 = this.interpolateVertexColors(face.getVertexColors().get(indexOfvPrevIndex), vCol1); |
||||
vertexColors = new ArrayList<byte[]>(Arrays.asList(vCol1, vCol2, vCol3, vCol4)); |
||||
} |
||||
|
||||
newFaces.add(new Face(indexes, face.isSmooth(), face.getMaterialNumber(), newUVSets, vertexColors, temporalMesh)); |
||||
} |
||||
} |
||||
|
||||
vertices.addAll(faceVertices); |
||||
vertices.addAll(edgeVertices); |
||||
normals.addAll(faceNormals); |
||||
normals.addAll(edgeNormals); |
||||
|
||||
List<Edge> newEdges = new ArrayList<Edge>(temporalMesh.getEdges().size() * 2); |
||||
for (Edge edge : temporalMesh.getEdges()) { |
||||
if (!edge.isInFace()) { |
||||
int newVertexIndex = vertices.size(); |
||||
vertices.add(vertices.get(edge.getFirstIndex()).add(vertices.get(edge.getSecondIndex())).divideLocal(2)); |
||||
normals.add(normals.get(edge.getFirstIndex()).add(normals.get(edge.getSecondIndex())).normalizeLocal()); |
||||
|
||||
newEdges.add(new Edge(edge.getFirstIndex(), newVertexIndex, 0, false, vertices)); |
||||
newEdges.add(new Edge(newVertexIndex, edge.getSecondIndex(), 0, false, vertices)); |
||||
} else { |
||||
Integer edgePoint = edgePoints.get(edge); |
||||
newEdges.add(new Edge(edge.getFirstIndex(), edgePoint, edge.getCrease(), true, vertices)); |
||||
newEdges.add(new Edge(edgePoint, edge.getSecondIndex(), edge.getCrease(), true, vertices)); |
||||
// adding edges between face points and edge points
|
||||
List<Face> facesContainingTheEdge = temporalMesh.getAdjacentFaces(edge); |
||||
for (Face f : facesContainingTheEdge) { |
||||
newEdges.add(new Edge(facePoints.get(f), edgePoint, 0, true, vertices)); |
||||
} |
||||
} |
||||
} |
||||
|
||||
temporalMesh.getFaces().clear(); |
||||
temporalMesh.getFaces().addAll(newFaces); |
||||
temporalMesh.getEdges().clear(); |
||||
temporalMesh.getEdges().addAll(newEdges); |
||||
|
||||
temporalMesh.rebuildIndexesMappings(); |
||||
} |
||||
|
||||
/** |
||||
* The method subdivides mesh's UV coordinates. It actually performs only Catmull-Clark modifications because if any UV's are present then they are |
||||
* automatically subdivided by the simple algorithm. |
||||
* @param temporalMesh |
||||
* the mesh whose UV coordinates will be applied Catmull-Clark algorithm |
||||
*/ |
||||
private void subdivideUVs(TemporalMesh temporalMesh) { |
||||
List<Face> faces = temporalMesh.getFaces(); |
||||
Map<String, UvCoordsSubdivideTemporalMesh> subdividedUVS = new HashMap<String, UvCoordsSubdivideTemporalMesh>(); |
||||
for (Face face : faces) { |
||||
if (face.getUvSets() != null) { |
||||
for (Entry<String, List<Vector2f>> uvset : face.getUvSets().entrySet()) { |
||||
UvCoordsSubdivideTemporalMesh uvCoordsSubdivideTemporalMesh = subdividedUVS.get(uvset.getKey()); |
||||
if (uvCoordsSubdivideTemporalMesh == null) { |
||||
try { |
||||
uvCoordsSubdivideTemporalMesh = new UvCoordsSubdivideTemporalMesh(temporalMesh.getBlenderContext()); |
||||
} catch (BlenderFileException e) { |
||||
assert false : "Something went really wrong! The UvCoordsSubdivideTemporalMesh class should NOT throw exceptions here!"; |
||||
} |
||||
subdividedUVS.put(uvset.getKey(), uvCoordsSubdivideTemporalMesh); |
||||
} |
||||
uvCoordsSubdivideTemporalMesh.addFace(uvset.getValue()); |
||||
} |
||||
} |
||||
} |
||||
|
||||
for (Entry<String, UvCoordsSubdivideTemporalMesh> entry : subdividedUVS.entrySet()) { |
||||
entry.getValue().rebuildIndexesMappings(); |
||||
this.subdivideCatmullClark(entry.getValue()); |
||||
|
||||
for (int i = 0; i < faces.size(); ++i) { |
||||
List<Vector2f> uvs = faces.get(i).getUvSets().get(entry.getKey()); |
||||
if (uvs != null) { |
||||
uvs.clear(); |
||||
uvs.addAll(entry.getValue().faceToUVs(i)); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* The method computes the face's normal vector. |
||||
* @param face |
||||
* the face of the mesh |
||||
* @return face's normal vector |
||||
*/ |
||||
private Vector3f computeFaceNormal(Face face) { |
||||
Vector3f result = new Vector3f(); |
||||
for (Integer index : face.getIndexes()) { |
||||
result.addLocal(face.getTemporalMesh().getNormals().get(index)); |
||||
} |
||||
result.divideLocal(face.getIndexes().size()); |
||||
return result; |
||||
} |
||||
|
||||
/** |
||||
* The method computes the UV coordinates of the face middle point. |
||||
* @param face |
||||
* the face of the mesh |
||||
* @return a map whose key is the name of the UV set and value is the UV coordinate of the face's middle point |
||||
*/ |
||||
private Map<String, Vector2f> computeFaceUVs(Face face) { |
||||
Map<String, Vector2f> result = null; |
||||
|
||||
Map<String, List<Vector2f>> uvSets = face.getUvSets(); |
||||
if (uvSets != null && uvSets.size() > 0) { |
||||
result = new HashMap<String, Vector2f>(uvSets.size()); |
||||
|
||||
for (Entry<String, List<Vector2f>> entry : uvSets.entrySet()) { |
||||
Vector2f faceUV = new Vector2f(); |
||||
for (Vector2f uv : entry.getValue()) { |
||||
faceUV.addLocal(uv); |
||||
} |
||||
faceUV.divideLocal(entry.getValue().size()); |
||||
result.put(entry.getKey(), faceUV); |
||||
} |
||||
} |
||||
|
||||
return result; |
||||
} |
||||
|
||||
/** |
||||
* The mesh interpolates the values of vertex groups weights for new vertices. |
||||
* @param vertexGroups |
||||
* the vertex groups |
||||
* @return interpolated weights of given vertex groups' weights |
||||
*/ |
||||
private Map<String, Float> interpolateVertexGroups(List<Map<String, Float>> vertexGroups) { |
||||
Map<String, Float> weightSums = new HashMap<String, Float>(); |
||||
if (vertexGroups.size() > 0) { |
||||
for (Map<String, Float> vGroup : vertexGroups) { |
||||
for (Entry<String, Float> entry : vGroup.entrySet()) { |
||||
if (weightSums.containsKey(entry.getKey())) { |
||||
weightSums.put(entry.getKey(), weightSums.get(entry.getKey()) + entry.getValue()); |
||||
} else { |
||||
weightSums.put(entry.getKey(), entry.getValue()); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
Map<String, Float> result = new HashMap<String, Float>(weightSums.size()); |
||||
for (Entry<String, Float> entry : weightSums.entrySet()) { |
||||
result.put(entry.getKey(), entry.getValue() / vertexGroups.size()); |
||||
} |
||||
|
||||
return result; |
||||
} |
||||
|
||||
/** |
||||
* The method computes the vertex groups values for face's middle point. |
||||
* @param face |
||||
* the face of the mesh |
||||
* @return face's middle point interpolated vertex groups' weights |
||||
*/ |
||||
private Map<String, Float> computeFaceVertexGroups(Face face) { |
||||
if (face.getTemporalMesh().getVertexGroups().size() > 0) { |
||||
List<Map<String, Float>> vertexGroups = new ArrayList<Map<String, Float>>(face.getIndexes().size()); |
||||
for (Integer index : face.getIndexes()) { |
||||
vertexGroups.add(face.getTemporalMesh().getVertexGroups().get(index)); |
||||
} |
||||
return this.interpolateVertexGroups(vertexGroups); |
||||
} |
||||
return new HashMap<String, Float>(); |
||||
} |
||||
|
||||
/** |
||||
* The method computes face's middle point vertex color. |
||||
* @param face |
||||
* the face of the mesh |
||||
* @return face's middle point vertex color |
||||
*/ |
||||
private byte[] computeFaceVertexColor(Face face) { |
||||
if (face.getVertexColors() != null) { |
||||
return this.interpolateVertexColors(face.getVertexColors().toArray(new byte[face.getVertexColors().size()][])); |
||||
} |
||||
return null; |
||||
} |
||||
|
||||
/** |
||||
* The method computes the average value for the given vertex colors. |
||||
* @param colors |
||||
* the vertex colors |
||||
* @return vertex colors' average value |
||||
*/ |
||||
private byte[] interpolateVertexColors(byte[]... colors) { |
||||
TexturePixel pixel = new TexturePixel(); |
||||
TexturePixel temp = new TexturePixel(); |
||||
for (int i = 0; i < colors.length; ++i) { |
||||
temp.fromARGB8(colors[i][3], colors[i][0], colors[i][1], colors[i][2]); |
||||
pixel.add(temp); |
||||
} |
||||
pixel.divide(colors.length); |
||||
byte[] result = new byte[4]; |
||||
pixel.toRGBA8(result); |
||||
return result; |
||||
} |
||||
|
||||
/** |
||||
* The method finds an edge between the given vertices in the mesh. |
||||
* @param temporalMesh |
||||
* the mesh |
||||
* @param index1 |
||||
* first index of the edge |
||||
* @param index2 |
||||
* second index of the edge |
||||
* @return found edge or null |
||||
*/ |
||||
private Edge findEdge(TemporalMesh temporalMesh, int index1, int index2) { |
||||
for (Edge edge : temporalMesh.getEdges()) { |
||||
if (edge.getFirstIndex() == index1 && edge.getSecondIndex() == index2 || edge.getFirstIndex() == index2 && edge.getSecondIndex() == index1) { |
||||
return edge; |
||||
} |
||||
} |
||||
return null; |
||||
} |
||||
|
||||
/** |
||||
* This is a helper class for UV coordinates subdivision. UV's form a mesh that is being applied the same algorithms as a regular mesh. |
||||
* This way one code handles two issues. After applying Catmull-Clark algorithm the UV-mesh is transformed back into UV coordinates. |
||||
* |
||||
* @author Marcin Roguski (Kaelthas) |
||||
*/ |
||||
private static class UvCoordsSubdivideTemporalMesh extends TemporalMesh { |
||||
private static final Vector3f NORMAL = new Vector3f(0, 0, 1); |
||||
|
||||
public UvCoordsSubdivideTemporalMesh(BlenderContext blenderContext) throws BlenderFileException { |
||||
super(null, blenderContext, false); |
||||
} |
||||
|
||||
/** |
||||
* Adds a UV-face to the mesh. |
||||
* @param uvs |
||||
* the UV coordinates |
||||
*/ |
||||
public void addFace(List<Vector2f> uvs) { |
||||
Integer[] indexes = new Integer[uvs.size()]; |
||||
int i = 0; |
||||
|
||||
for (Vector2f uv : uvs) { |
||||
Vector3f v = new Vector3f(uv.x, uv.y, 0); |
||||
int index = vertices.indexOf(v); |
||||
if (index >= 0) { |
||||
indexes[i++] = index; |
||||
} else { |
||||
indexes[i++] = vertices.size(); |
||||
vertices.add(v); |
||||
normals.add(NORMAL); |
||||
} |
||||
} |
||||
faces.add(new Face(indexes, false, 0, null, null, this)); |
||||
for (i = 1; i < indexes.length; ++i) { |
||||
edges.add(new Edge(indexes[i - 1], indexes[i], 0, true, vertices)); |
||||
} |
||||
edges.add(new Edge(indexes[indexes.length - 1], indexes[0], 0, true, vertices)); |
||||
} |
||||
|
||||
/** |
||||
* Converts the mesh back into UV coordinates for the given face. |
||||
* @param faceIndex |
||||
* the index of the face |
||||
* @return UV coordinates |
||||
*/ |
||||
public List<Vector2f> faceToUVs(int faceIndex) { |
||||
Face face = faces.get(faceIndex); |
||||
List<Vector2f> result = new ArrayList<Vector2f>(face.getIndexes().size()); |
||||
for (Integer index : face.getIndexes()) { |
||||
Vector3f v = vertices.get(index); |
||||
result.add(new Vector2f(v.x, v.y)); |
||||
} |
||||
return result; |
||||
} |
||||
} |
||||
} |
||||
Loading…
Reference in new issue