Java 类com.badlogic.gdx.graphics.g3d.model.Node 实例源码

private void init() {
    float centerX = 0f;
    float centerY = ((((float) words.length) * FONT_HEIGHT) - FONT_HEIGHT) / 2f;

    nodes.clear();
    nodesPosition = new Array<Vector3>();
    if(words != null && words.length > 0){
        for(int y = 0; y < words.length; y++){
            String[] word = translateSpecialCharacters(words[y]);
            centerX = (((float) word.length) * FONT_WIDTH) / 2f;
            for(int x = 0; x < word.length; x++){
                String letter = String.valueOf(word[x]);

                Node node = model.getNode(letter);
                if(node != null){
                    Vector3 position = new Vector3((FONT_WIDTH*x) - centerX,(-FONT_HEIGHT*y) + centerY,0);
                    node = node.copy();
                    node.globalTransform.setTranslation(position);
                    nodes.add(node);
                    nodesPosition.add(position.cpy());
                }
            }
        }
    }
}

public NodeComponent() {
    node = new Node();

    tempVec = new Vector3();
    tempVec2 = new Vector3();
    tempQuat = new Quaternion();

    translation = new Vector3();
    rotation = new Vector3();
    scale = new Vector3(1, 1, 1);

    localTranslation = new Vector3();
    localRotation = new Vector3();
    localScale = new Vector3(1, 1, 1);

    translationDelta = new Vector3();
    rotationDelta = new Vector3();
    scaleDelta = new Vector3();

    localRotationQuaternion = new Quaternion();
    rotationQuaternion = new Quaternion();
}

/**
 * Updates the rigid body parts to follow nodes of the model instance
 */
private void updateBodiesToArmature() {
    // Ragdoll parts should follow the model animation.
    // Loop over each part and set it to the global transform of the armature node it should follow.
    capsuleTransform.set(modelTransform);
    for (Iterator<ObjectMap.Entry<btRigidBody, RigidBodyNodeConnection>> iterator
         = bodyPartMap.iterator(); iterator.hasNext(); ) {
        ObjectMap.Entry<btRigidBody, RigidBodyNodeConnection> entry = iterator.next();
        RigidBodyNodeConnection data = entry.value;
        btRigidBody body = entry.key;
        Node followNode = data.followNode;
        Vector3 offset = data.bodyNodeOffsets.get(followNode);

        body.proceedToTransform(tmpMatrix.set(capsuleTransform)
                .mul(followNode.globalTransform).translate(offset));
    }
}

/**
 * @param bodyPart The rigid body which is to be synchronized with a node
 * @param node     The node which is to be synchronized with a body
 */
private void addPart(btRigidBody bodyPart, Node node) {
    if (!bodyPartMap.containsKey(bodyPart)) {
        bodyPartMap.put(bodyPart, new RigidBodyNodeConnection());
    }
    RigidBodyNodeConnection conn = bodyPartMap.get(bodyPart);
    conn.followNode = node;
    // Set the follow offset to the middle of the armature bone
    Vector3 offsetTranslation = new Vector3();
    node.getChild(0).localTransform.getTranslation(offsetTranslation).scl(0.5f);
    conn.bodyNodeOffsets.put(node, offsetTranslation);

    if (!ragdollMappedNodes.contains(node, true)) {
        ragdollMappedNodes.add(node);
    }
}

/**
 * Creates and adds the navmesh to this scene.
 */
private void setNavmesh(GameObjectBlueprint bp) {
    // We need to set the node transforms before calculating the navmesh shape
    GameModel gameModel = new GameModel(bp.model, bp.name, bp.position, bp.rotation, bp.scale);

    Array<NodePart> nodes = gameModel.modelInstance.model.getNode("navmesh").parts;
    // Sort the model meshParts array according to material name
    nodes.sort(new NavMeshNodeSorter());

    // The model transform must be applied to the meshparts for shape generation to work correctly.
    gameModel.modelInstance.calculateTransforms();
    Matrix4 transform = new Matrix4();
    for (Node node : gameModel.modelInstance.nodes) {
        transform.set(node.globalTransform).inv();
        for (NodePart nodePart : node.parts) {
            nodePart.meshPart.mesh.transform(transform);
        }
    }
    navMesh = new NavMesh(gameModel.modelInstance.model);
    btCollisionShape shape = navMesh.getShape();

    navmeshBody = new InvisibleBody("navmesh",
            shape, 0, gameModel.modelInstance.transform, GameEngine.NAVMESH_FLAG, GameEngine.NAVMESH_FLAG, false, false);
    worldBounds.set(gameModel.boundingBox);
    gameModel.dispose();
}

