Example usage for org.jdom2 Element getAttributeValue

List of usage examples for org.jdom2 Element getAttributeValue

Introduction

In this page you can find the example usage for org.jdom2 Element getAttributeValue.

Prototype

public String getAttributeValue(final String attname) 

Source Link

Document

This returns the attribute value for the attribute with the given name and within no namespace, null if there is no such attribute, and the empty string if the attribute value is empty.

Usage

From source file:com.ardor3d.extension.model.collada.jdom.ColladaAnimUtils.java

License:Open Source License

/**
 * Construct skin mesh(es) from the skin element and attach them (under a single new Node) to the given parent Node.
 * /*  w  w  w.  j ava2 s.c  o  m*/
 * @param ardorParentNode
 *            Ardor3D Node to attach our skin node to.
 * @param instanceController
 *            the <instance_controller> element. We'll parse the skeleton reference from here.
 * @param controller
 *            the referenced <controller> element. Used for naming purposes.
 * @param skin
 *            our <skin> element.
 */
@SuppressWarnings("unchecked")
private void buildSkinMeshes(final Node ardorParentNode, final Element instanceController,
        final Element controller, final Element skin) {
    final String skinSource = skin.getAttributeValue("source");

    final Element skinNodeEL = _colladaDOMUtil.findTargetWithId(skinSource);
    if (skinNodeEL == null || !"geometry".equals(skinNodeEL.getName())) {
        throw new ColladaException(
                "Expected a mesh for skin source with url: " + skinSource + " got instead: " + skinNodeEL,
                skin);
    }

    final Element geometry = skinNodeEL;

    final Node meshNode = _colladaMeshUtils.buildMesh(geometry);
    if (meshNode != null) {
        // Look for skeleton entries in the original <instance_controller> element
        final List<Element> skeletonRoots = Lists.newArrayList();
        for (final Element sk : instanceController.getChildren("skeleton")) {
            final Element skroot = _colladaDOMUtil.findTargetWithId(sk.getText());
            if (skroot != null) {
                // add as a possible root for when we need to locate a joint by name later.
                skeletonRoots.add(skroot);
            } else {
                throw new ColladaException(
                        "Unable to find node with id: " + sk.getText() + ", referenced from skeleton " + sk,
                        sk);
            }
        }

        // Read in our joints node
        final Element jointsEL = skin.getChild("joints");
        if (jointsEL == null) {
            throw new ColladaException("skin found without joints.", skin);
        }

        // Pull out our joint names and bind matrices
        final List<String> jointNames = Lists.newArrayList();
        final List<Transform> bindMatrices = Lists.newArrayList();
        final List<ColladaInputPipe.ParamType> paramTypes = Lists.newArrayList();

        for (final Element inputEL : jointsEL.getChildren("input")) {
            final ColladaInputPipe pipe = new ColladaInputPipe(_colladaDOMUtil, inputEL);
            final ColladaInputPipe.SourceData sd = pipe.getSourceData();
            if (pipe.getType() == ColladaInputPipe.Type.JOINT) {
                final String[] namesData = sd.stringArray;
                for (int i = sd.offset; i < namesData.length; i += sd.stride) {
                    jointNames.add(namesData[i]);
                    paramTypes.add(sd.paramType);
                }
            } else if (pipe.getType() == ColladaInputPipe.Type.INV_BIND_MATRIX) {
                final float[] floatData = sd.floatArray;
                final FloatBuffer source = BufferUtils.createFloatBufferOnHeap(16);
                for (int i = sd.offset; i < floatData.length; i += sd.stride) {
                    source.rewind();
                    source.put(floatData, i, 16);
                    source.flip();
                    final Matrix4 mat = new Matrix4().fromFloatBuffer(source);
                    bindMatrices.add(new Transform().fromHomogeneousMatrix(mat));
                }
            }
        }

        // Use the skeleton information from the instance_controller to set the parent array locations on the
        // joints.
        Skeleton ourSkeleton = null; // TODO: maybe not the best way. iterate
        final int[] order = new int[jointNames.size()];
        for (int i = 0; i < jointNames.size(); i++) {
            final String name = jointNames.get(i);
            final ParamType paramType = paramTypes.get(i);
            final String searcher = paramType == ParamType.idref_param ? "id" : "sid";
            Element found = null;
            for (final Element root : skeletonRoots) {
                if (name.equals(root.getAttributeValue(searcher))) {
                    found = root;
                } else if (paramType == ParamType.idref_param) {
                    found = _colladaDOMUtil.findTargetWithId(name);
                } else {
                    found = (Element) _colladaDOMUtil.selectSingleNode(root, ".//*[@sid='" + name + "']");
                }

                // Last resorts (bad exporters)
                if (found == null) {
                    found = _colladaDOMUtil.findTargetWithId(name);
                }
                if (found == null) {
                    found = (Element) _colladaDOMUtil.selectSingleNode(root, ".//*[@name='" + name + "']");
                }

                if (found != null) {
                    break;
                }
            }
            if (found == null) {
                if (paramType == ParamType.idref_param) {
                    found = _colladaDOMUtil.findTargetWithId(name);
                } else {
                    found = (Element) _colladaDOMUtil.selectSingleNode(geometry,
                            "/*//visual_scene//*[@sid='" + name + "']");
                }

                // Last resorts (bad exporters)
                if (found == null) {
                    found = _colladaDOMUtil.findTargetWithId(name);
                }
                if (found == null) {
                    found = (Element) _colladaDOMUtil.selectSingleNode(geometry,
                            "/*//visual_scene//*[@name='" + name + "']");
                }

                if (found == null) {
                    throw new ColladaException("Unable to find joint with " + searcher + ": " + name, skin);
                }
            }

            final Joint joint = _dataCache.getElementJointMapping().get(found);
            if (joint == null) {
                logger.warning("unable to parse joint for: " + found.getName() + " " + name);
                return;
            }
            joint.setInverseBindPose(bindMatrices.get(i));

            ourSkeleton = _dataCache.getJointSkeletonMapping().get(joint);
            order[i] = joint.getIndex();
        }

        // Make our skeleton pose
        SkeletonPose skPose = _dataCache.getSkeletonPoseMapping().get(ourSkeleton);
        if (skPose == null) {
            skPose = new SkeletonPose(ourSkeleton);
            _dataCache.getSkeletonPoseMapping().put(ourSkeleton, skPose);

            // attach any attachment points found for the skeleton's joints
            addAttachments(skPose);

            // Skeleton's default to bind position, so update the global transforms.
            skPose.updateTransforms();
        }

        // Read in our vertex_weights node
        final Element weightsEL = skin.getChild("vertex_weights");
        if (weightsEL == null) {
            throw new ColladaException("skin found without vertex_weights.", skin);
        }

        // Pull out our per vertex joint indices and weights
        final List<Short> jointIndices = Lists.newArrayList();
        final List<Float> jointWeights = Lists.newArrayList();
        int indOff = 0, weightOff = 0;

        int maxOffset = 0;
        for (final Element inputEL : weightsEL.getChildren("input")) {
            final ColladaInputPipe pipe = new ColladaInputPipe(_colladaDOMUtil, inputEL);
            final ColladaInputPipe.SourceData sd = pipe.getSourceData();
            if (pipe.getOffset() > maxOffset) {
                maxOffset = pipe.getOffset();
            }
            if (pipe.getType() == ColladaInputPipe.Type.JOINT) {
                indOff = pipe.getOffset();
                final String[] namesData = sd.stringArray;
                for (int i = sd.offset; i < namesData.length; i += sd.stride) {
                    // XXX: the Collada spec says this could be -1?
                    final String name = namesData[i];
                    final int index = jointNames.indexOf(name);
                    if (index >= 0) {
                        jointIndices.add((short) index);
                    } else {
                        throw new ColladaException("Unknown joint accessed: " + name, inputEL);
                    }
                }
            } else if (pipe.getType() == ColladaInputPipe.Type.WEIGHT) {
                weightOff = pipe.getOffset();
                final float[] floatData = sd.floatArray;
                for (int i = sd.offset; i < floatData.length; i += sd.stride) {
                    jointWeights.add(floatData[i]);
                }
            }
        }

        // Pull our values array
        int firstIndex = 0, count = 0;
        final int[] vals = _colladaDOMUtil.parseIntArray(weightsEL.getChild("v"));
        try {
            count = weightsEL.getAttribute("count").getIntValue();
        } catch (final DataConversionException e) {
            throw new ColladaException("Unable to parse count attribute.", weightsEL);
        }
        // use the vals to fill our vert weight map
        final int[][] vertWeightMap = new int[count][];
        int index = 0;
        for (final int length : _colladaDOMUtil.parseIntArray(weightsEL.getChild("vcount"))) {
            final int[] entry = new int[(maxOffset + 1) * length];
            vertWeightMap[index++] = entry;

            System.arraycopy(vals, (maxOffset + 1) * firstIndex, entry, 0, entry.length);

            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);

        // Add skin record to storage.
        _colladaStorage.getSkins().add(skinDataStore);
    }
}

