Java Code Examples for com.jme3.animation.Bone#getChildren()

/**
 * Updates a bone position and rotation. if the child bones are not in the
 * bone list this means, they are not associated with a physics shape. So
 * they have to be updated
 *
 * @param bone the bone
 * @param pos the position
 * @param rot the rotation
 * @param restoreBoneControl true → user-control flag should be set
 * @param boneList the names of all bones without collision shapes (not
 * null, unaffected)
 */
public static void setTransform(Bone bone, Vector3f pos, Quaternion rot, boolean restoreBoneControl, Set<String> boneList) {
    //we ensure that we have the control
    if (restoreBoneControl) {
        bone.setUserControl(true);
    }
    //we set te user transforms of the bone
    bone.setUserTransformsInModelSpace(pos, rot);
    for (Bone childBone : bone.getChildren()) {
        //each child bone that is not in the list is updated
        if (!boneList.contains(childBone.getName())) {
            Transform t = childBone.getCombinedTransform(pos, rot);
            setTransform(childBone, t.getTranslation(), t.getRotation(), restoreBoneControl, boneList);
        }
    }
    //we give back the control to the keyframed animation
    if (restoreBoneControl) {
        bone.setUserControl(false);
    }
}
 

/**
 * The method updates the geometry according to the poitions of the bones.
 */
public void updateGeometry() {
    VertexBuffer vb = this.getBuffer(Type.Position);
    FloatBuffer posBuf = this.getFloatBuffer(Type.Position);
    posBuf.clear();
    for (int i = 0; i < skeleton.getBoneCount(); ++i) {
        Bone bone = skeleton.getBone(i);
        Vector3f parentTail = bone.getModelSpacePosition().add(bone.getModelSpaceRotation().mult(Vector3f.UNIT_Y.mult(boneLengths.get(i))));

        for (Bone child : bone.getChildren()) {
            Vector3f childHead = child.getModelSpacePosition();
            Vector3f v = childHead.subtract(parentTail);
            float pointDelta = v.length() / POINT_AMOUNT;
            v.normalizeLocal().multLocal(pointDelta);
            Vector3f pointPosition = parentTail.clone();
            for (int j = 0; j < POINT_AMOUNT; ++j) {
                posBuf.put(pointPosition.getX()).put(pointPosition.getY()).put(pointPosition.getZ());
                pointPosition.addLocal(v);
            }
        }
    }
    posBuf.flip();
    vb.updateData(posBuf);

    this.updateBound();
}
 

/**
 * Updates a bone position and rotation.
 * if the child bones are not in the bone list this means, they are not associated with a physic shape.
 * So they have to be updated
 * @param bone the bone
 * @param pos the position
 * @param rot the rotation
 */
public static void setTransform(Bone bone, Vector3f pos, Quaternion rot, boolean restoreBoneControl, Set<String> boneList) {
    //we ensure that we have the control
    if (restoreBoneControl) {
        bone.setUserControl(true);
    }
    //we set te user transforms of the bone
    bone.setUserTransformsWorld(pos, rot);
    for (Bone childBone : bone.getChildren()) {
        //each child bone that is not in the list is updated
        if (!boneList.contains(childBone.getName())) {
            Transform t = childBone.getCombinedTransform(pos, rot);
            setTransform(childBone, t.getTranslation(), t.getRotation(), restoreBoneControl, boneList);
        }
    }
    //we give back the control to the keyframed animation
    if (restoreBoneControl) {
        bone.setUserControl(false);
    }
}
 

/**
 * Updates a bone position and rotation.
 * if the child bones are not in the bone list this means, they are not associated with a physic shape.
 * So they have to be updated
 * @param bone the bone
 * @param pos the position
 * @param rot the rotation
 */
public static void setTransform(Bone bone, Vector3f pos, Quaternion rot, boolean restoreBoneControl, Set<String> boneList) {
    //we ensure that we have the control
    if (restoreBoneControl) {
        bone.setUserControl(true);
    }
    //we set te user transforms of the bone
    bone.setUserTransformsWorld(pos, rot);
    for (Bone childBone : bone.getChildren()) {
        //each child bone that is not in the list is updated
        if (!boneList.contains(childBone.getName())) {
            Transform t = childBone.getCombinedTransform(pos, rot);
            setTransform(childBone, t.getTranslation(), t.getRotation(), restoreBoneControl, boneList);
        }
    }
    //we give back the control to the keyframed animation
    if (restoreBoneControl) {
        bone.setUserControl(false);
    }
}
 