private void drawArmatureNodes(Node currentNode, Vector3 modelPos,
                               Quaternion modelRot,
                               Vector3 parentNodePos, Vector3 currentNodePos) {
    currentNode.globalTransform.getTranslation(currentNodePos);
    modelRot.transform(currentNodePos);
    currentNodePos.add(modelPos);
    drawVertex(currentNodePos, 0.02f, Color.GREEN);
    shapeRenderer.setColor(Color.YELLOW);
    if (currentNode.hasParent()) {
        shapeRenderer.line(parentNodePos, currentNodePos);
    }
    if (currentNode.hasChildren()) {
        float x = currentNodePos.x;
        float y = currentNodePos.y;
        float z = currentNodePos.z;
        for (Node child : currentNode.getChildren()) {
            drawArmatureNodes(child, modelPos, modelRot, currentNodePos, parentNodePos);
            currentNodePos.set(x, y, z);
        }
    }
}

@Deprecated
public static Model createFromMesh (final Mesh mesh, int indexOffset, int vertexCount, int primitiveType,
    final Material material) {
    Model result = new Model();
    MeshPart meshPart = new MeshPart();
    meshPart.id = "part1";
    meshPart.indexOffset = indexOffset;
    meshPart.numVertices = vertexCount;
    meshPart.primitiveType = primitiveType;
    meshPart.mesh = mesh;

    NodePart partMaterial = new NodePart();
    partMaterial.material = material;
    partMaterial.meshPart = meshPart;
    Node node = new Node();
    node.id = "node1";
    node.parts.add(partMaterial);

    result.meshes.add(mesh);
    result.materials.add(material);
    result.nodes.add(node);
    result.meshParts.add(meshPart);
    result.manageDisposable(mesh);
    return result;
}

/** Convenience method to create a model with three orthonormal vectors shapes. The resources the Material might contain are not
 * managed, use {@link Model#manageDisposable(Disposable)} to add those to the model.
 * @param axisLength Length of each axis.
 * @param capLength is the height of the cap in percentage, must be in (0,1)
 * @param stemThickness is the percentage of stem diameter compared to cap diameter, must be in (0,1]
 * @param divisions the amount of vertices used to generate the cap and stem ellipsoidal bases */
public Model createXYZCoordinates (float axisLength, float capLength, float stemThickness, int divisions, int primitiveType,
    Material material, long attributes) {
    begin();
    MeshPartBuilder partBuilder;
    Node node = node();

    partBuilder = part("xyz", primitiveType, attributes, material);
    partBuilder.setColor(Color.RED);
    partBuilder.arrow(0, 0, 0, axisLength, 0, 0, capLength, stemThickness, divisions);
    partBuilder.setColor(Color.GREEN);
    partBuilder.arrow(0, 0, 0, 0, axisLength, 0, capLength, stemThickness, divisions);
    partBuilder.setColor(Color.BLUE);
    partBuilder.arrow(0, 0, 0, 0, 0, axisLength, capLength, stemThickness, divisions);

    return end();
}

private void loadAnimations (Iterable<ModelAnimation> modelAnimations) {
    for (final ModelAnimation anim : modelAnimations) {
        Animation animation = new Animation();
        animation.id = anim.id;
        for (ModelNodeAnimation nanim : anim.nodeAnimations) {
            final Node node = getNode(nanim.nodeId);
            if (node == null) continue;
            NodeAnimation nodeAnim = new NodeAnimation();
            nodeAnim.node = node;
            for (ModelNodeKeyframe kf : nanim.keyframes) {
                if (kf.keytime > animation.duration) animation.duration = kf.keytime;
                NodeKeyframe keyframe = new NodeKeyframe();
                keyframe.keytime = kf.keytime;
                keyframe.rotation.set(kf.rotation == null ? node.rotation : kf.rotation);
                keyframe.scale.set(kf.scale == null ? node.scale : kf.scale);
                keyframe.translation.set(kf.translation == null ? node.translation : kf.translation);
                nodeAnim.keyframes.add(keyframe);
            }
            if (nodeAnim.keyframes.size > 0) animation.nodeAnimations.add(nodeAnim);
        }
        if (animation.nodeAnimations.size > 0) animations.add(animation);
    }
}