From source file:com.ardor3d.extension.model.collada.jdom.ColladaAnimUtils.java

License:Open Source License

/**
 * Construct morph mesh(es) from the <morph> element and attach them (under a single new Node) to the given parent
 * Node.//from  w  ww. ja  v  a  2  s .co  m
 * 
 * Note: This method current does not do anything but attach the referenced mesh since Ardor3D does not yet support
 * morph target animation.
 * 
 * @param ardorParentNode
 *            Ardor3D Node to attach our morph mesh to.
 * @param controller
 *            the referenced <controller> element. Used for naming purposes.
 * @param morph
 *            our <morph> element
 */
private void buildMorphMeshes(final Node ardorParentNode, final Element controller, final Element morph) {
    final String skinSource = morph.getAttributeValue("source");

    final Element skinNode = _colladaDOMUtil.findTargetWithId(skinSource);
    if (skinNode == null || !"geometry".equals(skinNode.getName())) {
        throw new ColladaException("Expected a mesh for morph source with url: " + skinSource
                + " (line number is referring morph)", morph);
    }

    final Element geometry = skinNode;

    final Spatial baseMesh = _colladaMeshUtils.buildMesh(geometry);

    // TODO: support morph animations someday.
    if (logger.isLoggable(Level.WARNING)) {
        logger.warning("Morph target animation not yet supported.");
    }

    // Just add mesh.
    if (baseMesh != null) {
        ardorParentNode.attachChild(baseMesh);
    }
}

