/*
* Copyright (c) 2009-2012 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.scene.plugins.ogre;
//import static com.jmex.model.XMLUtil.getAttribute;
//import static com.jmex.model.XMLUtil.getIntAttribute;
//
//import java.util.ArrayList;
//import java.util.List;
//import java.util.Map;
//
//import org.w3c.dom.Node;
//
//import com.jme.math.Vector3f;
//import com.jmex.model.XMLUtil;
//import com.jmex.model.ogrexml.anim.PoseTrack.PoseFrame;
/**
* Utility class used by OgreLoader to load poses and mesh animations.
*/
public class MeshAnimationLoader {
// public static void loadMeshAnimations(Node animationsNode, List<Pose> poseList, OgreMesh sharedgeom, List<OgreMesh> submeshes, Map<String, Animation> animations){
// Node animationNode = animationsNode.getFirstChild();
// while (animationNode != null){
// if (animationNode.getNodeName().equals("animation")){
// MeshAnimation mAnim =
// loadMeshAnimation(animationNode, poseList, sharedgeom, submeshes);
//
// Animation anim = animations.get(mAnim.getName());
// if (anim != null){
// anim.setMeshAnimation(mAnim);
// }else{
// anim = new Animation(null, mAnim);
// animations.put(anim.getName(), anim);
// }
// }
// animationNode = animationNode.getNextSibling();
// }
//
//// Map<TriMesh, List<Pose>> trimeshPoses = new HashMap<TriMesh, List<Pose>>();
////
//// // find the poses for each mesh
//// for (Pose p : poses){
//// List<Pose> poseList = trimeshPoses.get(p.getTarget());
//// if (poseList == null){
//// poseList = new ArrayList<Pose>();
//// trimeshPoses.put(p.getTarget(), poseList);
//// }
////
//// poseList.add(p);
//// }
////
//// for (Map.Entry<TriMesh, List<Pose>> poseEntry: trimeshPoses){
//// PoseController
//// }
// }
//
// public static MeshAnimation loadMeshAnimation(Node animationNode, List<Pose> poseList, OgreMesh sharedgeom, List<OgreMesh> submeshes){
// String name = XMLUtil.getAttribute(animationNode, "name");
// float length = XMLUtil.getFloatAttribute(animationNode, "length");
//
// MeshAnimation anim = new MeshAnimation(name, length);
// List<Track> tracks = new ArrayList<Track>();
//
// Node tracksNode = XMLUtil.getChildNode(animationNode, "tracks");
// if (tracksNode != null){
// Node trackNode = tracksNode.getFirstChild();
// while (trackNode != null){
// if (trackNode.getNodeName().equals("track")){
// int targetMeshIndex;
// if (XMLUtil.getAttribute(trackNode, "target").equals("mesh")){
// targetMeshIndex = -1;
// }else{
// if (XMLUtil.getAttribute(trackNode, "index") == null)
// targetMeshIndex = 0;
// else
// targetMeshIndex = getIntAttribute(trackNode, "index");
// }
//
// if (XMLUtil.getAttribute(trackNode, "type").equals("pose")){
// PoseTrack pt = loadPoseTrack(trackNode, targetMeshIndex, poseList);
// tracks.add(pt);
// }else{
// throw new UnsupportedOperationException("Morph animations not supported!");
// }
// }
//
// trackNode = trackNode.getNextSibling();
// }
// }
//
// anim.setTracks(tracks.toArray(new Track[0]));
//
// return anim;
// }
//
// public static List<Pose> loadPoses(Node posesNode, OgreMesh sharedgeom, List<OgreMesh> submeshes){
// List<Pose> poses = new ArrayList<Pose>();
// Node poseNode = posesNode.getFirstChild();
// while (poseNode != null){
// if (poseNode.getNodeName().equals("pose")){
// int targetMeshIndex = 0;
// if (getAttribute(poseNode, "target").equals("mesh")){
// targetMeshIndex = -1;
// }else{
// if (getAttribute(poseNode, "index") == null)
// targetMeshIndex = 0;
// else
// targetMeshIndex = getIntAttribute(poseNode, "index");
// }
//
// Pose p = MeshAnimationLoader.loadPose(poseNode, targetMeshIndex);
// poses.add(p);
// }
//
// poseNode = poseNode.getNextSibling();
// }
//
// return poses;
// }
//
// public static Pose loadPose(Node poseNode, int targetMeshIndex){
// String name = XMLUtil.getAttribute(poseNode, "name");
//
// List<Vector3f> offsets = new ArrayList<Vector3f>();
// List<Integer> indices = new ArrayList<Integer>();
//
// Node poseoffsetNode = poseNode.getFirstChild();
// while (poseoffsetNode != null){
// if (poseoffsetNode.getNodeName().equals("poseoffset")){
// int vertIndex = XMLUtil.getIntAttribute(poseoffsetNode, "index");
// Vector3f offset = new Vector3f();
// offset.x = XMLUtil.getFloatAttribute(poseoffsetNode, "x");
// offset.y = XMLUtil.getFloatAttribute(poseoffsetNode, "y");
// offset.z = XMLUtil.getFloatAttribute(poseoffsetNode, "z");
//
// offsets.add(offset);
// indices.add(vertIndex);
// }
//
// poseoffsetNode = poseoffsetNode.getNextSibling();
// }
//
// int[] indicesArray = new int[indices.size()];
// for (int i = 0; i < indicesArray.length; i++){
// indicesArray[i] = indices.get(i);
// }
//
// Pose pose = new Pose(name,
// targetMeshIndex,
// offsets.toArray(new Vector3f[0]),
// indicesArray);
//
// return pose;
// }
//
// public static PoseTrack loadPoseTrack(Node trackNode, int targetMeshIndex, List<Pose> posesList){
// List<Float> times = new ArrayList<Float>();
// List<PoseFrame> frames = new ArrayList<PoseFrame>();
//
// Node keyframesNode = XMLUtil.getChildNode(trackNode, "keyframes");
// Node keyframeNode = keyframesNode.getFirstChild();
// while (keyframeNode != null){
// if (keyframeNode.getNodeName().equals("keyframe")){
// float time = XMLUtil.getFloatAttribute(keyframeNode, "time");
// List<Pose> poses = new ArrayList<Pose>();
// List<Float> weights = new ArrayList<Float>();
//
// Node poserefNode = keyframeNode.getFirstChild();
// while (poserefNode != null){
// if (poserefNode.getNodeName().equals("poseref")){
// int poseindex = XMLUtil.getIntAttribute(poserefNode, "poseindex");
// poses.add(posesList.get(poseindex));
// float weight = XMLUtil.getFloatAttribute(poserefNode, "influence");
// weights.add(weight);
// }
//
// poserefNode = poserefNode.getNextSibling();
// }
//
// // convert poses and weights to arrays and create a PoseFrame
// float[] weightsArray = new float[weights.size()];
// for (int i = 0; i < weightsArray.length; i++){
// weightsArray[i] = weights.get(i);
// }
// PoseFrame frame = new PoseFrame(poses.toArray(new Pose[0]), weightsArray);
//
// times.add(time);
// frames.add(frame);
// }
//
// keyframeNode = keyframeNode.getNextSibling();
// }
//
// // convert times and frames to arrays and write to the track
// float[] timesArray = new float[times.size()];
// for (int i = 0; i < timesArray.length; i++){
// timesArray[i] = times.get(i);
// }
//
// PoseTrack track = new PoseTrack(targetMeshIndex,
// timesArray,
// frames.toArray(new PoseFrame[0]));
//
// return track;
// }
}