firstIndex += length;
}
// Create a record for the global ColladaStorage.
final String storeName = getSkinStoreName(instanceController, controller);
final SkinData skinDataStore = new SkinData(storeName);
// add pose to store
skinDataStore.setPose(skPose);
// Create a base Node for our skin meshes
final Node skinNode = new Node(meshNode.getName());
// copy Node render states across.
copyRenderStates(meshNode, skinNode);
// add node to store
skinDataStore.setSkinBaseNode(skinNode);
// Grab the bind_shape_matrix from skin
final Element bindShapeMatrixEL = skin.getChild("bind_shape_matrix");
final Transform bindShapeMatrix = new Transform();
if (bindShapeMatrixEL != null) {
final double[] array = _colladaDOMUtil.parseDoubleArray(bindShapeMatrixEL);
bindShapeMatrix.fromHomogeneousMatrix(new Matrix4().fromArray(array));
}
// Visit our Node and pull out any Mesh children. Turn them into SkinnedMeshes
for (final Spatial spat : meshNode.getChildren()) {
if (spat instanceof Mesh && ((Mesh) spat).getMeshData().getVertexCount() > 0) {
final Mesh sourceMesh = (Mesh) spat;
final SkinnedMesh skMesh = new SkinnedMesh(sourceMesh.getName());
skMesh.setCurrentPose(skPose);
// copy material info mapping for later use
final String material = _dataCache.getMeshMaterialMap().get(sourceMesh);
_dataCache.getMeshMaterialMap().put(skMesh, material);
// copy mesh render states across.
copyRenderStates(sourceMesh, skMesh);
// copy hints across
skMesh.getSceneHints().set(sourceMesh.getSceneHints());
try {
// Use source mesh as bind pose data in the new SkinnedMesh
final MeshData bindPose = copyMeshData(sourceMesh.getMeshData());
skMesh.setBindPoseData(bindPose);
// Apply our BSM
if (!bindShapeMatrix.isIdentity()) {
bindPose.transformVertices(bindShapeMatrix);
if (bindPose.getNormalBuffer() != null) {
bindPose.transformNormals(bindShapeMatrix, true);
}
}
// TODO: This is only needed for CPU skinning... consider a way of making it optional.
// Copy bind pose to mesh data to setup for CPU skinning
final MeshData meshData = copyMeshData(skMesh.getBindPoseData());
meshData.getVertexCoords().setVboAccessMode(VBOAccessMode.StreamDraw);
if (meshData.getNormalCoords() != null) {
meshData.getNormalCoords().setVboAccessMode(VBOAccessMode.StreamDraw);
}
skMesh.setMeshData(meshData);
} catch (final IOException e) {
e.printStackTrace();
throw new ColladaException("Unable to copy skeleton bind pose data.", geometry);
}
// Grab the MeshVertPairs from Global for this mesh.
final Collection<MeshVertPairs> vertPairsList = _dataCache.getVertMappings().get(geometry);
MeshVertPairs pairsMap = null;
if (vertPairsList != null) {
for (final MeshVertPairs pairs : vertPairsList) {
if (pairs.getMesh() == sourceMesh) {
pairsMap = pairs;
break;
}
}
}
if (pairsMap == null) {
throw new ColladaException("Unable to locate pair map for geometry.", geometry);
}
// Check for a remapping, if we optimized geometry
final VertMap vertMap = _dataCache.getMeshVertMap().get(sourceMesh);
// Use pairs map and vertWeightMap to build our weights and joint indices.
{
// count number of weights used
int maxWeightsPerVert = 0;
int weightCount;
for (final int originalIndex : pairsMap.getIndices()) {
weightCount = 0;
// get weights and joints at original index and add weights up to get divisor sum
// we'll assume 0's for vertices with no matching weight.
if (vertWeightMap.length > originalIndex) {
final int[] data = vertWeightMap[originalIndex];
for (int i = 0; i < data.length; i += maxOffset + 1) {
final float weight = jointWeights.get(data[i + weightOff]);
if (weight != 0) {
weightCount++;
}
}
if (weightCount > maxWeightsPerVert) {
maxWeightsPerVert = weightCount;
}
}
}
final int verts = skMesh.getMeshData().getVertexCount();
final FloatBuffer weightBuffer = BufferUtils.createFloatBuffer(verts * maxWeightsPerVert);
final ShortBuffer jointIndexBuffer = BufferUtils.createShortBuffer(verts * maxWeightsPerVert);
int j;
float sum = 0;
final float[] weights = new float[maxWeightsPerVert];
final short[] indices = new short[maxWeightsPerVert];
int originalIndex;
for (int x = 0; x < verts; x++) {
if (vertMap != null) {
originalIndex = pairsMap.getIndices()[vertMap.getFirstOldIndex(x)];
} else {
originalIndex = pairsMap.getIndices()[x];
}
j = 0;
sum = 0;
// get weights and joints at original index and add weights up to get divisor sum
// we'll assume 0's for vertices with no matching weight.
if (vertWeightMap.length > originalIndex) {
final int[] data = vertWeightMap[originalIndex];
for (int i = 0; i < data.length; i += maxOffset + 1) {
final float weight = jointWeights.get(data[i + weightOff]);
if (weight != 0) {
weights[j] = jointWeights.get(data[i + weightOff]);
indices[j] = (short) order[jointIndices.get(data[i + indOff])];
sum += weights[j++];
}
}
}
// add extra padding as needed
while (j < maxWeightsPerVert) {
weights[j] = 0;
indices[j++] = 0;
}
// add weights to weightBuffer / sum
for (final float w : weights) {
weightBuffer.put(sum != 0 ? w / sum : 0);
}
// add joint indices to jointIndexBuffer
jointIndexBuffer.put(indices);
}
final float[] totalWeights = new float[weightBuffer.capacity()];
weightBuffer.flip();
weightBuffer.get(totalWeights);
skMesh.setWeights(totalWeights);
final short[] totalIndices = new short[jointIndexBuffer.capacity()];
jointIndexBuffer.flip();
jointIndexBuffer.get(totalIndices);
skMesh.setJointIndices(totalIndices);
skMesh.setWeightsPerVert(maxWeightsPerVert);
}
// add to the skinNode.
skinNode.attachChild(skMesh);
// Manually apply our bind pose to the skin mesh.
skMesh.applyPose();
// Update the model bounding.
skMesh.updateModelBound();
// add mesh to store
skinDataStore.getSkins().add(skMesh);
}
}
// add to Node
ardorParentNode.attachChild(skinNode);