From source file:com.ardor3d.extension.model.collada.jdom.ColladaAnimUtils.java

License:Open Source License

/**
 * Merge all animation channels into Ardor jointchannels
 * /*from w  ww.  ja v a 2  s.  c o  m*/
 * @param entry
 */
@SuppressWarnings("unchecked")
private void buildAnimations(final Element parentElement, final Collection<TargetChannel> targetList) {

    final List<Element> elementTransforms = new ArrayList<Element>();
    for (final Element child : parentElement.getChildren()) {
        if (_dataCache.getTransformTypes().contains(child.getName())) {
            elementTransforms.add(child);
        }
    }
    final List<TransformElement> transformList = getNodeTransformList(elementTransforms);

    AnimationItem animationItemRoot = null;
    for (final TargetChannel targetChannel : targetList) {
        if (animationItemRoot == null) {
            animationItemRoot = targetChannel.animationItemRoot;
        }
        final String source = targetChannel.source;
        // final Target target = targetChannel.target;
        final Element targetNode = targetChannel.targetNode;

        final int targetIndex = elementTransforms.indexOf(targetNode);
        if (logger.isLoggable(Level.FINE)) {
            logger.fine(parentElement.getName() + "(" + parentElement.getAttributeValue("name") + ") -> "
                    + targetNode.getName() + "(" + targetIndex + ")");
        }

        final EnumMap<Type, ColladaInputPipe> pipes = Maps.newEnumMap(Type.class);

        final Element samplerElement = _colladaDOMUtil.findTargetWithId(source);
        for (final Element inputElement : samplerElement.getChildren("input")) {
            final ColladaInputPipe pipe = new ColladaInputPipe(_colladaDOMUtil, inputElement);
            pipes.put(pipe.getType(), pipe);
        }

        // get input (which is TIME for now)
        final ColladaInputPipe inputPipe = pipes.get(Type.INPUT);
        final ColladaInputPipe.SourceData sdIn = inputPipe.getSourceData();
        final float[] time = sdIn.floatArray;
        targetChannel.time = time;
        if (logger.isLoggable(Level.FINE)) {
            logger.fine("inputPipe: " + Arrays.toString(time));
        }

        // get output data
        final ColladaInputPipe outputPipe = pipes.get(Type.OUTPUT);
        final ColladaInputPipe.SourceData sdOut = outputPipe.getSourceData();
        final float[] animationData = sdOut.floatArray;
        targetChannel.animationData = animationData;
        if (logger.isLoggable(Level.FINE)) {
            logger.fine("outputPipe: " + Arrays.toString(animationData));
        }

        // TODO: Need to add support for other interpolation types.

        // get target array from transform list
        final TransformElement transformElement = transformList.get(targetIndex);
        final double[] array = transformElement.getArray();
        targetChannel.array = array;

        final int stride = sdOut.stride;
        targetChannel.stride = stride;

        targetChannel.currentPos = 0;
    }

    final List<Float> finalTimeList = Lists.newArrayList();
    final List<Transform> finalTransformList = Lists.newArrayList();
    final List<TargetChannel> workingChannels = Lists.newArrayList();
    for (;;) {
        float lowestTime = Float.MAX_VALUE;
        boolean found = false;
        for (final TargetChannel targetChannel : targetList) {
            if (targetChannel.currentPos < targetChannel.time.length) {
                final float time = targetChannel.time[targetChannel.currentPos];
                if (time < lowestTime) {
                    lowestTime = time;
                }
                found = true;
            }
        }
        if (!found) {
            break;
        }

        workingChannels.clear();
        for (final TargetChannel targetChannel : targetList) {
            if (targetChannel.currentPos < targetChannel.time.length) {
                final float time = targetChannel.time[targetChannel.currentPos];
                if (time == lowestTime) {
                    workingChannels.add(targetChannel);
                }
            }
        }

        for (final TargetChannel targetChannel : workingChannels) {
            final Target target = targetChannel.target;
            final float[] animationData = targetChannel.animationData;
            final double[] array = targetChannel.array;

            // set the correct values depending on accessor
            final int position = targetChannel.currentPos * targetChannel.stride;
            if (target.accessorType == AccessorType.None) {
                for (int j = 0; j < array.length; j++) {
                    array[j] = animationData[position + j];
                }
            } else {
                if (target.accessorType == AccessorType.Vector) {
                    array[target.accessorIndexX] = animationData[position];
                } else if (target.accessorType == AccessorType.Matrix) {
                    array[target.accessorIndexY * 4 + target.accessorIndexX] = animationData[position];
                }
            }
            targetChannel.currentPos++;
        }

        // bake the transform
        final Transform transform = bakeTransforms(transformList);
        finalTimeList.add(lowestTime);
        finalTransformList.add(transform);
    }

    final float[] time = new float[finalTimeList.size()];
    for (int i = 0; i < finalTimeList.size(); i++) {
        time[i] = finalTimeList.get(i);
    }
    final Transform[] transforms = finalTransformList.toArray(new Transform[finalTransformList.size()]);

    AnimationClip animationClip = animationItemRoot.getAnimationClip();
    if (animationClip == null) {
        animationClip = new AnimationClip(animationItemRoot.getName());
        animationItemRoot.setAnimationClip(animationClip);
    }

    // Make an animation channel - first find if we have a matching joint
    Joint joint = _dataCache.getElementJointMapping().get(parentElement);
    if (joint == null) {
        String nodeName = parentElement.getAttributeValue("name", (String) null);
        if (nodeName == null) { // use id if name doesn't exist
            nodeName = parentElement.getAttributeValue("id", parentElement.getName());
        }
        if (nodeName != null) {
            joint = _dataCache.getExternalJointMapping().get(nodeName);
        }

        if (joint == null) {
            // no joint still, so make a transform channel.
            final TransformChannel transformChannel = new TransformChannel(nodeName, time, transforms);
            animationClip.addChannel(transformChannel);
            _colladaStorage.getAnimationChannels().add(transformChannel);
            return;
        }
    }

    // create joint channel
    final JointChannel jointChannel = new JointChannel(joint, time, transforms);
    animationClip.addChannel(jointChannel);
    _colladaStorage.getAnimationChannels().add(jointChannel);
}