/** @param model The source {@link Model}
 * @param transform The {@link Matrix4} instance for this ModelInstance to reference or null to create a new matrix.
 * @param nodeId The ID of the {@link Node} within the {@link Model} for the instance to contain
 * @param recursive True to recursively search the Model's node tree, false to only search for a root node
 * @param parentTransform True to apply the parent's node transform to the instance (only applicable if recursive is true).
 * @param mergeTransform True to apply the source node transform to the instance transform, resetting the node transform. */
public ModelInstance (final Model model, final Matrix4 transform, final String nodeId, boolean recursive,
    boolean parentTransform, boolean mergeTransform, boolean shareKeyframes) {
    this.model = model;
    this.transform = transform == null ? new Matrix4() : transform;
    nodePartBones.clear();
    Node copy, node = model.getNode(nodeId, recursive);
    this.nodes.add(copy = copyNode(node));
    if (mergeTransform) {
        this.transform.mul(parentTransform ? node.globalTransform : node.localTransform);
        copy.translation.set(0, 0, 0);
        copy.rotation.idt();
        copy.scale.set(1, 1, 1);
    } else if (parentTransform && copy.hasParent()) this.transform.mul(node.getParent().globalTransform);
    setBones();
    copyAnimations(model.animations, shareKeyframes);
    calculateTransforms();
}

private Node copyNode (Node node) {
    Node copy = new Node();
    copy.id = node.id;
    copy.inheritTransform = node.inheritTransform;
    copy.translation.set(node.translation);
    copy.rotation.set(node.rotation);
    copy.scale.set(node.scale);
    copy.localTransform.set(node.localTransform);
    copy.globalTransform.set(node.globalTransform);
    for (NodePart nodePart : node.parts) {
        copy.parts.add(copyNodePart(nodePart));
    }
    for (Node child : node.getChildren()) {
        copy.addChild(copyNode(child));
    }
    return copy;
}

@Deprecated
public static Model createFromMesh(final Mesh mesh, int indexOffset, int vertexCount, int primitiveType, final Material material) {
    Model result = new Model();
    MeshPart meshPart = new MeshPart();
    meshPart.id = "part1";
    meshPart.offset = indexOffset;
    meshPart.size = vertexCount;
    meshPart.primitiveType = primitiveType;
    meshPart.mesh = mesh;

    NodePart partMaterial = new NodePart();
    partMaterial.material = material;
    partMaterial.meshPart = meshPart;
    Node node = new Node();
    node.id = "node1";
    node.parts.add(partMaterial);

    result.meshes.add(mesh);
    result.materials.add(material);
    result.nodes.add(node);
    result.meshParts.add(meshPart);
    result.manageDisposable(mesh);
    return result;
}

/** players are represented by cubes, with another cube marking the direction it is facing */
public void createPlayerModel() {
    ModelBuilder mb = new ModelBuilder();
    ModelBuilder mb2 = new ModelBuilder();
    long attr = Usage.Position | Usage.Normal;
    float r = 0.5f;
    float g = 1f;
    float b = 0.75f;
    Material material = new Material(ColorAttribute.createDiffuse(new Color(r, g, b, 1f)));
    Material faceMaterial = new Material(ColorAttribute.createDiffuse(Color.BLUE));
    float w = 1f;
    float d = w;
    float h = 2f;
    mb.begin();
    //playerModel = mb.createBox(w, h, d, material, attr);
    Node node = mb.node("box", mb2.createBox(w, h, d, material, attr));
    // the face is just a box to show which direction the player is facing
    Node faceNode = mb.node("face", mb2.createBox(w/2, h/2, d/2, faceMaterial, attr));
    faceNode.translation.set(0f, 0f, d/2);
    playerModel = mb.end();
}

/** client builds statics, probably based on info from server */
public static void buildStatics(LevelStatic[] statics) {
    if (staticGeometry == null) {
        staticGeometry = new Array<>();
    }
    Log.debug("client building statics received from server: " + statics.length);
    ModelBuilder mb = new ModelBuilder();
    mb.begin();
    for (LevelStatic stat : statics) {
        Model model = Assets.manager.get(stat.modelName, Model.class);
        setupStaticModel(model.meshParts, stat.mtx, true);
        Node node = mb.node("piece", model);
        stat.mtx.getTranslation(tmp);
        node.translation.set(tmp);
        node.rotation.set(stat.mtx.getRotation(q));
    }
    Model finalModel = mb.end();
    ModelInstance instance = new ModelInstance(finalModel);
    staticGeometry.add(instance);
}