/**
 * Enumerate the bone indices of the specified bone and all its descendents.
 *
 * @param bone the input bone (not null)
 * @param skeleton the skeleton containing the bone (not null)
 * @param boneList a set of bone names (not null, unaffected)
 *
 * @return a new list (not null)
 */
public static List<Integer> getBoneIndices(Bone bone, Skeleton skeleton, Set<String> boneList) {
    List<Integer> list = new LinkedList<Integer>();
    if (boneList.isEmpty()) {
        list.add(skeleton.getBoneIndex(bone));
    } else {
        list.add(skeleton.getBoneIndex(bone));
        for (Bone chilBone : bone.getChildren()) {
            if (!boneList.contains(chilBone.getName())) {
                list.addAll(getBoneIndices(chilBone, skeleton, boneList));
            }
        }
    }
    return list;
}
 

/**
 * Alter the user-control flags of a bone and all its descendents.
 *
 * @param bone the ancestor bone (not null, modified)
 * @param bool true to enable user control, false to disable
 */
public static void setUserControl(Bone bone, boolean bool) {
    bone.setUserControl(bool);
    for (Bone child : bone.getChildren()) {
        setUserControl(child, bool);
    }
}
 

/**
 * Th method couns the connections between bones.
 * @param bone
 *            the bone where counting starts
 */
private void countConnections(Bone bone) {
    for (Bone child : bone.getChildren()) {
        ++connectionsAmount;
        this.countConnections(child);
    }
}
 

/**
 * Th method couns the connections between bones.
 * @param bone
 *            the bone where counting starts
 */
private void countConnections(Bone bone) {
    for (Bone child : bone.getChildren()) {
        numConnections++;
        this.countConnections(child);
    }
}
 

/**
 * The method writes the indexes for the connection vertices. Used in non-length mode.
 * @param indexBuf
 *            the index buffer
 * @param bone
 *            the bone
 */
private void writeConnections(ShortBuffer indexBuf, Bone bone) {
    for (Bone child : bone.getChildren()) {
        // write myself
        indexBuf.put((short) skeleton.getBoneIndex(bone));
        // write the child
        indexBuf.put((short) skeleton.getBoneIndex(child));

        this.writeConnections(indexBuf, child);
    }
}
 

public static List<Integer> getBoneIndices(Bone bone, Skeleton skeleton, Set<String> boneList) {
    List<Integer> list = new LinkedList<Integer>();
    if (boneList.isEmpty()) {
        list.add(skeleton.getBoneIndex(bone));
    } else {
        list.add(skeleton.getBoneIndex(bone));
        for (Bone chilBone : bone.getChildren()) {
            if (!boneList.contains(chilBone.getName())) {
                list.addAll(getBoneIndices(chilBone, skeleton, boneList));
            }
        }
    }
    return list;
}
 

public static List<Integer> getBoneIndices(Bone bone, Skeleton skeleton, Set<String> boneList) {
    List<Integer> list = new LinkedList<Integer>();
    if (boneList.isEmpty()) {
        list.add(skeleton.getBoneIndex(bone));
    } else {
        list.add(skeleton.getBoneIndex(bone));
        for (Bone chilBone : bone.getChildren()) {
            if (!boneList.contains(chilBone.getName())) {
                list.addAll(getBoneIndices(chilBone, skeleton, boneList));
            }
        }
    }
    return list;
}
 

void updateWorldVectors(Bone bone) {
//        pmdNode.getSkeleton().updateWorldVectors();
        bone.updateWorldVectors();
        final ArrayList<Bone> children = bone.getChildren();
        final int size = children.size();
        for(int i=0;i<size;i++) {
            Bone childBone = children.get(i);
            updateWorldVectors(childBone);
        }
    }
 

private void writeConnections(ShortBuffer indexBuf, Bone bone){
    for (Bone child : bone.getChildren()){
        // write myself
        indexBuf.put( (short) skeleton.getBoneIndex(bone) );
        // write the child
        indexBuf.put( (short) skeleton.getBoneIndex(child) );

        writeConnections(indexBuf, child);
    }
}
 

public static void setUserControl(Bone bone, boolean bool) {
    bone.setUserControl(bool);
    for (Bone child : bone.getChildren()) {
        setUserControl(child, bool);
    }
}
 

public static void setUserControl(Bone bone, boolean bool) {
    bone.setUserControl(bool);
    for (Bone child : bone.getChildren()) {
        setUserControl(child, bool);
    }
}
 

private void countConnections(Bone bone){
    for (Bone child : bone.getChildren()){
        numConnections ++;
        countConnections(child);
    }
}