From source file:com.ardor3d.extension.model.collada.jdom.ColladaAnimUtils.java

License:Open Source License

/**
 * Gather up all animation channels based on what nodes they affect.
 * /*  w w  w.  j  a  va2  s  .c  o  m*/
 * @param channelMap
 * @param animationRoot
 * @param animationItemRoot
 */
@SuppressWarnings("unchecked")
private void parseAnimations(final Multimap<Element, TargetChannel> channelMap, final Element animationRoot,
        final AnimationItem animationItemRoot) {
    if (animationRoot.getChild("animation") != null) {
        Attribute nameAttribute = animationRoot.getAttribute("name");
        if (nameAttribute == null) {
            nameAttribute = animationRoot.getAttribute("id");
        }
        final String name = nameAttribute != null ? nameAttribute.getValue() : "Default";

        final AnimationItem animationItem = new AnimationItem(name);
        animationItemRoot.getChildren().add(animationItem);

        for (final Element animationElement : animationRoot.getChildren("animation")) {
            parseAnimations(channelMap, animationElement, animationItem);
        }
    }
    if (animationRoot.getChild("channel") != null) {
        if (logger.isLoggable(Level.FINE)) {
            logger.fine("\n-- Parsing animation channels --");
        }
        final List<Element> channels = animationRoot.getChildren("channel");
        for (final Element channel : channels) {
            final String source = channel.getAttributeValue("source");

            final String targetString = channel.getAttributeValue("target");
            if (targetString == null || targetString.isEmpty()) {
                return;
            }

            final Target target = processTargetString(targetString);
            if (logger.isLoggable(Level.FINE)) {
                logger.fine("channel source: " + target.toString());
            }
            final Element targetNode = findTargetNode(target);
            if (targetNode == null || !_dataCache.getTransformTypes().contains(targetNode.getName())) {
                // TODO: pass with warning or exception or nothing?
                // throw new ColladaException("No target transform node found for target: " + target, target);
                continue;
            }
            if ("rotate".equals(targetNode.getName())) {
                target.accessorType = AccessorType.Vector;
                target.accessorIndexX = 3;
            }

            channelMap.put(targetNode.getParentElement(),
                    new TargetChannel(target, targetNode, source, animationItemRoot));
        }
    }
}

From source file:com.ardor3d.extension.model.collada.jdom.ColladaDOMUtil.java

License:Open Source License

/**
 * Find Element with semantic POSITION under an element with inputs
 * //from w  w w. j  ava2  s  . c o m
 * @param v
 * @return
 */
@SuppressWarnings("unchecked")
public Element getPositionSource(final Element v) {
    for (final Element input : v.getChildren("input")) {
        if ("POSITION".equals(input.getAttributeValue("semantic"))) {
            final Element n = findTargetWithId(input.getAttributeValue("source"));
            if (n != null && "source".equals(n.getName())) {
                return n;
            }
        }
    }

    // changed this to throw an exception instead - otherwise, there will just be a nullpointer exception
    // outside. This provides much more information about what went wrong / Petter
    // return null;
    throw new ColladaException("Unable to find POSITION semantic for inputs under DaeVertices", v);
}

From source file:com.ardor3d.extension.model.collada.jdom.ColladaInputPipe.java

License:Open Source License