private void loadAnimations (Iterable<ModelAnimation> modelAnimations) {
    for (final ModelAnimation anim : modelAnimations) {
        Animation animation = new Animation();
        animation.id = anim.id;
        for (ModelNodeAnimation nanim : anim.nodeAnimations) {
            final Node node = getNode(nanim.nodeId);
            if (node == null) continue;
            NodeAnimation nodeAnim = new NodeAnimation();
            nodeAnim.node = node;
            for (ModelNodeKeyframe kf : nanim.keyframes) {
                if (kf.keytime > animation.duration) animation.duration = kf.keytime;
                NodeKeyframe keyframe = new NodeKeyframe();
                keyframe.keytime = kf.keytime;
                keyframe.rotation.set(kf.rotation == null ? node.rotation : kf.rotation);
                keyframe.scale.set(kf.scale == null ? node.scale : kf.scale);
                keyframe.translation.set(kf.translation == null ? node.translation : kf.translation);
                nodeAnim.keyframes.add(keyframe);
            }
            if (nodeAnim.keyframes.size > 0) animation.nodeAnimations.add(nodeAnim);
        }
        if (animation.nodeAnimations.size > 0) animations.add(animation);
    }
}

/** @param model The source {@link Model}
 * @param transform The {@link Matrix4} instance for this ModelInstance to reference or null to create a new matrix. 
 * @param nodeId The ID of the {@link Node} within the {@link Model} for the instance to contain
 * @param recursive True to recursively search the Model's node tree, false to only search for a root node
 * @param parentTransform True to apply the parent's node transform to the instance (only applicable if recursive is true).
 * @param mergeTransform True to apply the source node transform to the instance transform, resetting the node transform. */
public SharedModel(final Model model, final Matrix4 transform, final String nodeId, boolean recursive, boolean parentTransform, boolean mergeTransform) {
    this.model = model;
    this.transform = transform == null ? new Matrix4() : transform; 
    nodePartBones.clear();
    Node copy, node = model.getNode(nodeId, recursive);
    this.nodes.add(copy = copyNode(null, node));
    if (mergeTransform) {
        this.transform.mul(parentTransform ? node.globalTransform : node.localTransform);
        copy.translation.set(0,0,0);
        copy.rotation.idt();
        copy.scale.set(1,1,1);
    } else if (parentTransform && copy.parent != null)
        this.transform.mul(node.parent.globalTransform);
    setBones();
    copyAnimations(model.animations);
    calculateTransforms();
}

private Node copyNode(Node parent, Node node) {
    Node copy = new Node();
    copy.id = node.id;
    //copy.boneId = node.boneId;
    copy.parent = parent;
    copy.translation.set(node.translation);
    copy.rotation.set(node.rotation);
    copy.scale.set(node.scale);
    copy.localTransform.set(node.localTransform);
    copy.globalTransform.set(node.globalTransform);
    for(NodePart nodePart: node.parts) {
        copy.parts.add(copyNodePart(nodePart));
    }
    for(Node child: node.children) {
        copy.children.add(copyNode(copy, child));
    }
    return copy;
}

private void copyAnimations (final Iterable<Animation> source) {
    for (final Animation anim : source) {
        Animation animation = new Animation();
        animation.id = anim.id;
        animation.duration = anim.duration;
        for (final NodeAnimation nanim : anim.nodeAnimations) {
            final Node node = getNode(nanim.node.id);
            if (node == null)
                continue;
            NodeAnimation nodeAnim = new NodeAnimation();
            nodeAnim.node = node;
            for (final NodeKeyframe kf : nanim.keyframes) {
                NodeKeyframe keyframe = new NodeKeyframe();
                keyframe.keytime = kf.keytime;
                keyframe.rotation.set(kf.rotation);
                keyframe.scale.set(kf.scale);
                keyframe.translation.set(kf.translation);
                nodeAnim.keyframes.add(keyframe);
            }
            if (nodeAnim.keyframes.size > 0)
                animation.nodeAnimations.add(nodeAnim);
        }
        if (animation.nodeAnimations.size > 0)
            animations.add(animation);
    }
}

private void doneLoading() {
    Model model = assets.get("data/g3d/test.g3db", Model.class);
    for (int i = 0; i < model.nodes.size; i++) {
        Node node = model.nodes.get(i);
        log.debug("loader node " + node.id);

        if (node.id.equals("test_root")) {
            node = node.getChild("Building", false, false);
            log.debug("loader node " + node.id);

            node.rotation.setFromAxis(1, 0, 0, 90);
            mModel = model;

            break;
        }

        //}
    }

    loading = false;
}

