Bugfix: fixed an issue with wrong vertrex colors applying (along with classes prepared to implement line and point mesh loading).
git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@10913 75d07b2b-3a1a-0410-a2c5-0572b91ccdcaexperimental
Kae..pl
11 years ago
parent
e20d0c0045
commit
69e4392ba9
@ -1,342 +0,0 @@ |
|||||||
package com.jme3.scene.plugins.blender.meshes; |
|
||||||
|
|
||||||
import java.nio.ByteBuffer; |
|
||||||
import java.util.ArrayList; |
|
||||||
import java.util.HashMap; |
|
||||||
import java.util.LinkedHashMap; |
|
||||||
import java.util.List; |
|
||||||
import java.util.Map; |
|
||||||
import java.util.Map.Entry; |
|
||||||
import java.util.logging.Logger; |
|
||||||
|
|
||||||
import com.jme3.math.FastMath; |
|
||||||
import com.jme3.math.Vector2f; |
|
||||||
import com.jme3.math.Vector3f; |
|
||||||
import com.jme3.scene.plugins.blender.textures.UserUVCollection; |
|
||||||
import com.jme3.util.BufferUtils; |
|
||||||
|
|
||||||
/** |
|
||||||
* A builder class for meshes. |
|
||||||
* |
|
||||||
* @author Marcin Roguski (Kaelthas) |
|
||||||
*/ |
|
||||||
/* package */class MeshBuilder { |
|
||||||
private static final Logger LOGGER = Logger.getLogger(MeshBuilder.class.getName()); |
|
||||||
|
|
||||||
/** An array of reference vertices. */ |
|
||||||
private Vector3f[][] verticesAndNormals; |
|
||||||
/** An list of vertices colors. */ |
|
||||||
private List<byte[]> verticesColors; |
|
||||||
/** 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; |
|
||||||
/** 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 vertices colors by material number (because in jme Mesh can have only one material). */ |
|
||||||
private Map<Integer, List<byte[]>> vertexColorsMap = new HashMap<Integer, List<byte[]>>(); |
|
||||||
/** 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 collection of user defined UV coordinates (one mesh can have more than one such mappings). */ |
|
||||||
private UserUVCollection userUVCollection = new UserUVCollection(); |
|
||||||
|
|
||||||
/** |
|
||||||
* 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 verticesAndNormals |
|
||||||
* the reference vertices and normals array |
|
||||||
* @param usesGeneratedTextures |
|
||||||
* a variable that indicates if the model uses generated textures or not |
|
||||||
*/ |
|
||||||
public MeshBuilder(Vector3f[][] verticesAndNormals, List<byte[]> verticesColors, boolean usesGeneratedTextures) { |
|
||||||
this.verticesAndNormals = verticesAndNormals; |
|
||||||
this.verticesColors = verticesColors; |
|
||||||
this.usesGeneratedTextures = usesGeneratedTextures; |
|
||||||
globalVertexReferenceMap = new HashMap<Integer, Map<Integer, List<Integer>>>(verticesAndNormals.length); |
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* This method adds a point to the mesh. |
|
||||||
* @param coordinates |
|
||||||
* the coordinates of the point |
|
||||||
* @param normal |
|
||||||
* the point's normal vector |
|
||||||
* @param materialNumber |
|
||||||
* the material number for this point |
|
||||||
*/ |
|
||||||
public void appendPoint(Vector3f coordinates, Vector3f normal, int materialNumber) { |
|
||||||
LOGGER.warning("Appending single point not yet supported!");// TODO
|
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* This method adds a line 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 smooth |
|
||||||
* indicates if this face should have smooth shading or flat shading |
|
||||||
*/ |
|
||||||
public void appendEdge(int v1, int v2, boolean smooth) { |
|
||||||
LOGGER.warning("Appending single line not yet supported!");// TODO
|
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* 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 uvsForFace |
|
||||||
* a 3-element array of vertices UV coordinates mapped to the UV's set name |
|
||||||
* @param quad |
|
||||||
* indicates if the appended face is a part of a quad face (used for creating vertex colors buffer) |
|
||||||
* @param faceIndex |
|
||||||
* the face index (used for creating vertex colors buffer) |
|
||||||
*/ |
|
||||||
public void appendFace(int v1, int v2, int v3, boolean smooth, int materialNumber, Map<String, Vector2f[]> uvsForFace, boolean quad, int faceIndex) { |
|
||||||
if (uvsForFace != null && uvsForFace.size() > 0) { |
|
||||||
for (Entry<String, Vector2f[]> entry : uvsForFace.entrySet()) { |
|
||||||
if (entry.getValue().length != 3) { |
|
||||||
throw new IllegalArgumentException("UV coordinates must be a 3-element array!" + (entry.getKey() != null ? " (UV set name: " + entry.getKey() + ')' : "")); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// getting the required lists
|
|
||||||
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<byte[]> vertexColorsList = vertexColorsMap != null ? vertexColorsMap.get(materialNumber) : null; |
|
||||||
int[] vertexColorIndex = new int[] { 0, 1, 2 }; |
|
||||||
if (vertexColorsList == null && vertexColorsMap != null) { |
|
||||||
vertexColorsList = new ArrayList<byte[]>(); |
|
||||||
vertexColorsMap.put(materialNumber, vertexColorsList); |
|
||||||
} |
|
||||||
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); |
|
||||||
} |
|
||||||
|
|
||||||
faceIndex *= 3; |
|
||||||
if (quad) { |
|
||||||
vertexColorIndex[1] = 2; |
|
||||||
vertexColorIndex[2] = 3; |
|
||||||
} |
|
||||||
|
|
||||||
// creating faces
|
|
||||||
Integer[] index = new Integer[] { v1, v2, v3 }; |
|
||||||
if (smooth && !usesGeneratedTextures) { |
|
||||||
for (int i = 0; i < 3; ++i) { |
|
||||||
if (!vertexReferenceMap.containsKey(index[i])) { |
|
||||||
//if this index is not yet used then create another face
|
|
||||||
this.appendVertexReference(index[i], vertexList.size(), vertexReferenceMap); |
|
||||||
if (uvsForFace != null) { |
|
||||||
for (Entry<String, Vector2f[]> entry : uvsForFace.entrySet()) { |
|
||||||
userUVCollection.addUV(materialNumber, entry.getKey(), entry.getValue()[i], vertexList.size()); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
vertexList.add(verticesAndNormals[index[i]][0]); |
|
||||||
if (verticesColors != null) { |
|
||||||
vertexColorsList.add(verticesColors.get(faceIndex + vertexColorIndex[i])); |
|
||||||
} |
|
||||||
normalList.add(verticesAndNormals[index[i]][1]); |
|
||||||
|
|
||||||
index[i] = vertexList.size() - 1; |
|
||||||
} else if (uvsForFace != null) { |
|
||||||
//if the index is used then check if the vertexe's UV coordinates match, if yes then the vertex doesn't have separate UV's
|
|
||||||
//in different faces so we can use it here as well, if UV's are different in separate faces the we need to add this vert
|
|
||||||
//because in jme one vertex can have only on UV coordinate
|
|
||||||
boolean vertexAlreadyUsed = false; |
|
||||||
for (Integer vertexIndex : vertexReferenceMap.get(index[i])) { |
|
||||||
int vertexUseCounter = 0; |
|
||||||
for (Entry<String, Vector2f[]> entry : uvsForFace.entrySet()) { |
|
||||||
if (entry.getValue()[i].equals(userUVCollection.getUVForVertex(entry.getKey(), vertexIndex))) { |
|
||||||
++vertexUseCounter; |
|
||||||
} |
|
||||||
} |
|
||||||
if (vertexUseCounter == uvsForFace.size()) { |
|
||||||
vertexAlreadyUsed = true; |
|
||||||
index[i] = vertexIndex; |
|
||||||
break; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
if (!vertexAlreadyUsed) { |
|
||||||
// treat this face as a new one because its vertices have separate UV's
|
|
||||||
this.appendVertexReference(index[i], vertexList.size(), vertexReferenceMap); |
|
||||||
for (Entry<String, Vector2f[]> entry : uvsForFace.entrySet()) { |
|
||||||
userUVCollection.addUV(materialNumber, entry.getKey(), entry.getValue()[i], vertexList.size()); |
|
||||||
} |
|
||||||
vertexList.add(verticesAndNormals[index[i]][0]); |
|
||||||
if (verticesColors != null) { |
|
||||||
vertexColorsList.add(verticesColors.get(faceIndex + vertexColorIndex[i])); |
|
||||||
} |
|
||||||
normalList.add(verticesAndNormals[index[i]][1]); |
|
||||||
index[i] = vertexList.size() - 1; |
|
||||||
} |
|
||||||
} else { |
|
||||||
//use this index again
|
|
||||||
index[i] = vertexList.indexOf(verticesAndNormals[index[i]][0]); |
|
||||||
} |
|
||||||
indexList.add(index[i]); |
|
||||||
} |
|
||||||
} else { |
|
||||||
Vector3f n = smooth ? null : FastMath.computeNormal(verticesAndNormals[v1][0], verticesAndNormals[v2][0], verticesAndNormals[v3][0]); |
|
||||||
for (int i = 0; i < 3; ++i) { |
|
||||||
indexList.add(vertexList.size()); |
|
||||||
this.appendVertexReference(index[i], vertexList.size(), vertexReferenceMap); |
|
||||||
if (uvsForFace != null) { |
|
||||||
for (Entry<String, Vector2f[]> entry : uvsForFace.entrySet()) { |
|
||||||
userUVCollection.addUV(materialNumber, entry.getKey(), entry.getValue()[i], vertexList.size()); |
|
||||||
} |
|
||||||
} |
|
||||||
vertexList.add(verticesAndNormals[index[i]][0]); |
|
||||||
if (verticesColors != null) { |
|
||||||
vertexColorsList.add(verticesColors.get(faceIndex + vertexColorIndex[i])); |
|
||||||
} |
|
||||||
normalList.add(smooth ? verticesAndNormals[index[i]][1] : n); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* @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; |
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* @param materialNumber |
|
||||||
* the material index |
|
||||||
* @return result vertices array |
|
||||||
*/ |
|
||||||
public Vector3f[] getVertices(int materialNumber) { |
|
||||||
return vertexMap.get(materialNumber).toArray(new Vector3f[vertexMap.get(materialNumber).size()]); |
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* @param materialNumber |
|
||||||
* the material index |
|
||||||
* @return the amount of result vertices |
|
||||||
*/ |
|
||||||
public int getVerticesAmount(int materialNumber) { |
|
||||||
return vertexMap.get(materialNumber).size(); |
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* @param materialNumber |
|
||||||
* the material index |
|
||||||
* @return normals result array |
|
||||||
*/ |
|
||||||
public Vector3f[] getNormals(int materialNumber) { |
|
||||||
return normalMap.get(materialNumber).toArray(new Vector3f[normalMap.get(materialNumber).size()]); |
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* @param materialNumber |
|
||||||
* the material index |
|
||||||
* @return the vertices colors buffer or null if no vertex colors is set |
|
||||||
*/ |
|
||||||
public ByteBuffer getVertexColorsBuffer(int materialNumber) { |
|
||||||
ByteBuffer result = null; |
|
||||||
if (verticesColors != null && vertexColorsMap.get(materialNumber) != null) { |
|
||||||
List<byte[]> data = vertexColorsMap.get(materialNumber); |
|
||||||
result = BufferUtils.createByteBuffer(4 * data.size()); |
|
||||||
for (byte[] v : data) { |
|
||||||
if (v != null) { |
|
||||||
result.put(v[0]).put(v[1]).put(v[2]).put(v[3]); |
|
||||||
} else { |
|
||||||
result.put((byte) 0).put((byte) 0).put((byte) 0).put((byte) 0); |
|
||||||
} |
|
||||||
} |
|
||||||
result.flip(); |
|
||||||
} |
|
||||||
return result; |
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* @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 LinkedHashMap<String, List<Vector2f>> getUVCoordinates(int materialNumber) { |
|
||||||
return userUVCollection.getUVCoordinates(materialNumber); |
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* @return indicates if the mesh has UV coordinates |
|
||||||
*/ |
|
||||||
public boolean hasUVCoordinates() { |
|
||||||
return userUVCollection.hasUVCoordinates(); |
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* @return <b>true</b> if the mesh has no vertices and <b>false</b> otherwise |
|
||||||
*/ |
|
||||||
public boolean isEmpty() { |
|
||||||
return vertexMap.size() == 0; |
|
||||||
} |
|
||||||
|
|
||||||
/** |
|
||||||
* 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)); |
|
||||||
} |
|
||||||
} |
|
||||||
@ -0,0 +1,591 @@ |
|||||||
|
package com.jme3.scene.plugins.blender.meshes.builders; |
||||||
|
|
||||||
|
import java.nio.ByteBuffer; |
||||||
|
import java.util.ArrayList; |
||||||
|
import java.util.HashMap; |
||||||
|
import java.util.LinkedHashMap; |
||||||
|
import java.util.List; |
||||||
|
import java.util.Map; |
||||||
|
import java.util.Map.Entry; |
||||||
|
import java.util.logging.Logger; |
||||||
|
|
||||||
|
import com.jme3.math.FastMath; |
||||||
|
import com.jme3.math.Vector2f; |
||||||
|
import com.jme3.math.Vector3f; |
||||||
|
import com.jme3.scene.Mesh; |
||||||
|
import com.jme3.scene.VertexBuffer; |
||||||
|
import com.jme3.scene.VertexBuffer.Format; |
||||||
|
import com.jme3.scene.VertexBuffer.Type; |
||||||
|
import com.jme3.scene.VertexBuffer.Usage; |
||||||
|
import com.jme3.scene.plugins.blender.BlenderContext; |
||||||
|
import com.jme3.scene.plugins.blender.file.BlenderFileException; |
||||||
|
import com.jme3.scene.plugins.blender.file.DynamicArray; |
||||||
|
import com.jme3.scene.plugins.blender.file.Pointer; |
||||||
|
import com.jme3.scene.plugins.blender.file.Structure; |
||||||
|
import com.jme3.scene.plugins.blender.meshes.MeshHelper; |
||||||
|
import com.jme3.scene.plugins.blender.textures.UserUVCollection; |
||||||
|
import com.jme3.util.BufferUtils; |
||||||
|
|
||||||
|
/** |
||||||
|
* A builder class for meshes made of triangles (faces). |
||||||
|
* |
||||||
|
* @author Marcin Roguski (Kaelthas) |
||||||
|
*/ |
||||||
|
/* package */class FaceMeshBuilder { |
||||||
|
private static final Logger LOGGER = Logger.getLogger(FaceMeshBuilder.class.getName()); |
||||||
|
|
||||||
|
/** An array of reference vertices. */ |
||||||
|
private Vector3f[][] verticesAndNormals; |
||||||
|
/** An list of vertices colors. */ |
||||||
|
private List<byte[]> verticesColors; |
||||||
|
/** 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; |
||||||
|
/** 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 vertices colors by material number (because in jme Mesh can have only one material). */ |
||||||
|
private Map<Integer, List<byte[]>> vertexColorsMap = new HashMap<Integer, List<byte[]>>(); |
||||||
|
/** 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 collection of user defined UV coordinates (one mesh can have more than one such mappings). */ |
||||||
|
private UserUVCollection userUVCollection = new UserUVCollection(); |
||||||
|
|
||||||
|
/** |
||||||
|
* 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 verticesAndNormals |
||||||
|
* the reference vertices and normals array |
||||||
|
* @param usesGeneratedTextures |
||||||
|
* a variable that indicates if the model uses generated textures or not |
||||||
|
*/ |
||||||
|
public FaceMeshBuilder(Vector3f[][] verticesAndNormals, boolean usesGeneratedTextures) { |
||||||
|
this.verticesAndNormals = verticesAndNormals; |
||||||
|
this.usesGeneratedTextures = usesGeneratedTextures; |
||||||
|
globalVertexReferenceMap = new HashMap<Integer, Map<Integer, List<Integer>>>(verticesAndNormals.length); |
||||||
|
} |
||||||
|
|
||||||
|
public void readMesh(Structure structure, BlenderContext blenderContext) throws BlenderFileException { |
||||||
|
verticesColors = this.getVerticesColors(structure, blenderContext); |
||||||
|
MeshHelper meshHelper = blenderContext.getHelper(MeshHelper.class); |
||||||
|
|
||||||
|
if (meshHelper.isBMeshCompatible(structure)) { |
||||||
|
this.readBMesh(structure, blenderContext); |
||||||
|
} else { |
||||||
|
this.readTraditionalFaces(structure, blenderContext); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Builds the meshes. |
||||||
|
* @return a map between material index and the mesh |
||||||
|
*/ |
||||||
|
public Map<Integer, Mesh> buildMeshes() { |
||||||
|
Map<Integer, Mesh> result = new HashMap<Integer, Mesh>(indexMap.size()); |
||||||
|
|
||||||
|
for (Entry<Integer, List<Integer>> meshEntry : indexMap.entrySet()) { |
||||||
|
int materialIndex = meshEntry.getKey(); |
||||||
|
// key is the material index (or -1 if the material has no texture)
|
||||||
|
// value is a list of vertex indices
|
||||||
|
Mesh mesh = new Mesh(); |
||||||
|
|
||||||
|
// creating vertices indices for this mesh
|
||||||
|
List<Integer> indexList = meshEntry.getValue(); |
||||||
|
if (this.getVerticesAmount(materialIndex) <= Short.MAX_VALUE) { |
||||||
|
short[] indices = new short[indexList.size()]; |
||||||
|
for (int i = 0; i < indexList.size(); ++i) { |
||||||
|
indices[i] = indexList.get(i).shortValue(); |
||||||
|
} |
||||||
|
mesh.setBuffer(Type.Index, 1, indices); |
||||||
|
} else { |
||||||
|
int[] indices = new int[indexList.size()]; |
||||||
|
for (int i = 0; i < indexList.size(); ++i) { |
||||||
|
indices[i] = indexList.get(i).intValue(); |
||||||
|
} |
||||||
|
mesh.setBuffer(Type.Index, 1, indices); |
||||||
|
} |
||||||
|
|
||||||
|
LOGGER.fine("Creating vertices buffer."); |
||||||
|
VertexBuffer verticesBuffer = new VertexBuffer(Type.Position); |
||||||
|
verticesBuffer.setupData(Usage.Static, 3, Format.Float, BufferUtils.createFloatBuffer(this.getVertices(materialIndex))); |
||||||
|
mesh.setBuffer(verticesBuffer); |
||||||
|
|
||||||
|
LOGGER.fine("Creating normals buffer."); |
||||||
|
VertexBuffer normalsBuffer = new VertexBuffer(Type.Normal); |
||||||
|
normalsBuffer.setupData(Usage.Static, 3, Format.Float, BufferUtils.createFloatBuffer(this.getNormals(materialIndex))); |
||||||
|
mesh.setBuffer(normalsBuffer); |
||||||
|
|
||||||
|
if (verticesColors != null) { |
||||||
|
LOGGER.fine("Setting vertices colors."); |
||||||
|
mesh.setBuffer(Type.Color, 4, this.getVertexColorsBuffer(materialIndex)); |
||||||
|
mesh.getBuffer(Type.Color).setNormalized(true); |
||||||
|
} |
||||||
|
|
||||||
|
result.put(materialIndex, mesh); |
||||||
|
} |
||||||
|
|
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* This method reads the mesh from the new BMesh system. |
||||||
|
* |
||||||
|
* @param meshStructure |
||||||
|
* the mesh structure |
||||||
|
* @param blenderContext |
||||||
|
* the blender context |
||||||
|
* @throws BlenderFileException |
||||||
|
* an exception is thrown when there are problems with the |
||||||
|
* blender file |
||||||
|
*/ |
||||||
|
private void readBMesh(Structure meshStructure, BlenderContext blenderContext) throws BlenderFileException { |
||||||
|
LOGGER.fine("Reading BMesh."); |
||||||
|
Pointer pMLoop = (Pointer) meshStructure.getFieldValue("mloop"); |
||||||
|
Pointer pMPoly = (Pointer) meshStructure.getFieldValue("mpoly"); |
||||||
|
Pointer pMEdge = (Pointer) meshStructure.getFieldValue("medge"); |
||||||
|
Map<String, Vector2f[]> uvCoordinatesForFace = new HashMap<String, Vector2f[]>(); |
||||||
|
|
||||||
|
if (pMPoly.isNotNull() && pMLoop.isNotNull() && pMEdge.isNotNull()) { |
||||||
|
Map<String, List<Vector2f>> uvs = this.loadUVCoordinates(meshStructure, true, blenderContext); |
||||||
|
List<Structure> polys = pMPoly.fetchData(blenderContext.getInputStream()); |
||||||
|
List<Structure> loops = pMLoop.fetchData(blenderContext.getInputStream()); |
||||||
|
int[] vertexColorIndex = verticesColors == null ? null : new int[3]; |
||||||
|
for (Structure poly : polys) { |
||||||
|
int materialNumber = ((Number) poly.getFieldValue("mat_nr")).intValue(); |
||||||
|
int loopStart = ((Number) poly.getFieldValue("loopstart")).intValue(); |
||||||
|
int totLoop = ((Number) poly.getFieldValue("totloop")).intValue(); |
||||||
|
boolean smooth = (((Number) poly.getFieldValue("flag")).byteValue() & 0x01) != 0x00; |
||||||
|
int[] vertexIndexes = new int[totLoop]; |
||||||
|
|
||||||
|
for (int i = loopStart; i < loopStart + totLoop; ++i) { |
||||||
|
vertexIndexes[i - loopStart] = ((Number) loops.get(i).getFieldValue("v")).intValue(); |
||||||
|
} |
||||||
|
|
||||||
|
int i = 0; |
||||||
|
while (i < totLoop - 2) { |
||||||
|
int v1 = vertexIndexes[0]; |
||||||
|
int v2 = vertexIndexes[i + 1]; |
||||||
|
int v3 = vertexIndexes[i + 2]; |
||||||
|
if(vertexColorIndex != null) { |
||||||
|
vertexColorIndex[0] = loopStart; |
||||||
|
vertexColorIndex[1] = loopStart + i + 1; |
||||||
|
vertexColorIndex[2] = loopStart + i + 2; |
||||||
|
} |
||||||
|
|
||||||
|
if (uvs != null) { |
||||||
|
// uvs always must be added wheater we have texture or not
|
||||||
|
for (Entry<String, List<Vector2f>> entry : uvs.entrySet()) { |
||||||
|
Vector2f[] uvCoordsForASingleFace = new Vector2f[3]; |
||||||
|
uvCoordsForASingleFace[0] = entry.getValue().get(loopStart); |
||||||
|
uvCoordsForASingleFace[1] = entry.getValue().get(loopStart + i + 1); |
||||||
|
uvCoordsForASingleFace[2] = entry.getValue().get(loopStart + i + 2); |
||||||
|
uvCoordinatesForFace.put(entry.getKey(), uvCoordsForASingleFace); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
this.appendFace(v1, v2, v3, smooth, materialNumber, uvs == null ? null : uvCoordinatesForFace, vertexColorIndex); |
||||||
|
uvCoordinatesForFace.clear(); |
||||||
|
++i; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* This method reads the mesh from traditional triangle/quad storing |
||||||
|
* structures. |
||||||
|
* |
||||||
|
* @param meshStructure |
||||||
|
* the mesh structure |
||||||
|
* @param blenderContext |
||||||
|
* the blender context |
||||||
|
* @throws BlenderFileException |
||||||
|
* an exception is thrown when there are problems with the |
||||||
|
* blender file |
||||||
|
*/ |
||||||
|
private void readTraditionalFaces(Structure meshStructure, BlenderContext blenderContext) throws BlenderFileException { |
||||||
|
LOGGER.fine("Reading traditional faces."); |
||||||
|
Pointer pMFace = (Pointer) meshStructure.getFieldValue("mface"); |
||||||
|
List<Structure> mFaces = pMFace.isNotNull() ? pMFace.fetchData(blenderContext.getInputStream()) : null; |
||||||
|
if (mFaces != null && mFaces.size() > 0) { |
||||||
|
// indicates if the material with the specified number should have a texture attached
|
||||||
|
Map<String, List<Vector2f>> uvs = this.loadUVCoordinates(meshStructure, false, blenderContext); |
||||||
|
Map<String, Vector2f[]> uvCoordinatesForFace = new HashMap<String, Vector2f[]>(); |
||||||
|
int[] vertexColorIndex = verticesColors == null ? null : new int[3]; |
||||||
|
for (int i = 0; i < mFaces.size(); ++i) { |
||||||
|
Structure mFace = mFaces.get(i); |
||||||
|
int materialNumber = ((Number) mFace.getFieldValue("mat_nr")).intValue(); |
||||||
|
boolean smooth = (((Number) mFace.getFieldValue("flag")).byteValue() & 0x01) != 0x00; |
||||||
|
if (uvs != null) { |
||||||
|
// uvs always must be added wheater we have texture or not
|
||||||
|
for (Entry<String, List<Vector2f>> entry : uvs.entrySet()) { |
||||||
|
Vector2f[] uvCoordsForASingleFace = new Vector2f[3]; |
||||||
|
uvCoordsForASingleFace[0] = entry.getValue().get(i * 4); |
||||||
|
uvCoordsForASingleFace[1] = entry.getValue().get(i * 4 + 1); |
||||||
|
uvCoordsForASingleFace[2] = entry.getValue().get(i * 4 + 2); |
||||||
|
uvCoordinatesForFace.put(entry.getKey(), uvCoordsForASingleFace); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
int v1 = ((Number) mFace.getFieldValue("v1")).intValue(); |
||||||
|
int v2 = ((Number) mFace.getFieldValue("v2")).intValue(); |
||||||
|
int v3 = ((Number) mFace.getFieldValue("v3")).intValue(); |
||||||
|
int v4 = ((Number) mFace.getFieldValue("v4")).intValue(); |
||||||
|
if(vertexColorIndex != null) { |
||||||
|
vertexColorIndex[0] = i * 4; |
||||||
|
vertexColorIndex[1] = i * 4 + 1; |
||||||
|
vertexColorIndex[2] = i * 4 + 2; |
||||||
|
} |
||||||
|
|
||||||
|
this.appendFace(v1, v2, v3, smooth, materialNumber, uvs == null ? null : uvCoordinatesForFace, vertexColorIndex); |
||||||
|
uvCoordinatesForFace.clear(); |
||||||
|
if (v4 > 0) { |
||||||
|
if (uvs != null) { |
||||||
|
// uvs always must be added wheater we have texture or not
|
||||||
|
for (Entry<String, List<Vector2f>> entry : uvs.entrySet()) { |
||||||
|
Vector2f[] uvCoordsForASingleFace = new Vector2f[3]; |
||||||
|
uvCoordsForASingleFace[0] = entry.getValue().get(i * 4); |
||||||
|
uvCoordsForASingleFace[1] = entry.getValue().get(i * 4 + 2); |
||||||
|
uvCoordsForASingleFace[2] = entry.getValue().get(i * 4 + 3); |
||||||
|
uvCoordinatesForFace.put(entry.getKey(), uvCoordsForASingleFace); |
||||||
|
} |
||||||
|
} |
||||||
|
if(vertexColorIndex != null) { |
||||||
|
vertexColorIndex[0] = i * 4; |
||||||
|
vertexColorIndex[1] = i * 4 + 2; |
||||||
|
vertexColorIndex[2] = i * 4 + 3; |
||||||
|
} |
||||||
|
this.appendFace(v1, v3, v4, smooth, materialNumber, uvs == null ? null : uvCoordinatesForFace, vertexColorIndex); |
||||||
|
uvCoordinatesForFace.clear(); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* 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 uvsForFace |
||||||
|
* a 3-element array of vertices UV coordinates mapped to the UV's set name |
||||||
|
*/ |
||||||
|
private void appendFace(int v1, int v2, int v3, boolean smooth, int materialNumber, Map<String, Vector2f[]> uvsForFace, int[] vertexColorIndex) { |
||||||
|
if (uvsForFace != null && uvsForFace.size() > 0) { |
||||||
|
for (Entry<String, Vector2f[]> entry : uvsForFace.entrySet()) { |
||||||
|
if (entry.getValue().length != 3) { |
||||||
|
throw new IllegalArgumentException("UV coordinates must be a 3-element array!" + (entry.getKey() != null ? " (UV set name: " + entry.getKey() + ')' : "")); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// getting the required lists
|
||||||
|
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<byte[]> vertexColorsList = vertexColorsMap != null ? vertexColorsMap.get(materialNumber) : null; |
||||||
|
if (vertexColorsList == null && vertexColorsMap != null) { |
||||||
|
vertexColorsList = new ArrayList<byte[]>(); |
||||||
|
vertexColorsMap.put(materialNumber, vertexColorsList); |
||||||
|
} |
||||||
|
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); |
||||||
|
} |
||||||
|
|
||||||
|
// creating faces
|
||||||
|
Integer[] index = new Integer[] { v1, v2, v3 }; |
||||||
|
if (smooth && !usesGeneratedTextures) { |
||||||
|
for (int i = 0; i < 3; ++i) { |
||||||
|
if (!vertexReferenceMap.containsKey(index[i])) { |
||||||
|
// if this index is not yet used then create another face
|
||||||
|
this.appendVertexReference(index[i], vertexList.size(), vertexReferenceMap); |
||||||
|
if (uvsForFace != null) { |
||||||
|
for (Entry<String, Vector2f[]> entry : uvsForFace.entrySet()) { |
||||||
|
userUVCollection.addUV(materialNumber, entry.getKey(), entry.getValue()[i], vertexList.size()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
vertexList.add(verticesAndNormals[index[i]][0]); |
||||||
|
if (verticesColors != null) { |
||||||
|
vertexColorsList.add(verticesColors.get(vertexColorIndex[i])); |
||||||
|
} |
||||||
|
normalList.add(verticesAndNormals[index[i]][1]); |
||||||
|
|
||||||
|
index[i] = vertexList.size() - 1; |
||||||
|
} else if (uvsForFace != null) { |
||||||
|
// if the index is used then check if the vertexe's UV coordinates match, if yes then the vertex doesn't have separate UV's
|
||||||
|
// in different faces so we can use it here as well, if UV's are different in separate faces the we need to add this vert
|
||||||
|
// because in jme one vertex can have only on UV coordinate
|
||||||
|
boolean vertexAlreadyUsed = false; |
||||||
|
for (Integer vertexIndex : vertexReferenceMap.get(index[i])) { |
||||||
|
int vertexUseCounter = 0; |
||||||
|
for (Entry<String, Vector2f[]> entry : uvsForFace.entrySet()) { |
||||||
|
if (entry.getValue()[i].equals(userUVCollection.getUVForVertex(entry.getKey(), vertexIndex))) { |
||||||
|
++vertexUseCounter; |
||||||
|
} |
||||||
|
} |
||||||
|
if (vertexUseCounter == uvsForFace.size()) { |
||||||
|
vertexAlreadyUsed = true; |
||||||
|
index[i] = vertexIndex; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if (!vertexAlreadyUsed) { |
||||||
|
// treat this face as a new one because its vertices have separate UV's
|
||||||
|
this.appendVertexReference(index[i], vertexList.size(), vertexReferenceMap); |
||||||
|
for (Entry<String, Vector2f[]> entry : uvsForFace.entrySet()) { |
||||||
|
userUVCollection.addUV(materialNumber, entry.getKey(), entry.getValue()[i], vertexList.size()); |
||||||
|
} |
||||||
|
vertexList.add(verticesAndNormals[index[i]][0]); |
||||||
|
if (verticesColors != null) { |
||||||
|
vertexColorsList.add(verticesColors.get(vertexColorIndex[i])); |
||||||
|
} |
||||||
|
normalList.add(verticesAndNormals[index[i]][1]); |
||||||
|
index[i] = vertexList.size() - 1; |
||||||
|
} |
||||||
|
} else { |
||||||
|
// use this index again
|
||||||
|
index[i] = vertexList.indexOf(verticesAndNormals[index[i]][0]); |
||||||
|
} |
||||||
|
indexList.add(index[i]); |
||||||
|
} |
||||||
|
} else { |
||||||
|
Vector3f n = smooth ? null : FastMath.computeNormal(verticesAndNormals[v1][0], verticesAndNormals[v2][0], verticesAndNormals[v3][0]); |
||||||
|
for (int i = 0; i < 3; ++i) { |
||||||
|
indexList.add(vertexList.size()); |
||||||
|
this.appendVertexReference(index[i], vertexList.size(), vertexReferenceMap); |
||||||
|
if (uvsForFace != null) { |
||||||
|
for (Entry<String, Vector2f[]> entry : uvsForFace.entrySet()) { |
||||||
|
userUVCollection.addUV(materialNumber, entry.getKey(), entry.getValue()[i], vertexList.size()); |
||||||
|
} |
||||||
|
} |
||||||
|
vertexList.add(verticesAndNormals[index[i]][0]); |
||||||
|
if (verticesColors != null) { |
||||||
|
vertexColorsList.add(verticesColors.get(vertexColorIndex[i])); |
||||||
|
} |
||||||
|
normalList.add(smooth ? verticesAndNormals[index[i]][1] : n); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* The method loads the UV coordinates. The result is a map where the key is the user's UV set name and the values are UV coordinates. |
||||||
|
* But depending on the mesh type (triangle/quads or bmesh) the lists in the map have different meaning. |
||||||
|
* For bmesh they are enlisted just like they are stored in the blend file (in loops). |
||||||
|
* For traditional faces every 4 UV's should be assigned for a single face. |
||||||
|
* @param meshStructure |
||||||
|
* the mesh structure |
||||||
|
* @param useBMesh |
||||||
|
* tells if we should load the coordinates from loops of from faces |
||||||
|
* @param blenderContext |
||||||
|
* the blender context |
||||||
|
* @return a map that sorts UV coordinates between different UV sets |
||||||
|
* @throws BlenderFileException |
||||||
|
* an exception is thrown when problems with blend file occur |
||||||
|
*/ |
||||||
|
@SuppressWarnings("unchecked") |
||||||
|
private Map<String, List<Vector2f>> loadUVCoordinates(Structure meshStructure, boolean useBMesh, BlenderContext blenderContext) throws BlenderFileException { |
||||||
|
Map<String, List<Vector2f>> result = new HashMap<String, List<Vector2f>>(); |
||||||
|
if (useBMesh) { |
||||||
|
// in this case the UV's are assigned to vertices (an array is the same length as the vertex array)
|
||||||
|
Structure loopData = (Structure) meshStructure.getFieldValue("ldata"); |
||||||
|
Pointer pLoopDataLayers = (Pointer) loopData.getFieldValue("layers"); |
||||||
|
List<Structure> loopDataLayers = pLoopDataLayers.fetchData(blenderContext.getInputStream()); |
||||||
|
for (Structure structure : loopDataLayers) { |
||||||
|
Pointer p = (Pointer) structure.getFieldValue("data"); |
||||||
|
if (p.isNotNull() && ((Number) structure.getFieldValue("type")).intValue() == MeshHelper.UV_DATA_LAYER_TYPE_BMESH) { |
||||||
|
String uvSetName = structure.getFieldValue("name").toString(); |
||||||
|
List<Structure> uvsStructures = p.fetchData(blenderContext.getInputStream()); |
||||||
|
List<Vector2f> uvs = new ArrayList<Vector2f>(uvsStructures.size()); |
||||||
|
for (Structure uvStructure : uvsStructures) { |
||||||
|
DynamicArray<Number> loopUVS = (DynamicArray<Number>) uvStructure.getFieldValue("uv"); |
||||||
|
uvs.add(new Vector2f(loopUVS.get(0).floatValue(), loopUVS.get(1).floatValue())); |
||||||
|
} |
||||||
|
result.put(uvSetName, uvs); |
||||||
|
} |
||||||
|
} |
||||||
|
} else { |
||||||
|
// in this case UV's are assigned to faces (the array has the same legnth as the faces count)
|
||||||
|
Structure facesData = (Structure) meshStructure.getFieldValue("fdata"); |
||||||
|
Pointer pFacesDataLayers = (Pointer) facesData.getFieldValue("layers"); |
||||||
|
List<Structure> facesDataLayers = pFacesDataLayers.fetchData(blenderContext.getInputStream()); |
||||||
|
for (Structure structure : facesDataLayers) { |
||||||
|
Pointer p = (Pointer) structure.getFieldValue("data"); |
||||||
|
if (p.isNotNull() && ((Number) structure.getFieldValue("type")).intValue() == MeshHelper.UV_DATA_LAYER_TYPE_FMESH) { |
||||||
|
String uvSetName = structure.getFieldValue("name").toString(); |
||||||
|
List<Structure> uvsStructures = p.fetchData(blenderContext.getInputStream()); |
||||||
|
List<Vector2f> uvs = new ArrayList<Vector2f>(uvsStructures.size()); |
||||||
|
for (Structure uvStructure : uvsStructures) { |
||||||
|
DynamicArray<Number> mFaceUVs = (DynamicArray<Number>) uvStructure.getFieldValue("uv"); |
||||||
|
uvs.add(new Vector2f(mFaceUVs.get(0).floatValue(), mFaceUVs.get(1).floatValue())); |
||||||
|
uvs.add(new Vector2f(mFaceUVs.get(2).floatValue(), mFaceUVs.get(3).floatValue())); |
||||||
|
uvs.add(new Vector2f(mFaceUVs.get(4).floatValue(), mFaceUVs.get(5).floatValue())); |
||||||
|
uvs.add(new Vector2f(mFaceUVs.get(6).floatValue(), mFaceUVs.get(7).floatValue())); |
||||||
|
} |
||||||
|
result.put(uvSetName, uvs); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* This method returns the vertices colors. Each vertex is stored in byte[4] array. |
||||||
|
* |
||||||
|
* @param meshStructure |
||||||
|
* the structure containing the mesh data |
||||||
|
* @param blenderContext |
||||||
|
* the blender context |
||||||
|
* @return a list of vertices colors, each color belongs to a single vertex |
||||||
|
* @throws BlenderFileException |
||||||
|
* this exception is thrown when the blend file structure is somehow invalid or corrupted |
||||||
|
*/ |
||||||
|
private List<byte[]> getVerticesColors(Structure meshStructure, BlenderContext blenderContext) throws BlenderFileException { |
||||||
|
MeshHelper meshHelper = blenderContext.getHelper(MeshHelper.class); |
||||||
|
Pointer pMCol = (Pointer) meshStructure.getFieldValue(meshHelper.isBMeshCompatible(meshStructure) ? "mloopcol" : "mcol"); |
||||||
|
List<byte[]> verticesColors = null; |
||||||
|
// it was likely a bug in blender untill version 2.63 (the blue and red factors were misplaced in their structure)
|
||||||
|
// so we need to put them right
|
||||||
|
boolean useBGRA = blenderContext.getBlenderVersion() < 263; |
||||||
|
if (pMCol.isNotNull()) { |
||||||
|
List<Structure> mCol = pMCol.fetchData(blenderContext.getInputStream()); |
||||||
|
verticesColors = new ArrayList<byte[]>(mCol.size()); |
||||||
|
for (Structure color : mCol) { |
||||||
|
byte r = ((Number) color.getFieldValue("r")).byteValue(); |
||||||
|
byte g = ((Number) color.getFieldValue("g")).byteValue(); |
||||||
|
byte b = ((Number) color.getFieldValue("b")).byteValue(); |
||||||
|
byte a = ((Number) color.getFieldValue("a")).byteValue(); |
||||||
|
verticesColors.add(useBGRA ? new byte[] { b, g, r, a } : new byte[] { r, g, b, a }); |
||||||
|
} |
||||||
|
} |
||||||
|
return verticesColors; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @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; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @param materialNumber |
||||||
|
* the material index |
||||||
|
* @return result vertices array |
||||||
|
*/ |
||||||
|
private Vector3f[] getVertices(int materialNumber) { |
||||||
|
return vertexMap.get(materialNumber).toArray(new Vector3f[vertexMap.get(materialNumber).size()]); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @param materialNumber |
||||||
|
* the material index |
||||||
|
* @return the amount of result vertices |
||||||
|
*/ |
||||||
|
private int getVerticesAmount(int materialNumber) { |
||||||
|
return vertexMap.get(materialNumber).size(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @param materialNumber |
||||||
|
* the material index |
||||||
|
* @return normals result array |
||||||
|
*/ |
||||||
|
private Vector3f[] getNormals(int materialNumber) { |
||||||
|
return normalMap.get(materialNumber).toArray(new Vector3f[normalMap.get(materialNumber).size()]); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @param materialNumber |
||||||
|
* the material index |
||||||
|
* @return the vertices colors buffer or null if no vertex colors is set |
||||||
|
*/ |
||||||
|
private ByteBuffer getVertexColorsBuffer(int materialNumber) { |
||||||
|
ByteBuffer result = null; |
||||||
|
if (verticesColors != null && vertexColorsMap.get(materialNumber) != null) { |
||||||
|
List<byte[]> data = vertexColorsMap.get(materialNumber); |
||||||
|
result = BufferUtils.createByteBuffer(4 * data.size()); |
||||||
|
for (byte[] v : data) { |
||||||
|
if (v != null) { |
||||||
|
result.put(v[0]).put(v[1]).put(v[2]).put(v[3]); |
||||||
|
} else { |
||||||
|
result.put((byte) 0).put((byte) 0).put((byte) 0).put((byte) 0); |
||||||
|
} |
||||||
|
} |
||||||
|
result.flip(); |
||||||
|
} |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @param materialNumber |
||||||
|
* the material number that is appied to the mesh |
||||||
|
* @return UV coordinates of vertices that belong to the required mesh part |
||||||
|
*/ |
||||||
|
public LinkedHashMap<String, List<Vector2f>> getUVCoordinates(int materialNumber) { |
||||||
|
return userUVCollection.getUVCoordinates(materialNumber); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return indicates if the mesh has UV coordinates |
||||||
|
*/ |
||||||
|
public boolean hasUVCoordinates() { |
||||||
|
return userUVCollection.hasUVCoordinates(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return <b>true</b> if the mesh has no vertices and <b>false</b> otherwise |
||||||
|
*/ |
||||||
|
public boolean isEmpty() { |
||||||
|
return vertexMap.size() == 0; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* 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)); |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,5 @@ |
|||||||
|
package com.jme3.scene.plugins.blender.meshes.builders; |
||||||
|
|
||||||
|
/*package*/ class LineMeshBuilder { |
||||||
|
//TODO: this will be implemented soon
|
||||||
|
} |
||||||
@ -0,0 +1,129 @@ |
|||||||
|
package com.jme3.scene.plugins.blender.meshes.builders; |
||||||
|
|
||||||
|
import java.util.ArrayList; |
||||||
|
import java.util.HashMap; |
||||||
|
import java.util.LinkedHashMap; |
||||||
|
import java.util.List; |
||||||
|
import java.util.Map; |
||||||
|
import java.util.Map.Entry; |
||||||
|
|
||||||
|
import com.jme3.math.Vector2f; |
||||||
|
import com.jme3.math.Vector3f; |
||||||
|
import com.jme3.scene.Mesh; |
||||||
|
import com.jme3.scene.plugins.blender.BlenderContext; |
||||||
|
import com.jme3.scene.plugins.blender.file.BlenderFileException; |
||||||
|
import com.jme3.scene.plugins.blender.file.DynamicArray; |
||||||
|
import com.jme3.scene.plugins.blender.file.Pointer; |
||||||
|
import com.jme3.scene.plugins.blender.file.Structure; |
||||||
|
import com.jme3.scene.plugins.blender.materials.MaterialContext; |
||||||
|
|
||||||
|
public class MeshBuilder { |
||||||
|
private boolean fixUpAxis; |
||||||
|
//TODO: these will be added soon
|
||||||
|
// private PointMeshBuilder pointMeshBuilder;
|
||||||
|
// private LineMeshBuilder lineMeshBuilder;
|
||||||
|
private FaceMeshBuilder faceMeshBuilder; |
||||||
|
|
||||||
|
public MeshBuilder(Structure meshStructure, MaterialContext[] materials, BlenderContext blenderContext) throws BlenderFileException { |
||||||
|
fixUpAxis = blenderContext.getBlenderKey().isFixUpAxis(); |
||||||
|
Vector3f[][] verticesAndNormals = this.getVerticesAndNormals(meshStructure, blenderContext); |
||||||
|
boolean generatedTexturesPresent = this.areGeneratedTexturesPresent(materials); |
||||||
|
|
||||||
|
faceMeshBuilder = new FaceMeshBuilder(verticesAndNormals, generatedTexturesPresent); |
||||||
|
faceMeshBuilder.readMesh(meshStructure, blenderContext); |
||||||
|
} |
||||||
|
|
||||||
|
public Map<Integer, List<Mesh>> buildMeshes() { |
||||||
|
Map<Integer, List<Mesh>> result = new HashMap<Integer, List<Mesh>>(); |
||||||
|
|
||||||
|
Map<Integer, Mesh> meshes = faceMeshBuilder.buildMeshes(); |
||||||
|
for(Entry<Integer, Mesh> entry : meshes.entrySet()) { |
||||||
|
List<Mesh> meshList = new ArrayList<Mesh>(); |
||||||
|
meshList.add(entry.getValue()); |
||||||
|
result.put(entry.getKey(), meshList); |
||||||
|
} |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
public boolean isEmpty() { |
||||||
|
return faceMeshBuilder.isEmpty(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @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 faceMeshBuilder.getVertexReferenceMap(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @param materialNumber |
||||||
|
* the material number that is appied to the mesh |
||||||
|
* @return UV coordinates of vertices that belong to the required mesh part |
||||||
|
*/ |
||||||
|
public LinkedHashMap<String, List<Vector2f>> getUVCoordinates(int materialNumber) { |
||||||
|
return faceMeshBuilder.getUVCoordinates(materialNumber); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return indicates if the mesh has UV coordinates |
||||||
|
*/ |
||||||
|
public boolean hasUVCoordinates() { |
||||||
|
return faceMeshBuilder.hasUVCoordinates(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* This method returns the vertices. |
||||||
|
* |
||||||
|
* @param meshStructure |
||||||
|
* the structure containing the mesh data |
||||||
|
* @param blenderContext |
||||||
|
* the blender context |
||||||
|
* @return a list of two - element arrays, the first element is the vertex and the second - its normal |
||||||
|
* @throws BlenderFileException |
||||||
|
* this exception is thrown when the blend file structure is somehow invalid or corrupted |
||||||
|
*/ |
||||||
|
@SuppressWarnings("unchecked") |
||||||
|
private Vector3f[][] getVerticesAndNormals(Structure meshStructure, BlenderContext blenderContext) throws BlenderFileException { |
||||||
|
int count = ((Number) meshStructure.getFieldValue("totvert")).intValue(); |
||||||
|
Vector3f[][] result = new Vector3f[count][2]; |
||||||
|
if (count == 0) { |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
Pointer pMVert = (Pointer) meshStructure.getFieldValue("mvert"); |
||||||
|
List<Structure> mVerts = pMVert.fetchData(blenderContext.getInputStream()); |
||||||
|
if (fixUpAxis) { |
||||||
|
for (int i = 0; i < count; ++i) { |
||||||
|
DynamicArray<Number> coordinates = (DynamicArray<Number>) mVerts.get(i).getFieldValue("co"); |
||||||
|
result[i][0] = new Vector3f(coordinates.get(0).floatValue(), coordinates.get(2).floatValue(), -coordinates.get(1).floatValue()); |
||||||
|
|
||||||
|
DynamicArray<Number> normals = (DynamicArray<Number>) mVerts.get(i).getFieldValue("no"); |
||||||
|
result[i][1] = new Vector3f(normals.get(0).shortValue() / 32767.0f, normals.get(2).shortValue() / 32767.0f, -normals.get(1).shortValue() / 32767.0f); |
||||||
|
} |
||||||
|
} else { |
||||||
|
for (int i = 0; i < count; ++i) { |
||||||
|
DynamicArray<Number> coordinates = (DynamicArray<Number>) mVerts.get(i).getFieldValue("co"); |
||||||
|
result[i][0] = new Vector3f(coordinates.get(0).floatValue(), coordinates.get(1).floatValue(), coordinates.get(2).floatValue()); |
||||||
|
|
||||||
|
DynamicArray<Number> normals = (DynamicArray<Number>) mVerts.get(i).getFieldValue("no"); |
||||||
|
result[i][1] = new Vector3f(normals.get(0).shortValue() / 32767.0f, normals.get(1).shortValue() / 32767.0f, normals.get(2).shortValue() / 32767.0f); |
||||||
|
} |
||||||
|
} |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return <b>true</b> if the material has at least one generated component and <b>false</b> otherwise |
||||||
|
*/ |
||||||
|
private boolean areGeneratedTexturesPresent(MaterialContext[] materials) { |
||||||
|
if (materials != null) { |
||||||
|
for (MaterialContext material : materials) { |
||||||
|
if (material != null && material.hasGeneratedTextures()) { |
||||||
|
return true; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,5 @@ |
|||||||
|
package com.jme3.scene.plugins.blender.meshes.builders; |
||||||
|
|
||||||
|
/*package*/ class PointMeshBuilder { |
||||||
|
//TODO: this will be implemented soon
|
||||||
|
} |
||||||
Loading…
Reference in new issue