@SuppressWarnings("unchecked")
public ColladaInputPipe(final ColladaDOMUtil colladaDOMUtil, final Element input) {
    // Setup our type
    try {//from ww  w. j a v a  2s. com
        _type = Type.valueOf(input.getAttributeValue("semantic"));
    } catch (final Exception ex) {
        ColladaInputPipe.logger.warning("Unknown input type: " + input.getAttributeValue("semantic"));
        _type = Type.UNKNOWN;
    }

    // Locate our source
    final Element n = colladaDOMUtil.findTargetWithId(input.getAttributeValue("source"));
    if (n == null) {
        throw new ColladaException("Input source not found: " + input.getAttributeValue("source"), input);
    }

    if ("source".equals(n.getName())) {
        _source = n;
    } else if ("vertices".equals(n.getName())) {
        _source = colladaDOMUtil.getPositionSource(n);
    } else {
        throw new ColladaException("Input source not found: " + input.getAttributeValue("source"), input);
    }

    // TODO: Need to go through the params and see if they have a name set, and skip values if not when
    // parsing the array?

    _sourceData = new SourceData();
    if (_source.getChild("float_array") != null) {
        _sourceData.floatArray = colladaDOMUtil.parseFloatArray(_source.getChild("float_array"));
        _sourceData.paramType = ParamType.float_param;
    } else if (_source.getChild("bool_array") != null) {
        _sourceData.boolArray = colladaDOMUtil.parseBooleanArray(_source.getChild("bool_array"));
        _sourceData.paramType = ParamType.bool_param;
    } else if (_source.getChild("int_array") != null) {
        _sourceData.intArray = colladaDOMUtil.parseIntArray(_source.getChild("int_array"));
        _sourceData.paramType = ParamType.int_param;
    } else if (_source.getChild("Name_array") != null) {
        _sourceData.stringArray = colladaDOMUtil.parseStringArray(_source.getChild("Name_array"));
        _sourceData.paramType = ParamType.name_param;
    } else if (_source.getChild("IDREF_array") != null) {
        _sourceData.stringArray = colladaDOMUtil.parseStringArray(_source.getChild("IDREF_array"));
        _sourceData.paramType = ParamType.idref_param;
    }

    // add a hook to our params from the technique_common
    final Element accessor = getCommonAccessor(_source);
    if (accessor != null) {
        if (ColladaInputPipe.logger.isLoggable(Level.FINE)) {
            ColladaInputPipe.logger.fine("Creating buffers for: " + _source.getAttributeValue("id"));
        }

        final List<Element> params = accessor.getChildren("param");
        _paramCount = params.size();

        // Might use this info for real later, but use for testing for unsupported param skipping.
        boolean skippedParam = false;
        for (final Element param : params) {
            final String paramName = param.getAttributeValue("name");
            if (paramName == null) {
                skippedParam = true;
                break;
            }
            // String paramType = param.getAttributeValue("type");
        }
        if (_paramCount > 1 && skippedParam) {
            ColladaInputPipe.logger.warning("Parameter skipping not yet supported when parsing sources. "
                    + _source.getAttributeValue("id"));
        }

        _sourceData.count = colladaDOMUtil.getAttributeIntValue(accessor, "count", 0);
        _sourceData.stride = colladaDOMUtil.getAttributeIntValue(accessor, "stride", 1);
        _sourceData.offset = colladaDOMUtil.getAttributeIntValue(accessor, "offset", 0);
    }

    // save our offset
    _offset = colladaDOMUtil.getAttributeIntValue(input, "offset", 0);
    _set = colladaDOMUtil.getAttributeIntValue(input, "set", 0);

    _texCoord = 0;
}

From source file:com.ardor3d.extension.model.collada.jdom.ColladaMaterialUtils.java

License:Open Source License

/**
 * Find and apply the given material to the given Mesh.
 * //from   w  ww  .j av  a2 s.  co m
 * @param materialName
 *            our material name
 * @param mesh
 *            the mesh to apply material to.
 */