protected void collectModelNodeVertexPositions(Node node, Array<Vector3> destVertices, Vector3 scaleFactor, Vector3 positionOffset) {
    final Matrix4 transform = node.globalTransform;

    for (int i = 0; i < node.parts.size; ++i) {
        NodePart nodePart = node.parts.get(i);
        MeshPart meshPart = nodePart.meshPart;
        ShortBuffer indices = meshPart.mesh.getIndicesBuffer();
        FloatBuffer vertices = meshPart.mesh.getVerticesBuffer();
        final int strideInFloats = meshPart.mesh.getVertexSize() / (Float.SIZE / 8);

        for (int j = 0; j < meshPart.numVertices; ++j) {
            int index = indices.get(meshPart.indexOffset + j);
            int offset = index * strideInFloats;

            tmpPosition.set(vertices.get(offset), vertices.get(offset + 1), vertices.get(offset + 2))
                       .add(positionOffset)
                       .scl(scaleFactor)
                       .mul(transform);
            destVertices.add(new Vector3(tmpPosition));
        }
    }

    for (int i = 0; i < node.children.size; ++i)
        collectModelNodeVertexPositions(node.children.get(i), destVertices, scaleFactor, positionOffset);
}

public Gun(Matrix4 transform, int hp, int health, int range, float cooldown, EnumSet<Types> types, EnumSet<Effects> effects, ModelInstance instance, btCollisionShape shape, btCollisionWorld world, IntMap<Entity> entities, String attack, EntityTemplate<Bullet> projectile, Vector3 attackOffset, Map<String, Sound> sounds) {
    super(transform, hp, health, range, cooldown, types, effects, instance, shape, world, entities, attack, projectile, attackOffset, sounds);
    nodes = new HashMap<String, Node>();
    /*for(Node node: instance.model.nodes) {
        System.out.println(node.id);
        if (node.id.startsWith("Leg")) {
            legs.add(node);
        }
    }*/
    //legs.get(0).rotation.setEulerAngles(100, 0, 0);

    for(Node node: instance.getNode("Gun_root").getChildren())
        nodes.put(node.id, node);
}

public static btCollisionShape obtainStaticNodeShape (final Node node, final boolean applyTransform) {
    getShapeParts(node, applyTransform, shapePartArray, 0, shapePartPool);
    btCollisionShape result = obtainStaticShape(shapePartArray);
    shapePartPool.freeAll(shapePartArray);
    shapePartArray.clear();
    return result;
}

public static btCollisionShape obtainStaticNodeShape (final Array<Node> nodes) {
    getShapeParts(nodes, shapePartArray, 0, shapePartPool);
    btCollisionShape result = obtainStaticShape(shapePartArray);
    shapePartPool.freeAll(shapePartArray);
    shapePartArray.clear();
    return result;
}

private NodePart getPart(int index) {
    ModelInstance inst = gameWorld.renderer().getRenderable(selected());
    int i = 0;
    for (Node node : inst.nodes) {
        for (NodePart part : node.parts) {
            if(i == index) return part;
            i++;
        }
    }
    return null;
}

public Hydrogen(int ve, boolean[][][] mtx, PerspectiveCamera cam) {
    super(ve, mtx, cam);

    //begin building the model
    hydrogen_builder.begin();

    //first node
    Node electron_1 = hydrogen_builder.node();
    electron_1.id = Hydrogen.VE_1;

    //make the cube
    hydrogen_builder.part(Hydrogen.VE_1, GL20.GL_TRIANGLES, VertexAttributes.Usage.Position | VertexAttributes.Usage.Normal,
            new Material(ColorAttribute.createDiffuse(new Color(195f/255f,207f/255f,255f/255f,1f))))
            .box(1f, 1f, 1f);

    //end the model
    Model hModel = hydrogen_builder.end();

    atom = new ModelInstance(hModel,2,10,2);
    shadow = new ModelInstance(hModel,2,10,2);
    frame = new ModelInstance(hModel,2,10,2);
    frame.transform.scl(.01f);

    for(int i = 0; i < shadow.materials.size; ++i){
        shadow.materials.get(i).set(ColorAttribute.createDiffuse(105/255f,105/255f,105/255f,1f));
        frame.materials.get(i).set(ColorAttribute.createDiffuse(Color.WHITE));
    }
}

