Done. Hope it does not break anything ... too much :) git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@9509 75d07b2b-3a1a-0410-a2c5-0572b91ccdca3.0
Kae..pl
13 years ago
parent
4e987ae63e
commit
d63683d240
@ -0,0 +1,244 @@ |
||||
package com.jme3.scene.plugins.blender.meshes; |
||||
|
||||
import java.util.ArrayList; |
||||
import java.util.HashMap; |
||||
import java.util.List; |
||||
import java.util.Map; |
||||
|
||||
import com.jme3.math.FastMath; |
||||
import com.jme3.math.Vector2f; |
||||
import com.jme3.math.Vector3f; |
||||
|
||||
/*package*/ class MeshBuilder { |
||||
/** An array of reference vertices. */ |
||||
private Vector3f[] vertices; |
||||
/** A variable that indicates if the model uses generated textures. */ |
||||
private boolean usesGeneratedTextures; |
||||
|
||||
/** This map's key is the vertex index from 'vertices 'table and the value are indices from 'vertexList' |
||||
positions (it simply tells which vertex is referenced where in the result list). */ |
||||
private Map<Integer, Map<Integer, List<Integer>>> globalVertexReferenceMap; |
||||
/** A map between vertex and its normal vector. */ |
||||
private Map<Vector3f, Vector3f> globalNormalMap = new HashMap<Vector3f, Vector3f>(); |
||||
|
||||
/** A map between vertex index and its UV coordinates. */ |
||||
private Map<Integer, Vector2f> uvsMap = new HashMap<Integer, Vector2f>(); |
||||
/** The following map sorts vertices by material number (because in jme Mesh can have only one material). */ |
||||
private Map<Integer, List<Vector3f>> normalMap = new HashMap<Integer, List<Vector3f>>(); |
||||
/** The following map sorts vertices by material number (because in jme Mesh can have only one material). */ |
||||
private Map<Integer, List<Vector3f>> vertexMap = new HashMap<Integer, List<Vector3f>>(); |
||||
/** The following map sorts indexes by material number (because in jme Mesh can have only one material). */ |
||||
private Map<Integer, List<Integer>> indexMap = new HashMap<Integer, List<Integer>>(); |
||||
/** A map between material number and UV coordinates of mesh that has this material applied. */ |
||||
private Map<Integer, List<Vector2f>> uvCoordinates = new HashMap<Integer, List<Vector2f>>();//<material_number; list of uv coordinates for mesh's vertices>
|
||||
|
||||
/** |
||||
* Constructor. Stores the given array (not copying it). |
||||
* The second argument describes if the model uses generated textures. If yes then no vertex amount optimisation is applied. |
||||
* The amount of vertices is always faceCount * 3. |
||||
* @param vertices the reference vertices array |
||||
* @param usesGeneratedTextures a variable that indicates if the model uses generated textures or not |
||||
*/ |
||||
public MeshBuilder(Vector3f[] vertices, boolean usesGeneratedTextures) { |
||||
if(vertices == null || vertices.length == 0) { |
||||
throw new IllegalArgumentException("No vertices loaded to build mesh."); |
||||
} |
||||
this.vertices = vertices; |
||||
this.usesGeneratedTextures = usesGeneratedTextures; |
||||
globalVertexReferenceMap = new HashMap<Integer, Map<Integer, List<Integer>>>(vertices.length); |
||||
} |
||||
|
||||
/** |
||||
* This method adds a face to the mesh. |
||||
* @param v1 index of the 1'st vertex from the reference vertex table |
||||
* @param v2 index of the 2'nd vertex from the reference vertex table |
||||
* @param v3 index of the 3'rd vertex from the reference vertex table |
||||
* @param smooth indicates if this face should have smooth shading or flat shading |
||||
* @param materialNumber the material number for this face |
||||
* @param uvs a 3-element array of vertices UV coordinates |
||||
*/ |
||||
public void appendFace(int v1, int v2, int v3, boolean smooth, int materialNumber, Vector2f[] uvs) { |
||||
if(uvs != null && uvs.length != 3) { |
||||
throw new IllegalArgumentException("UV coordinates must be a 3-element array!"); |
||||
} |
||||
List<Integer> indexList = indexMap.get(materialNumber); |
||||
if (indexList == null) { |
||||
indexList = new ArrayList<Integer>(); |
||||
indexMap.put(materialNumber, indexList); |
||||
} |
||||
List<Vector3f> vertexList = vertexMap.get(materialNumber); |
||||
if (vertexList == null) { |
||||
vertexList = new ArrayList<Vector3f>(); |
||||
vertexMap.put(materialNumber, vertexList); |
||||
} |
||||
List<Vector3f> normalList = normalMap.get(materialNumber); |
||||
if (normalList == null) { |
||||
normalList = new ArrayList<Vector3f>(); |
||||
normalMap.put(materialNumber, normalList); |
||||
} |
||||
Map<Integer, List<Integer>> vertexReferenceMap = globalVertexReferenceMap.get(materialNumber); |
||||
if(vertexReferenceMap == null) { |
||||
vertexReferenceMap = new HashMap<Integer, List<Integer>>(); |
||||
globalVertexReferenceMap.put(materialNumber, vertexReferenceMap); |
||||
} |
||||
|
||||
List<Vector2f> uvCoordinatesList = null; |
||||
if(uvs != null) { |
||||
uvCoordinatesList = uvCoordinates.get(Integer.valueOf(materialNumber)); |
||||
if(uvCoordinatesList == null) { |
||||
uvCoordinatesList = new ArrayList<Vector2f>(); |
||||
uvCoordinates.put(Integer.valueOf(materialNumber), uvCoordinatesList); |
||||
} |
||||
} |
||||
|
||||
Integer[] index = new Integer[] {v1, v2, v3}; |
||||
Vector3f n = FastMath.computeNormal(vertices[v1], vertices[v2], vertices[v3]); |
||||
this.addNormal(n, globalNormalMap, smooth, vertices[v1], vertices[v2], vertices[v3]); |
||||
if(smooth && !usesGeneratedTextures) { |
||||
for (int i = 0; i < 3; ++i) { |
||||
if(!vertexReferenceMap.containsKey(index[i])) { |
||||
this.appendVertexReference(index[i], vertexList.size(), vertexReferenceMap); |
||||
vertexList.add(vertices[index[i]]); |
||||
normalList.add(globalNormalMap.get(vertices[index[i]])); |
||||
if(uvCoordinatesList != null) { |
||||
uvsMap.put(vertexList.size(), uvs[i]); |
||||
uvCoordinatesList.add(uvs[i]); |
||||
} |
||||
index[i] = vertexList.size() - 1; |
||||
} else if(uvCoordinatesList != null) { |
||||
boolean vertexAlreadyUsed = false; |
||||
for(Integer vertexIndex : vertexReferenceMap.get(index[i])) { |
||||
if(uvs[i].equals(uvsMap.get(vertexIndex))) { |
||||
vertexAlreadyUsed = true; |
||||
index[i] = vertexIndex; |
||||
break; |
||||
} |
||||
} |
||||
if(!vertexAlreadyUsed) { |
||||
this.appendVertexReference(index[i], vertexList.size(), vertexReferenceMap); |
||||
uvsMap.put(vertexList.size(), uvs[i]); |
||||
vertexList.add(vertices[index[i]]); |
||||
normalList.add(globalNormalMap.get(vertices[index[i]])); |
||||
uvCoordinatesList.add(uvs[i]); |
||||
index[i] = vertexList.size() - 1; |
||||
} |
||||
} else { |
||||
index[i] = vertexList.indexOf(vertices[index[i]]); |
||||
} |
||||
indexList.add(index[i]); |
||||
} |
||||
} else { |
||||
for (int i = 0; i < 3; ++i) { |
||||
indexList.add(vertexList.size()); |
||||
this.appendVertexReference(index[i], vertexList.size(), vertexReferenceMap); |
||||
if(uvCoordinatesList != null) { |
||||
uvCoordinatesList.add(uvs[i]); |
||||
uvsMap.put(vertexList.size(), uvs[i]); |
||||
} |
||||
vertexList.add(vertices[index[i]]); |
||||
normalList.add(globalNormalMap.get(vertices[index[i]])); |
||||
} |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* @return a map that maps vertex index from reference array to its indices in the result list |
||||
*/ |
||||
public Map<Integer, Map<Integer, List<Integer>>> getVertexReferenceMap() { |
||||
return globalVertexReferenceMap; |
||||
} |
||||
|
||||
/** |
||||
* @return result vertices array |
||||
*/ |
||||
public Vector3f[] getVertices(int materialNumber) { |
||||
return vertexMap.get(materialNumber).toArray(new Vector3f[vertexMap.get(materialNumber).size()]); |
||||
} |
||||
|
||||
/** |
||||
* @return the amount of result vertices |
||||
*/ |
||||
public int getVerticesAmount(int materialNumber) { |
||||
return vertexMap.get(materialNumber).size(); |
||||
} |
||||
|
||||
/** |
||||
* @return normals result array |
||||
*/ |
||||
public Vector3f[] getNormals(int materialNumber) { |
||||
return normalMap.get(materialNumber).toArray(new Vector3f[normalMap.get(materialNumber).size()]); |
||||
} |
||||
|
||||
/** |
||||
* @return a map between material number and the mesh part vertices indices |
||||
*/ |
||||
public Map<Integer, List<Integer>> getMeshesMap() { |
||||
return indexMap; |
||||
} |
||||
|
||||
/** |
||||
* @return the amount of meshes the source mesh was split into (depends on the applied materials count) |
||||
*/ |
||||
public int getMeshesPartAmount() { |
||||
return indexMap.size(); |
||||
} |
||||
|
||||
/** |
||||
* @param materialNumber the material number that is appied to the mesh |
||||
* @return UV coordinates of vertices that belong to the required mesh part |
||||
*/ |
||||
public List<Vector2f> getUVCoordinates(int materialNumber) { |
||||
return uvCoordinates.get(materialNumber); |
||||
} |
||||
|
||||
/** |
||||
* @return indicates if the mesh has UV coordinates |
||||
*/ |
||||
public boolean hasUVCoordinates() { |
||||
return uvCoordinates.size() > 0; |
||||
} |
||||
|
||||
/** |
||||
* This method adds a normal to a normals' map. This map is used to merge normals of a vertor that should be rendered smooth. |
||||
* |
||||
* @param normalToAdd |
||||
* a normal to be added |
||||
* @param normalMap |
||||
* merges normals of faces that will be rendered smooth; the key is the vertex and the value - its normal vector |
||||
* @param smooth |
||||
* the variable that indicates wheather to merge normals (creating the smooth mesh) or not |
||||
* @param vertices |
||||
* a list of vertices read from the blender file |
||||
*/ |
||||
private void addNormal(Vector3f normalToAdd, Map<Vector3f, Vector3f> normalMap, boolean smooth, Vector3f... vertices) { |
||||
for (Vector3f v : vertices) { |
||||
Vector3f n = normalMap.get(v); |
||||
if (!smooth || n == null) { |
||||
normalMap.put(v, normalToAdd.clone()); |
||||
} else { |
||||
n.addLocal(normalToAdd).normalizeLocal(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* This method fills the vertex reference map. The vertices are loaded once and referenced many times in the model. This map is created |
||||
* to tell where the basic vertices are referenced in the result vertex lists. The key of the map is the basic vertex index, and its key |
||||
* - the reference indices list. |
||||
* |
||||
* @param basicVertexIndex |
||||
* the index of the vertex from its basic table |
||||
* @param resultIndex |
||||
* the index of the vertex in its result vertex list |
||||
* @param vertexReferenceMap |
||||
* the reference map |
||||
*/ |
||||
private void appendVertexReference(int basicVertexIndex, int resultIndex, Map<Integer, List<Integer>> vertexReferenceMap) { |
||||
List<Integer> referenceList = vertexReferenceMap.get(Integer.valueOf(basicVertexIndex)); |
||||
if (referenceList == null) { |
||||
referenceList = new ArrayList<Integer>(); |
||||
vertexReferenceMap.put(Integer.valueOf(basicVertexIndex), referenceList); |
||||
} |
||||
referenceList.add(Integer.valueOf(resultIndex)); |
||||
} |
||||
} |
||||
Loading…
Reference in new issue