public void applyMaterial(final String materialName, final Mesh mesh) {
    if (materialName == null) {
        logger.warning("materialName is null");
        return;
    }

    Element mat = _dataCache.getBoundMaterial(materialName);
    if (mat == null) {
        logger.warning("material not bound: " + materialName + ", trying search with id.");
        mat = _colladaDOMUtil.findTargetWithId(materialName);
    }
    if (mat == null || !"material".equals(mat.getName())) {
        logger.warning("material not found: " + materialName);
        return;
    }

    final String originalMaterial = mat.getAttributeValue("id");
    MaterialInfo mInfo = null;
    if (!_dataCache.getMaterialInfoMap().containsKey(originalMaterial)) {
        mInfo = new MaterialInfo();
        mInfo.setMaterialName(originalMaterial);
        _dataCache.getMaterialInfoMap().put(originalMaterial, mInfo);
    }
    _dataCache.getMeshMaterialMap().put(mesh, originalMaterial);

    final Element child = mat.getChild("instance_effect");
    final Element effectNode = _colladaDOMUtil.findTargetWithId(child.getAttributeValue("url"));
    if (effectNode == null) {
        logger.warning(
                "material effect not found: " + mat.getChild("instance_material").getAttributeValue("url"));
        return;
    }

    if ("effect".equals(effectNode.getName())) {
        /*
         * temp cache for textures, we do not want to add textures twice (for example, transparant map might point
         * to diffuse texture)
         */
        final HashMap<String, Texture> loadedTextures = new HashMap<String, Texture>();
        final Element effect = effectNode;
        // XXX: For now, just grab the common technique:
        final Element common = effect.getChild("profile_COMMON");
        if (common != null) {
            if (mInfo != null) {
                mInfo.setProfile("COMMON");
            }

            final Element commonExtra = common.getChild("extra");
            if (commonExtra != null) {
                // process with any plugins
                _importer.readExtra(commonExtra, mesh);
            }

            final Element technique = common.getChild("technique");
            String type = "blinn";
            if (technique.getChild(type) == null) {
                type = "phong";
                if (technique.getChild(type) == null) {
                    type = "lambert";
                    if (technique.getChild(type) == null) {
                        type = "constant";
                        if (technique.getChild(type) == null) {
                            ColladaMaterialUtils.logger.warning("COMMON material has unusuable techinque. "
                                    + child.getAttributeValue("url"));
                            return;
                        }
                    }
                }
            }
            final Element blinnPhongLambert = technique.getChild(type);
            if (mInfo != null) {
                mInfo.setTechnique(type);
            }
            final MaterialState mState = new MaterialState();

            // TODO: implement proper transparency handling
            Texture diffuseTexture = null;
            ColorRGBA transparent = new ColorRGBA(1.0f, 1.0f, 1.0f, 1.0f);
            float transparency = 1.0f;
            boolean useTransparency = false;
            String opaqueMode = "A_ONE";

            /*
             * place holder for current property, we import material properties in fixed order (for texture order)
             */
            Element property = null;
            /* Diffuse property */
            property = blinnPhongLambert.getChild("diffuse");
            if (property != null) {
                final Element propertyValue = property.getChildren().get(0);
                if ("color".equals(propertyValue.getName())) {
                    final ColorRGBA color = _colladaDOMUtil.getColor(propertyValue.getText());
                    mState.setDiffuse(MaterialFace.FrontAndBack, color);
                } else if ("texture".equals(propertyValue.getName()) && _loadTextures) {
                    diffuseTexture = populateTextureState(mesh, propertyValue, effect, loadedTextures, mInfo,
                            "diffuse");
                }
            }
            /* Ambient property */
            property = blinnPhongLambert.getChild("ambient");
            if (property != null) {
                final Element propertyValue = property.getChildren().get(0);
                if ("color".equals(propertyValue.getName())) {
                    final ColorRGBA color = _colladaDOMUtil.getColor(propertyValue.getText());
                    mState.setAmbient(MaterialFace.FrontAndBack, color);
                } else if ("texture".equals(propertyValue.getName()) && _loadTextures) {
                    populateTextureState(mesh, propertyValue, effect, loadedTextures, mInfo, "ambient");
                }
            }
            /* Transparent property */
            property = blinnPhongLambert.getChild("transparent");
            if (property != null) {
                final Element propertyValue = property.getChildren().get(0);
                if ("color".equals(propertyValue.getName())) {
                    transparent = _colladaDOMUtil.getColor(propertyValue.getText());
                    // TODO: use this
                    useTransparency = true;
                } else if ("texture".equals(propertyValue.getName()) && _loadTextures) {
                    populateTextureState(mesh, propertyValue, effect, loadedTextures, mInfo, "transparent");
                }
                opaqueMode = property.getAttributeValue("opaque", "A_ONE");
            }
            /* Transparency property */
            property = blinnPhongLambert.getChild("transparency");
            if (property != null) {
                final Element propertyValue = property.getChildren().get(0);
                if ("float".equals(propertyValue.getName())) {
                    transparency = Float.parseFloat(propertyValue.getText().replace(",", "."));
                    // TODO: use this
                    if (_flipTransparency) {
                        transparency = 1f - transparency;
                    }
                    useTransparency = true;
                } else if ("texture".equals(propertyValue.getName()) && _loadTextures) {
                    populateTextureState(mesh, propertyValue, effect, loadedTextures, mInfo, "transparency");
                }
            }
            /* Emission property */
            property = blinnPhongLambert.getChild("emission");
            if (property != null) {
                final Element propertyValue = property.getChildren().get(0);
                if ("color".equals(propertyValue.getName())) {
                    mState.setEmissive(MaterialFace.FrontAndBack,
                            _colladaDOMUtil.getColor(propertyValue.getText()));
                } else if ("texture".equals(propertyValue.getName()) && _loadTextures) {
                    populateTextureState(mesh, propertyValue, effect, loadedTextures, mInfo, "emissive");
                }
            }
            /* Specular property */
            property = blinnPhongLambert.getChild("specular");
            if (property != null) {
                final Element propertyValue = property.getChildren().get(0);
                if ("color".equals(propertyValue.getName())) {
                    mState.setSpecular(MaterialFace.FrontAndBack,
                            _colladaDOMUtil.getColor(propertyValue.getText()));
                } else if ("texture".equals(propertyValue.getName()) && _loadTextures) {
                    populateTextureState(mesh, propertyValue, effect, loadedTextures, mInfo, "specular");
                }
            }
            /* Shininess property */
            property = blinnPhongLambert.getChild("shininess");
            if (property != null) {
                final Element propertyValue = property.getChildren().get(0);
                if ("float".equals(propertyValue.getName())) {
                    float shininess = Float.parseFloat(propertyValue.getText().replace(",", "."));
                    if (shininess >= 0.0f && shininess <= 1.0f) {
                        final float oldShininess = shininess;
                        shininess *= 128;
                        logger.finest("Shininess - " + oldShininess
                                + " - was in the [0,1] range. Scaling to [0, 128] - " + shininess);
                    } else if (shininess < 0 || shininess > 128) {
                        final float oldShininess = shininess;
                        shininess = MathUtils.clamp(shininess, 0, 128);
                        logger.warning("Shininess must be between 0 and 128. Shininess " + oldShininess
                                + " was clamped to " + shininess);
                    }
                    mState.setShininess(MaterialFace.FrontAndBack, shininess);
                } else if ("texture".equals(propertyValue.getName()) && _loadTextures) {
                    populateTextureState(mesh, propertyValue, effect, loadedTextures, mInfo, "shininess");
                }
            }
            /* Reflectivity property */
            float reflectivity = 1.0f;
            property = blinnPhongLambert.getChild("reflectivity");
            if (property != null) {
                final Element propertyValue = property.getChildren().get(0);
                if ("float".equals(propertyValue.getName())) {
                    reflectivity = Float.parseFloat(propertyValue.getText().replace(",", "."));
                }
            }
            /* Reflective property. Texture only */
            property = blinnPhongLambert.getChild("reflective");
            if (property != null) {
                final Element propertyValue = property.getChildren().get(0);
                if ("texture".equals(propertyValue.getName()) && _loadTextures) {
                    final Texture reflectiveTexture = populateTextureState(mesh, propertyValue, effect,
                            loadedTextures, mInfo, "reflective");

                    reflectiveTexture.setEnvironmentalMapMode(Texture.EnvironmentalMapMode.SphereMap);
                    reflectiveTexture.setApply(ApplyMode.Combine);

                    reflectiveTexture.setCombineFuncRGB(CombinerFunctionRGB.Interpolate);
                    // color 1
                    reflectiveTexture.setCombineSrc0RGB(CombinerSource.CurrentTexture);
                    reflectiveTexture.setCombineOp0RGB(CombinerOperandRGB.SourceColor);
                    // color 2
                    reflectiveTexture.setCombineSrc1RGB(CombinerSource.Previous);
                    reflectiveTexture.setCombineOp1RGB(CombinerOperandRGB.SourceColor);
                    // interpolate param will come from alpha of constant color
                    reflectiveTexture.setCombineSrc2RGB(CombinerSource.Constant);
                    reflectiveTexture.setCombineOp2RGB(CombinerOperandRGB.SourceAlpha);

                    reflectiveTexture.setConstantColor(new ColorRGBA(1, 1, 1, reflectivity));
                }
            }

            /*
             * An extra tag defines some materials not part of the collada standard. Since we're not able to parse
             * we simply extract the textures from the element (such that shaders etc can at least pick up on them)
             */
            property = technique.getChild("extra");
            if (property != null) {
                // process with any plugins
                if (!_importer.readExtra(property, mesh)) {
                    // no plugin processed our mesh, so process ourselves.
                    getTexturesFromElement(mesh, property, effect, loadedTextures, mInfo);
                }
            }

            // XXX: There are some issues with clarity on how to use alpha blending in OpenGL FFP.
            // The best interpretation I have seen is that if transparent has a texture == diffuse,
            // Turn on alpha blending and use diffuse alpha.

            // check to make sure we actually need this.
            // testing separately for a transparency of 0.0 is to hack around erroneous exports, since usually
            // there is no use in exporting something with 100% transparency.
            if ("A_ONE".equals(opaqueMode) && ColorRGBA.WHITE.equals(transparent) && transparency == 1.0
                    || transparency == 0.0) {
                useTransparency = false;
            }

            if (useTransparency) {
                if (diffuseTexture != null) {
                    final BlendState blend = new BlendState();
                    blend.setBlendEnabled(true);
                    blend.setTestEnabled(true);
                    blend.setSourceFunction(BlendState.SourceFunction.SourceAlpha);
                    blend.setDestinationFunction(BlendState.DestinationFunction.OneMinusSourceAlpha);
                    mesh.setRenderState(blend);
                } else {
                    final BlendState blend = new BlendState();
                    blend.setBlendEnabled(true);
                    blend.setTestEnabled(true);
                    transparent.setAlpha(transparent.getAlpha() * transparency);
                    blend.setConstantColor(transparent);
                    blend.setSourceFunction(BlendState.SourceFunction.ConstantAlpha);
                    blend.setDestinationFunction(BlendState.DestinationFunction.OneMinusConstantAlpha);
                    mesh.setRenderState(blend);
                }

                mesh.getSceneHints().setRenderBucketType(RenderBucketType.Transparent);
            }

            if (mInfo != null) {
                if (useTransparency) {
                    mInfo.setUseTransparency(useTransparency);
                    if (diffuseTexture == null) {
                        mInfo.setTransparency(transparent.getAlpha() * transparency);
                    }
                }
                mInfo.setMaterialState(mState);
            }
            mesh.setRenderState(mState);
        }
    } else {
        ColladaMaterialUtils.logger.warning(
                "material effect not found: " + mat.getChild("instance_material").getAttributeValue("url"));
    }
}