private static void buildCave(Matrix4 transform) {
    Model caveModel = Assets.get(CURR_MODEL, Model.class);
    if (WORLD.getConstructor("cave") == null) {
        for (Node n : caveModel.nodes) n.scale.set(.6f, .6f, .6f);
        btCollisionShape collisionShape = Bullet.obtainStaticNodeShape(caveModel.nodes);
        collisionShape.setLocalScaling(new Vector3(.6f, .6f, .6f));
        WORLD.addConstructor("cave", new BulletConstructor(caveModel, 0, collisionShape));
    }
    BulletEntity cave = WORLD.add("cave", transform);
    cave.body.setCollisionFlags(cave.body.getCollisionFlags()
            | btCollisionObject.CollisionFlags.CF_KINEMATIC_OBJECT);
    cave.body.setActivationState(Collision.DISABLE_DEACTIVATION);
    cave.body.userData = new BulletUserData("cave", cave);
}

public static btCollisionShape obtainStaticNodeShape (final Node node, final boolean applyTransform) {
    getShapeParts(node, applyTransform, shapePartArray, 0, shapePartPool);
    btCollisionShape result = obtainStaticShape(shapePartArray);
    shapePartPool.freeAll(shapePartArray);
    shapePartArray.clear();
    return result;
}

public static btCollisionShape obtainStaticNodeShape (final Array<Node> nodes) {
    getShapeParts(nodes, shapePartArray, 0, shapePartPool);
    btCollisionShape result = obtainStaticShape(shapePartArray);
    shapePartPool.freeAll(shapePartArray);
    shapePartArray.clear();
    return result;
}

public static Model createArrowStub(Material mat, Vector3 from, Vector3 to) {
    ModelBuilder modelBuilder = new ModelBuilder();
    modelBuilder.begin();
    MeshPartBuilder meshBuilder;
    // line
    meshBuilder = modelBuilder.part("line", GL20.GL_LINES,
            VertexAttributes.Usage.Position | VertexAttributes.Usage.ColorUnpacked, mat);
    meshBuilder.line(from.x, from.y, from.z, to.x, to.y, to.z);
    // stub
    Node node = modelBuilder.node();
    node.translation.set(to.x, to.y, to.z);
    meshBuilder = modelBuilder.part("stub", GL20.GL_TRIANGLES, Usage.Position | Usage.Normal, mat);
    BoxShapeBuilder.build(meshBuilder, 2, 2, 2);
    return modelBuilder.end();
}

public static void applyTransform(Vector3 location, Vector3 rotation, Vector3 scale,
                                  ModelInstance modelInstance) {
    for (Node node : modelInstance.nodes) {
        node.scale.set(Math.abs(scale.x), Math.abs(scale.y), Math.abs(scale.z));
    }
    modelInstance.transform.rotate(Vector3.X, rotation.x);
    modelInstance.transform.rotate(Vector3.Z, rotation.z);
    modelInstance.transform.rotate(Vector3.Y, rotation.y);
    modelInstance.transform.setTranslation(location);

    modelInstance.calculateTransforms();
}

/**
 * Direction vector of an armature bone, in world coordinate system.
 *
 * @param nodeId Name of the bone
 * @param out    Output vector
 * @return Output vector for chaining
 */
public Vector3 getBoneDirection(String nodeId, Vector3 out) {
    Node node = modelInstance.getNode(nodeId);
    Node endPointNode = (node.hasChildren()) ? node.getChild(0) : node;
    node.globalTransform.getTranslation(TMP_V1);
    endPointNode.globalTransform.getTranslation(TMP_V2);
    TMP_V1.sub(TMP_V2).scl(-1);
    modelInstance.transform.getRotation(TMP_Q);
    TMP_Q.transform(TMP_V1);
    return out.set(TMP_V1).nor();
}

/**
 * Midpoint of an armature bone, in world coordinate system.
 *
 * @param nodeId Name of the bone
 * @param out    Output vector
 * @return Output vector for chaining
 */
public Vector3 getBoneMidpointWorldPosition(String nodeId, Vector3 out) {
    Node node = modelInstance.getNode(nodeId);
    Node endPointNode = (node.hasChildren()) ? node.getChild(0) : node;
    // Use global transform to account for model scaling
    node.globalTransform.getTranslation(TMP_V1);
    TMP_V3.set(TMP_V1);
    endPointNode.globalTransform.getTranslation(TMP_V2);
    TMP_V3.sub(TMP_V1.sub(TMP_V2).scl(0.5f));
    modelInstance.transform.getRotation(TMP_Q, true).transform(TMP_V3);
    TMP_V3.add(getPosition());
    return out.set(TMP_V3);
}

/**
 * Updates the nodes of the model instance to follow the rigid body parts
 */