From source file:com.ardor3d.extension.model.collada.jdom.ColladaMaterialUtils.java

License:Open Source License

/**
 * Convert a <texture> element to an Ardor3D representation and store in the given state.
 * //from   w ww  . ja  v a2  s . c o  m
 * @param mesh
 *            the Ardor3D Mesh to add the Texture to.
 * @param daeTexture
 *            our <texture> element
 * @param effect
 *            our <instance_effect> element
 * @return the created Texture.
 */
private Texture populateTextureState(final Mesh mesh, final Element daeTexture, final Element effect,
        final HashMap<String, Texture> loadedTextures, final MaterialInfo info, String textureSlot) {
    // TODO: Use vert data to determine which texcoords and set to use.
    // final String uvName = daeTexture.getAttributeValue("texcoord");
    TextureState tState = (TextureState) mesh.getLocalRenderState(RenderState.StateType.Texture);
    if (tState == null) {
        tState = new TextureState();
        mesh.setRenderState(tState);
    }

    // Use texture attrib to find correct sampler
    final String textureReference = daeTexture.getAttributeValue("texture");
    if (textureSlot == null) {
        // if we have no texture slot defined (like in the case of an "extra" texture), we'll use the
        // textureReference.
        textureSlot = textureReference;
    }

    /* only add the texture to the state once */
    if (loadedTextures.containsKey(textureReference)) {
        final Texture tex = loadedTextures.get(textureReference);
        if (info != null) {
            info.setTextureSlot(textureSlot, textureReference, tex, null);
        }
        return tex;
    }

    Element node = _colladaDOMUtil.findTargetWithSid(textureReference);
    if (node == null) {
        // Not sure if this is quite right, but spec seems to indicate looking for global id
        node = _colladaDOMUtil.findTargetWithId("#" + textureReference);
    }

    if ("newparam".equals(node.getName())) {
        node = node.getChildren().get(0);
    }

    Element sampler = null;
    Element surface = null;
    Element image = null;

    Texture.MinificationFilter min = Texture.MinificationFilter.BilinearNoMipMaps;
    if ("sampler2D".equals(node.getName())) {
        sampler = node;
        if (sampler.getChild("minfilter") != null) {
            final String minfilter = sampler.getChild("minfilter").getText();
            min = Enum.valueOf(SamplerTypes.MinFilterType.class, minfilter).getArdor3dFilter();
        }
        // Use sampler to get correct surface
        node = _colladaDOMUtil.findTargetWithSid(sampler.getChild("source").getText());
        // node = resolveSid(effect, sampler.getSource());
    }

    if ("newparam".equals(node.getName())) {
        node = node.getChildren().get(0);
    }

    if ("surface".equals(node.getName())) {
        surface = node;
        // image(s) will come from surface.
    } else if ("image".equals(node.getName())) {
        image = node;
    }

    // Ok, a few possibilities here...
    Texture texture = null;
    String fileName = null;
    if (surface == null && image != null) {
        // Only an image found (no sampler). Assume 2d texture. Load.
        fileName = image.getChild("init_from").getText();
        texture = loadTexture2D(fileName, min);
    } else if (surface != null) {
        // We have a surface, pull images from that.
        if ("2D".equals(surface.getAttributeValue("type"))) {
            // look for an init_from with lowest mip and use that. (usually 0)

            // TODO: mip?
            final Element lowest = surface.getChildren("init_from").get(0);
            // Element lowest = null;
            // for (final Element i : (List<Element>) surface.getChildren("init_from")) {
            // if (lowest == null || lowest.getMip() > i.getMip()) {
            // lowest = i;
            // }
            // }

            if (lowest == null) {
                logger.warning("surface given with no usable init_from: " + surface);
                return null;
            }

            image = _colladaDOMUtil.findTargetWithId("#" + lowest.getText());
            // image = (DaeImage) root.resolveUrl("#" + lowest.getValue());
            if (image != null) {
                fileName = image.getChild("init_from").getText();
                texture = loadTexture2D(fileName, min);
            }

            // TODO: add support for mip map levels other than 0.
        }
        // TODO: add support for the other texture types.
    } else {
        // No surface OR image... warn.
        logger.warning("texture given with no matching <sampler*> or <image> found.");
        if (info != null) {
            info.setTextureSlot(textureSlot, textureReference, null, null);
        }
        return null;
    }

    if (texture != null) {
        if (sampler != null) {
            // Apply params from our sampler.
            applySampler(sampler, texture);
        }

        // Add to texture state.
        tState.setTexture(texture, tState.getNumberOfSetTextures());
        loadedTextures.put(textureReference, texture);
        if (info != null) {
            info.setTextureSlot(textureSlot, textureReference, texture, fileName);
        }
    } else {
        logger.warning("unable to load texture: " + daeTexture);
        if (info != null) {
            info.setTextureSlot(textureSlot, textureReference, null, fileName);
        }
    }

    return texture;
}

From source file:com.ardor3d.extension.model.collada.jdom.ColladaMaterialUtils.java

License:Open Source License

@SuppressWarnings("unchecked")
public void bindMaterials(final Element bindMaterial) {
    if (bindMaterial == null || bindMaterial.getChildren().isEmpty()) {
        return;/*from  ww w  . j  a va2  s .c o  m*/
    }

    for (final Element instance : bindMaterial.getChild("technique_common").getChildren("instance_material")) {
        final Element matNode = _colladaDOMUtil.findTargetWithId(instance.getAttributeValue("target"));
        if (matNode != null && "material".equals(matNode.getName())) {
            _dataCache.bindMaterial(instance.getAttributeValue("symbol"), matNode);
        } else {
            logger.warning("instance material target not found: " + instance.getAttributeValue("target"));
        }

        // TODO: need to store bound vert data as local data. (also unstore on unbind.)
    }
}

From source file:com.ardor3d.extension.model.collada.jdom.ColladaMaterialUtils.java

License:Open Source License

@SuppressWarnings("unchecked")
public void unbindMaterials(final Element bindMaterial) {
    if (bindMaterial == null || bindMaterial.getChildren().isEmpty()) {
        return;/*  w w  w . j  a  v a2s. c o  m*/
    }
    for (final Element instance : bindMaterial.getChild("technique_common").getChildren("instance_material")) {
        _dataCache.unbindMaterial(instance.getAttributeValue("symbol"));
    }
}