private void updateArmatureToBodies() {
    // Let dynamicsworld control ragdoll. Loop over all ragdoll part collision shapes
    // and their node connection data.
    for (Iterator<ObjectMap.Entry<btRigidBody, RigidBodyNodeConnection>> iterator1
         = bodyPartMap.iterator(); iterator1.hasNext(); ) {
        ObjectMap.Entry<btRigidBody, RigidBodyNodeConnection> bodyEntry = iterator1.next();
        btRigidBody partBody = bodyEntry.key;
        RigidBodyNodeConnection connection = bodyEntry.value;
        capsuleTransform.getTranslation(capsuleTranslation);

        // Loop over each node connected to this collision shape
        for (Iterator<ObjectMap.Entry<Node, Vector3>> iterator2
             = connection.bodyNodeOffsets.iterator(); iterator2.hasNext(); ) {
            ObjectMap.Entry<Node, Vector3> nodeEntry = iterator2.next();
            // A node which is to follow this collision shape
            Node node = nodeEntry.key;
            // The offset of this node from the untranslated collision shape origin
            Vector3 offset = nodeEntry.value;
            // Set the node to the transform of the collision shape it follows
            partBody.getWorldTransform(node.localTransform);
            // Calculate difference in translation between the node/ragdoll part and the
            // base capsule shape.
            node.localTransform.getTranslation(nodeTranslation);
            // Calculate the final node transform
            node.localTransform.setTranslation(nodeTranslation.sub(capsuleTranslation)).translate(tmpVec.set(offset).scl(-1));
        }
    }
    // Calculate the final transform of the model.
    modelInstance.calculateTransforms();
}

/**
 * @param bodyPart       The rigid body which is to be synchronized with a node
 * @param node           The node which is to be synchronized with a body
 * @param nodeBodyOffset The offset from the node to rigid body origin
 */
private void addPart(btRigidBody bodyPart, Node node, Vector3 nodeBodyOffset) {
    if (!bodyPartMap.containsKey(bodyPart)) {
        bodyPartMap.put(bodyPart, new RigidBodyNodeConnection());
    }
    RigidBodyNodeConnection conn = bodyPartMap.get(bodyPart);
    conn.bodyNodeOffsets.put(node, nodeBodyOffset);

    if (!ragdollMappedNodes.contains(node, true)) {
        ragdollMappedNodes.add(node);
    }
}

private void setVColorBlendAttributes() {
    Array<String> modelsIdsInScene = assets.getPlaceholderIdsByType(BlenderModel.class);
    Array<BlenderModel> instancesWithId = new Array<BlenderModel>();
    for (String id : modelsIdsInScene) {
        instancesWithId.clear();
        assets.getPlaceholders(id, BlenderModel.class, instancesWithId);
        for (BlenderModel blenderModel : instancesWithId) {
            // Maybe check if
            // renderable.meshPart.mesh.getVertexAttribute(VertexAttributes.Usage.ColorUnpacked) != null
            if (blenderModel.custom_properties.containsKey("v_color_material_blend")) {
                Model model = assets.getAsset(id, Model.class);
                String redMaterialName = blenderModel.custom_properties.get("v_color_material_red");
                String greenMaterialName = blenderModel.custom_properties.get("v_color_material_green");
                String blueMaterialName = blenderModel.custom_properties.get("v_color_material_blue");

                TextureAttribute redTexAttr = (TextureAttribute)
                        model.getMaterial(redMaterialName).get(TextureAttribute.Diffuse);
                TextureAttribute greenTexAttr = (TextureAttribute)
                        model.getMaterial(greenMaterialName).get(TextureAttribute.Diffuse);
                TextureAttribute blueTexAttr = (TextureAttribute)
                        model.getMaterial(blueMaterialName).get(TextureAttribute.Diffuse);
                VertexColorTextureBlend redAttribute =
                        new VertexColorTextureBlend(VertexColorTextureBlend.Red,
                                redTexAttr.textureDescription.texture);
                VertexColorTextureBlend greenAttribute =
                        new VertexColorTextureBlend(VertexColorTextureBlend.Green,
                                greenTexAttr.textureDescription.texture);
                VertexColorTextureBlend blueAttribute =
                        new VertexColorTextureBlend(VertexColorTextureBlend.Blue,
                                blueTexAttr.textureDescription.texture);
                for (Node node : model.nodes) {
                    for (NodePart nodePart : node.parts) {
                        nodePart.material.set(redAttribute, greenAttribute, blueAttribute);
                    }
                }
                break;
            }
        }
    }
}

/**
 * Translate each vertex along its normal by specified amount.
 *
 * @param model
 * @param amount
 */
public static void fatten(Model model, float amount) {
    Vector3 pos = new Vector3();
    Vector3 nor = new Vector3();
    for (Node node : model.nodes) {
        for (NodePart n : node.parts) {
            Mesh mesh = n.meshPart.mesh;
            FloatBuffer buf = mesh.getVerticesBuffer();
            int lastFloat = mesh.getNumVertices() * mesh.getVertexSize() / 4;
            int vertexFloats = (mesh.getVertexSize() / 4);
            VertexAttribute posAttr = mesh.getVertexAttributes().findByUsage(VertexAttributes.Usage.Position);
            VertexAttribute norAttr = mesh.getVertexAttributes().findByUsage(VertexAttributes.Usage.Normal);
            if (posAttr == null || norAttr == null) {
                throw new IllegalArgumentException("Position/normal vertex attribute not found");
            }
            int pOff = posAttr.offset / 4;
            int nOff = norAttr.offset / 4;

            for (int i = 0; i < lastFloat; i += vertexFloats) {
                pos.x = buf.get(pOff + i);
                pos.y = buf.get(pOff + i + 1);
                pos.z = buf.get(pOff + i + 2);

                nor.x = buf.get(nOff + i);
                nor.y = buf.get(nOff + i + 1);
                nor.z = buf.get(nOff + i + 2);

                nor.nor().scl(amount);

                buf.put(pOff + i, pos.x + nor.x);
                buf.put(pOff + i + 1, pos.y + nor.y);
                buf.put(pOff + i + 2, pos.z + nor.z);
            }
        }
    }
}

/**
 * Creates the collision objects of this planet part.
 */
private void initPhysics() {
    for (int landscapeLayerIndex = 0; landscapeLayerIndex < planetConfig.layerConfigs.size(); landscapeLayerIndex++) {

        String partName = LANDSCAPE_NODE_NAME + landscapeLayerIndex;
        Node landscapeNode = model.getNode(partName);
        CollisionTypes landscapeType = CollisionTypes.byName(planetConfig.layerConfigs.get(landscapeLayerIndex).collisionType);

        if (areAllPartsValid(landscapeNode)) {
            btCollisionShape collisionShape = Bullet.obtainStaticNodeShape(landscapeNode, false);
            shapes.add(collisionShape);

            if (landscapeType != CollisionTypes.WATER) {
                float mass = 0;
                float friction = 1;
                PlanetConfig.LandscapeLayerConfig layerConfig = planetConfig.layerConfigs.get(landscapeLayerIndex);
                int userValue = CollisionTypes.byName(layerConfig.collisionType).mask;
                addRigidBody(collisionShape, mass, friction, userValue,
                        new StandardMotionState(modelInstance.transform));
            } else {
                btCollisionObject object = new btCollisionObject();
                object.setCollisionShape(collisionShape);
                object.setWorldTransform(modelInstance.transform);
                object.setUserValue(CollisionTypes.WATER.mask);
                addCollisionObject(object);
            }
        }
    }
}

/**
 * Returns true if all parts of the assigned node can be used to create collision shapes
 * @param node The node to check.
 * @return True if the node is valid.
 */
private boolean areAllPartsValid(Node node) {
    if (node == null) {
        return false;
    }
    for (NodePart nodePart : node.parts) {
        boolean usesTriangles = (nodePart.meshPart.primitiveType == GL20.GL_TRIANGLES);
        if ((nodePart.meshPart.size <= 0) || !usesTriangles) {
            return false;
        }
    }
    return true;
}

/** Resets the references to {@link Material}s, {@link Mesh}es and {@link MeshPart}s within the model to the ones used within
 * it's nodes. This will make the model responsible for disposing all referenced meshes. */
public static void rebuildReferences (final Model model) {
    model.materials.clear();
    model.meshes.clear();
    model.meshParts.clear();
    for (final Node node : model.nodes)
        rebuildReferences(model, node);
}

private static void rebuildReferences (final Model model, final Node node) {
    for (final NodePart mpm : node.parts) {
        if (!model.materials.contains(mpm.material, true)) model.materials.add(mpm.material);
        if (!model.meshParts.contains(mpm.meshPart, true)) {
            model.meshParts.add(mpm.meshPart);
            if (!model.meshes.contains(mpm.meshPart.mesh, true)) model.meshes.add(mpm.meshPart.mesh);
            model.manageDisposable(mpm.meshPart.mesh);
        }
    }
    for (final Node child : node.getChildren())
        rebuildReferences(model, child);
}